cosyselect.cc

Go to the documentation of this file.

/*--------------------------------------------------------------------
 *
 * (C) Copyright Koninklijke Philips Electronics NV 2006. 
 * All rights reserved. This software is licensed under the terms of
 * version 2.1 of the GNU Lesser General Public License as published 
 * by the Free Software Foundation. For licensing and warranty
 * information, see the file COPYING in the main directory.
 *
 *------------------------------------------------------------------*/

#include <sys/types.h>
#include "cosyselect.h"
#include "rte.h"
#include "cosyfifo.h"
#include "portimpl.h"
#include "fifoimpl.h"
#include "semaphoreapi.h"
#include "utilbase.h"

#include <stdlib.h>

bool cosySelect::random = true;

unsigned int rnd(unsigned int n)
{
  return rand() % n;
}

cosySelect::cosySelect(SelectImpl& s, cosyRte& r) : 
  rteSelect(s), retvalue(0), sema(0), block(false)
{ 
  rte = &r;
}

cosySelect::~cosySelect()
{ }

void cosySelect::pushBack(const InPortImpl& p, unsigned int n)
{
  f.push_back ((cosyFifo*)((FifoImpl*)getFarFifo(&p))->rte());
  s.push_back (n);
  input.push_back (true);
  r.push_back (retvalue);
  retvalue++;
}

void cosySelect::pushBack(const OutPortImpl& p, unsigned int n)
{
  FifoImpl* fifo = (FifoImpl*)getFarFifo(&p);
  for (unsigned int i=0; i<fifo->nrRteFifos(); i++)
  {
    f.push_back ((cosyFifo*)fifo->rte(i));
    s.push_back (n);
    input.push_back (false);
    r.push_back (retvalue);
  }
  retvalue++;
}

unsigned int cosySelect::select()
{
  if (f.size() == 0) {
    rte->cerr() << "Error: There are no ports added" <<
      " to the selectList '" << base->name() << "'" << std::endl;
    exit (1);
  }

  std::vector<int> enable(f.size());  // index of enabled fifos
  int enabled = 0;
  unsigned int i;

#ifdef PREEMPTIVE
  // lock all fifos, such that they cannot be updated while 
  // selector is busy
  for (i = 0; i < f.size(); i++)
    f[i]->lock();
#endif

  for (i = 0; i < f.size(); i++)
  {
    if (input[i]) {
      if (s[i] <= f[i]->wn + f[i]->data())
      {
        enable[enabled++] = i;
      }
    } else {
      if (s[i] <= f[i]->rn - f[i]->data())
      {
        enable[enabled++] = i;
      }
    }
  }

  if (!enabled) {

    // none of the fifos is enabled: block

    for (i=0; i < f.size(); i++)
    {
      if (!f[i]->sel) {
        f[i]->sel = this;
      } else {
        printf("Error: multiple select operations are active simultaneously on channel %s\n",f[i]->api()->fullName());
        exit(1);
      }
  
      if (input[i]) {
        // ws is set to the number of items that
        // has to be written
        f[i]->ws = s[i] - f[i]->data();
      } else {
        // rs is set to the number of items that
        // has to be read
        f[i]->rs = s[i] + f[i]->data();
      }
    }
    
    block = true;

#ifdef PREEMPTIVE
    for (i = 0; i < f.size(); i++)
      f[i]->unlock();
#endif

    sema.wait();
    // returns here after one or more Selector::signal()

#ifdef PREEMPTIVE
    for (i=0; i < f.size(); i++)
      f[i]->lock();
#endif

    for (i=0; i < f.size(); i++)
    {
      if (f[i]->sel) {
        f[i]->sel = 0;
      } else {
        enable[enabled++] = i;
      }
    }
  }

#ifdef PREEMPTIVE
  for (i = 0; i < f.size(); i++)
    f[i]->unlock();
#endif

  return r[enable[random ? rnd(enabled) : 0]];
}

void cosySelect::signal()
{
  // can be called multiple times

#ifdef PREEMPTIVE
  lock();
#endif
  if (block) {
    block = false;
    sema.signal();
  }
#ifdef PREEMPTIVE
  unlock();
#endif
}

#ifdef PREEMPTIVE
void cosySelect::lock()
{
  mutex.lock();
}

void cosySelect::unlock()
{
  mutex.unlock();
}
#endif

---