abssemantics.hpp

Go to the documentation of this file.

/**********************************************************************           
    * abssemantics.hpp -- The common abstract semantics for all MoCs  *
    *                                                                 *
    * Author:  Hosein Attarzadeh (shan2@kth.se)                       *
    *                                                                 *
    * Purpose: The common base for mapping supported MoCs on top of   *
    *          the SystemC simulation kernel.                         *
    *                                                                 *
    * Usage:   This file is included automatically                    *
    *                                                                 *
    * License: BSD3                                                   *
    *******************************************************************/

#ifndef ABSSEMANTICS_HPP
#define ABSSEMANTICS_HPP


namespace ForSyDe
{

using namespace sc_core;

// Auxilliary Macro definitions
#define WRITE_MULTIPORT(PORT,VAL) \
    for (int WMPi=0;WMPi<PORT.size();WMPi++) PORT[WMPi]->write(VAL);

#define WRITE_VEC_MULTIPORT(PORT,VEC) \
    for (int WMPi=0;WMPi<PORT.size();WMPi++) \
        for (auto WMPit=VEC.begin();WMPit!=VEC.end();WMPit++) \
            PORT[WMPi]->write(*WMPit);

enum bound_type {PORT, CHANNEL};

class introspective_channel
{
public:
    virtual const char* token_type() const = 0;
    
    // TODO: remove if proved not to be needed
    //~ //! Size of the tokens in the channels
    //~ virtual unsigned token_size() const = 0;
    
    virtual std::string moc() const = 0;
    
    sc_object* iport;
    
    sc_object* oport;
};

template <typename T, typename TokenType>
class signal: public sc_fifo<TokenType>
#ifdef FORSYDE_INTROSPECTION
            , public ForSyDe::introspective_channel
#endif
{
public:
    signal() : sc_fifo<TokenType>() {}
    signal(sc_module_name name, unsigned size) : sc_fifo<TokenType>(name, size) {}
#ifdef FORSYDE_INTROSPECTION
    typedef T type;
    
    // TODO: remove if proved not to be needed
    //~ //! Returns only the size of the token type
    //~ virtual unsigned token_size() const
    //~ {
        //~ return sizeof(T);
    //~ }
    
    // TODO: remove if proved not to be needed
    virtual const char* token_type() const
    {
        return get_type_name<T>();
    }
    
    virtual std::string moc() const = 0;
#endif
};

struct PortInfo
{
    sc_object* port;
    // TODO: remove if proved not to be needed
    //~ unsigned toks;
    std::string portType;
};

class introspective_port
{
public:
    sc_object* bound_port;
    
    virtual const char* token_type() const = 0;
};

template <typename T, typename TokenType, typename ChanType>
class in_port: public sc_fifo_in<TokenType>
#ifdef FORSYDE_INTROSPECTION
            , public ForSyDe::introspective_port
#endif
{
public:
    in_port() : sc_fifo_in<TokenType>(){}
    in_port(const char* name) : sc_fifo_in<TokenType>(name){}
#ifdef FORSYDE_INTROSPECTION
    typedef T type;
    
    // NOTE: The following member functions could be overriden easier if
    //       bind() was declared virtual in the sc_port base classes.
    //       This will happen in SystemC 2.3, so adapt these accordingly.
    void operator()(sc_fifo_in_if<TokenType>& i)
    {
        sc_fifo_in<TokenType>::operator()(i);
        static_cast<ChanType&>(i).iport = this;
    }
    
    void operator()(in_port<T,TokenType,ChanType>& p)
    {
        sc_fifo_in<TokenType>::operator()(p);
        p.bound_port = this;
    }
    
    virtual const char* token_type() const
    {
        return get_type_name<T>();
    }
#endif
};

template <typename T, typename TokenType, typename ChanType>
class out_port: public sc_fifo_out<TokenType>
#ifdef FORSYDE_INTROSPECTION
            , public ForSyDe::introspective_port
#endif
{
public:
    out_port() : sc_fifo_out<TokenType>(){}
    out_port(const char* name) : sc_fifo_out<TokenType>(name){}
#ifdef FORSYDE_INTROSPECTION
    typedef T type;
    
    // NOTE: The following member functions could be overriden easier if
    //       bind() was declared virtual in the sc_port base classes.
    //       This will happen in SystemC 2.3, so adapt these accordingly.
    void operator()(sc_fifo_out_if<TokenType>& i)
    {
        sc_fifo_out<TokenType>::operator()(i);
        // Register the port-to-port binding
        static_cast<ChanType&>(i).oport = this;
    }
    
    void operator()(out_port<T,TokenType,ChanType>& p)
    {
        sc_fifo_out<TokenType>::operator()(p);
        // Register the port-to-port binding
        p.bound_port = this;
    }
    
    virtual const char* token_type() const
    {
        return get_type_name<T>();
    }
#endif
};


class process : public sc_module
{
private:
    SC_HAS_PROCESS(process);

    void worker()
    {
        //  We run the init stage here and not in the constructor to
        // force running it after the elaboration phase.
        init();
        while (1)
        {
            prep();     // The preparaion stage
            exec();     // The execution stage
            prod();     // The production stage
        }
    }

protected:

    virtual void init() = 0;
    

    virtual void prep() = 0;
    

    virtual void exec() = 0;
    

    virtual void prod() = 0;
    

    virtual void clean() = 0;
    
    void end_of_simulation()
    {
        clean();
    }
    
#ifdef FORSYDE_INTROSPECTION

    void end_of_elaboration()
    {
        bindInfo();
    }


    virtual void bindInfo() = 0;
#endif

public:

#ifdef FORSYDE_INTROSPECTION
    std::vector<PortInfo> boundInChans;
    std::vector<PortInfo> boundOutChans;
    
    std::vector<std::tuple<std::string,std::string>> arg_vec;
#endif
 

    process(sc_module_name _name    
            ): sc_module(_name)
    {
        SC_THREAD(worker);
    }
    
    virtual std::string forsyde_kind() const = 0;
    
};

}

#endif