cosynetwork.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 "cosynetwork.h"
#include "cosyprocess.h"
#include "cosyfifo.h"
#include "cosyselect.h"
#include "rte.h"
#include "rteport.h"
#include "networkimpl.h"
#include "processimpl.h"
#include "portimpl.h"
#include "fifoimpl.h"
#include "portbase.h"
#include "os.h"
#include "taskapi.h"
#include "semaphoreapi.h"
#include "utilbase.h"
#include <assert.h>
#include <string>

bool  cosyNetwork::growingFifos = true;
bool  cosyNetwork::dd           = true;

cosyNetwork::cosyNetwork(NetworkImpl& n, Os& o, cosyRte& r) : 
  rteNetwork(n),
  os(o),
  task(0),
  zero1(0), zero2(0)
{ 
  rte = &r;

  // construct all fifos
  for (unsigned int i=0; i<api()->nrFifos(); ++i)
  {
    FifoImpl* f = (FifoImpl*)api()->getFifo(i);
    
    OutPortBases ops;
    getFarOutPorts(f,ops);

    InPortBases ips;
    getFarInPorts(f,ips);
    
    assert(ops.size() == 1);
    OutPortImpl* op = (OutPortImpl*)*ops.begin();
    
    std::vector<const InPortBase*>::iterator ip;
    for(ip = ips.begin(); ip != ips.end(); ++ip)
    {
      cosyFifo* fifo = new cosyFifo(*f, r); 
      cf.push_back(fifo);
      co.push_back(new rteOutPort(*op,*fifo));
      ci.push_back(new rteInPort(*((InPortImpl*)*ip),*fifo));        
    }   
  }

  // construct all subnetworks
  for (unsigned int i=0; i<api()->nrNetworks(); i++)
  {
    cn.push_back(new cosyNetwork(*(NetworkImpl*)api()->getNetwork(i),os, r));
  }

  // construct all processes
  for (unsigned int i=0; i<api()->nrProcesses(); i++)
  {
    cp.push_back(new cosyProcess(*(ProcessImpl*)api()->getProcess(i), r));
  }
}

cosyNetwork::~cosyNetwork()
{ 
  if (task)
  {
    delete task;
  }

  // delete all processes
  cosyProcesses::iterator j;
  for (j=cp.begin(); j!=cp.end(); ++j)
  {
    delete *j;
  }

  // delete all subnetworks
  cosyNetworks::iterator k;
  for (k=cn.begin(); k!=cn.end(); ++k)
  {
    delete *k;
  }

  // delete all fifos
  cosyFifos::iterator i;
  for (i=cf.begin(); i!=cf.end(); ++i)
  {
    delete *i;
  }

  // delete all output ports
  cosyOutPorts::iterator op;
  for (op=co.begin(); op!=co.end(); ++op)
  {
    delete *op;
  }

  // delete all input ports
  cosyInPorts::iterator ip;
  for (ip=ci.begin(); ip!=ci.end(); ++ip)
  {
    delete *ip;
  }
}

void cosyNetwork::run()
{
  // start all processes
  cosyProcesses::iterator j;
  for (j=cp.begin(); j!=cp.end(); ++j)
  {
    (*j)->start();
  }
  
  // start all subnetworks
  cosyNetworks::iterator k;
  for (k=cn.begin(); k!=cn.end(); ++k)
  {
    (*k)->run();
  }
}

void cosyNetwork::join()
{
  // join all processes
  cosyProcesses::iterator j;
  for (j=cp.begin(); j!=cp.end(); ++j)
  {
    (*j)->join();
  }
  
  // join all subnetworks
  cosyNetworks::iterator k;
  for (k=cn.begin(); k!=cn.end(); ++k)
  {
    (*k)->join();
  }
}

void cosyNetwork::kill()
{
  // kill all processes
  cosyProcesses::iterator j;
  for (j=cp.begin(); j!=cp.end(); ++j)
  {
    (*j)->kill();
  }
  
  // kill all subnetworks
  cosyNetworks::iterator k;
  for (k=cn.begin(); k!=cn.end(); ++k)
  {
    (*k)->kill();
  }
}

void handler1(void* arg)
{
  cosyNetwork* n = (cosyNetwork*)arg;
  if (!n->growFifo())
  {
    if (n->deadlock())
    {
      n->rte->cerr() << "YAPI > Deadlock, since all processes have blocked:" << std::endl;
    } else {
      n->rte->cerr() << "YAPI > Finished, but some processes have not terminated:" << std::endl;
    }
    if (cosyNetwork::dd) 
    {
      n->printProcessStatus();
      n->printFifoStatus();
    }
    n->os.setDeadlockHandler(fatal_func,n);
    n->task = new Task(clean_func,n);
    n->task->start();
  }
}

void handler2(void* arg)
{
  cosyNetwork* n = (cosyNetwork*)arg;
        if (!n->growFifo())
  {
    if (n->deadlock())
    {
      n->task = new Task(zero0_func,n);
      n->task->start();
    } else {
      n->os.setDeadlockHandler(fatal_func,n);
      n->task = new Task(clean_func,n);
      n->task->start();
    }
  }
}

void fatal_func(void* arg)
{
  cosyNetwork* n = (cosyNetwork*)arg;
  n->rte->cerr() << "YAPI > Fatal error occurred while simulating process network ";
  n->rte->cerr() << n->api()->fullName() << std::endl;
}

void clean_func(void* arg)
{
  cosyNetwork* n = (cosyNetwork*)arg;
  n->kill();
  n->task->exit();
}

void zero0_func(void* arg)
{
  cosyNetwork* n = (cosyNetwork*)arg;
  if (n->zero1) n->zero1->kill();
  if (n->zero2) n->zero2->kill();
  n->zero1 = new Task(zero1_func,n);
  n->zero2 = new Task(zero2_func,n);
  n->zero1->start();
  n->zero2->start();
  n->task->exit();
}

void zero1_func(void* arg)
{
  cosyNetwork* n = (cosyNetwork*)arg;
  n->zero2->join();
}

void zero2_func(void* arg)
{
  cosyNetwork* n = (cosyNetwork*)arg;
  n->zero1->join();
}

void cosyNetwork::start()
{
  // Deadlock = all processes are blocked and none has finished

  // When deadlocked run null process 
  // os.setDeadlockHandler(handler2,this);

  // When deadlocked terminate network
  os.setDeadlockHandler(handler1,this);
  
  run();
  join();
}

bool cosyNetwork::growFifo()
{
  if (!cosyNetwork::growingFifos)
    return false;

  unsigned int i;
  for (i=0; i<api()->nrFifos(); i++)
  {
    cosyFifo* f = (cosyFifo*)((FifoImpl*)api()->getFifo(i))->rte();
    if (f->grow())
      return true;
  }

  for (i=0; i<api()->nrNetworks(); i++)
  {
    cosyNetwork* n = (cosyNetwork*)((NetworkImpl*)api()->getNetwork(i))->rte();
    if (n->growFifo())
    return true;
  }
  return false;
}

bool cosyNetwork::deadlock()
{
  unsigned int i;
  for (i=0; i<api()->nrProcesses(); i++)
  {
    cosyProcess* p = (cosyProcess*)((ProcessImpl*)api()->getProcess(i))->rte();
    if (p->finished())
      return false;
  }

  for (i=0; i<api()->nrNetworks(); i++)
  {
    cosyNetwork* n = (cosyNetwork*)((NetworkImpl*)api()->getNetwork(i))->rte();
    if (!n->deadlock())
      return false;
  }
  return true;
}

void cosyNetwork::printFifoMetrics(Table& t, const FifoMetric* m, 
                                   unsigned int n, bool title)
{
  for (unsigned int i=0; i<api()->nrFifos(); i++)
  {
    FifoImpl* fifo = (FifoImpl*)api()->getFifo(i);
    for (unsigned int j=0; j<fifo->nrRteFifos(); j++)
    {
      cosyFifo* f = (cosyFifo*)fifo->rte(j);

      if ((i+j==0) && title)
      {
        t << "";
        for (unsigned int k=0; k<n; k++)
        {
          t << f->getMetricName(m[k]);
        }
      }
      if (fifo->nrRteFifos() == 1)
        t << f->api()->fullName();
      else
      { 
        char buf[32];
        sprintf(buf, "[%d]", j);
        std::string s = f->api()->fullName();
        s += buf;
        t << s.c_str();
      }
      for (unsigned int k=0; k<n; k++)
      {
        t << f->getMetricValue(m[k]);
      }
    }
  }

  for (unsigned int i=0; i<api()->nrNetworks(); i++)
  {
    cosyNetwork* s = (cosyNetwork*)((NetworkImpl*)api()->getNetwork(i))->rte();
    s->printFifoMetrics(t, m, n, false);
  }
}

void cosyNetwork::printFifoStatus()
{
  const FifoMetric wm[] = {
    MinSize, MaxSize,
    Size, Room, Data,
    TokensWritten,
    TokensRead,
    PendingWriteTokens,
    PendingReadTokens,
    NeededWriteTokens,
    NeededReadTokens
  };

  Table t(12, "Fifo Status");
  t.align(0, Table::left);
  for (unsigned int j=0; j<11; j++)
  {
    t.align(j+1, Table::right);
  }
  printFifoMetrics(t, wm, 11);

  std::ostream& stream = rte->cerr();
  t.print(stream);
}

void cosyNetwork::printCommunicationWorkload()
{
  const FifoMetric wm[] = {
    Size,
    TokenSize,
    TokensWritten,
    WriteCalls,
    TokensPerWrite,
    TokensRead,
    ReadCalls,
    TokensPerRead
  };

  api()->commWorkload->align(0, Table::left);
  for (unsigned int j=0; j<8; j++)
  {
    api()->commWorkload->align(j+1, Table::right);
  }
  printFifoMetrics(*api()->commWorkload, wm, 8);
}

void cosyNetwork::printProcessStatus(Table& t)
{
  for (unsigned int i=0; i<api()->nrFifos(); i++)
  {
    FifoImpl* fifo = (FifoImpl*)api()->getFifo(i);
    for (unsigned int j=0; j<fifo->nrRteFifos(); j++)
    {
      cosyFifo* f = (cosyFifo*)fifo->rte(j);

      std::string s = f->api()->fullName();
      if (fifo->nrRteFifos()>1)
      {
        char buf[32];
        sprintf(buf, "[%d]", j);
        s += buf;
      }
 
      // FifoStat::printProcessStatus:
      if (f->sel && f->rs) {
        t << f->api()->srcPort()->parentComponent()->fullName();
        t << "select";
        t << s.c_str();
      } else if (f->sel && f->ws) {
        t << f->getDst()->api()->parentComponent()->fullName();
        t << "select";
        t << s.c_str();
      } else if (f->block && f->wn) {
        t << f->api()->srcPort()->parentComponent()->fullName();
        t << "write";
        t << s.c_str();
      } else if (f->block && f->rn) {
        t << f->getDst()->api()->parentComponent()->fullName();
        t << "read";
        t << s.c_str();
      }
    }
  }

  for (unsigned int i=0; i<api()->nrNetworks(); i++)
  {
    cosyNetwork* n = (cosyNetwork*)((NetworkImpl*)api()->getNetwork(i))->rte();
    n->printProcessStatus(t);
  }
}

void cosyNetwork::printProcessStatus()
{
  Table t(3, "Blocked processes");
  t.align(0, Table::left);
  t.align(1, Table::left);
  t.align(2, Table::left);
  t << "Process" << "by" << "on Fifo";
  printProcessStatus(t);
  t.print(rte->cerr());
}

void cosyNetwork::printComputationWorkload(Table& t)
{
  unsigned int i;

  for (i=0; i<api()->nrProcesses(); i++)
  {
    cosyProcess* p = (cosyProcess*)((ProcessImpl*)api()->getProcess(i))->rte();

    t << p->api()->fullName() << "" << "";
    Counters::iterator i;
    for (i = p->cntr.begin(); i != p->cntr.end(); i++)
    {
      t << "" << (*i).name << (*i).count;
    }
  }

  for (i=0; i<api()->nrNetworks(); i++)
  {
    cosyNetwork* n = (cosyNetwork*)((NetworkImpl*)api()->getNetwork(i))->rte();
    n->printComputationWorkload(t);
  }

}

void cosyNetwork::printComputationWorkload()
{
  api()->compWorkload->align(0, Table::left);
  api()->compWorkload->align(1, Table::left);
  api()->compWorkload->align(2, Table::right);
  *api()->compWorkload << "Process" << "Instruction" << "Count";
  printComputationWorkload(*api()->compWorkload);
}

---