cosyfifo.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 "cosyfifo.h"
#include "rte.h"
#include "cosyselect.h"
#include "fifoimpl.h"
#include "taskapi.h"
#include <limits.h>
#include <minmax.h>

#include "cosyprocess.h"
#include "utilbase.h"

unsigned int cosyFifo::defaultMinSize =      1; // should be 0 !
unsigned int cosyFifo::defaultMaxSize = 2*1024;
unsigned int cosyFifo::defaultBytes   =    512;

unsigned int cosyFifo::calcSize(unsigned int lo, unsigned int hi, unsigned int s)
{
  if (lo > hi) {
    rte->cerr() << "Sorry, cannot implement Fifo size" << std::endl;
    exit(1);
  }

  // choose defaultSize depending on default/token size (bytes)
  return min(max(lo, s), hi);
}

cosyFifo::cosyFifo(FifoImpl& f, cosyRte& r) :
  rteFifo(f),
  rte(&r),
  minSize(max(f.minSize(), defaultMinSize)), 
  maxSize(f.maxSize() == INT_MAX ? defaultMaxSize : f.maxSize()),
  countw(0), countr(0), wcount(0), rcount(0),
  q(calcSize(minSize,maxSize,defaultBytes/f.tokenSize()),f.tokenSize()),
  wp(0), rp(0), wn(0), rn(0), ws(0), rs(0), 
  block(false), sema(0), sel(0)
{ }

unsigned int cosyFifo::size() const
{
  return q.size();
}

unsigned int cosyFifo::data() const
{
  return q.data();
}

unsigned int cosyFifo::room() const
{
  return q.room();
}

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

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

void cosyFifo::read(void* p, unsigned int nitems)
{
#ifdef PREEMPTIVE
  lock();   // enter critical section
#endif

  rp = (char*)p;
  rn = nitems;

  if (sel) {
    if (rs <= rn) {
      sel->signal();
      sel = 0;
    } else {
      rs -= rn;
    }
  }

  while (rn) {
    if (rn <= q.data()) {
      q.get(rp, rn);
      countr += rn;
      rn = 0;
      if (block && (wn <= q.room())) {
        block = false;
        sema.signal();
      }
    } else {
      if (block) {
        unsigned int d = q.data();
        q.get(rp, d);
        countr += d;
        rp += d*api()->tokenSize();
        rn -= d;

        sema.signal();
      }

      block = true;
#ifdef PREEMPTIVE
      unlock(); // leave critical section
#endif
      sema.wait();
#ifdef PREEMPTIVE
      lock();   // enter critical section
#endif
    }
  }
  
  // statistics
  rcount++;

#ifdef PREEMPTIVE
  unlock(); // leave critical section
#endif
}

void cosyFifo::write(const void* p, unsigned int nitems)
{
#ifdef PREEMPTIVE
  lock();   // enter critical section
#endif

  wp = (char*)p;
  wn = nitems;

  if (sel) {
    if (ws <= wn) {
      sel->signal();
      sel = 0;
    } else {
      ws -= wn;
    }
  }

  while (wn) {
    if (wn <= q.room()) {
      q.put(wp, wn);
      countw += wn;
      wn = 0;
      if (block && (rn <= q.data())) {
        block = false;
        sema.signal();
      }
    } else {
      if (block) {
        unsigned int r = q.room();
        q.put(wp, r);
        countw += r;
        wp += r*api()->tokenSize();
        wn -= r;

        sema.signal();
      }

      block = true;
#ifdef PREEMPTIVE
      unlock(); // leave critical section
#endif
      sema.wait();
#ifdef PREEMPTIVE
      lock();   // enter critical section
#endif
    }
  }

  // statistics
  wcount++;

#ifdef PREEMPTIVE
  unlock(); // leave critical section
#endif
}

bool cosyFifo::grow()
{
  if (block && (0 < wn) && (q.data() + wn <= maxSize))
  {
#ifdef PREEMPTIVE
    lock();
#endif
    unsigned int sz = q.data() + wn;
    q.resize(sz);
    q.put(wp, wn);
    countw += wn;
    wn = 0;
    block = false;
    sema.signal();
#ifdef PREEMPTIVE
    unlock();
#endif
    return true;
  }
  return false;
}

const char* cosyFifo::getMetricName(FifoMetric m)
{
  switch (m) {
  case MinSize:   return "min";
  case MaxSize:   return "max";
  case Size:    return "size";
  case Data:    return "data";
  case Room:    return "room";
  case TokensWritten: return "Wtokens";
  case TokensRead:  return "Rtokens";
  case PendingWriteTokens:return "Wpend";
  case PendingReadTokens: return "Rpend";
  case NeededWriteTokens: return "Wneed";
  case NeededReadTokens:  return "Rneed";
  case WriteCalls:  return "Wcalls";
  case ReadCalls:   return "Rcalls";
  case TokensPerWrite:  return "T/W";
  case TokensPerRead: return "T/R";
  case TokenSize:   return "Tsize";
  case BytesWritten:  return "Wbytes";
  case BytesRead:   return "Rbytes";
  default:    return "unknown fifo metric";
  }
}

unsigned int cosyFifo::getMetricValue(FifoMetric m)
{
  switch (m) {
  case MinSize:   return minSize;
  case MaxSize:   return maxSize;
  case Size:    return size();
  case Data:    return data();
  case Room:    return room();
  case TokensRead:  return countr;
  case TokensWritten: return countw;
  case PendingWriteTokens:return wn;
  case PendingReadTokens: return rn;
  case NeededWriteTokens: return ws;
  case NeededReadTokens:  return rs;
  case WriteCalls:  return wcount;
  case ReadCalls:   return rcount;
  case TokensPerWrite:  return (wcount == 0) ? 0
          : countw / wcount;
  case TokensPerRead: return (rcount == 0) ? 0
          : countr / rcount;
  case TokenSize:   return api()->tokenSize();
  case BytesWritten:  return countw * api()->tokenSize();
  case BytesRead:   return countr * api()->tokenSize();
  default:    return 0;
  }
}

---