multiplexer.h

Go to the documentation of this file.

/***************************************************************************
 ** @file multiplexer.h General multiplexer
                             -------------------
    begin                : Wed December 11 2002
    copyright            : (C) 2002 by Christian Stimming
    email                : stimming@tuhh.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef MULTIPLEXER_H
#define MULTIPLEXER_H

#include "basicdevicefactory.h"
#include "basicdevice.h"
#include "phbib.h"
#include "signals.h"


namespace simthlib
{

class Multiplexer : public simth::Device
{
  protected:
    unsigned int iports;
    unsigned int oports;

    Multiplexer(int deviceID, simth::DeviceSystemIntf* system,
        const simth::PropertyList& pl,
                unsigned int _iports,
                unsigned int _oports);

  public:
    virtual void updateInputLengths();
    virtual void updateOutputLengths();

    template<class seqT>
    void process();

    void print(std::ostream &os) const;

    static void init(const std::string& fileName,
                     simth::Device** dev,
                     simth::DeviceSystemIntf* sysPtr,
                     int ID,
                     const std::string& regionQualifier);

    static void init(simth::DeviceFactory& registration);
};


template<class seqT>
class MultiplexerT : public Multiplexer
{
  public:
    MultiplexerT(int deviceID, simth::DeviceSystemIntf* system,
         const simth::PropertyList& pl,
                 unsigned int _iports,
                 unsigned int _oports,
                 typename seqT::value_type default_val =
                   typename seqT::value_type() );

    MultiplexerT(int deviceID, simth::DeviceSystemIntf* system,
         const simth::PropertyList& pl) 
      : Multiplexer (deviceID, system, pl, 
             pl.simth::PropertyList::getProperty<unsigned>("input_ports"), 
             pl.simth::PropertyList::getProperty<unsigned>("output_ports"))
      {
    insertInputInterface< seqT >(iports);
    insertOutputInterface< seqT >(oports);
      };

    void process()
    { Multiplexer::process<seqT>(); };
};




template<class seqT>
class AdaptiveMultiplexerT : public Multiplexer
{
  private:
    simth::checkedVector<unsigned int> inCycle;
    simth::checkedVector<unsigned int> outCycle;

    unsigned int elemPerInCycle;
    unsigned int elemPerOutCycle;
    unsigned int desiredTotalLength;
    unsigned int totalInputLength;
    unsigned int totalOutputLength;
    
  public:
    AdaptiveMultiplexerT(int deviceID, simth::DeviceSystemIntf* system,
             const simth::PropertyList& pl);

    
    void setInputCycle(simth::checkedVector<unsigned int> inputCycle);
    void setOutputCycle(simth::checkedVector<unsigned int> outputCycle);

    /* For the time being the following two functions are equivalent
       because the total input and output lengths are always
       identical. */
    void setTotalInputLength(unsigned int length){desiredTotalLength=length;totalInputLength=length;updateInOutLengths();};
    void setTotalOutputLength(unsigned int length){setTotalInputLength(length);};
    
    void process();
    void updateInputLengths();
    void updateOutputLengths();
    void updateInOutLengths();
    void startOfSimulation();
};


/***************************************************************************************/
/*                                 AdaptiveMultiplexerT                                */
/***************************************************************************************/
/* Implementation is here in the header file because implementation in the source file */
/* would result in undefined symbol errors.*/
//template AdaptiveMultiplexerT<BitSeq>;

template<class seqT>
AdaptiveMultiplexerT<seqT>::AdaptiveMultiplexerT(
             int deviceID, simth::DeviceSystemIntf* system,
             const simth::PropertyList& pl)
  : Multiplexer (deviceID, system, pl,
         pl.simth::PropertyList::getProperty<unsigned>("input_ports"), 
         pl.simth::PropertyList::getProperty<unsigned>("output_ports"))
{
    insertInputInterface< seqT >(iports);
    insertOutputInterface< seqT >(oports);

    inCycle.resize(iports);
    outCycle.resize(oports);

    elemPerInCycle = iports;
    elemPerOutCycle = oports;


    for(unsigned int i=0;i<iports;i++)
    {
      inCycle[i]=1;
    }
    for(unsigned int i=0;i<oports;i++)
    {
      outCycle[i]=1;
    }
}


template<class seqT>
void AdaptiveMultiplexerT<seqT>::setInputCycle(simth::checkedVector<unsigned int> inputCycle)
{
  if(inputCycle.size()!=iports)
  {
    throw std::runtime_error("AdaptiveMultiplexerT::setInputCycle(): "
                                    "Number of cycles does not match number of input ports!");
  }
  else
  {
    inCycle=inputCycle;
    elemPerInCycle=0;
    for(unsigned int i=0;i<inCycle.size();i++)
    {
      elemPerInCycle+=inCycle[i];
    }
  }
}

template<class seqT>
void AdaptiveMultiplexerT<seqT>::setOutputCycle(simth::checkedVector<unsigned int> outputCycle)
{
  if(outputCycle.size()!=oports)
  {
    throw std::runtime_error("AdaptiveMultiplexerT::setOutputCycle(): "
                                    "Number of cycles does not match number of output ports!");
  }
  else
  {
    outCycle=outputCycle;
    elemPerOutCycle=0;
    for(unsigned int i=0;i<outCycle.size();i++)
    {
      elemPerOutCycle+=outCycle[i];
    }
  }
}




template<class seqT>
void AdaptiveMultiplexerT<seqT>::process()
{
  //std::vector< seqT* > iseqs (iports);
  std::vector<unsigned> iindex(iports), oindex(oports);
  /*if(oports==1)                                                     
    std::cout<<"Start receiver multiplexer processing"<<std::endl;
  else
    std::cout<<"Start transmitter multiplexer processing"<<std::endl; */
  
  if((elemPerOutCycle%elemPerInCycle!=0)&&(elemPerInCycle%elemPerOutCycle!=0))
  {
    throw std::runtime_error("AdaptiveMultiplexerT::process(): "
                             "Incompatible input/output cycles!");
  }


  for (unsigned int i = 0; i < iports; i++)
  {
    if (!isInputInterfaceConnected (i))
      throw simth::ParameterErr("Multiplexer::process(): Input interface no. "+simth::i2string(i)+" is not connected in device "+simth::i2string(ID()));
    iindex[i]=0;
    if(!isInputSequence(i))
    {
      return;
    }
  }
  for (unsigned int i = 0; i < oports; i++)
  {
    if (!isOutputInterfaceConnected (i))
      throw simth::ParameterErr("Multiplexer::process(): "
                                 "Output interface no. "
                                 + simth::i2string(i) +
                                 " is not connected in device "
                                 +simth::i2string(ID()));
    oindex[i]=0;
  }

  std::vector< seqT* > iseqs (iports);
  std::vector< seqT* > oseqs (oports);

  for (unsigned i = 0; i < iports; i++)
  {
    iseqs[i] = getInputSequence< seqT >(i);
    if (iseqs[i]->rAttributes() != iseqs[0]->rAttributes())
      throw std::runtime_error("Multiplexer::process(): "
                               "Attributes of input ports #"
                               +simth::i2string(i)+
                               " and #0 are different in device "
                               +simth::i2string(ID()));
    //std::cout<<"input length "<<i<<": "<<iseqs[i]->size()<<std::endl;                           
  }
  for (unsigned i = 0; i < oports; i++)
  {
     oseqs[i] = getOutputSequence< seqT >(i);
     if (oseqs[i]->rAttributes() != iseqs[0]->rAttributes())
       oseqs[i]->wAttributes() = iseqs[0]->rAttributes();
     //std::cout<<"output length "<<i<<": "<<oseqs[i]->size()<<std::endl;

  }

  unsigned iLength = totalInputLength;
  unsigned oLength = totalOutputLength;

  unsigned oport = 0, onumber = 0, iport=0, inumber=0;
  unsigned inRepCount=0, outRepCount=0;
  for (unsigned n = 0; n < iLength; n++)
  {
    while((inCycle[iport]==0)&&(iport<iports))
    {
      iport++;
      if(iport==iports)
        iport=0;
    }

    while((outCycle[oport]==0)&&(oport<oports))
    {
      oport++;
      if(oport==oports)
        oport=0;
    }
/*
                  std::cout<<"oport: "<<oport<<" onumber: "<<onumber<<" iport: "<<iport<<" n: "<<n<<std::endl ;
                  std::cout<<"oseqsize: "<<oseqs[oport]->size()<<" iseqsize: "<<iseqs[iport]->size()<<std::endl ;
                  std::cout<<"outcycle: "<<outCycle[oport]<<" incycle: "<<inCycle[iport]<<std::endl ;
                  
                  std::cout<<"oindex[oport]: "<<oindex[oport]<<" iindex[iport]: "<<iindex[iport]<<std::endl ;
*/
    oseqs[oport]->operator[](oindex[oport]++) =   iseqs[iport]->operator[](iindex[iport]++);              
    //oseqs[oport]->operator[](onumber) =   iseqs[iport]->operator[](n);

    if((oindex[oport]>outputLength(oport))||(iindex[iport]>inputLength(iport)))
    {
      throw std::runtime_error("AdaptiveMultiplexerT::process(): Index exceeds sequence length! ");
    }
    
/*    if(oports==1)
      std::cout<<"Data from input "<<oport<<" written to multiplexer output "<<iport<<" ! "<<std::endl;
  */

    outRepCount++;
    inRepCount++;
    if(outRepCount==outCycle[oport])
    {
      oport++;
      outRepCount=0;
    }


    if(inRepCount==inCycle[iport])
    {
      iport++;
      inRepCount=0;
    }

    if (oport >= oports)
    {
      oport = 0;
      onumber++;

      if (onumber > oLength)
      {
        // Only compare on true greater, since
        // usually the comparison of the outer
        // for-loop will terminate just about now.
        throw std::runtime_error("AdaptiveMultiplexerT::process(): Oops, output length overflow in device "+simth::i2string(ID()));
      }
      
    }

 

    if (iport >= iports)
    {
      iport = 0;
      inumber++;
      if (inumber > iLength)
        // Only compare on true greater, since
        // usually the comparison of the outer
        // for-loop will terminate just about now.
        throw std::runtime_error("AdaptiveMultiplexerT::process(): Oops, oinput length overflow in device "+simth::i2string(ID()));
    }
  }

  flushProcessedSequences();
  if(oports==1)
    std::cout<<"."<<std::flush;
    //std::cout<<"Data written to rx multiplexer output! ("<< onumber<<"bits)"<<std::endl;
  
  //std::cout<<"Leave multiplexer processing"<<std::endl;

}



template<class seqT>
void AdaptiveMultiplexerT<seqT>::updateInOutLengths()
{
   totalInputLength=desiredTotalLength;
   totalOutputLength=totalInputLength;
   unsigned numOutputCycles=totalOutputLength/elemPerOutCycle;
   totalOutputLength=numOutputCycles* elemPerOutCycle;

   totalInputLength=totalOutputLength;
   unsigned numInputCycles=totalInputLength/elemPerInCycle;
   totalInputLength=numInputCycles* elemPerInCycle;
   totalOutputLength=totalInputLength;
     //std::cout<<"elemperincycle: "<<elemPerInCycle<<"  elemperoutcycle: "<<elemPerOutCycle<<" totalInputLength: "<<totalInputLength<<std::endl;
   
   if(totalInputLength%elemPerOutCycle)
   {
     std::cout<<"elemperincycle: "<<elemPerInCycle<<"  elemperoutcycle: "<<elemPerOutCycle<<" totalInputLength: "<<totalInputLength<<std::endl;

     throw std::runtime_error("AdaptiveMultiplexerT::updateInOutLengths(): Incompatible in/out cycles!");
   }

   numOutputCycles=totalOutputLength/elemPerOutCycle;
   totalOutputLength=numOutputCycles* elemPerOutCycle;

   //totalInputLength=totalOutputLength;

   for(unsigned int i=0;i<oports;i++)
   {
     outputInterface(i)->setSequenceLength(numOutputCycles*outCycle[i]);
     //std::cout<<"multiplexer output length: "<< numOutputCycles*outCycle[i]<<std::endl;

     //setOutputLength(numOutputCycles*outCycle[i],i);
   }
   for(unsigned int i=0;i<iports;i++)
   {
     inputInterface(i)->setSequenceLength(numInputCycles*inCycle[i]);
     //std::cout<<"multiplexer input length: "<< numInputCycles*inCycle[i]<<std::endl;

   }
}



template<class seqT>
void AdaptiveMultiplexerT<seqT>::updateOutputLengths()
{
   updateInOutLengths();

}

template<class seqT>
void AdaptiveMultiplexerT<seqT>::updateInputLengths()
{
  /* For this device, Input nd Output Lengths are jointly updated! */
  updateInOutLengths();
/*   totalInputLength=totalOutputLength;
   unsigned numInputCycles=totalInputLength/elemPerInCycle;
   totalInputLength=numInputCycles* elemPerInCycle;
   if(totalInputLength%elemPerOutCycle)
   {
     std::cout<<"elemperincycle: "<<elemPerInCycle<<"  elemperoutcycle: "<<elemPerOutCycle<<" totalInputLength: "<<totalInputLength<<std::endl;

     throw std::runtime_error("AdaptiveMultiplexerT::updateInputLengths(): Incompatible in/out cycles!");
   }
   if(totalInputLength!=totalOutputLength)
   {
     updateOutputLengths();
   }
   

   for(unsigned int i=0;i<iports;i++)
   {
     inputInterface(i)->setSequenceLength(numInputCycles*inCycle[i]);
     std::cout<<"multiplexer input length: "<< numInputCycles*inCycle[i]<<std::endl;

   }
   */
}

template<class seqT>
void AdaptiveMultiplexerT<seqT>::startOfSimulation()
{
  setTotalInputLength(getProperty<int>("input_length"));
}

} // namespace

#endif /* MULTIPLEXER_H */

---