sy_process_constructors_strict.hpp

Go to the documentation of this file.

/**********************************************************************           
    * sy_process_constructors_strict.hpp -- Strict process            *
    *                                       constructors in the SY MOC*
    *                                                                 *
    * Author:  Hosein Attarzadeh (shan2@kth.se)                       *
    *                                                                 *
    * Purpose: Providing basic process constructors for modeling      *
    *          strict synchronous systems in ForSyDe-SystemC          *
    *                                                                 *
    * Usage:   This file is included automatically                    *
    *                                                                 *
    * License: BSD3                                                   *
    *******************************************************************/

#ifndef SY_PROCESS_CONSTRUCTORS_STRICT_HPP
#define SY_PROCESS_CONSTRUCTORS_STRICT_HPP

#include <functional>
#include <tuple>
#include <array>
#include <algorithm>

#include "abst_ext.hpp"
#include "sy_process.hpp"

namespace ForSyDe
{

namespace SY
{

using namespace sc_core;


template <typename T0, typename T1>
class scomb : public sy_process
{
public:
    SY_in<T1>  iport1;       
    SY_out<T0> oport1;        
    
    typedef std::function<void(T0&,const T1&)> functype;


    scomb(const sc_module_name& _name,      
         const functype& _func             
         ) : sy_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 "SY::scomb";}

private:
    // Inputs and output variables
    T0* oval;
    T1* ival1;
    
    functype _func;
    
    //Implementing the abstract semantics
    void init()
    {
        oval = new T0;
        ival1 = new T1;
    }
    
    void prep()
    {
        auto ival1_temp = iport1.read();
        CHECK_PRESENCE(ival1_temp);
        *ival1 = unsafe_from_abst_ext(ival1_temp);
    }
    
    void exec()
    {
        _func(*oval, *ival1);
    }
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, abst_ext<T0>(*oval))
    }
    
    void clean()
    {
        delete ival1;
        delete oval;
    }
    
#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
};


template <typename T0, typename T1, typename T2>
class scomb2 : public sy_process
{
public:
    SY_in<T1> iport1;        
    SY_in<T2> iport2;        
    SY_out<T0> oport1;        
    
    typedef std::function<void(T0&, const T1&, const T2&)> functype;


    scomb2(const sc_module_name& _name,      
           const functype& _func             
          ) : sy_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 "SY::scomb2";}
private:
    // Inputs and output variables
    T0* oval;
    T1* ival1;
    T2* ival2;
    
    functype _func;

    //Implementing the abstract semantics
    void init()
    {
        oval = new T0;
        ival1 = new T1;
        ival2 = new T2;
    }
    
    void prep()
    {
        auto ival1_temp = iport1.read();
        auto ival2_temp = iport2.read();
        CHECK_PRESENCE(ival1_temp);
        CHECK_PRESENCE(ival2_temp);
        *ival1 = unsafe_from_abst_ext(ival1_temp);
        *ival2 = unsafe_from_abst_ext(ival2_temp);
    }
    
    void exec()
    {
        _func(*oval, *ival1, *ival2);
    }
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, abst_ext<T0>(*oval))
    }
    
    void clean()
    {
        delete ival2;
        delete ival1;
        delete oval;
    }
    
#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 <typename T0, typename T1, typename T2, typename T3>
class scomb3 : public sy_process
{
public:
    SY_in<T1> iport1;        
    SY_in<T2> iport2;        
    SY_in<T3> iport3;        
    SY_out<T0> oport1;        
    
    typedef std::function<void(T0&, const T1&, const T2&, 
                                    const T3&)> functype;


    scomb3(const sc_module_name& _name,      
           const functype& _func             
          ) : sy_process(_name), iport1("iport1"), iport2("iport2"), iport3("iport3"), 
              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 "SY::scomb3";}
    
private:
    // Inputs and output variables
    T0* oval;
    T1* ival1;
    T2* ival2;
    T3* ival3;

    functype _func;
    
    //Implementing the abstract semantics
    void init()
    {
        oval = new T0;
        ival1 = new T1;
        ival2 = new T2;
        ival3 = new T3;
    }
    
    void prep()
    {
        auto ival1_temp = iport1.read();
        auto ival2_temp = iport2.read();
        auto ival3_temp = iport3.read();
        CHECK_PRESENCE(ival1_temp);
        CHECK_PRESENCE(ival2_temp);
        CHECK_PRESENCE(ival3_temp);
        *ival1 = unsafe_from_abst_ext(ival1_temp);
        *ival2 = unsafe_from_abst_ext(ival2_temp);
        *ival3 = unsafe_from_abst_ext(ival3_temp);
    }
    
    void exec()
    {
        _func(*oval, *ival1, *ival2, *ival3);
    }
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, abst_ext<T0>(*oval))
    }
    
    void clean()
    {
        delete ival3;
        delete ival2;
        delete ival1;
        delete oval;
    }
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(3);     // only one input port
        boundInChans[0].port = &iport1;
        boundInChans[1].port = &iport2;
        boundInChans[2].port = &iport3;
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


template <typename T0, typename T1, typename T2, typename T3, typename T4>
class scomb4 : public sy_process
{
public:
    SY_in<T1> iport1;       
    SY_in<T2> iport2;       
    SY_in<T3> iport3;       
    SY_in<T4> iport4;       
    SY_out<T0> oport1;        
    
    typedef std::function<void(T0&, const T1&, const T2&,
                                    const T3&, const T4&)> functype;


    scomb4(const sc_module_name& _name,      
           const functype& _func             
          ) : sy_process(_name), iport1("iport1"), iport2("iport2"), 
              iport3("iport3"), iport4("iport4"), _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 "SY::scomb4";}
    
private:
    // Inputs and output variables
    T0* oval;
    T1* ival1;
    T2* ival2;
    T3* ival3;
    T4* ival4;
    
    functype _func;

    //Implementing the abstract semantics
    void init()
    {
        oval = new T0;
        ival1 = new T1;
        ival2 = new T2;
        ival3 = new T3;
        ival4 = new T4;
    }
    
    void prep()
    {
        auto ival1_temp = iport1.read();
        auto ival2_temp = iport2.read();
        auto ival3_temp = iport3.read();
        auto ival4_temp = iport4.read();
        CHECK_PRESENCE(ival1_temp);
        CHECK_PRESENCE(ival2_temp);
        CHECK_PRESENCE(ival3_temp);
        CHECK_PRESENCE(ival4_temp);
        *ival1 = unsafe_from_abst_ext(ival1_temp);
        *ival2 = unsafe_from_abst_ext(ival2_temp);
        *ival3 = unsafe_from_abst_ext(ival3_temp);
        *ival4 = unsafe_from_abst_ext(ival4_temp);
    }
    
    void exec()
    {
        _func(*oval, *ival1, *ival2, *ival3, *ival4);
    }
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, abst_ext<T0>(*oval))
    }
    
    void clean()
    {
        delete ival4;
        delete ival3;
        delete ival2;
        delete ival1;
        delete oval;
    }
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(4);     // only one input port
        boundInChans[0].port = &iport1;
        boundInChans[1].port = &iport2;
        boundInChans[2].port = &iport3;
        boundInChans[3].port = &iport4;
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


template <typename T0, typename T1, std::size_t N>
class scombX : public sy_process
{
public:
    std::array<SY_in<T1>,N> iport;       
    SY_out<T0> oport1;        

    typedef std::function<void(T0&, const std::array<T1,N>&)> functype;


    scombX(const sc_module_name& _name,      
           const functype& _func             
          ) : sy_process(_name), _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 "SY::scombX";}

private:
    // Inputs and output variables
    T0* oval;
    std::array<T1,N> ival;

    functype _func;

    //Implementing the abstract semantics
    void init()
    {
        oval = new T0;
    }

    void prep()
    {
        for (size_t i=0; i<N; i++)
        {
            auto ival_temp = iport.read();
            CHECK_PRESENCE(ival_temp);
            ival[i] = unsafe_from_abst_ext(ival_temp);
        }
    }

    void exec()
    {
        _func(*oval, ival);
    }

    void prod()
    {
        WRITE_MULTIPORT(oport1, abst_ext<T0>(*oval))
    }

    void clean()
    {
        delete oval;
    }

#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(N);     // only one input port
        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
};


template <typename T0, typename T1, std::size_t N>
class sdpmap : public sy_process
{
public:
    SY_in<std::array<T1,N>> iport1;       
    SY_out<std::array<T0,N>> oport1;        

    typedef std::function<void(T0&, const T1&)> functype;


    sdpmap(const sc_module_name& _name,    
           const functype& _func            
          ) : sy_process(_name), _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 "SY::sdpmap";}

private:
    // Inputs and output variables
    std::array<T0,N> oval;
    std::array<T1,N> ival;

    functype _func;

    //Implementing the abstract semantics
    void init() {}

    void prep()
    {
        auto ival_temp = iport1.read();
        CHECK_PRESENCE(ival_temp);
        ival = unsafe_from_abst_ext(ival_temp);
    }

    void exec()
    {
        #ifdef FORSYDE_OPENMP
        #pragma omp parallel for
        #endif
        for (size_t i=0; i<N; i++)
        {
            _func(oval[i], ival[i]);
        }
    }

    void prod()
    {
        auto tempval = abst_ext<std::array<T0,N>>(oval);
        WRITE_MULTIPORT(oport1, tempval)
    }

    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
};


template <typename T0, std::size_t N>
class sdpreduce : public sy_process
{
public:
    SY_in<std::array<T0,N>> iport1;     
    SY_out<T0> oport1;                  

    typedef std::function<void(T0&, const T0&, const T0&)> functype;


    sdpreduce(const sc_module_name& _name,      
           const functype& _func             
          ) : sy_process(_name), _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 "SY::sdpreduce";}

private:
    // Inputs and output variables
    T0* oval;
    std::array<T0,N> ival;

    functype _func;

    //Implementing the abstract semantics
    void init()
    {
        oval = new T0;
    }

    void prep()
    {
        auto ival1_temp = iport1.read();
        CHECK_PRESENCE(ival1_temp);
        ival = unsafe_from_abst_ext(ival1_temp);
    }

    void exec()
    {
        T0 res = T0();
        #ifdef FORSYDE_OPENMP  // this can be enhanced with the new delare reduction clause in OpenMP 4.0
        
        #pragma omp parallel shared(res) // Create omp threads
        {
            T0 val = T0();  // val can be declared as local variable (for each thread) 
            #pragma omp for nowait
            for (int i = 0; i < N; ++i)
            {
                _func(val, val, ival[i]);
            }
            #pragma omp critical
            {
                _func(res, res, val);
            }
        }
        
        #else
        
        res = ival[0];
        for (size_t i=1;i<N;i++)
            _func(res, res, ival[i]);
        
        #endif
        *oval = res;
    }

    void prod()
    {
        WRITE_MULTIPORT(oport1, abst_ext<T0>(*oval))
    }

    void clean()
    {
        delete oval;
    }

#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
};


template <typename T0, typename T1, std::size_t N>
class sdpscan : public sy_process
{
public:
    SY_in<std::array<T1,N>> iport1;       
    SY_out<std::array<T0,N>> oport1;        

    typedef std::function<void(T0&, const T0&, const T1&)> functype;


    sdpscan(const sc_module_name& _name,      
           const functype& _func,             
           const T0& init_res                 
          ) : sy_process(_name), _func(_func), init_res(init_res)
    {
#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 << init_res;
        arg_vec.push_back(std::make_tuple("init_res",ss.str()));
#endif
    }

    std::string forsyde_kind() const{return "SY::sdpscan";}

private:
    // Inputs and output variables
    std::array<T0,N> oval;
    std::array<T0,N> ival;

    functype _func;
    
    T0 init_res;

    //Implementing the abstract semantics
    void init() {}

    void prep()
    {
        auto ival1_temp = iport1.read();
        CHECK_PRESENCE(ival1_temp);
        ival = unsafe_from_abst_ext(ival1_temp);
    }

    void exec()
    {
        _func(oval[0], init_res, ival[0]);
        for (size_t i=1;i<N;i++)
            _func(oval[i], oval[i-1], ival[i]);
    }

    void prod()
    {
        auto tempval = abst_ext<std::array<T0,N>>(oval);
        WRITE_MULTIPORT(oport1, tempval)
    }

    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
};


template <class T>
class sdelay : public sy_process
{
public:
    SY_in<T>  iport1;       
    SY_out<T> oport1;        


    sdelay(const sc_module_name& _name,  
           const T& init_val            
          ) : sy_process(_name), iport1("iport1"), 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()));
#endif
    }
    
    std::string forsyde_kind() const {return "SY::sdelay";}
    
private:
    // Initial value
    T init_val;
    
    // Inputs and output variables
    T* val;
    
    //Implementing the abstract semantics
    void init()
    {
        val = new T;
        WRITE_MULTIPORT(oport1, abst_ext<T>(init_val))
    }
    
    void prep()
    {
        auto ival1_temp = iport1.read();
        CHECK_PRESENCE(ival1_temp);
        *val = unsafe_from_abst_ext(ival1_temp);
    }
    
    void exec() {}
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, abst_ext<T>(*val))
    }
    
    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
};


template <class T>
class sdelayn : public sy_process
{
public:
    SY_in<T>  iport1;       
    SY_out<T> oport1;        


    sdelayn(const sc_module_name& _name,    
            const T& init_val,              
            const unsigned int& n           
          ) : sy_process(_name), iport1("iport1"), oport1("oport1"),
              init_val(init_val), ns(n)
    {
#ifdef FORSYDE_INTROSPECTION
        std::stringstream ss;
        ss << init_val;
        arg_vec.push_back(std::make_tuple("init_val", ss.str()));
        ss.str("");
        ss << n;
        arg_vec.push_back(std::make_tuple("n", ss.str()));
#endif
    }
    
    std::string forsyde_kind() const {return "SY::sdelayn";}
    
private:
    // Initial value
    T init_val;
    unsigned int ns;
    
    // Inputs and output variables
    T* val;
    
    //Implementing the abstract semantics
    void init()
    {
        val = new T;
        for (int i=0; i<ns; i++)
            WRITE_MULTIPORT(oport1, abst_ext<T>(init_val))
    }
    
    void prep()
    {
        auto ival1_temp = iport1.read();
        CHECK_PRESENCE(ival1_temp);
        *val = unsafe_from_abst_ext(ival1_temp);
    }
    
    void exec() {}
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, abst_ext<T>(*val))
    }
    
    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
};


template <class IT, class ST, class OT>
class smoore : public sy_process
{
public:
    SY_in<IT>  iport1;        
    SY_out<OT> oport1;        
    
    typedef std::function<void(ST&, const ST&, const IT&)> ns_functype;
    
    typedef std::function<void(OT&, const ST&)> od_functype;


    smoore(const sc_module_name& _name,      
           const ns_functype& _ns_func, 
           const od_functype& _od_func, 
           const ST& init_st  
          ) : sy_process(_name), _ns_func(_ns_func), _od_func(_od_func),
              init_st(init_st)
    {
#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("_ns_func",func_name+std::string("_ns_func")));
        arg_vec.push_back(std::make_tuple("_od_func",func_name+std::string("_od_func")));
        std::stringstream ss;
        ss << init_st;
        arg_vec.push_back(std::make_tuple("init_st",ss.str()));
#endif
    }
    
    std::string forsyde_kind() const{return "SY::smoore";}
    
private:
    ns_functype _ns_func;
    od_functype _od_func;
    // Initial value
    ST init_st;
    
    bool first_run;
    
    // Input, output, current state, and next state variables
    IT* ival;
    ST* stval;
    ST* nsval;
    OT* oval;

    //Implementing the abstract semantics
    void init()
    {
        ival = new IT;
        stval = new ST;
        *stval = init_st;
        nsval = new ST;
        oval = new OT;
        // First evaluation cycle
        first_run = true;
    }
    
    void prep()
    {
        if (!first_run)
        {
            auto ival_temp = iport1.read();
            CHECK_PRESENCE(ival_temp);
            *ival = unsafe_from_abst_ext(ival_temp);
        }
    }
    
    void exec()
    {
        if (first_run)
            first_run = false;
        else
        {
            _ns_func(*nsval, *stval, *ival);
            *stval = *nsval;
        }
        _od_func(*oval, *stval);
    }
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, abst_ext<OT>(*oval))
    }
    
    void clean()
    {
        delete ival;
        delete stval;
        delete nsval;
        delete oval;
    }
#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
};


template <class IT, class ST, class OT>
class smealy : public sy_process
{
public:
    SY_in<IT>  iport1;        
    SY_out<OT> oport1;        
    
    typedef std::function<void(ST&, const ST&, const IT&)> ns_functype;
    
    typedef std::function<void(OT&, const ST&, const IT&)> od_functype;
    

    smealy(const sc_module_name& _name,      
           const ns_functype& _ns_func, 
           const od_functype& _od_func, 
           const ST& init_st  
          ) : sy_process(_name), _ns_func(_ns_func), _od_func(_od_func),
              init_st(init_st)
    {
#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("_ns_func",func_name+std::string("_ns_func")));
        arg_vec.push_back(std::make_tuple("_od_func",func_name+std::string("_od_func")));
        std::stringstream ss;
        ss << init_st;
        arg_vec.push_back(std::make_tuple("init_st",ss.str()));
#endif
    }
    
    std::string forsyde_kind() const{return "SY::smealy";}
    
private:
    ns_functype _ns_func;
    od_functype _od_func;
    // Initial value
    ST init_st;
    
    // Input, output, current state, and next state variables
    IT* ival;
    ST* stval;
    ST* nsval;
    OT* oval;

    //Implementing the abstract semantics
    void init()
    {
        ival = new IT;
        stval = new ST;
        *stval = init_st;
        nsval = new ST;
        oval = new OT;
    }
    
    void prep()
    {
        auto ival_temp = iport1.read();
        CHECK_PRESENCE(ival_temp);
        *ival = unsafe_from_abst_ext(ival_temp);
    }
    
    void exec()
    {
        _ns_func(*nsval, *stval, *ival);
        _od_func(*oval, *stval, *ival);
        *stval = *nsval;
    }
    
    void prod()
    {
        WRITE_MULTIPORT(oport1, abst_ext<OT>(*oval))
    }
    
    void clean()
    {
        delete ival;
        delete stval;
        delete nsval;
        delete oval;
    }
#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
};


template <class T>
class sconstant : public sy_process
{
public:
    SY_out<T> oport1;            


    sconstant(const sc_module_name& _name,      
              const T& init_val,                
              const unsigned long long& take=0  
             ) : sy_process(_name), oport1("oport1"),
                 init_val(init_val), take(take)
                 
    {
#ifdef FORSYDE_INTROSPECTION
        std::stringstream ss;
        ss << init_val;
        arg_vec.push_back(std::make_tuple("init_val", ss.str()));
        ss.str("");
        ss << take;
        arg_vec.push_back(std::make_tuple("take", ss.str()));
#endif
    }
    
    std::string forsyde_kind() const {return "SY::sconstant";}
    
private:
    T init_val;
    unsigned long long take;    // Number of tokens produced
    
    unsigned long long tok_cnt;
    bool infinite;
    
    //Implementing the abstract semantics
    void init()
    {
        infinite = take==0 ? true : false;
        tok_cnt = 0;
    }
    
    void prep() {}
    
    void exec() {}
    
    void prod()
    {
        if (tok_cnt++ < take || infinite)
            WRITE_MULTIPORT(oport1, abst_ext<T>(init_val))
        else wait();
    }
    
    void clean() {}

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


template <class T>
class ssource : public sy_process
{
public:
    SY_out<T> oport1;        
    
    typedef std::function<void(T&, const T&)> functype;


    ssource(const sc_module_name& _name,    
            const functype& _func,          
            const T& init_val,              
            const unsigned long long& take=0
          ) : sy_process(_name), oport1("oport1"),
              init_st(init_val), take(take), _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")));
        std::stringstream ss;
        ss << init_val;
        arg_vec.push_back(std::make_tuple("init_val", ss.str()));
        ss.str("");
        ss << take;
        arg_vec.push_back(std::make_tuple("take", ss.str()));
#endif
    }
    
    std::string forsyde_kind() const {return "SY::ssource";}
    
private:
    T init_st;        // The current state
    unsigned long long take;    // Number of tokens produced
    
    T* cur_st;        // The current state of the process
    unsigned long long tok_cnt;
    bool infinite;
    
    functype _func;
    
    //Implementing the abstract semantics
    void init()
    {
        cur_st = new T;
        *cur_st = init_st;
        WRITE_MULTIPORT(oport1, abst_ext<T>(*cur_st))
        infinite = take==0 ? true : false;
        tok_cnt = 1;
    }
    
    void prep() {}
    
    void exec()
    {
        _func(*cur_st, *cur_st);
    }
    
    void prod()
    {
        if (tok_cnt++ < take || infinite)
            WRITE_MULTIPORT(oport1, abst_ext<T>(*cur_st))
        else wait();
    }
    
    void clean()
    {
        delete cur_st;
    }
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


template <class T>
class svsource : public sy_process
{
public:
    SY_out<T> oport1;     


    svsource(const sc_module_name& _name,   
            const std::vector<T>& in_vec    
            ) : sy_process(_name), in_vec(in_vec)
    {
#ifdef FORSYDE_INTROSPECTION
        std::stringstream ss;
        ss << in_vec;
        arg_vec.push_back(std::make_tuple("in_vec", ss.str()));
#endif
    }
    
    std::string forsyde_kind() const {return "SY::svsource";}
    
private:
    std::vector<T> in_vec;
    
    unsigned long tok_cnt;

    //Implementing the abstract semantics
    void init()
    {
        tok_cnt = 0;
    }
    
    void prep() {}
    
    void exec() {}
    
    void prod()
    {
        if (tok_cnt < in_vec.size())
        {
            WRITE_MULTIPORT(oport1, abst_ext<T>(in_vec[tok_cnt]))
            tok_cnt++;
        }
        else
            wait();
    }
    
    void clean() {}
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


template <class T>
class ssink : public sy_process
{
public:
    SY_in<T> iport1;         
    
    typedef std::function<void(const T&)> functype;


    ssink(const sc_module_name& _name,      
          const functype& _func             
        ) : sy_process(_name), iport1("iport1"), _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 "SY::ssink";}
    
private:
    T* val;         // The current state of the process

    functype _func;
    
    //Implementing the abstract semantics
    void init()
    {
        val = new T;
    }
    
    void prep()
    {
        auto val_temp = iport1.read();
        CHECK_PRESENCE(val_temp);
        *val = unsafe_from_abst_ext(val_temp);
    }
    
    void exec()
    {
        _func(*val);
    }
    
    void prod() {}
    
    void clean()
    {
        delete val;
    }
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(1);    // only one output port
        boundInChans[0].port = &iport1;
    }
#endif
};


template <class T1, class T2>
class szip : public sy_process
{
public:
    SY_in<T1> iport1;        
    SY_in<T2> iport2;        
    SY_out<std::tuple<T1,T2>> oport1;


    szip(const sc_module_name& _name      
        )
         :sy_process(_name), iport1("iport1"), iport2("iport2"), oport1("oport1")
    { }
    
    std::string forsyde_kind() const {return "SY::szip";}
    
private:
    // intermediate values
    T1* ival1;
    T2* ival2;
    
    void init()
    {
        ival1 = new T1;
        ival2 = new T2;
    }
    
    void prep()
    {
        auto ival1_temp = iport1.read();
        auto ival2_temp = iport2.read();
        CHECK_PRESENCE(ival1_temp);
        CHECK_PRESENCE(ival2_temp);
        *ival1 = unsafe_from_abst_ext(ival1_temp);
        *ival2 = unsafe_from_abst_ext(ival2_temp);
    }
    
    void exec() {}
    
    void prod()
    {
        auto outval = abst_ext<std::tuple<T1,T2>>(std::make_tuple(*ival1,*ival2));
        WRITE_MULTIPORT(oport1, outval)  // write to the output
    }
    
    void clean()
    {
        delete ival1;
        delete ival2;
    }
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(2);     // two input ports
        boundInChans[0].port = &iport1;
        boundInChans[1].port = &iport2;
        boundOutChans.resize(1);    // only one output port
        boundOutChans[0].port = &oport1;
    }
#endif
};


template <class T1, std::size_t N>
class szipX : public sy_process
{
public:
    std::array<SY_in<T1>,N> iport;      
    SY_out<std::array<T1,N>> oport1;    


    szipX(const sc_module_name& _name      
        )
         :sy_process(_name), oport1("oport1")
    { }
    
    std::string forsyde_kind() const {return "SY::szipX";}
    
private:
    // intermediate values
    std::array<T1,N> ival;
    
    void init() {}
    
    void prep()
    {
        for (size_t i=0; i<N; i++)
        {
            auto ival_temp = iport[i].read();
            CHECK_PRESENCE(ival_temp);
            ival[i] = unsafe_from_abst_ext(ival_temp);
        }
    }
    
    void exec() {}
    
    void prod()
    {
        auto oval = abst_ext<std::array<T1,N>>(ival);
        WRITE_MULTIPORT(oport1,oval)  // write to the output
    }
    
    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
};


template <class... Ts>
class szipN : public sy_process
{
public:
    std::tuple<SY_in<Ts>...> iport;
    SY_out<std::tuple<Ts...> > oport1;


    szipN(const sc_module_name& _name      
         )
         : sy_process(_name), oport1("oport1")
    { }
    
    std::string forsyde_kind() const {return "SY::szipN";}
private:
    // intermediate values
    std::tuple<Ts...>* in_vals;
    
    void init()
    {
        in_vals = new std::tuple<Ts...>;
    }
    
    void prep()
    {
        *in_vals = sc_fifo_tuple_read<Ts...>(iport);
    }
    
    void exec() {}
    
    void prod()
    {
        WRITE_MULTIPORT(oport1,abst_ext<std::tuple<Ts...>>(*in_vals))    // write to the output
    }
    
    void clean()
    {
        delete in_vals;
    }
    
    template<size_t N,class R,  class T>
    struct fifo_read_helper
    {
        static void read(R& ret, T& t)
        {
            fifo_read_helper<N-1,R,T>::read(ret,t);
            std::get<N>(ret) = std::get<N>(t).read();
        }
    };

    template<class R, class T>
    struct fifo_read_helper<0,R,T>
    {
        static void read(R& ret, T& t)
        {
            auto ival_temp = std::get<0>(t).read();
            //~ CHECK_PRESENCE(ival_temp);
            if (is_absent(ival_temp)) SC_REPORT_ERROR("szipN","Unexpected absent value received in");
            std::get<0>(ret) = unsafe_from_abst_ext(ival_temp);
        }
    };

    template<class... T>
    std::tuple<T...> sc_fifo_tuple_read(std::tuple<SY_in<T>...>& ports)
    {
        std::tuple<T...> ret;
        fifo_read_helper<sizeof...(T)-1,
                         std::tuple<T...>,
                         std::tuple<SY_in<T>...>>::read(ret,ports);
        return ret;
    }

};


template <class T1, class T2>
class sunzip : public sy_process
{
public:
    SY_in<std::tuple<T1,T2>> iport1;
    SY_out<T1> oport1;        
    SY_out<T2> oport2;        


    sunzip(const sc_module_name& _name      
          )
         :sy_process(_name), iport1("iport1"), oport1("oport1"), oport2("oport2")
    {}
    
    std::string forsyde_kind() const {return "SY::sunzip";}
private:
    // intermediate values
    abst_ext<std::tuple<T1,T2>>* in_val;
    
    void init()
    {
        in_val = new abst_ext<std::tuple<T1,T2>>;
    }
    
    void prep()
    {
        *in_val = iport1.read();
        CHECK_PRESENCE(*in_val);
    }
    
    void exec() {}
    
    void prod()
    {
        WRITE_MULTIPORT(oport1,abst_ext<T1>(std::get<0>(*in_val)))  // write to the output 1
        WRITE_MULTIPORT(oport2,abst_ext<T2>(std::get<1>(*in_val)))  // write to the output 2
    }
    
    void clean()
    {
        delete in_val;
    }
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(1);     // only one input port
        boundInChans[0].port = &iport1;
        boundOutChans.resize(2);    // two output ports
        boundOutChans[0].port = &oport1;
        boundOutChans[1].port = &oport2;
    }
#endif
};


template <class T1, std::size_t N>
class sunzipX : public sy_process
{
public:
    SY_in<std::array<T1,N>> iport1;
    std::array<SY_out<T1>,N> oport;


    sunzipX(const sc_module_name& _name      
          )
         :sy_process(_name), iport1("iport1")
    {}
    
    std::string forsyde_kind() const {return "SY::sunzipX";}
private:
    // intermediate values
    abst_ext<std::array<T1,N>>* in_val;
    
    void init()
    {
        in_val = new abst_ext<std::array<T1,N>>;
    }
    
    void prep()
    {
        *in_val = iport1.read();
        CHECK_PRESENCE(*in_val);
    }
    
    void exec() {}
    
    void prod()
    {
        for (size_t i=0; i<N; i++)
            WRITE_MULTIPORT(oport[i],abst_ext<T1>(in_val->unsafe_from_abst_ext()[i]))  // write to the output i
    }
    
    void clean()
    {
        delete in_val;
    }
    
#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(1);     // only one input port
        boundInChans[0].port = &iport1;
        boundOutChans.resize(N);    // output ports
        for (size_t i=0;i<N;i++)
            boundOutChans[i].port = &oport[i];
    }
#endif
};


template <class... Ts>
class sunzipN : public sy_process
{
public:
    SY_in<std::tuple<Ts...>> iport1;
    std::tuple<SY_out<Ts>...> oport;


    sunzipN(const sc_module_name& _name      
           )
          :sy_process(_name), iport1("iport1")
    { }
    
    std::string forsyde_kind() const {return "SY::sunzipN";}
private:
    // intermediate values
    abst_ext<std::tuple<Ts...>>* in_val;
    
    void init()
    {
        in_val = new abst_ext<std::tuple<Ts...>>;
    }
    
    void prep()
    {
        *in_val = iport1.read();
        CHECK_PRESENCE(*in_val);
    }
    
    void exec() {}
    
    void prod()
    {
        fifo_tuple_write<Ts...>(in_val->unsafe_from_abst_ext(), oport);
    }
    
    void clean()
    {
        delete in_val;
    }
    
    template<size_t N,class R,  class T>
    struct fifo_write_helper
    {
        static void write(const R& vals, T& t)
        {
            fifo_write_helper<N-1,R,T>::write(vals,t);
            std::get<N>(t).write(std::get<N>(vals));
        }
    };

    template<class R, class T>
    struct fifo_write_helper<0,R,T>
    {
        static void write(const R& vals, T& t)
        {
            std::get<0>(t).write(std::get<0>(vals));
        }
    };

    template<class... T>
    void fifo_tuple_write(const std::tuple<T...>& vals,
                             std::tuple<SY_out<T>...>& ports)
    {
        fifo_write_helper<sizeof...(T)-1,
                          std::tuple<T...>,
                          std::tuple<SY_out<T>...>>::write(vals,ports);
    }

#ifdef FORSYDE_INTROSPECTION
    void bindInfo()
    {
        boundInChans.resize(1);     // only one input port
        boundInChans[0].port = &iport1;
        boundOutChans.resize(sizeof...(Ts));    // two output ports
        register_ports(boundOutChans, oport);
    }
    
    template<size_t N, class T>
    struct register_ports_helper
    {
        static void reg_port(std::vector<PortInfo>& boundChans, T& t)
        {
            register_ports_helper<N-1,T>::reg_port(boundChans,t);
            boundChans[N].port = &std::get<N>(t);
        }
    };

    template<class T>
    struct register_ports_helper<0,T>
    {
        static void reg_port(std::vector<PortInfo>& boundChans, T& t)
        {
            boundChans[0].port = &std::get<0>(t);
        }
    };

    template<class... T>
    void register_ports(std::vector<PortInfo>& boundChans,
                             std::tuple<SY_out<T>...>& ports)
    {
        register_ports_helper<sizeof...(T)-1,
                              std::tuple<SY_out<T>...>&>::reg_port(boundChans,ports);
    }
#endif

};


template <class T>
class sgroup : public sy_process
{
public:
    SY_in<T> iport1;                    
    SY_out<std::vector<T>> oport1;      


    sgroup(const sc_module_name& _name,      
           const unsigned long& samples       
          )
         :sy_process(_name), samples(samples)
    {
#ifdef FORSYDE_INTROSPECTION
        std::stringstream ss;
        ss << samples;
        arg_vec.push_back(std::make_tuple("samples", ss.str()));
#endif
    }
    
    std::string forsyde_kind() const {return "SY::sgroup";}
    
private:
    // Number of samples in each group
    unsigned long samples;
    
    unsigned long samples_took;
    
    // The output vector
    std::vector<T>* oval;
    
    //Implementing the abstract semantics
    void init()
    {
        oval = new std::vector<T>;
        oval->resize(samples);
        samples_took = 0;
    }
    
    void prep()
    {
        auto val_temp = iport1.read();
        CHECK_PRESENCE(val_temp);
        (*oval)[samples_took] = unsafe_from_abst_ext(val_temp);
        samples_took++;
    }
    
    void exec() {}
    
    void prod()
    {
        if (samples_took==samples)
        {
            WRITE_MULTIPORT(oport1, abst_ext<std::vector<T>>(*oval))
            samples_took = 0;
        }
        else
            WRITE_MULTIPORT(oport1, abst_ext<std::vector<T>>())
    }
    
    void clean()
    {
        delete oval;
    }
#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