Changeset 27


Ignore:
Timestamp:
02/09/12 16:39:23 (6 years ago)
Author:
shan2
Message:

ForSyDe-SystemC/CoMPSoC: added support for zipN and unzipN, and their optimization in the XML backend.

Location:
ForSyDe-SystemC/branches/CoMPSoC/src/forsyde
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • ForSyDe-SystemC/branches/CoMPSoC/src/forsyde/sdfmoc.hpp

    r21 r27  
    6565{ 
    6666public: 
     67    SDF2SDF() : sc_fifo<T>() {} 
     68    SDF2SDF(sc_module_name name, unsigned size) : sc_fifo<T>(name, size) {} 
    6769    virtual unsigned tokenSize() 
    6870    { 
     
    137139    sc_fifo_out<OTYP> oport;        ///< port for the output channel 
    138140     
    139     typedef std::function<void(std::vector<OTYP>&, const std::vector<ITYP>&)> functype; 
     141    typedef std::function<void(std::vector<OTYP>&, 
     142                                const std::vector<ITYP>& 
     143                                )> functype; 
    140144 
    141145    //! The constructor requires the module name and the number of tokens to be produced and consumed 
     
    207211    sc_fifo_out<OTYP> oport;        ///< port for the output channel 
    208212     
    209     typedef std::function<void(std::vector<OTYP>&, const std::vector<I1TYP>&, const std::vector<I2TYP>&)> functype; 
     213    typedef std::function<void(std::vector<OTYP>&, 
     214                                const std::vector<I1TYP>&, 
     215                                const std::vector<I2TYP>& 
     216                                )> functype; 
    210217 
    211218    //! The constructor requires the module name and the number of tokens to be produced and consumed 
     
    266273    functype _func; 
    267274 
    268 //~ protected: 
    269     //~ //! The main caclulation function 
    270     //~ /*! It is abstract and the user should provide an implementation for 
    271      //~ * it in the derived class. 
    272      //~ */ 
    273     //~ virtual std::vector<OTYP> (_func)(std::vector<I1TYP>, std::vector<I2TYP>) = 0; 
     275 
    274276}; 
    275277 
     
    285287    sc_fifo_in<I3TYP> iport3;       ///< port for the input channel 3 
    286288    sc_fifo_out<OTYP> oport;        ///< port for the output channel 
     289     
     290    typedef std::function<void(std::vector<OTYP>&, 
     291                                std::vector<I1TYP>&, 
     292                                std::vector<I2TYP>&, 
     293                                std::vector<I3TYP>& 
     294                                )> functype; 
    287295 
    288296    //! The constructor requires the module name 
     
    292300     */ 
    293301    comb3(sc_module_name _name, 
     302          functype _func, 
    294303          unsigned in1Toks, 
    295304          unsigned in2Toks, 
    296305          unsigned in3Toks, 
    297306          unsigned int outToks 
    298          ):process(_name) 
     307         ):process(_name), _func(_func) 
    299308    { 
    300309        itoks.push_back(in1Toks); 
     
    314323        std::vector<I2TYP> in_vals2(itoks[1]); 
    315324        std::vector<I3TYP> in_vals3(itoks[2]); 
    316         std::vector<OTYP> out_vals(otoks[3]); 
     325        std::vector<OTYP> out_vals(otoks[0]); 
    317326        while (1) 
    318327        { 
     
    321330            for (unsigned i=0;i<itoks[1];i++) in_vals2[i] = iport2.read(); 
    322331            for (unsigned i=0;i<itoks[2];i++) in_vals3[i] = iport3.read(); 
    323             out_vals = _func(in_vals1, in_vals2, in_vals3);// do the calculation 
     332            _func(out_vals, in_vals1, in_vals2, in_vals3);// do the calculation 
    324333            WRITE_VEC_MULTIPORT(oport,out_vals,otoks[0]);    // write to the output 
    325334        } 
     
    347356            boundOutChans[0].boundChans.push_back(dynamic_cast<sc_object*>(oport[i])); 
    348357    } 
    349  
    350 protected: 
    351     //! The main caclulation function 
    352     /*! It is abstract and the user should provide an implementation for 
    353      * it in the derived class. 
    354      */ 
    355     virtual std::vector<OTYP> (_func)(std::vector<I1TYP>, std::vector<I2TYP>, std::vector<I3TYP>) = 0; 
     358     
     359    functype _func; 
    356360}; 
    357361 
     
    368372    sc_fifo_in<I4TYP> iport4;       ///< port for the input channel 4 
    369373    sc_fifo_out<OTYP> oport;        ///< port for the output channel 
     374     
     375    typedef std::function<void(std::vector<OTYP>&, 
     376                                std::vector<I1TYP>&, 
     377                                std::vector<I2TYP>&, 
     378                                std::vector<I3TYP>&, 
     379                                std::vector<I4TYP>& 
     380                                )> functype; 
    370381 
    371382    //! The constructor requires the module name 
     
    375386     */ 
    376387    comb4(sc_module_name _name, 
     388          functype _func, 
    377389          unsigned in1Toks, 
    378390          unsigned in2Toks, 
     
    380392          unsigned in4Toks, 
    381393          unsigned outToks 
    382          ):process(_name) 
     394         ):process(_name), _func(_func) 
    383395    { 
    384396        itoks.push_back(in1Toks); 
     
    408420            for (unsigned int i=0;i<itoks[2];i++) in_vals3[i] = iport3.read(); 
    409421            for (unsigned int i=0;i<itoks[3];i++) in_vals4[i] = iport4.read(); 
    410             out_vals = _func(in_vals1, in_vals2, in_vals3, in_vals4);// do the calculation 
     422            _func(out_vals, in_vals1, in_vals2, in_vals3, in_vals4);// do the calculation 
    411423            WRITE_VEC_MULTIPORT(oport,out_vals,otoks[0]);    // write to the output 
    412424        } 
     
    438450            boundOutChans[0].boundChans.push_back(dynamic_cast<sc_object*>(oport[i])); 
    439451    } 
    440  
    441 protected: 
    442     //! The main caclulation function 
    443     /*! It is abstract and the user should provide an implementation for 
    444      * it in the derived class. 
    445      */ 
    446     virtual std::vector<OTYP> (_func)(std::vector<I1TYP>, std::vector<I2TYP>, std::vector<I3TYP>, std::vector<I4TYP>) = 0; 
     452     
     453    functype _func; 
    447454}; 
    448455 
     
    813820        if (inToks.size()!=sizeof...(ITYPs)) 
    814821            SC_REPORT_ERROR(name(),"Wrong number of consumption rates provided"); 
    815         itoks.assign(inToks.begin(),inToks.end()); 
     822        itoks = inToks; 
     823        otoks.push_back(1); 
    816824    } 
    817825     
     
    833841    void bindInfo() 
    834842    { 
    835         //~ boundInChans.resize(sizeof...(ITYPS)); 
     843        boundInChans.resize(sizeof...(ITYPs)); 
    836844        boundOutChans.resize(1); 
    837845        boundOutChans[0].port = &oport; 
    838         boundOutChans[0].toks = 1; 
    839         //~ for (int j=0;j<sizeof...(ITYPS);j++) 
    840             //~ for (int i=0;i<iport.size();i++) 
    841                 //~ boundInChans[0].push_back(dynamic_cast<sc_object*>(iport[i])); 
     846        boundOutChans[0].toks = otoks[0]; 
     847        populateIPorts<ITYPs...>(boundInChans, itoks, iport); 
    842848        for (int i=0;i<oport.size();i++) 
    843849            boundOutChans[0].boundChans.push_back(dynamic_cast<sc_object*>(oport[i])); 
    844850    } 
    845851     
     852    // Begin of some TMP magic // 
    846853    template<size_t N,class R, class T> 
    847854    struct fifo_read_helper 
     
    875882        return ret; 
    876883    } 
    877  
     884    // End of TMP magic // 
     885    // Begin of some TMP magic // 
     886    template<size_t N, class T> 
     887    struct populateIPorts_helper 
     888    { 
     889        static void populate(std::vector<PortInfo>& boundInChans, 
     890                             const std::vector<unsigned>& itoks, T& ports) 
     891        { 
     892            populateIPorts_helper<N-1,T>::populate(boundInChans,itoks,ports); 
     893            boundInChans[N].port = &std::get<N>(ports); 
     894            boundInChans[N].toks = itoks[N]; 
     895            for (int i=0;i<std::get<N>(ports).size();i++) 
     896                boundInChans[N].boundChans.push_back( 
     897                    dynamic_cast<sc_object*>(std::get<N>(ports)[i]) 
     898                ); 
     899        } 
     900    }; 
     901 
     902    template<class T> 
     903    struct populateIPorts_helper<0,T> 
     904    { 
     905        static void populate(std::vector<PortInfo>& boundInChans, 
     906                             const std::vector<unsigned>& itoks, T& ports) 
     907        { 
     908            boundInChans[0].port = &std::get<0>(ports); 
     909            boundInChans[0].toks = itoks[0]; 
     910            for (int i=0;i<std::get<0>(ports).size();i++) 
     911                boundInChans[0].boundChans.push_back( 
     912                    dynamic_cast<sc_object*>(std::get<0>(ports)[i]) 
     913                ); 
     914        } 
     915    }; 
     916 
     917    template<class... T> 
     918    void populateIPorts(std::vector<PortInfo>& boundInChans, 
     919                        const std::vector<unsigned>& itoks, 
     920                        std::tuple<sc_fifo_in<T>...>& ports) 
     921    { 
     922        populateIPorts_helper<sizeof...(T)-1, 
     923            std::tuple<sc_fifo_in<T>...>>::populate(boundInChans, itoks, ports); 
     924    } 
     925    // End of TMP magic // 
    878926}; 
    879927 
     
    9601008     * unzips it and writes the results using the output ports 
    9611009     */ 
    962     unzipN(sc_module_name _name 
     1010    unzipN(sc_module_name _name, 
     1011           std::vector<unsigned> outToks 
    9631012          ):process(_name) 
    9641013    { 
    965          
     1014        if (outToks.size()!=sizeof...(ITYPs)) 
     1015            SC_REPORT_ERROR(name(),"Wrong number of production rates provided"); 
     1016        itoks.push_back(1); 
     1017        otoks = outToks; 
    9661018    } 
    9671019     
     
    9811033    } 
    9821034     
    983     //~ void bindInfo() 
    984     //~ { 
    985         //~ boundInChans.resize(1);     // only one input ports 
    986         //~ boundOutChans.resize(1);    // only one output port 
    987         //~ for (int i=0;i<iport.size();i++) 
    988             //~ boundInChans[0].push_back(dynamic_cast<sc_object*>(iport[i])); 
    989         //~ for (int i=0;i<oport.size();i++) 
    990             //~ boundOutChans[0].push_back(dynamic_cast<sc_object*>(oport[i])); 
    991     //~ } 
    992      
     1035    void bindInfo() 
     1036    { 
     1037        boundInChans.resize(1);     // only one input port 
     1038        boundInChans[0].port = &iport; 
     1039        boundInChans[0].toks = itoks[0]; 
     1040        boundOutChans.resize(sizeof...(ITYPs));    // output ports 
     1041        for (int i=0;i<iport.size();i++) 
     1042            boundInChans[0].boundChans.push_back(dynamic_cast<sc_object*>(iport[i])); 
     1043        populateOPorts<ITYPs...>(boundOutChans, otoks, oport); 
     1044    } 
     1045     
     1046    // Begin of some TMP magic // 
    9931047    template<size_t N,class R,  class T> 
    9941048    struct fifo_write_helper 
     
    10201074                          std::tuple<sc_fifo_out<T>...>>::write(vals,ports); 
    10211075    } 
    1022  
     1076    // End of TMP magic // 
     1077    // Begin of some TMP magic // 
     1078    template<size_t N, class T> 
     1079    struct populateOPorts_helper 
     1080    { 
     1081        static void populate(std::vector<PortInfo>& boundOutChans, 
     1082                             const std::vector<unsigned>& otoks, T& ports) 
     1083        { 
     1084            populateOPorts_helper<N-1,T>::populate(boundOutChans,otoks,ports); 
     1085            boundOutChans[N].port = &std::get<N>(ports); 
     1086            boundOutChans[N].toks = otoks[N]; 
     1087            for (int i=0;i<std::get<N>(ports).size();i++) 
     1088                boundOutChans[N].boundChans.push_back( 
     1089                    dynamic_cast<sc_object*>(std::get<N>(ports)[i]) 
     1090                ); 
     1091        } 
     1092    }; 
     1093 
     1094    template<class T> 
     1095    struct populateOPorts_helper<0,T> 
     1096    { 
     1097        static void populate(std::vector<PortInfo>& boundOutChans, 
     1098                             const std::vector<unsigned>& otoks, T& ports) 
     1099        { 
     1100            boundOutChans[0].port = &std::get<0>(ports); 
     1101            boundOutChans[0].toks = otoks[0]; 
     1102            for (int i=0;i<std::get<0>(ports).size();i++) 
     1103                boundOutChans[0].boundChans.push_back( 
     1104                    dynamic_cast<sc_object*>(std::get<0>(ports)[i]) 
     1105                ); 
     1106        } 
     1107    }; 
     1108 
     1109    template<class... T> 
     1110    void populateOPorts(std::vector<PortInfo>& boundOutChans, 
     1111                        const std::vector<unsigned>& otoks, 
     1112                        std::tuple<sc_fifo_out<T>...>& ports) 
     1113    { 
     1114        populateOPorts_helper<sizeof...(T)-1, 
     1115            std::tuple<sc_fifo_out<T>...>>::populate(boundOutChans, otoks, ports); 
     1116    } 
     1117    // End of TMP magic // 
    10231118}; 
    10241119 
  • ForSyDe-SystemC/branches/CoMPSoC/src/forsyde/xml.hpp

    r21 r27  
    238238            } 
    239239        } 
    240         // Merge unzip processes with their previous actors 
     240        // Merge unzip processes with their previous actor and zip 
     241        // processes with their next actor. 
    241242        // TODO : Cover other unzips 
    242243        for (auto it=processes.begin();it!=processes.end();it++) 
     
    261262                channels.erase(zipChan); 
    262263                // remove the unzip process 
     264                processes.erase(it); 
     265            } 
     266            if (!strcmp(it->second->ForSyDe_kind().c_str(), "SDF::unzipN")) 
     267            { 
     268                // find the incoming and outgoing channels 
     269                decltype(channels.begin()) zipChan; 
     270                std::vector<decltype(channels.begin())> unzipChans; 
     271                for (auto it2=channels.begin();it2!=channels.end();it2++) 
     272                { 
     273                    if (it2->second.desActor == it->second) 
     274                        zipChan = it2; 
     275                    if (it2->second.srcActor == it->second) 
     276                        unzipChans.push_back(it2); 
     277                } 
     278                // connect the outputs of unzip to the original actor 
     279                for (auto it3=unzipChans.begin();it3!=unzipChans.end();it3++) 
     280                    (*it3)->second.srcActor = zipChan->second.srcActor; 
     281                // remove the zipped channel 
     282                channels.erase(zipChan); 
     283                // remove the unzip process 
     284                processes.erase(it); 
     285            } 
     286            if (!strcmp(it->second->ForSyDe_kind().c_str(), "SDF::zipN")) 
     287            { 
     288                // find the incoming and outgoing channels 
     289                decltype(channels.begin()) zipChan; 
     290                std::vector<decltype(channels.begin())> unzipChans; 
     291                for (auto it2=channels.begin();it2!=channels.end();it2++) 
     292                { 
     293                    if (it2->second.desActor == it->second) 
     294                        unzipChans.push_back(it2); 
     295                    if (it2->second.srcActor == it->second) 
     296                        zipChan = it2; 
     297                } 
     298                // connect the inputs of zip to the original actor 
     299                for (auto it3=unzipChans.begin();it3!=unzipChans.end();it3++) 
     300                    (*it3)->second.desActor = zipChan->second.desActor; 
     301                // remove the zipped channel 
     302                channels.erase(zipChan); 
     303                // remove the zip process 
    263304                processes.erase(it); 
    264305            } 
Note: See TracChangeset for help on using the changeset viewer.