ct_process_constructors.hpp

Go to the documentation of this file.

/**********************************************************************           
    * ct_process_constructors.hpp -- Process constructors in the CT   *
    *                                MOC                              *
    *                                                                 *
    * Author:  Hosein Attarzadeh (shan2@kth.se)                       *
    *                                                                 *
    * Purpose: Providing basic process constructors for modeling      *
    *          continuous-time systems in ForSyDe-SystemC             *
    *                                                                 *
    * Usage:   This file is included automatically                    *
    *                                                                 *
    * License: BSD3                                                   *
    *******************************************************************/

#ifndef CT_PROCESS_CONSTRUCTORS_HPP
#define CT_PROCESS_CONSTRUCTORS_HPP

#include <functional>
#include <fstream>
#include <string>

#include "sub_signal.hpp"
#include "ct_process.hpp"

namespace ForSyDe
{

namespace CT
{

using namespace sc_core;


class comb : public ct_process
{
public:
    CT_in  iport1;       
    CT_out oport1;       
    
    typedef std::function<void(CTTYPE&,const CTTYPE&)> functype;


    comb(sc_module_name _name,      
         const functype& _func      
         ) : ct_process(_name), iport1("iport1"), oport1("oport1"),
             _func(_func)
    {
#ifdef FORSYDE_INTROSPECTION
        std::string func_name = std::string(basename());
        func_name = func_name.substr(0, func_name.find_last_not_of("0123456789")+1);
        arg_vec.push_back(std::make_tuple("_func",func_name+std::string("_func")));
#endif
    }
    
    std::string forsyde_kind() const {return "CT::comb";}

private:
    // Inputs and output variables
    sub_signal oval;
    sub_signal ival1;
    
    functype _func;
    
    //Implementing the abstract semantics
    void init() {}
    
    void prep()
    {
        ival1 = iport1.read();
    }
    
    void exec()
    {
        sub_signal iv1 = ival1;
        oval = sub_signal(get_start_time(ival1), get_end_time(ival1),
                    [this,iv1](const sc_time& t)
                    {
                        CTTYPE res;
                        _func(res, iv1(t));
                        return res;
                    }
               );
    }
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, oval)
        wait(get_end_time(oval) - sc_time_stamp());
    }
    
    void clean(){}
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(1);     // only one input port
        boundInChans[0].port = &iport1;
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


class comb2 : public ct_process
{
public:
    CT_in iport1;        
    CT_in iport2;        
    CT_out oport1;        
    
    typedef std::function<void(CTTYPE&, const CTTYPE&,
                                              const CTTYPE&)> functype;


    comb2(sc_module_name _name,      
          const functype& _func      
          ) : ct_process(_name), iport1("iport1"), iport2("iport2"), oport1("oport1"),
              _func(_func)
    {
#ifdef FORSYDE_INTROSPECTION
        std::string func_name = std::string(basename());
        func_name = func_name.substr(0, func_name.find_last_not_of("0123456789")+1);
        arg_vec.push_back(std::make_tuple("_func",func_name+std::string("_func")));
#endif
    }
    
    std::string forsyde_kind() const {return "CT::comb2";}
private:    
    // Inputs and output sub-signals
    sub_signal oss;
    sub_signal iss1;
    sub_signal iss2;
    
    // the current time (local time) and the next time
    sc_time tl, tn;
    
    // clocks of the input ports (channel times)
    sc_time in1T, in2T;
    
    functype _func;

    //Implementing the abstract semantics
    void init()
    {
        in1T = in2T = tl = tn = SC_ZERO_TIME;
        set_range(iss1, SC_ZERO_TIME, SC_ZERO_TIME);
        set_range(iss2, SC_ZERO_TIME, SC_ZERO_TIME);
    }
    
    void prep()
    {
        if (in1T == tl)
        {
            iss1 = iport1.read();
            in1T = get_end_time(iss1);
        }
        if (in2T == tl)
        {
            iss2 = iport2.read();
            in2T = get_end_time(iss2);
        }
        
        // update the next local clock
        tn = std::min(in1T, in2T);
    }
    
    void exec()
    {
        sub_signal iv1 = iss1;
        sub_signal iv2 = iss2;
        oss = sub_signal(tl, tn, 
                             [iv1,iv2,this](const sc_time& t)
                             {
                                 CTTYPE res;
                                 _func(res, iv1(t), iv2(t));
                                 return res;
                             }
               );
        tl = tn;
    }
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, oss)
        wait(tl - sc_time_stamp());
    }
    
    void clean(){}
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(2);     // only one input port
        boundInChans[0].port = &iport1;
        boundInChans[1].port = &iport2;
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


template <std::size_t N>
class combX : public ct_process
{
public:
    std::array<CT_in,N> iport;  
    CT_out oport1;              
    
    typedef std::function<void(CTTYPE&, const std::array<CTTYPE,N>&)> functype;


    combX(sc_module_name _name,      
          const functype& _func      
          ) : ct_process(_name), oport1("oport1"), _func(_func)
    {
#ifdef FORSYDE_INTROSPECTION
        std::string func_name = std::string(basename());
        func_name = func_name.substr(0, func_name.find_last_not_of("0123456789")+1);
        arg_vec.push_back(std::make_tuple("_func",func_name+std::string("_func")));
#endif
    }
    
    std::string forsyde_kind() const {return "CT::combX";}
private:    
    // Inputs and output sub-signals
    sub_signal oss;
    std::array<sub_signal,N> isss;
    
    // the current time (local time) and the next time
    sc_time tl, tn;
    
    // clocks of the input ports (channel times)
    std::array<sc_time,N> insT;
    
    functype _func;

    //Implementing the abstract semantics
    void init()
    {
        tl = tn = SC_ZERO_TIME;
        std::fill(insT.begin(), insT.end(), SC_ZERO_TIME);
        for(sub_signal &iss: isss)
            set_range(iss, SC_ZERO_TIME, SC_ZERO_TIME);
    }
    
    void prep()
    {
        for (size_t i=0;i<N;i++)
            if (insT[i] == tl)
            {
                isss[i] = iport[i].read();
                insT[i] = get_end_time(isss[i]);
            }
        
        // update the next local clock
        tn = *std::min_element(insT.begin(), insT.end());
    }
    
    void exec()
    {
        std::array<sub_signal,N> temp_isss = isss;
        oss = sub_signal(tl, tn, 
                             [temp_isss,this](const sc_time& t)
                             {
                                 CTTYPE res;
                                 std::array<CTTYPE,N> ivs;
                                 for (size_t i=0;i<N;i++)
                                    ivs[i] = temp_isss[i](t);
                                 _func(res, ivs);
                                 return res;
                             }
               );
        tl = tn;
    }
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, oss)
        wait(tl - sc_time_stamp());
    }
    
    void clean(){}
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(N);     // N input ports
        for (size_t i=0;i<N;i++)
            boundInChans[i].port = &iport[i];
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


class delay : public ct_process
{
public:
    CT_in  iport1;        
    CT_out oport1;        


    delay(sc_module_name _name,     
          sc_time delay_time         
          ) : ct_process(_name), iport1("iport1"), oport1("oport1"),
              delay_time(delay_time)
    {
#ifdef FORSYDE_INTROSPECTION
        std::stringstream ss;
        ss << delay_time;
        arg_vec.push_back(std::make_tuple("delay_time", ss.str()));
#endif
    }
    
    std::string forsyde_kind() const {return "CT::delay";}
    
private:
    // Initial value
    sc_time delay_time;
    
    // Inputs and output variables
    sub_signal val;
    
    //Implementing the abstract semantics
    void init()
    {
        if (delay_time > SC_ZERO_TIME)
        {
            WRITE_MULTIPORT(oport1, 
                sub_signal(SC_ZERO_TIME, delay_time, 
                    [](const sc_time& t){return 0;}
                )
            )
            wait(delay_time);
        }
    }
    
    void prep()
    {
        val = iport1.read();
    }
    
    void exec()
    {
        set_range(val, get_start_time(val)+delay_time,
                       get_end_time(val)+delay_time);
    }
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, val)
        wait(get_end_time(val) - sc_time_stamp());
    }
    
    void clean(){}
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(1);     // only one input port
        boundInChans[0].port = &iport1;
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


class shift : public ct_process
{
public:
    CT_in  iport1;       
    CT_out oport1;       


    shift(sc_module_name _name,     
          sc_time delay_time         
          ) : ct_process(_name), iport1("iport1"), oport1("oport1"),
              delay_time(delay_time)
    {
#ifdef FORSYDE_INTROSPECTION
        std::stringstream ss;
        ss << delay_time;
        arg_vec.push_back(std::make_tuple("delay_time", ss.str()));
#endif
    }
    
    std::string forsyde_kind() const {return "CT::shift";}
    
private:
    // Initial value
    sc_time delay_time;
    
    // Inputs and output variables
    sub_signal val;
    
    //Implementing the abstract semantics
    void init()
    {
        if (delay_time > SC_ZERO_TIME)
        {
            WRITE_MULTIPORT(oport1, 
                sub_signal(SC_ZERO_TIME, delay_time, 
                    [](const sc_time& t){return 0;}
                )
            )
            wait(delay_time);
        }
    }
    
    void prep()
    {
        val = iport1.read();
    }
    
    void exec()
    {
        set_range(val, get_start_time(val)+delay_time,
                       get_end_time(val)+delay_time);
        sub_signal v = val;
        set_function(val, [v,this](const sc_time& t){
                return get_function(v)(t-delay_time);
            }
        );
    }
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, val)
        wait(get_end_time(val) - sc_time_stamp());
    }
    
    void clean() {}
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(1);     // only one input port
        boundInChans[0].port = &iport1;
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


class constant : public ct_process
{
public:
    CT_out oport1;            


    constant(sc_module_name _name,      
              CTTYPE init_val,          
              sc_time end_time           
             ) : ct_process(_name), oport1("oport1"),
                 init_val(init_val)
                 
    {
#ifdef FORSYDE_INTROSPECTION
        std::stringstream ss;
        ss << init_val;
        arg_vec.push_back(std::make_tuple("init_val", ss.str()));
        ss.str("");
        ss << end_time;
        arg_vec.push_back(std::make_tuple("end_time", ss.str()));
#endif
    }
    
    std::string forsyde_kind() const {return "CT::constant";}
    
private:
    CTTYPE init_val;
    sc_time end_time;
    
    //Implementing the abstract semantics
    void init()
    {
        auto ss = sub_signal(sc_time(0,SC_NS), end_time, 
                        [this](const sc_time& t){return init_val;}
                  );
        WRITE_MULTIPORT(oport1, ss)
        wait(get_end_time(ss) - sc_time_stamp());
    }
    
    void prep() {}
    
    void exec()
    {
        wait();
    }
    
    void prod() {}
    
    void clean() {}

#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


class source : public ct_process
{
public:
    CT_out oport1;        
    
    typedef std::function<void(CTTYPE&, const sc_time&)> functype;


    source(sc_module_name _name,   
           functype _func,         
           const sc_time& end_time 
          ) : ct_process(_name), oport1("oport1"),
              _func(_func), end_time(end_time)
    {
#ifdef FORSYDE_INTROSPECTION
        std::string func_name = std::string(basename());
        func_name = func_name.substr(0, func_name.find_last_not_of("0123456789")+1);
        arg_vec.push_back(std::make_tuple("_func",func_name+std::string("_func")));
        std::stringstream ss;
        ss << end_time;
        arg_vec.push_back(std::make_tuple("end_time", ss.str()));
#endif
    }
    
    std::string forsyde_kind() const {return "CT::source";}
    
private:
    functype _func;
    
    sc_time end_time;        // The end time    
    
    //Implementing the abstract semantics
    void init()
    {
        auto ss = sub_signal(sc_time(0,SC_NS), end_time,
                                [this](const sc_time& t)
                                {
                                    CTTYPE res=0;
                                    _func(res, t);
                                    return res;
                                }
                            );
        WRITE_MULTIPORT(oport1, ss)
        wait(get_end_time(ss) - sc_time_stamp());
    }
    
    void prep() {}
    
    void exec()
    {
        wait();
    }
    
    void prod() {}
    
    void clean(){}
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


class sink : public ct_process
{
public:
    CT_in iport1;         
    
    typedef std::function<void(const CTTYPE&)> functype;


    sink(sc_module_name _name,      
         functype _func,           
         sc_time sampling_period    
        ) : ct_process(_name), iport1("iport1"), _func(_func),
            sampling_period(sampling_period)
            
    {
#ifdef FORSYDE_INTROSPECTION
        std::string func_name = std::string(basename());
        func_name = func_name.substr(0, func_name.find_last_not_of("0123456789")+1);
        arg_vec.push_back(std::make_tuple("_func",func_name+std::string("_func")));
#endif
    }
    
    std::string forsyde_kind() const {return "CT::sink";}
    
private:
    sub_signal val;         // The current read sub_signal
    sc_time cur_time;        // The current time used for sampling

    functype _func;
    
    sc_time sampling_period;
    
    //Implementing the abstract semantics
    void init()
    {
        cur_time = sc_time(0, SC_NS);
    }
    
    void prep()
    {
        while(get_end_time(val) <= cur_time)
            val = iport1.read();
    }
    
    void exec()
    {
        _func(val(cur_time));
        cur_time+=sampling_period;
    }
    
    void prod() {}
    
    void clean(){}
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(1);    // only one output port
        boundInChans[0].port = &iport1;
    }
#endif
};


class traceSig : public ct_process
{
public:
    CT_in  iport1;       


    traceSig(sc_module_name _name,          
             const sc_time& sample_period   
             ) : ct_process(_name), iport1("iport1"),
                 sample_period(sample_period)
    {
#ifdef FORSYDE_INTROSPECTION
        std::stringstream ss;
        ss << sample_period;
        arg_vec.push_back(std::make_tuple("sample_period", ss.str()));
#endif        
    }
    
    std::string forsyde_kind() const {return "CT::traceSig";}

private:
    sc_time sample_period;
    
    // The internal variables
    std::ofstream outFile;
    sub_signal in_val;
    sc_time curTime;
    
    //Implementing the abstract semantics
    void init()
    {
        outFile.open(name()+std::string(".dat"));
        if (!outFile.is_open())
            SC_REPORT_ERROR(name(),"file could not be opened");
        outFile << "#time " << name() << std::endl;
        in_val = iport1.read();
        curTime = get_start_time(in_val);
    }
    
    void prep()
    {
        while (curTime >= get_end_time(in_val)) in_val = iport1.read();
    }
    
    void exec() {}
    
    void prod()
    {
        outFile << curTime.to_seconds() << " " << in_val(curTime)
                << std::endl;
        curTime += sample_period;
    }
    
    void clean()
    {
        if (outFile.is_open()) outFile.close();
    }
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(1);     // only one input port
        boundInChans[0].port = &iport1;
    }
#endif
};


class fanout : public ct_process
{
public:
    CT_in iport1;        
    CT_out oport1;       


    fanout(sc_module_name _name)  // module name
         : ct_process(_name) { }
    
    std::string forsyde_kind() const {return "CT::fanout";}
    
private:
    // Inputs and output variables
    sub_signal* val;
    
    //Implementing the abstract semantics
    void init()
    {
        val = new sub_signal;
    }
    
    void prep()
    {
        *val = iport1.read();
    }
    
    void exec() {}
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, *val)
        wait(get_end_time(*val) - sc_time_stamp());
    }
    
    void clean()
    {
        delete val;
    }
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(1);     // only one input port
        boundInChans[0].port = &iport1;
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};

}
}

#endif