Changeset 38


Ignore:
Timestamp:
02/24/12 10:47:45 (6 years ago)
Author:
shan2
Message:

added the doc and papers folders

Location:
ForSyDe-SystemC
Files:
2 added
3 edited

Legend:

Unmodified
Added
Removed
  • ForSyDe-SystemC/branches/functional/examples/sy/mulacc/mulacc.hpp

    r25 r38  
    2626    sc_fifo_out<int> result; 
    2727     
    28     comb2<int,int,int> mul1; 
    29     comb2<int,int,int> add1; 
    30     delay<int> accum; 
     28    SY2SY<int> addi1, addi2, acci; 
    3129     
    32     sc_fifo<int> addi1, addi2, acci; 
    33      
    34     SC_CTOR(mulacc): mul1("mul1", mul_func), add1("add1", add_func), 
    35                      accum("accum", 0) 
     30    SC_CTOR(mulacc) 
    3631    { 
    37         mul1.iport1(a); 
    38         mul1.iport2(b); 
    39         mul1.oport(addi1); 
     32        make_comb2("mul1", mul_func, a, b, addi1); 
     33 
     34        auto add1 = make_comb2("add1", add_func, addi1, addi2, acci); 
     35        (*add1).oport(result); 
    4036         
    41         add1.iport1(addi1); 
    42         add1.iport2(addi2); 
    43         add1.oport(acci); 
    44         //~ comb2<int,int,int> add1 = make_comb2<int,int,int>("add1", add_func, addi1, addi2, acci); 
    45         //~ comb2<int,int,int> add1 = make_comb2("add1", add_func, addi1, addi2, acci); 
    46         add1.oport(result); 
    47          
    48         //~ auto accum = make_delay("accum",0,acci,addi2); 
    49         accum.iport(acci); 
    50         accum.oport(addi2); 
     37        make_delay("accum",0,acci,addi2); 
    5138    } 
    5239}; 
  • ForSyDe-SystemC/branches/functional/src/forsyde.hpp

    r14 r38  
    2525// include utility libraries 
    2626#include "forsyde/prettyprint.hpp" 
     27#include "forsyde/Typelist.h" 
    2728 
    2829// include the main SystemC library 
  • ForSyDe-SystemC/branches/functional/src/forsyde/symoc.hpp

    r25 r38  
    101101}; 
    102102 
     103//! The SY signal used to inter-connect SY processes 
     104template <class T> 
     105class SY2SY: public sc_fifo<T> 
     106{ 
     107public: 
     108    typedef T type; 
     109}; 
     110 
    103111//! Process constructor for a combinational process with one input and one output 
    104112/*! This class is used to build combinational processes with one input 
     
    304312}; 
    305313 
     314//! Process constructor for a combinational process with variable inputs outputs 
     315/*! similar to comb with variable inputs and outputs. 
     316 * The template parameters are Loki typelists and ports have a tuple-like 
     317 * interface. 
     318 */ 
     319template <class ITL, class OTL> 
     320class combN : public sc_module 
     321{ 
     322public: 
     323    sc_fifo_in<I1TYP> iport1;       ///< port for the input channel 1 
     324    sc_fifo_in<I2TYP> iport2;       ///< port for the input channel 2 
     325    sc_fifo_in<I3TYP> iport3;       ///< port for the input channel 3 
     326    sc_fifo_in<I4TYP> iport4;       ///< port for the input channel 4 
     327    sc_fifo_out<OTYP> oport;        ///< port for the output channel 
     328     
     329    //! Type of the function to be passed to the process constructor 
     330    typedef std::function<OTYP(const I1TYP&, const I2TYP&, 
     331                               const I3TYP&, const I4TYP&)> functype; 
     332 
     333    //! The constructor requires the module name 
     334    /*! It creates an SC_THREAD which reads data from its input ports, 
     335     * applies the user-imlpemented function to them and writes the 
     336     * results using the output port 
     337     */ 
     338    combN(sc_module_name _name,     ///< process name 
     339          functype _func            ///< function to be passed 
     340         ) : sc_module(_name), _func(_func) 
     341    { 
     342        SC_THREAD(worker); 
     343    } 
     344private: 
     345    SC_HAS_PROCESS(combN); 
     346 
     347    //! The main and only execution thread of the module 
     348    void worker() 
     349    { 
     350        I1TYP in_val1; 
     351        I2TYP in_val2; 
     352        I3TYP in_val3; 
     353        I4TYP in_val4; 
     354        OTYP out_val; 
     355        while (1) 
     356        { 
     357            in_val1 = iport1.read();  // read from input 
     358            in_val2 = iport2.read();  // read from input 
     359            in_val3 = iport3.read();  // read from input 
     360            in_val4 = iport4.read();  // read from input 
     361            out_val = _func(in_val1, in_val2, in_val3, in_val4); // do the calculation 
     362            WRITE_MULTIPORT(oport,out_val);     // write to the output 
     363        } 
     364    } 
     365     
     366    //! The function passed to the process constructor 
     367    functype _func; 
     368}; 
     369 
    306370//! Process constructor for a delay element 
    307371/*! This class is used to build the most basic sequential process which 
     
    331395        SC_THREAD(worker); 
    332396    } 
     397     
    333398private: 
    334399    IOTYP init_val; 
     
    12351300}; 
    12361301 
    1237 //~ //! Helper function to construct a comb process 
    1238 //~ /*! This function is used to construct a process (SystemC module) and 
    1239  //~ * connect its output and output signals. 
    1240  //~ * It provides a more functional style definition of a ForSyDe process. 
    1241  //~ * It also removes bilerplate code by using type-inference feature of 
    1242  //~ * C++ and automatic binding to the input and output FIFOs. 
    1243  //~ */ 
    1244 //~ template <class ITYP, class OTYP> 
    1245 //~ comb<ITYP,OTYP>& make_comb(char* pName, 
    1246                            //~ std::function<OTYP(const ITYP&)> _func, 
    1247                            //~ const sc_fifo<ITYP>& inpS, 
    1248                            //~ const sc_fifo<OTYP>& outS) 
    1249 //~ { 
    1250     //~ comb<ITYP,OTYP> p = new comb<ITYP,OTYP>(pName, _func); 
    1251     //~  
    1252     //~ p.iport(inpS); 
    1253     //~ p.oport(outS); 
    1254     //~  
    1255     //~ return p; 
    1256 //~ } 
    1257 //~  
    1258 //~ //! Helper function to construct a comb process 
    1259 //~ /*! This function is used to construct a process (SystemC module) and 
    1260  //~ * connect its output and output signals. 
    1261  //~ * It provides a more functional style definition of a ForSyDe process. 
    1262  //~ * It also removes bilerplate code by using type-inference feature of 
    1263  //~ * C++ and automatic binding to the input and output FIFOs. 
    1264  //~ */ 
    1265 //~ template <class I1TYP, class I2TYP, class OTYP> 
    1266 //~ comb2<I1TYP,I2TYP,OTYP> make_comb2(std::string pName, 
    1267                                    //~ std::function<OTYP(const I1TYP&,const I2TYP&)> _func, 
    1268                                    //~ sc_fifo<I1TYP>& inp1S, 
    1269                                    //~ sc_fifo<I2TYP>& inp2S, 
    1270                                    //~ sc_fifo<OTYP>& outS) 
    1271 //~ { 
    1272     //~ comb2<I1TYP,I2TYP,OTYP> ret = *(new comb2<I1TYP,I2TYP,OTYP>(pName.c_str(), _func)); 
    1273     //~  
    1274     //~ ret.iport1(inp1S); 
    1275     //~ ret.iport2(inp2S); 
    1276     //~ ret.oport(outS); 
    1277     //~  
    1278     //~ return ret; 
    1279 //~ } 
    1280 //~  
    1281 //~ //! Helper function to construct a delay process 
    1282 //~ /*! This function is used to construct a process (SystemC module) and 
    1283  //~ * connect its output and output signals. 
    1284  //~ * It provides a more functional style definition of a ForSyDe process. 
    1285  //~ * It also removes bilerplate code by using type-inference feature of 
    1286  //~ * C++ and automatic binding to the input and output FIFOs. 
    1287  //~ */ 
    1288 //~ template <class TYP> 
    1289 //~ delay<TYP> make_delay(std::string pName, 
    1290                        //~ TYP initval, 
    1291                        //~ sc_fifo<TYP>& inpS, 
    1292                        //~ sc_fifo<TYP>& outS) 
    1293 //~ { 
    1294     //~ delay<TYP> p = *(new delay<TYP>(pName.c_str(), initval)); 
    1295     //~  
    1296     //~ p.iport(inpS); 
    1297     //~ p.oport(outS); 
    1298     //~  
    1299     //~ return p; 
    1300 //~ } 
     1302//! Helper function to construct a comb process 
     1303/*! This function is used to construct a process (SystemC module) and 
     1304 * connect its output and output signals. 
     1305 * It provides a more functional style definition of a ForSyDe process. 
     1306 * It also removes bilerplate code by using type-inference feature of 
     1307 * C++ and automatic binding to the input and output FIFOs. 
     1308 */ 
     1309template <class ITYP, template <class> class IIf, 
     1310          class OTYP, template <class> class OIf> 
     1311inline comb<ITYP,OTYP>* make_comb(std::string pName, 
     1312    typename comb<ITYP,OTYP>::functype _func, 
     1313    const IIf<ITYP>& inpS, 
     1314    const OIf<OTYP>& outS) 
     1315{ 
     1316    auto p = new comb<ITYP,OTYP>(pName.c_str(), _func); 
     1317     
     1318    (*p).iport(inpS); 
     1319    (*p).oport(outS); 
     1320     
     1321    return p; 
     1322} 
     1323 
     1324//! Helper function to construct a comb process 
     1325/*! This function is used to construct a process (SystemC module) and 
     1326 * connect its output and output signals. 
     1327 * It provides a more functional style definition of a ForSyDe process. 
     1328 * It also removes bilerplate code by using type-inference feature of 
     1329 * C++ and automatic binding to the input and output FIFOs. 
     1330 */ 
     1331template <class I1TYP, template <class> class I1If, 
     1332          class I2TYP, template <class> class I2If, 
     1333          class OTYP, template <class> class OIf> 
     1334inline comb2<I1TYP,I2TYP,OTYP>* make_comb2(std::string pName, 
     1335    typename comb2<I1TYP,I2TYP,OTYP>::functype _func, 
     1336    I1If<I1TYP>& inp1S, 
     1337    I2If<I2TYP>& inp2S, 
     1338    OIf<OTYP>& outS) 
     1339{ 
     1340    auto p = new comb2<I1TYP,I2TYP,OTYP>(pName.c_str(), _func); 
     1341     
     1342    (*p).iport1(inp1S); 
     1343    (*p).iport2(inp2S); 
     1344    (*p).oport(outS); 
     1345     
     1346    return p; 
     1347} 
     1348 
     1349//! Helper function to construct a delay process 
     1350/*! This function is used to construct a process (SystemC module) and 
     1351 * connect its output and output signals. 
     1352 * It provides a more functional style definition of a ForSyDe process. 
     1353 * It also removes bilerplate code by using type-inference feature of 
     1354 * C++ and automatic binding to the input and output FIFOs. 
     1355 */ 
     1356template <class TYP> 
     1357inline delay<TYP>* make_delay(std::string pName, 
     1358    TYP initval, 
     1359    sc_fifo_in_if<TYP>& inpS, 
     1360    sc_fifo_out_if<TYP>& outS) 
     1361{ 
     1362    auto p = new delay<TYP>(pName.c_str(), initval); 
     1363     
     1364    (*p).iport(inpS); 
     1365    (*p).oport(outS); 
     1366     
     1367    return p; 
     1368} 
    13011369 
    13021370} 
Note: See TracChangeset for help on using the changeset viewer.