Index: /branches/v5/modules/dspin_local_ring_fast_c/caba/docs/top.cpp =================================================================== --- /branches/v5/modules/dspin_local_ring_fast_c/caba/docs/top.cpp (revision 327) +++ /branches/v5/modules/dspin_local_ring_fast_c/caba/docs/top.cpp (revision 327) @@ -0,0 +1,549 @@ +#include +#include +#include +#include +#include + +#include "mapping_table.h" +#include "dspin_local_ring_fast_c.h" +#include "soclib_vci_initiator.h" +#include "soclib_vci_target.h" +#include "alloc_elems.h" +#include "vci_param.h" +#include "virtual_dspin_router.h" + +// Router ports index +#define NORTH 0 +#define SOUTH 1 +#define EAST 2 +#define WEST 3 +#define LOCAL 4 + +#define X_MAX 2 +#define Y_MAX 2 +#define cmd_width 40 +#define rsp_width 33 +#define X_WIDTH 1 +#define Y_WIDTH 1 +#define SRCID_WIDTH 14 + +#define cluster(x,y) (y+x*Y_MAX) + +#define CYCLES 10000000 + +int _main(int argc, char *argv[]) +{ + using namespace sc_core; + // Avoid repeating these everywhere + using soclib::common::IntTab; + using soclib::common::Segment; + using soclib::common::alloc_elems; + using namespace soclib::caba; + + // Define VCI parameters + typedef soclib::caba::VciParams<4,8,32,1,1,1,14,4,4,1> vci_param; + + // Mapping table primary network + soclib::common::MappingTable maptabp(32, IntTab(X_WIDTH + Y_WIDTH, SRCID_WIDTH - X_WIDTH - Y_WIDTH), IntTab(X_WIDTH + Y_WIDTH, SRCID_WIDTH - X_WIDTH - Y_WIDTH), 0x00FF0000); + for (size_t x = 0; x < X_MAX; x++) + { + for (size_t y = 0; y < Y_MAX; y++) + { + sc_uint<32> offset = cluster(x,y) << (32 - X_WIDTH - Y_WIDTH); + + for ( size_t p = 0 ; p < 4 ; p++) + { + std::ostringstream sp; + sp << "c_seg_proc_" << x << "_" << y << "_" << p; + maptabp.add( Segment( sp.str() , (p << (32 - SRCID_WIDTH)) + offset , 0x10 , IntTab(cluster(x,y), p) , false)); + } + } + } +/* + soclib::common::MappingTable maptabp(32, IntTab(2,12), IntTab(2,12), 0xFF000000); + + maptabp.add(Segment("target_0_0" , 0x00000000 , 0x00001000 , IntTab(0,0), true )); + maptabp.add(Segment("target_1_0" , 0x40000000 , 0x00001000 , IntTab(1,0), true )); + maptabp.add(Segment("target_1_1" , 0x40000000 , 0x00001000 , IntTab(1,1), true )); + maptabp.add(Segment("target_2_0" , 0x80000000 , 0x00001000 , IntTab(2,0), true )); + maptabp.add(Segment("target_2_1" , 0xC0000000 , 0x00001000 , IntTab(3,0), true )); +*/ + // Signals + + sc_clock signal_clk("clk"); + sc_signal signal_resetn("resetn"); + + DspinSignals<40> dspin_cmd[4][5]; + DspinSignals<33> dspin_rsp[4][5]; + + //--- Dspin router + DspinSignals*** signal_dspin_false_cmd_in = alloc_elems >("signal_dspin_false_cmd_in", (Y_MAX*X_MAX), 2, 2); + DspinSignals*** signal_dspin_false_cmd_out = alloc_elems >("signal_dspin_false_cmd_out", (Y_MAX*X_MAX), 2, 2); + DspinSignals*** signal_dspin_false_rsp_in = alloc_elems >("signal_dspin_false_rsp_in", (Y_MAX*X_MAX), 2, 2); + DspinSignals*** signal_dspin_false_rsp_out = alloc_elems >("signal_dspin_false_rsp_out", (Y_MAX*X_MAX), 2, 2); + + + // DSPIN signals between local ring & global interconnects + DspinSignals** signal_dspin_cmd_l2g_d = + alloc_elems >("signal_dspin_cmd_l2g_d", X_MAX, Y_MAX); + DspinSignals** signal_dspin_cmd_g2l_d = + alloc_elems >("signal_dspin_cmd_g2l_d", X_MAX, Y_MAX); + + DspinSignals** signal_dspin_cmd_l2g_c = + alloc_elems >("signal_dspin_cmd_l2g_c", X_MAX, Y_MAX); + DspinSignals** signal_dspin_cmd_g2l_c = + alloc_elems >("signal_dspin_cmd_g2l_c", X_MAX, Y_MAX); + + DspinSignals** signal_dspin_rsp_l2g_d = + alloc_elems >("signal_dspin_rsp_l2g_d", X_MAX, Y_MAX); + DspinSignals** signal_dspin_rsp_g2l_d = + alloc_elems >("signal_dspin_rsp_g2l_d", X_MAX, Y_MAX); + + DspinSignals** signal_dspin_rsp_l2g_c = + alloc_elems >("signal_dspin_rsp_l2g_c", X_MAX, Y_MAX); + DspinSignals** signal_dspin_rsp_g2l_c = + alloc_elems >("signal_dspin_rsp_g2l_c", X_MAX, Y_MAX); + + // Horizontal inter-clusters DSPIN signals + DspinSignals*** signal_dspin_h_cmd_inc = + alloc_elems >("signal_dspin_h_cmd_inc", X_MAX-1, Y_MAX, 2); + DspinSignals*** signal_dspin_h_cmd_dec = + alloc_elems >("signal_dspin_h_cmd_dec", X_MAX-1, Y_MAX, 2); + DspinSignals*** signal_dspin_h_rsp_inc = + alloc_elems >("signal_dspin_h_rsp_inc", X_MAX-1, Y_MAX, 2); + DspinSignals*** signal_dspin_h_rsp_dec = + alloc_elems >("signal_dspin_h_rsp_dec", X_MAX-1, Y_MAX, 2); + + // Vertical inter-clusters DSPIN signals + DspinSignals*** signal_dspin_v_cmd_inc = + alloc_elems >("signal_dspin_v_cmd_inc", X_MAX, Y_MAX-1, 2); + DspinSignals*** signal_dspin_v_cmd_dec = + alloc_elems >("signal_dspin_v_cmd_dec", X_MAX, Y_MAX-1, 2); + DspinSignals*** signal_dspin_v_rsp_inc = + alloc_elems >("signal_dspin_v_rsp_inc", X_MAX, Y_MAX-1, 2); + DspinSignals*** signal_dspin_v_rsp_dec = + alloc_elems >("signal_dspin_v_rsp_dec", X_MAX, Y_MAX-1, 2); + + soclib::caba::SoclibVciInitiator<40,33> initp0("initp0", 0, 16, X_WIDTH, Y_WIDTH, X_MAX, Y_MAX); + soclib::caba::SoclibVciInitiator<40,33> initp1("initp1", 4096, 16, X_WIDTH, Y_WIDTH, X_MAX, Y_MAX); + soclib::caba::SoclibVciInitiator<40,33> initp2("initp2", 8192, 16, X_WIDTH, Y_WIDTH, X_MAX, Y_MAX); + soclib::caba::SoclibVciInitiator<40,33> initp3("initp3", 12288,16, X_WIDTH, Y_WIDTH, X_MAX, Y_MAX); + + soclib::caba::SoclibVciTarget<40,33> target0_0("target0_0", 0 ); + soclib::caba::SoclibVciTarget<40,33> target0_1("target0_1", 1 ); + soclib::caba::SoclibVciTarget<40,33> target0_2("target0_2", 2 ); + soclib::caba::SoclibVciTarget<40,33> target0_3("target0_3", 3 ); + + soclib::caba::SoclibVciTarget<40,33> target1_0("target1_0", 4 ); + soclib::caba::SoclibVciTarget<40,33> target1_1("target1_1", 5 ); + soclib::caba::SoclibVciTarget<40,33> target1_2("target1_2", 6 ); + soclib::caba::SoclibVciTarget<40,33> target1_3("target1_3", 7 ); + + soclib::caba::SoclibVciTarget<40,33> target2_0("target2_0", 8 ); + soclib::caba::SoclibVciTarget<40,33> target2_1("target2_1", 9 ); + soclib::caba::SoclibVciTarget<40,33> target2_2("target2_2", 10 ); + soclib::caba::SoclibVciTarget<40,33> target2_3("target2_3", 11 ); + + soclib::caba::SoclibVciTarget<40,33> target3_0("target3_0", 12 ); + soclib::caba::SoclibVciTarget<40,33> target3_1("target3_1", 13 ); + soclib::caba::SoclibVciTarget<40,33> target3_2("target3_2", 14 ); + soclib::caba::SoclibVciTarget<40,33> target3_3("target3_3", 15 ); + + // Local ring interconnects : 1 direct ring per cluster + soclib::caba::DspinLocalRingFastC * clusterPN = (soclib::caba::DspinLocalRingFastC *) malloc(sizeof(soclib::caba::DspinLocalRingFastC )*4); + + new(&clusterPN[0]) soclib::caba::DspinLocalRingFastC("clusterPN0",maptabp, IntTab(0), 2, 2, 1, 4, 1, 1 ); + new(&clusterPN[1]) soclib::caba::DspinLocalRingFastC("clusterPN1",maptabp, IntTab(1), 2, 2, 1, 4, 1, 1 ); + new(&clusterPN[2]) soclib::caba::DspinLocalRingFastC("clusterPN2",maptabp, IntTab(2), 2, 2, 1, 4, 1, 1 ); + new(&clusterPN[3]) soclib::caba::DspinLocalRingFastC("clusterPN3",maptabp, IntTab(3), 2, 2, 1, 4, 1, 1 ); + + // Distributed Global Interconnect : one cmd router & one rsp router per cluster + VirtualDspinRouter* cmdrouter = (VirtualDspinRouter*) + malloc(sizeof(VirtualDspinRouter) * X_MAX * Y_MAX); + VirtualDspinRouter* rsprouter = (VirtualDspinRouter*) + malloc(sizeof(VirtualDspinRouter) * X_MAX * Y_MAX); + + for ( size_t x = 0 ; x < X_MAX ; x++ ) + { + for ( size_t y = 0 ; y < Y_MAX ; y++ ) + { + + std::ostringstream str_cmd; + std::ostringstream str_rsp; + + str_cmd << "cmdrouter_" << x << "_" << y; + str_rsp << "rsprouter_" << x << "_" << y; + + new(&cmdrouter[cluster(x,y)]) VirtualDspinRouter(str_cmd.str().c_str(), + x,y, // coordinate in the mesh + X_WIDTH, Y_WIDTH, // x & y fields width + 4,4); // input & output fifo depths + new(&rsprouter[cluster(x,y)]) VirtualDspinRouter(str_rsp.str().c_str(), + x,y, // coordinates in mesh + X_WIDTH, Y_WIDTH, // x & y fields width + 4,4); // input & output fifo depths + } + } + + // Initiators + initp0.p_clk(signal_clk); + initp0.p_resetn(signal_resetn); + initp0.p_cmd_out(dspin_cmd[0][0]); + initp0.p_rsp_in(dspin_rsp[0][0]); + + initp1.p_clk(signal_clk); + initp1.p_resetn(signal_resetn); + initp1.p_cmd_out(dspin_cmd[1][0]); + initp1.p_rsp_in(dspin_rsp[1][0]); + + initp2.p_clk(signal_clk); + initp2.p_resetn(signal_resetn); + initp2.p_cmd_out(dspin_cmd[2][0]); + initp2.p_rsp_in(dspin_rsp[2][0]); + + initp3.p_clk(signal_clk); + initp3.p_resetn(signal_resetn); + initp3.p_cmd_out(dspin_cmd[3][0]); + initp3.p_rsp_in(dspin_rsp[3][0]); + + // Target + target0_0.p_clk(signal_clk); + target0_0.p_resetn(signal_resetn); + target0_0.p_cmd_in(dspin_cmd[0][1]); + target0_0.p_rsp_out(dspin_rsp[0][1]); + + target0_1.p_clk(signal_clk); + target0_1.p_resetn(signal_resetn); + target0_1.p_cmd_in(dspin_cmd[0][2]); + target0_1.p_rsp_out(dspin_rsp[0][2]); + + target0_2.p_clk(signal_clk); + target0_2.p_resetn(signal_resetn); + target0_2.p_cmd_in(dspin_cmd[0][3]); + target0_2.p_rsp_out(dspin_rsp[0][3]); + + target0_3.p_clk(signal_clk); + target0_3.p_resetn(signal_resetn); + target0_3.p_cmd_in(dspin_cmd[0][4]); + target0_3.p_rsp_out(dspin_rsp[0][4]); + + target1_0.p_clk(signal_clk); + target1_0.p_resetn(signal_resetn); + target1_0.p_cmd_in(dspin_cmd[1][1]); + target1_0.p_rsp_out(dspin_rsp[1][1]); + + target1_1.p_clk(signal_clk); + target1_1.p_resetn(signal_resetn); + target1_1.p_cmd_in(dspin_cmd[1][2]); + target1_1.p_rsp_out(dspin_rsp[1][2]); + + target1_2.p_clk(signal_clk); + target1_2.p_resetn(signal_resetn); + target1_2.p_cmd_in(dspin_cmd[1][3]); + target1_2.p_rsp_out(dspin_rsp[1][3]); + + target1_3.p_clk(signal_clk); + target1_3.p_resetn(signal_resetn); + target1_3.p_cmd_in(dspin_cmd[1][4]); + target1_3.p_rsp_out(dspin_rsp[1][4]); + + target2_0.p_clk(signal_clk); + target2_0.p_resetn(signal_resetn); + target2_0.p_cmd_in(dspin_cmd[2][1]); + target2_0.p_rsp_out(dspin_rsp[2][1]); + + target2_1.p_clk(signal_clk); + target2_1.p_resetn(signal_resetn); + target2_1.p_cmd_in(dspin_cmd[2][2]); + target2_1.p_rsp_out(dspin_rsp[2][2]); + + target2_2.p_clk(signal_clk); + target2_2.p_resetn(signal_resetn); + target2_2.p_cmd_in(dspin_cmd[2][3]); + target2_2.p_rsp_out(dspin_rsp[2][3]); + + target2_3.p_clk(signal_clk); + target2_3.p_resetn(signal_resetn); + target2_3.p_cmd_in(dspin_cmd[2][4]); + target2_3.p_rsp_out(dspin_rsp[2][4]); + + target3_0.p_clk(signal_clk); + target3_0.p_resetn(signal_resetn); + target3_0.p_cmd_in(dspin_cmd[3][1]); + target3_0.p_rsp_out(dspin_rsp[3][1]); + + target3_1.p_clk(signal_clk); + target3_1.p_resetn(signal_resetn); + target3_1.p_cmd_in(dspin_cmd[3][2]); + target3_1.p_rsp_out(dspin_rsp[3][2]); + + target3_2.p_clk(signal_clk); + target3_2.p_resetn(signal_resetn); + target3_2.p_cmd_in(dspin_cmd[3][3]); + target3_2.p_rsp_out(dspin_rsp[3][3]); + + target3_3.p_clk(signal_clk); + target3_3.p_resetn(signal_resetn); + target3_3.p_cmd_in(dspin_cmd[3][4]); + target3_3.p_rsp_out(dspin_rsp[3][4]); + + + /////////////////////////////////////////////////////// + // Routers connections + /////////////////////////////////////////////////////// + for ( size_t x = 0 ; x < X_MAX ; x++ ) + { + for ( size_t y = 0 ; y < Y_MAX ; y++ ) + { + // cmd DSPIN router + cmdrouter[cluster(x,y)].p_clk (signal_clk); + cmdrouter[cluster(x,y)].p_resetn (signal_resetn); + cmdrouter[cluster(x,y)].p_out[0][LOCAL] (signal_dspin_cmd_g2l_d[x][y]); + cmdrouter[cluster(x,y)].p_out[1][LOCAL] (signal_dspin_cmd_g2l_c[x][y]); + cmdrouter[cluster(x,y)].p_in[0][LOCAL] (signal_dspin_cmd_l2g_d[x][y]); + cmdrouter[cluster(x,y)].p_in[1][LOCAL] (signal_dspin_cmd_l2g_c[x][y]); + + // rsp DSPIN router + rsprouter[cluster(x,y)].p_clk (signal_clk); + rsprouter[cluster(x,y)].p_resetn (signal_resetn); + rsprouter[cluster(x,y)].p_out[0][LOCAL] (signal_dspin_rsp_g2l_d[x][y]); + rsprouter[cluster(x,y)].p_out[1][LOCAL] (signal_dspin_rsp_g2l_c[x][y]); + rsprouter[cluster(x,y)].p_in[0][LOCAL] (signal_dspin_rsp_l2g_d[x][y]); + rsprouter[cluster(x,y)].p_in[1][LOCAL] (signal_dspin_rsp_l2g_c[x][y]); + } + } + + // Inter Clusters horizontal connections + for ( size_t x = 0 ; x < (X_MAX-1) ; x++ ) + { + for ( size_t y = 0 ; y < Y_MAX ; y++ ) + { + for ( size_t k = 0 ; k < 2 ; k++ ) + { + cmdrouter[cluster(x,y)].p_out[k][EAST] (signal_dspin_h_cmd_inc[x][y][k]); + cmdrouter[cluster((x+1),y)].p_in[k][WEST] (signal_dspin_h_cmd_inc[x][y][k]); + + cmdrouter[cluster(x,y)].p_in[k][EAST] (signal_dspin_h_cmd_dec[x][y][k]); + cmdrouter[cluster((x+1),y)].p_out[k][WEST] (signal_dspin_h_cmd_dec[x][y][k]); + + rsprouter[cluster(x,y)].p_out[k][EAST] (signal_dspin_h_rsp_inc[x][y][k]); + rsprouter[cluster((x+1),y)].p_in[k][WEST] (signal_dspin_h_rsp_inc[x][y][k]); + + rsprouter[cluster(x,y)].p_in[k][EAST] (signal_dspin_h_rsp_dec[x][y][k]); + rsprouter[cluster((x+1),y)].p_out[k][WEST] (signal_dspin_h_rsp_dec[x][y][k]); + } + } + } + + + // East & West boundary clusters connections + for ( size_t y = 0 ; y < Y_MAX ; y++ ) + { + for ( size_t k = 0 ; k < 2 ; k++ ) + { + cmdrouter[cluster(0,y)].p_in[k][WEST] (signal_dspin_false_cmd_in[cluster(0,y)][k][0]); + cmdrouter[cluster(0,y)].p_out[k][WEST] (signal_dspin_false_cmd_out[cluster(0,y)][k][0]); + rsprouter[cluster(0,y)].p_in[k][WEST] (signal_dspin_false_rsp_in[cluster(0,y)][k][0]); + rsprouter[cluster(0,y)].p_out[k][WEST] (signal_dspin_false_rsp_out[cluster(0,y)][k][0]); + + cmdrouter[cluster((X_MAX-1),y)].p_in[k][EAST] (signal_dspin_false_cmd_in[cluster((X_MAX-1),y)][k][0]); + cmdrouter[cluster((X_MAX-1),y)].p_out[k][EAST] (signal_dspin_false_cmd_out[cluster((X_MAX-1),y)][k][0]); + rsprouter[cluster((X_MAX-1),y)].p_in[k][EAST] (signal_dspin_false_rsp_in[cluster((X_MAX-1),y)][k][0]); + rsprouter[cluster((X_MAX-1),y)].p_out[k][EAST] (signal_dspin_false_rsp_out[cluster((X_MAX-1),y)][k][0]); + } + } + + // Inter Clusters vertical connections + for ( size_t y = 0 ; y < (Y_MAX-1) ; y++ ) + { + for ( size_t x = 0 ; x < X_MAX ; x++ ) + { + for ( size_t k = 0 ; k < 2 ; k++ ) + { + cmdrouter[cluster(x,y)].p_out[k][NORTH] (signal_dspin_v_cmd_inc[x][y][k]); + cmdrouter[cluster(x,(y+1))].p_in[k][SOUTH] (signal_dspin_v_cmd_inc[x][y][k]); + + cmdrouter[cluster(x,y)].p_in[k][NORTH] (signal_dspin_v_cmd_dec[x][y][k]); + cmdrouter[cluster(x,(y+1))].p_out[k][SOUTH] (signal_dspin_v_cmd_dec[x][y][k]); + + rsprouter[cluster(x,y)].p_out[k][NORTH] (signal_dspin_v_rsp_inc[x][y][k]); + rsprouter[cluster(x,(y+1))].p_in[k][SOUTH] (signal_dspin_v_rsp_inc[x][y][k]); + + rsprouter[cluster(x,y)].p_in[k][NORTH] (signal_dspin_v_rsp_dec[x][y][k]); + rsprouter[cluster(x,(y+1))].p_out[k][SOUTH] (signal_dspin_v_rsp_dec[x][y][k]); + } + } + } + + // North & South boundary clusters connections + for ( size_t x = 0 ; x < X_MAX ; x++ ) + { + for ( size_t k = 0 ; k < 2 ; k++ ) + { + cmdrouter[cluster(x,0)].p_in[k][SOUTH] (signal_dspin_false_cmd_in[cluster(x,0)][k][1]); + cmdrouter[cluster(x,0)].p_out[k][SOUTH] (signal_dspin_false_cmd_out[cluster(x,0)][k][1]); + rsprouter[cluster(x,0)].p_in[k][SOUTH] (signal_dspin_false_rsp_in[cluster(x,0)][k][1]); + rsprouter[cluster(x,0)].p_out[k][SOUTH] (signal_dspin_false_rsp_out[cluster(x,0)][k][1]); + + cmdrouter[cluster(x,(Y_MAX-1))].p_out[k][NORTH] (signal_dspin_false_cmd_out[cluster(x,(Y_MAX-1))][k][1]); + cmdrouter[cluster(x,(Y_MAX-1))].p_in[k][NORTH] (signal_dspin_false_cmd_in[cluster(x,(Y_MAX-1))][k][1]); + rsprouter[cluster(x,(Y_MAX-1))].p_out[k][NORTH] (signal_dspin_false_rsp_out[cluster(x,(Y_MAX-1))][k][1]); + rsprouter[cluster(x,(Y_MAX-1))].p_in[k][NORTH] (signal_dspin_false_rsp_in[cluster(x,(Y_MAX-1))][k][1]); + } + } + + clusterPN[0].p_clk(signal_clk); + clusterPN[0].p_resetn(signal_resetn); + + clusterPN[0].p_cmd_in[0](dspin_cmd[0][0]); + clusterPN[0].p_rsp_out[0](dspin_rsp[0][0]); + + + clusterPN[0].p_cmd_out[0](dspin_cmd[0][1]); + clusterPN[0].p_rsp_in[0](dspin_rsp[0][1]); + clusterPN[0].p_cmd_out[1](dspin_cmd[0][2]); + clusterPN[0].p_rsp_in[1](dspin_rsp[0][2]); + clusterPN[0].p_cmd_out[2](dspin_cmd[0][3]); + clusterPN[0].p_rsp_in[2](dspin_rsp[0][3]); + clusterPN[0].p_cmd_out[3](dspin_cmd[0][4]); + clusterPN[0].p_rsp_in[3](dspin_rsp[0][4]); + + clusterPN[0].p_cmd_in[1](signal_dspin_cmd_g2l_d[0][0]); + clusterPN[0].p_rsp_out[1](signal_dspin_rsp_l2g_d[0][0]); + clusterPN[0].p_cmd_out[4](signal_dspin_cmd_l2g_d[0][0]); + clusterPN[0].p_rsp_in[4](signal_dspin_rsp_g2l_d[0][0]); + + clusterPN[1].p_clk(signal_clk); + clusterPN[1].p_resetn(signal_resetn); + + clusterPN[1].p_cmd_in[0](dspin_cmd[1][0]); + clusterPN[1].p_rsp_out[0](dspin_rsp[1][0]); + + clusterPN[1].p_cmd_out[0](dspin_cmd[1][1]); + clusterPN[1].p_rsp_in[0](dspin_rsp[1][1]); + clusterPN[1].p_cmd_out[1](dspin_cmd[1][2]); + clusterPN[1].p_rsp_in[1](dspin_rsp[1][2]); + clusterPN[1].p_cmd_out[2](dspin_cmd[1][3]); + clusterPN[1].p_rsp_in[2](dspin_rsp[1][3]); + clusterPN[1].p_cmd_out[3](dspin_cmd[1][4]); + clusterPN[1].p_rsp_in[3](dspin_rsp[1][4]); + + clusterPN[1].p_cmd_in[1](signal_dspin_cmd_g2l_d[0][1]); + clusterPN[1].p_rsp_out[1](signal_dspin_rsp_l2g_d[0][1]); + clusterPN[1].p_cmd_out[4](signal_dspin_cmd_l2g_d[0][1]); + clusterPN[1].p_rsp_in[4](signal_dspin_rsp_g2l_d[0][1]); + + clusterPN[2].p_clk(signal_clk); + clusterPN[2].p_resetn(signal_resetn); + + clusterPN[2].p_cmd_in[0](dspin_cmd[2][0]); + clusterPN[2].p_rsp_out[0](dspin_rsp[2][0]); + + clusterPN[2].p_cmd_out[0](dspin_cmd[2][1]); + clusterPN[2].p_rsp_in[0](dspin_rsp[2][1]); + clusterPN[2].p_cmd_out[1](dspin_cmd[2][2]); + clusterPN[2].p_rsp_in[1](dspin_rsp[2][2]); + clusterPN[2].p_cmd_out[2](dspin_cmd[2][3]); + clusterPN[2].p_rsp_in[2](dspin_rsp[2][3]); + clusterPN[2].p_cmd_out[3](dspin_cmd[2][4]); + clusterPN[2].p_rsp_in[3](dspin_rsp[2][4]); + + clusterPN[2].p_cmd_in[1](signal_dspin_cmd_g2l_d[1][0]); + clusterPN[2].p_rsp_out[1](signal_dspin_rsp_l2g_d[1][0]); + clusterPN[2].p_cmd_out[4](signal_dspin_cmd_l2g_d[1][0]); + clusterPN[2].p_rsp_in[4](signal_dspin_rsp_g2l_d[1][0]); + + clusterPN[3].p_clk(signal_clk); + clusterPN[3].p_resetn(signal_resetn); + + clusterPN[3].p_cmd_in[0](dspin_cmd[3][0]); + clusterPN[3].p_rsp_out[0](dspin_rsp[3][0]); + + clusterPN[3].p_cmd_out[0](dspin_cmd[3][1]); + clusterPN[3].p_rsp_in[0](dspin_rsp[3][1]); + clusterPN[3].p_cmd_out[1](dspin_cmd[3][2]); + clusterPN[3].p_rsp_in[1](dspin_rsp[3][2]); + clusterPN[3].p_cmd_out[2](dspin_cmd[3][3]); + clusterPN[3].p_rsp_in[2](dspin_rsp[3][3]); + clusterPN[3].p_cmd_out[3](dspin_cmd[3][4]); + clusterPN[3].p_rsp_in[3](dspin_rsp[3][4]); + + clusterPN[3].p_cmd_in[1](signal_dspin_cmd_g2l_d[1][1]); + clusterPN[3].p_rsp_out[1](signal_dspin_rsp_l2g_d[1][1]); + clusterPN[3].p_cmd_out[4](signal_dspin_cmd_l2g_d[1][1]); + clusterPN[3].p_rsp_in[4](signal_dspin_rsp_g2l_d[1][1]); + +//////////////////////////////////////////////////////// + + int ncycles; + + sc_start(sc_core::sc_time(0, SC_NS)); + signal_resetn = false; + + for(size_t x = 0; x < X_MAX; x++) + { + for(size_t y = 0; y < Y_MAX; y++) + { + signal_dspin_cmd_g2l_c[x][y].write = false; + signal_dspin_cmd_g2l_c[x][y].read = true; + signal_dspin_rsp_g2l_c[x][y].write = false; + signal_dspin_rsp_g2l_c[x][y].read = true; + signal_dspin_cmd_l2g_c[x][y].write = false; + signal_dspin_cmd_l2g_c[x][y].read = true; + signal_dspin_rsp_l2g_c[x][y].write = false; + signal_dspin_rsp_l2g_c[x][y].read = true; + } + } + + for(size_t t = 0; t < X_MAX*Y_MAX; t++) + { + for (size_t k = 0; k < 2; k++) + { + for(size_t a = 0; a < 2; a ++) + { + signal_dspin_false_cmd_in[t][k][a].write = false; + signal_dspin_false_cmd_in[t][k][a].read = true; + signal_dspin_false_cmd_out[t][k][a].write = false; + signal_dspin_false_cmd_out[t][k][a].read = true; + + signal_dspin_false_rsp_in[t][k][a].write = false; + signal_dspin_false_rsp_in[t][k][a].read = true; + signal_dspin_false_rsp_out[t][k][a].write = false; + signal_dspin_false_rsp_out[t][k][a].read = true; + } + } + } + + sc_start(sc_core::sc_time(1, SC_NS)); + signal_resetn = true; + + + while(1) + { + //rsprouter[3].debug_trace(0); + //rsprouter[2].debug_trace(0); + sc_start(sc_core::sc_time(CYCLES, SC_NS)); + //sc_start(sc_core::sc_time(1, SC_NS)); + + } + + std::cout << "Hit ENTER to end simulation" << std::endl; + char buf[1]; + + std::cin.getline(buf,1); + + return EXIT_SUCCESS; +} + +int sc_main (int argc, char *argv[]) +{ + try { + return _main(argc, argv); + } catch (std::exception &e) { + std::cout << e.what() << std::endl; + } catch (...) { + std::cout << "Unknown exception occured" << std::endl; + throw; + } + return 1; +} Index: /branches/v5/modules/dspin_simple_ring_fast_c/caba/docs/top.cpp =================================================================== --- /branches/v5/modules/dspin_simple_ring_fast_c/caba/docs/top.cpp (revision 327) +++ /branches/v5/modules/dspin_simple_ring_fast_c/caba/docs/top.cpp (revision 327) @@ -0,0 +1,149 @@ +#include +#include +#include +#include +#include + +#include "mapping_table.h" +#include "dspin_simple_ring_fast_c.h" +#include "soclib_vci_initiator.h" +#include "soclib_vci_target.h" +#include "alloc_elems.h" +#include "vci_param.h" + +#define SRCID_WIDTH 4 +#define CYCLES 100000 + +int _main(int argc, char *argv[]) +{ + using namespace sc_core; + // Avoid repeating these everywhere + using soclib::common::IntTab; + using soclib::common::Segment; + using soclib::common::alloc_elems; + + // Define VCI parameters + typedef soclib::caba::VciParams<4,8,32,1,1,1,8,4,4,1> vci_param; + + // Mapping table primary network + + soclib::common::MappingTable maptabp(32, IntTab(SRCID_WIDTH), IntTab(SRCID_WIDTH), 0x00FF0000); + + for ( size_t p = 0 ; p < 4 ; p++) + { + std::ostringstream sp; + sp << "c_seg_proc_" << p; + maptabp.add( Segment( sp.str() , (p << (32 - SRCID_WIDTH)), 0x10 , IntTab(p) , false)); + } + // Signals + + sc_clock signal_clk("clk"); + sc_signal signal_resetn("resetn"); + + soclib::caba::DspinSignals<40> * dspin_cmd = soclib::common::alloc_elems >("dspin_cmd", 5); + soclib::caba::DspinSignals<33> * dspin_rsp = soclib::common::alloc_elems >("dspin_rsp", 5); + + + soclib::caba::SoclibVciInitiator<40,33> + initp0("initp0", 4); + //soclib::caba::SoclibVciInitiator + //initp1("initp1", 1); + //soclib::caba::SoclibVciInitiator + //initp2("initp2", 2); + //soclib::caba::SoclibVciInitiator + //initp3("initp3", 3); + + soclib::caba::SoclibVciTarget<40,33> + target0("target0"); + soclib::caba::SoclibVciTarget<40,33> + target1("target1"); + soclib::caba::SoclibVciTarget<40,33> + target2("target2"); + soclib::caba::SoclibVciTarget<40,33> + target3("target3"); + + // Local ring interconnects : 1 direct ring per cluster + soclib::caba::DspinSimpleRingFastC + cluster("cluster",maptabp, IntTab(), 2, 1, 4); + + + // Initiators + initp0.p_clk(signal_clk); + initp0.p_resetn(signal_resetn); + initp0.p_cmd_out(dspin_cmd[0]); + initp0.p_rsp_in(dspin_rsp[0]); + + + // Target + target0.p_clk(signal_clk); + target0.p_resetn(signal_resetn); + target0.p_cmd_in(dspin_cmd[1]); + target0.p_rsp_out(dspin_rsp[1]); + + target1.p_clk(signal_clk); + target1.p_resetn(signal_resetn); + target1.p_cmd_in(dspin_cmd[2]); + target1.p_rsp_out(dspin_rsp[2]); + + target2.p_clk(signal_clk); + target2.p_resetn(signal_resetn); + target2.p_cmd_in(dspin_cmd[3]); + target2.p_rsp_out(dspin_rsp[3]); + + target3.p_clk(signal_clk); + target3.p_resetn(signal_resetn); + target3.p_cmd_in(dspin_cmd[4]); + target3.p_rsp_out(dspin_rsp[4]); + + cluster.p_clk(signal_clk); + cluster.p_resetn(signal_resetn); + + cluster.p_cmd_out[0](dspin_cmd[1]); + cluster.p_rsp_in[0](dspin_rsp[1]); + cluster.p_cmd_out[1](dspin_cmd[2]); + cluster.p_rsp_in[1](dspin_rsp[2]); + cluster.p_cmd_out[2](dspin_cmd[3]); + cluster.p_rsp_in[2](dspin_rsp[3]); + cluster.p_cmd_out[3](dspin_cmd[4]); + cluster.p_rsp_in[3](dspin_rsp[4]); + + cluster.p_cmd_in[0](dspin_cmd[0]); + cluster.p_rsp_out[0](dspin_rsp[0]); + + +//////////////////////////////////////////////////////// + + int ncycles; + + sc_start(sc_core::sc_time(0, SC_NS)); + signal_resetn = false; + + sc_start(sc_core::sc_time(1, SC_NS)); + signal_resetn = true; + + while(1) + { + sc_start(sc_core::sc_time(CYCLES, SC_NS)); + + } + + std::cout << "Hit ENTER to end simulation" << std::endl; + char buf[1]; + + std::cin.getline(buf,1); + + return EXIT_SUCCESS; +} + +int sc_main (int argc, char *argv[]) +{ + try { + return _main(argc, argv); + } catch (std::exception &e) { + std::cout << e.what() << std::endl; + } catch (...) { + std::cout << "Unknown exception occured" << std::endl; + throw; + } + return 1; +}