URL https://opencores.org/ocsvn/an-fpga-implementation-of-low-latency-noc-based-mpsoc/an-fpga-implementation-of-low-latency-noc-based-mpsoc/trunk

Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

[/] [an-fpga-implementation-of-low-latency-noc-based-mpsoc/] [trunk/] [mpsoc/] [src_verilator/] [topology/] [mesh.h] - Blame information for rev 56

Details | Compare with Previous | View Log


#ifndef MESH_H
        #define MESH_H
 
        #define  LOCAL          0
        #define  EAST       1
        #define  NORTH      2
        #define  WEST       3
        #define  SOUTH      4
 
        //ring line
        #define  FORWARD    1
        #define  BACKWARD   2
        #define router_id(x,y)  ((y * T1) +    x)
        #define endp_id(x,y,l)  ((y * T1) +    x) * T3 + l
 
 
 
        unsigned int nxw=0;
        unsigned int nyw=0;
        unsigned int maskx=0;
        unsigned int masky=0;
 
 
 
        void mesh_tori_addrencod_sep(unsigned int id, unsigned int *x, unsigned int *y, unsigned int *l){
                (*l)=id%T3; // id%NL
                (*x)=(id/T3)%T1;// (id/NL)%NX
                (*y)=(id/T3)/T1;// (id/NL)/NX
        }
 
 
        void mesh_tori_addr_sep(unsigned int code, unsigned int *x, unsigned int *y, unsigned int *l){
                (*x) = code &  maskx;
                code>>=nxw;
                (*y) = code &  masky;
                code>>=nyw;
                (*l) = code;
        }
 
        void ring_line_addr_sep(unsigned int code, unsigned int *x, unsigned int *l){
                (*x) = code &  maskx;
                code>>=nxw;
                (*l) = code;
        }
 
        unsigned int mesh_tori_addr_join(unsigned int x, unsigned int y, unsigned int l){
                unsigned int addrencode=0;
                addrencode =(T3==1)?   (y<<nxw | x) : (l<<(nxw+nyw)|  (y<<nxw) | x);
                return addrencode;
        }
 
    unsigned int ring_line_addr_join(unsigned int x, unsigned int l){
                unsigned int addrencode=0;
                addrencode =(T3==1)?   x : (l<<nxw) | x;
                return addrencode;
        }
 
 
        unsigned int mesh_tori_addrencode (unsigned int id){
                unsigned int y, x, l;
                mesh_tori_addrencod_sep(id,&x,&y,&l);
                return mesh_tori_addr_join(x,y,l);
        }
 
        unsigned int ring_line_addrencode (unsigned int id){
                unsigned int y , x, l;
                mesh_tori_addrencod_sep(id,&x,&y,&l);
                return ring_line_addr_join(x,l);
        }
 
 
        void fmesh_addrencod_sep(unsigned int id, unsigned int *x, unsigned int *y, unsigned int *p){
                unsigned int  l, diff,mul,addrencode;
                mul  = T1*T2*T3;
                if(id < mul) {
                        *y = ((id/T3) / T1 );
                        *x = ((id/T3) % T1 );
                        l = (id % T3);
                        *p = (l==0)? LOCAL : 4+l;
                }else{
                        diff = id -  mul ;
                        if( diff <  T1) { //top mesh edge
                                        *y = 0;
                                        *x = diff;
                                        *p = NORTH;
                        } else if  ( diff < 2* T1) { //bottom mesh edge
                                        *y = T2-1;
                                        *x = diff-T1;
                                        *p = SOUTH;
                        } else if  ( diff < (2* T1) + T2 ) { //left mesh edge
                                        *y = diff - (2* T1);
                                        *x = 0;
                                        *p = WEST;
                        } else { //right mesh edge
                                        *y = diff - (2* T1) -T2;
                                        *x = T1-1;
                                        *p = EAST;
                        }
                }
 
        }
 
 
        unsigned int fmesh_addrencode(unsigned int id){
        //input integer in,nx,nxw,nl,nyw,ny;
                unsigned int  y, x, p, addrencode;
                fmesh_addrencod_sep(id, &x, &y, &p);
                addrencode = ( p<<(nxw+nyw) | (y<<nxw) | x);
                return addrencode;
        }
 
 
        unsigned int fmesh_endp_addr_decoder (unsigned int code){
                unsigned int x, y, p;
                mesh_tori_addr_sep(code,&x,&y,&p);
                if(p== LOCAL)   return ((y*T1)+x)*T3;
                if(p > SOUTH)   return ((y*T1)+x)*T3+(p-SOUTH);
                if(p== NORTH)   return ((T1*T2*T3) + x);
                if(p== SOUTH)   return ((T1*T2*T3) + T1 + x);
                if(p== WEST )   return ((T1*T2*T3) + 2*T1 + y);
                if(p== EAST )   return ((T1*T2*T3) + 2*T1 + T2 + y);
                return 0;//should not reach here
        }
 
 
 
 
 
 
        unsigned int mesh_tori_endp_addr_decoder (unsigned int code){
                unsigned int x, y, l;
                mesh_tori_addr_sep(code,&x,&y,&l);
                //if(code==0x1a) printf("code=%x,x=%u,y=%u,l=%u\n",code,x,y,l);
                return ((y*T1)+x)*T3+l;
        }
 
        unsigned int ring_line_endp_addr_decoder (unsigned int code){
                unsigned int x, l;
                ring_line_addr_sep(code,&x,&l);
                //if(code==0x1a) printf("code=%x,x=%u,y=%u,l=%u\n",code,x,y,l);
                return x*T3+l;
        }
 
 
 
 
        unsigned int endp_addr_encoder ( unsigned int id){
                        #if defined (IS_MESH) || defined (IS_TORUS)
                                return mesh_tori_addrencode(id);
                        #elif  defined (IS_LINE) || defined (IS_RING )
                                return ring_line_addrencode(id);
                        #else
                                return fmesh_addrencode(id);
                        #endif
        }
 
 
        unsigned int endp_addr_decoder (unsigned int code){
                #if defined (IS_MESH) || defined (IS_TORUS)
                        return mesh_tori_endp_addr_decoder (code);
                #elif defined (IS_LINE) || defined (IS_RING )
                        return ring_line_endp_addr_decoder (code);
                #endif
                return fmesh_endp_addr_decoder (code);
        }
 
 
void topology_connect_r2r (int n){
        conect_r2r(1,r2r_cnt_all[n].r1,r2r_cnt_all[n].p1,1,r2r_cnt_all[n].r2,r2r_cnt_all[n].p2);
}
 
void topology_connect_r2e (int n){
        connect_r2e(1,r2e_cnt_all[n].r1,r2e_cnt_all[n].p1,n);
}
 
 
 
 
 
 
 
 
 
void topology_connect_all_nodes_old (void){
 
 
        unsigned int  x,y,l;
        #if defined (IS_LINE) || defined (IS_RING )
                        #define R2R_CHANELS_MESH_TORI   2
                        for  (x=0;   x<T1; x=x+1) {
 
                                router1[x]->current_r_addr = x;
                                router1[x]->current_r_id   = x;
                                if(x    <   T1-1){// not_last_node
                                        //assign  router_chan_in[x][FORWARD] = router_chan_out [(x+1)][BACKWARD];
                                        conect_r2r(1,x,FORWARD,1,(x+1),BACKWARD);
 
                                } else { //last_node
 
                                        #if defined (IS_LINE) // : line_last_x
                                                //assign  router_chan_in[x][FORWARD]= {SMARTFLIT_CHANEL_w{1'b0}};
                                                connect_r2gnd(1,x,FORWARD);
                                        #else // : ring_last_x
                                                //assign router_chan_in[x][FORWARD]= router_chan_out [0][BACKWARD];
                                                conect_r2r(1,x,FORWARD,1,0,BACKWARD);
                                        #endif
                                }
 
                                if(x>0){// :not_first_x
                                        //assign router_chan_in[x][BACKWARD]= router_chan_out [(x-1)][FORWARD];
                                        conect_r2r(1,x,BACKWARD,1,(x-1),FORWARD);
 
                                }else {// :first_x
                                        #if defined (IS_LINE) // : line_first_x
                                                //assign  router_chan_in[x][BACKWARD]={SMARTFLIT_CHANEL_w{1'b0}};                                       
                                                connect_r2gnd(1,x,BACKWARD);
                                        #else // : ring_first_x
                                                //assign  router_chan_in[x][BACKWARD]= router_chan_out [(NX-1)][FORWARD];                                                                                       
                                                conect_r2r(1,x,BACKWARD,1,(T1-1),FORWARD);
                                        #endif
                                }
 
                                // connect other local ports
                                for  (l=0;   l<T3; l=l+1) {// :locals
                                        unsigned int ENDPID = endp_id(x,0,l);
                                        unsigned int LOCALP = (l==0) ? l : l + R2R_CHANELS_MESH_TORI; // first local port is connected to router port 0. The rest are connected at the }
                                        //assign router_chan_in[x][LOCALP]= chan_in_all [ENDPID];
                                        //assign chan_out_all [ENDPID] = router_chan_out[x][LOCALP];
                                        connect_r2e(1,x,LOCALP,ENDPID);
                                        er_addr [ENDPID] = x;
 
                                }// locals
                        }//x
 
                #else // :mesh_torus
                        #define R2R_CHANELS_MESH_TORI   4
                        for (y=0;    y<T2;    y=y+1) {//: y_loop
                                for (x=0;    x<T1; x=x+1) {// :x_loop
                                unsigned int R_ADDR = (y<<nxw) + x;
                                unsigned int ROUTER_NUM = (y * T1) +    x;
                                //assign current_r_addr [ROUTER_NUM] = R_ADDR[RAw-1 :0];
                router1[ROUTER_NUM]->current_r_addr = R_ADDR;
                router1[ROUTER_NUM]->current_r_id   = ROUTER_NUM;
 
                                if(x    <    T1-1) {//: not_last_x
                                        //assign router_chan_in[`router_id(x,y)][EAST]= router_chan_out [`router_id(x+1,y)][WEST];
                                        conect_r2r(1,router_id(x,y),EAST,1,router_id(x+1,y),WEST);
 
                                }else {// :last_x
                                        #if defined (IS_MESH) // :last_x_mesh
                                                //      assign router_chan_in[`router_id(x,y)][EAST] = {SMARTFLIT_CHANEL_w{1'b0}};                                      
                                                connect_r2gnd(1,router_id(x,y),EAST);
                                        #elif defined (IS_TORUS) // : last_x_torus
                                                //assign router_chan_in[`router_id(x,y)][EAST] = router_chan_out [`router_id(0,y)][WEST];
                                                conect_r2r(1,router_id(x,y),EAST,1,router_id(0,y),WEST);
                                        #elif defined (IS_FMESH) //:last_x_fmesh
                                                //connect to endp
                                                unsigned int  EAST_ID = T1*T2*T3 + 2*T1 + T2 + y;
                                                connect_r2e(1,router_id(x,y),EAST,EAST_ID);
                                                er_addr [EAST_ID] = R_ADDR;
                                        #endif//topology
                                }
 
 
                                if(y>0) {// : not_first_y
                                        //assign router_chan_in[`router_id(x,y)][NORTH] =  router_chan_out [`router_id(x,(y-1))][SOUTH];                                        
                                        conect_r2r(1,router_id(x,y),NORTH,1,router_id(x,(y-1)),SOUTH);
                                }else {// :first_y
                                        #if defined (IS_MESH) // : first_y_mesh
                                                //assign router_chan_in[`router_id(x,y)][NORTH] =  {SMARTFLIT_CHANEL_w{1'b0}};                                                                                          
                                                connect_r2gnd(1,router_id(x,y),NORTH);
                                        #elif defined (IS_TORUS)// :first_y_torus
                                                //assign router_chan_in[`router_id(x,y)][NORTH] =  router_chan_out [`router_id(x,(T2-1))][SOUTH];
                                                conect_r2r(1,router_id(x,y),NORTH,1,router_id(x,(T2-1)),SOUTH);
                                        #elif defined (IS_FMESH) // :first_y_fmesh
                                                unsigned int NORTH_ID = T1*T2*T3 + x;
                                                connect_r2e(1,router_id(x,y),NORTH,NORTH_ID);
                                                er_addr [NORTH_ID] = R_ADDR;
                                        #endif//topology
                                }//y>0
 
 
                                if(x>0){// :not_first_x
                                        //assign    router_chan_in[`router_id(x,y)][WEST] =  router_chan_out [`router_id((x-1),y)][EAST];                                       
                                        conect_r2r(1,router_id(x,y),WEST,1,router_id((x-1),y),EAST);
                                }else {// :first_x
 
                                        #if defined (IS_MESH) // :first_x_mesh
                                                //assign    router_chan_in[`router_id(x,y)][WEST] =   {SMARTFLIT_CHANEL_w{1'b0}};
                                                connect_r2gnd(1,router_id(x,y),WEST);
 
                                        #elif defined (IS_TORUS) // :first_x_torus
                                                //assign    router_chan_in[`router_id(x,y)][WEST] =   router_chan_out [`router_id((NX-1),y)][EAST] ;                                            
                                                conect_r2r(1,router_id(x,y),WEST,1,router_id((T1-1),y),EAST);
                                        #elif defined (IS_FMESH) // :first_x_fmesh
                                                unsigned int WEST_ID = T1*T2*T3 + 2*T1 + y;
                                                connect_r2e(1,router_id(x,y),WEST,WEST_ID);
                                                er_addr [WEST_ID] = R_ADDR;
                                        #endif//topology
                                }
 
                                if(y    <    T2-1) {// : firsty
                                        //assign  router_chan_in[`router_id(x,y)][SOUTH] =    router_chan_out [`router_id(x,(y+1))][NORTH];                                     
                                        conect_r2r(1,router_id(x,y),SOUTH,1,router_id(x,(y+1)),NORTH);
                                }else     {// : lasty
 
                                        #if defined (IS_MESH) // :ly_mesh
 
                                                //assign  router_chan_in[`router_id(x,y)][SOUTH]=  {SMARTFLIT_CHANEL_w{1'b0}};
                                                connect_r2gnd(1,router_id(x,y),SOUTH);
 
                                        #elif defined (IS_TORUS) // :ly_torus
                                                //assign  router_chan_in[`router_id(x,y)][SOUTH]=    router_chan_out [`router_id(x,0)][NORTH];
                                                conect_r2r(1,router_id(x,y),SOUTH,1,router_id(x,0),NORTH);
                                        #elif defined (IS_FMESH)  // :ly_Fmesh
                                                unsigned int SOUTH_ID = T1*T2*T3 + T1 + x;
                                                connect_r2e(1,router_id(x,y),SOUTH,SOUTH_ID);
                                                er_addr [SOUTH_ID] = R_ADDR;
                                        #endif//topology
                                }
 
 
                                // endpoint(s) connection
                                // connect other local ports
                                for  (l=0;   l<T3; l=l+1) {// :locals
                                        unsigned int ENDPID = endp_id(x,y,l);
                                        unsigned int LOCALP = (l==0) ? l : l + R2R_CHANELS_MESH_TORI; // first local port is connected to router port 0. The rest are connected at the }
 
                                        //assign router_chan_in [`router_id(x,y)][LOCALP] =    chan_in_all [ENDPID];
                                        //assign chan_out_all [ENDPID] = router_chan_out [`router_id(x,y)][LOCALP];     
                                        //assign er_addr [ENDPID] = R_ADDR;             
                    connect_r2e(1,router_id(x,y),LOCALP,ENDPID);
                                        er_addr [ENDPID] = R_ADDR;
                                }// locals
 
                        }//y
                }//x
        #endif
 
 
}
 
#define fill_r2r_cnt(T1,R1,P1,T2,R2,P2) (r2r_cnt_table_t){.id1=R1,.t1=T1,.r1=R1,.p1=P1,.id2=R2,.t2=T2,.r2=R2,.p2=P2}
 
void topology_init(void){
        nxw=Log2(T1);
        nyw=Log2(T2);
    maskx = (0x1<<nxw)-1;
    masky = (0x1<<nyw)-1;
    unsigned int num=0;
    unsigned int  x,y,l;
    #if defined (IS_LINE) || defined (IS_RING )
        #define R2R_CHANELS_MESH_TORI   2
        for  (x=0;   x<T1; x=x+1) {
 
                router1[x]->current_r_addr = x;
                router1[x]->current_r_id   = x;
                if(x    <   T1-1){// not_last_node
                        //assign  router_chan_in[x][FORWARD] = router_chan_out [(x+1)][BACKWARD];
                        //conect_r2r(1,x,FORWARD,1,(x+1),BACKWARD);
                        r2r_cnt_all[num]=fill_r2r_cnt(1,x,FORWARD,1,(x+1),BACKWARD);
                        num++;
                } else { //last_node
                                        #if defined (IS_LINE) // : line_last_x
                                //assign  router_chan_in[x][FORWARD]= {SMARTFLIT_CHANEL_w{1'b0}};
                                        connect_r2gnd(1,x,FORWARD);
                                #else // : ring_last_x
                                //assign router_chan_in[x][FORWARD]= router_chan_out [0][BACKWARD];
                                        //conect_r2r(1,x,FORWARD,1,0,BACKWARD);
                                        r2r_cnt_all[num]=fill_r2r_cnt(1,x,FORWARD,1,0,BACKWARD);
                                        num++;
                                #endif
                        }
 
                                if(x>0){// :not_first_x
                                        //assign router_chan_in[x][BACKWARD]= router_chan_out [(x-1)][FORWARD];
                                        //conect_r2r(1,x,BACKWARD,1,(x-1),FORWARD);
                                        r2r_cnt_all[num]=fill_r2r_cnt(1,x,BACKWARD,1,(x-1),FORWARD);
                                        num++;
                                }else {// :first_x
                                        #if defined (IS_LINE) // : line_first_x
                                                //assign  router_chan_in[x][BACKWARD]={SMARTFLIT_CHANEL_w{1'b0}};
                                                connect_r2gnd(1,x,BACKWARD);
                                        #else // : ring_first_x
                                                //assign  router_chan_in[x][BACKWARD]= router_chan_out [(NX-1)][FORWARD];
                                                //conect_r2r(1,x,BACKWARD,1,(T1-1),FORWARD);
                                                r2r_cnt_all[num]=fill_r2r_cnt(1,x,BACKWARD,1,(T1-1),FORWARD);
                                                num++;
                                        #endif
                                }
 
                                // connect other local ports
                                for  (l=0;   l<T3; l=l+1) {// :locals
                                        unsigned int ENDPID = endp_id(x,0,l);
                                        unsigned int LOCALP = (l==0) ? l : l + R2R_CHANELS_MESH_TORI; // first local port is connected to router port 0. The rest are connected at the }
                                        //assign router_chan_in[x][LOCALP]= chan_in_all [ENDPID];
                                        //assign chan_out_all [ENDPID] = router_chan_out[x][LOCALP];
                                        //connect_r2e(1,x,LOCALP,ENDPID);
                                        r2e_cnt_all[ENDPID].r1=x;
                                        r2e_cnt_all[ENDPID].p1=LOCALP;
                                        er_addr [ENDPID] = x;
 
                                }// locals
                        }//x
 
                #else // :mesh_torus
                        #define R2R_CHANELS_MESH_TORI   4
                        for (y=0;    y<T2;    y=y+1) {//: y_loop
                                for (x=0;    x<T1; x=x+1) {// :x_loop
                                unsigned int R_ADDR = (y<<nxw) + x;
                                unsigned int ROUTER_NUM = (y * T1) +    x;
                                //assign current_r_addr [ROUTER_NUM] = R_ADDR[RAw-1 :0];
                        router1[ROUTER_NUM]->current_r_addr = R_ADDR;
                        router1[ROUTER_NUM]->current_r_id   = ROUTER_NUM;
 
                                if(x    <    T1-1) {//: not_last_x
                                        //assign router_chan_in[`router_id(x,y)][EAST]= router_chan_out [`router_id(x+1,y)][WEST];
                                        //conect_r2r(1,router_id(x,y),EAST,1,router_id(x+1,y),WEST);
                                        r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),EAST,1,router_id(x+1,y),WEST);
                                        num++;
 
                                }else {// :last_x
                                        #if defined (IS_MESH) // :last_x_mesh
                                                //      assign router_chan_in[`router_id(x,y)][EAST] = {SMARTFLIT_CHANEL_w{1'b0}};
                                                connect_r2gnd(1,router_id(x,y),EAST);
                                        #elif defined (IS_TORUS) // : last_x_torus
                                                //assign router_chan_in[`router_id(x,y)][EAST] = router_chan_out [`router_id(0,y)][WEST];
                                                //conect_r2r(1,router_id(x,y),EAST,1,router_id(0,y),WEST);
                                                r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),EAST,1,router_id(0,y),WEST);
                                                num++;
                                        #elif defined (IS_FMESH) //:last_x_fmesh
                                                //connect to endp
                                                unsigned int  EAST_ID = T1*T2*T3 + 2*T1 + T2 + y;
                                                //connect_r2e(1,router_id(x,y),EAST,EAST_ID);
                                                r2e_cnt_all[EAST_ID].r1=router_id(x,y);
                                                r2e_cnt_all[EAST_ID].p1=EAST;
                                                er_addr [EAST_ID] = R_ADDR;
                                        #endif//topology
                                }
 
 
                                if(y>0) {// : not_first_y
                                        //assign router_chan_in[`router_id(x,y)][NORTH] =  router_chan_out [`router_id(x,(y-1))][SOUTH];
                                        //conect_r2r(1,router_id(x,y),NORTH,1,router_id(x,(y-1)),SOUTH);
                                        r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),NORTH,1,router_id(x,(y-1)),SOUTH);
                                        num++;
                                }else {// :first_y
                                        #if defined (IS_MESH) // : first_y_mesh
                                                //assign router_chan_in[`router_id(x,y)][NORTH] =  {SMARTFLIT_CHANEL_w{1'b0}};
                                                connect_r2gnd(1,router_id(x,y),NORTH);
                                        #elif defined (IS_TORUS)// :first_y_torus
                                                //assign router_chan_in[`router_id(x,y)][NORTH] =  router_chan_out [`router_id(x,(T2-1))][SOUTH];
                                                //conect_r2r(1,router_id(x,y),NORTH,1,router_id(x,(T2-1)),SOUTH);
                                                r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),NORTH,1,router_id(x,(T2-1)),SOUTH);
                                                num++;
                                        #elif defined (IS_FMESH) // :first_y_fmesh
                                                unsigned int NORTH_ID = T1*T2*T3 + x;
                                                //connect_r2e(1,router_id(x,y),NORTH,NORTH_ID);
                                                r2e_cnt_all[NORTH_ID].r1=router_id(x,y);
                                                r2e_cnt_all[NORTH_ID].p1=NORTH;
                                                er_addr [NORTH_ID] = R_ADDR;
                                        #endif//topology
                                }//y>0
 
 
                                if(x>0){// :not_first_x
                                        //assign    router_chan_in[`router_id(x,y)][WEST] =  router_chan_out [`router_id((x-1),y)][EAST];
                                        //conect_r2r(1,router_id(x,y),WEST,1,router_id((x-1),y),EAST);
                                        r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),WEST,1,router_id((x-1),y),EAST);
                                        num++;
 
                                }else {// :first_x
 
                                        #if defined (IS_MESH) // :first_x_mesh
                                                //assign    router_chan_in[`router_id(x,y)][WEST] =   {SMARTFLIT_CHANEL_w{1'b0}};
                                                connect_r2gnd(1,router_id(x,y),WEST);
 
                                        #elif defined (IS_TORUS) // :first_x_torus
                                                //assign    router_chan_in[`router_id(x,y)][WEST] =   router_chan_out [`router_id((NX-1),y)][EAST] ;
                                                //conect_r2r(1,router_id(x,y),WEST,1,router_id((T1-1),y),EAST);
                                                r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),WEST,1,router_id((T1-1),y),EAST);
                                                num++;
                                        #elif defined (IS_FMESH) // :first_x_fmesh
                                                unsigned int WEST_ID = T1*T2*T3 + 2*T1 + y;
                                                //connect_r2e(1,router_id(x,y),WEST,WEST_ID);
                                                r2e_cnt_all[WEST_ID].r1=router_id(x,y);
                                                r2e_cnt_all[WEST_ID].p1=WEST;
                                                er_addr [WEST_ID] = R_ADDR;
                                        #endif//topology
                                }
 
                                if(y    <    T2-1) {// : firsty
                                        //assign  router_chan_in[`router_id(x,y)][SOUTH] =    router_chan_out [`router_id(x,(y+1))][NORTH];
                                //      conect_r2r(1,router_id(x,y),SOUTH,1,router_id(x,(y+1)),NORTH);
                                        r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),SOUTH,1,router_id(x,(y+1)),NORTH);
                                        num++;
                                }else     {// : lasty
 
                                        #if defined (IS_MESH) // :ly_mesh
 
                                                //assign  router_chan_in[`router_id(x,y)][SOUTH]=  {SMARTFLIT_CHANEL_w{1'b0}};
                                                connect_r2gnd(1,router_id(x,y),SOUTH);
 
                                        #elif defined (IS_TORUS) // :ly_torus
                                                //assign  router_chan_in[`router_id(x,y)][SOUTH]=    router_chan_out [`router_id(x,0)][NORTH];
                                        //      conect_r2r(1,router_id(x,y),SOUTH,1,router_id(x,0),NORTH);
                                                r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),SOUTH,1,router_id(x,0),NORTH);
                                                num++;
                                        #elif defined (IS_FMESH)  // :ly_Fmesh
                                                unsigned int SOUTH_ID = T1*T2*T3 + T1 + x;
                                                //connect_r2e(1,router_id(x,y),SOUTH,SOUTH_ID);
                                                r2e_cnt_all[SOUTH_ID].r1=router_id(x,y);
                                                r2e_cnt_all[SOUTH_ID].p1=SOUTH;
                                                er_addr [SOUTH_ID] = R_ADDR;
                                        #endif//topology
                                }
 
 
                                // endpoint(s) connection
                                // connect other local ports
                                for  (l=0;   l<T3; l=l+1) {// :locals
                                        unsigned int ENDPID = endp_id(x,y,l);
                                        unsigned int LOCALP = (l==0) ? l : l + R2R_CHANELS_MESH_TORI; // first local port is connected to router port 0. The rest are connected at the }
 
                                        //assign router_chan_in [`router_id(x,y)][LOCALP] =    chan_in_all [ENDPID];
                                        //assign chan_out_all [ENDPID] = router_chan_out [`router_id(x,y)][LOCALP];
                                        //assign er_addr [ENDPID] = R_ADDR;
                       // connect_r2e(1,router_id(x,y),LOCALP,ENDPID);
                        r2e_cnt_all[ENDPID].r1=router_id(x,y);
                        r2e_cnt_all[ENDPID].p1=LOCALP;
                                        er_addr [ENDPID] = R_ADDR;
                                }// locals
 
                        }//y
                }//x
        #endif
 
        R2R_TABLE_SIZ=num;
 
}
 
 
unsigned int get_mah_distance ( unsigned int id1, unsigned int id2){
        #if defined (IS_FMESH)
                unsigned int x1,y1,p1,x2,y2,p2;
                fmesh_addrencod_sep        ( id1, &x1, &y1, &p1);
                fmesh_addrencod_sep        ( id2, &x2, &y2, &p2);
    #else
                unsigned int x1,y1,l1,x2,y2,l2;
                mesh_tori_addrencod_sep(id1, &x1, &y1, &l1);
                mesh_tori_addrencod_sep(id2, &x2, &y2, &l2);
        #endif
 
        unsigned int x_diff = (x1 > x2) ? (x1 - x2) : (x2 - x1);
        unsigned int y_diff = (y1 > y2) ? (y1 - y2) : (y2 - y1);
        return x_diff + y_diff;
}
 
 
#endif

Line No.	Rev	Author	Line
1	48	alirezamon	`#ifndef MESH_H`
2			`#define MESH_H`
3
4			`#define LOCAL 0`
5	56	alirezamon	`#define EAST 1`
6			`#define NORTH 2`
7			`#define WEST 3`
8	48	alirezamon	`#define SOUTH 4`
9
10	56	alirezamon	`//ring line`
11	48	alirezamon	`#define FORWARD 1`
12			`#define BACKWARD 2`
13			`#define router_id(x,y) ((y * T1) + x)`
14	56	alirezamon	`#define endp_id(x,y,l) ((y * T1) + x) * T3 + l`
15	48	alirezamon
16
17
18			`unsigned int nxw=0;`
19			`unsigned int nyw=0;`
20			`unsigned int maskx=0;`
21			`unsigned int masky=0;`
22
23
24
25			`void mesh_tori_addrencod_sep(unsigned int id, unsigned int x, unsigned int y, unsigned int *l){`
26			`(*l)=id%T3; // id%NL`
27			`(*x)=(id/T3)%T1;// (id/NL)%NX`
28			`(*y)=(id/T3)/T1;// (id/NL)/NX`
29			`}`
30
31
32			`void mesh_tori_addr_sep(unsigned int code, unsigned int x, unsigned int y, unsigned int *l){`
33			`(*x) = code & maskx;`
34			`code>>=nxw;`
35			`(*y) = code & masky;`
36			`code>>=nyw;`
37			`(*l) = code;`
38			`}`
39
40	56	alirezamon	`void ring_line_addr_sep(unsigned int code, unsigned int x, unsigned int l){`
41			`(*x) = code & maskx;`
42			`code>>=nxw;`
43			`(*l) = code;`
44			`}`
45	48	alirezamon
46			`unsigned int mesh_tori_addr_join(unsigned int x, unsigned int y, unsigned int l){`
47			`unsigned int addrencode=0;`
48			`addrencode =(T3==1)? (y<<nxw \| x) : (l<<(nxw+nyw)\| (y<<nxw) \| x);`
49			`return addrencode;`
50			`}`
51
52	56	alirezamon	`unsigned int ring_line_addr_join(unsigned int x, unsigned int l){`
53			`unsigned int addrencode=0;`
54			`addrencode =(T3==1)? x : (l<<nxw) \| x;`
55			`return addrencode;`
56			`}`
57
58
59	48	alirezamon	`unsigned int mesh_tori_addrencode (unsigned int id){`
60			`unsigned int y, x, l;`
61			`mesh_tori_addrencod_sep(id,&x,&y,&l);`
62			`return mesh_tori_addr_join(x,y,l);`
63			`}`
64
65	56	alirezamon	`unsigned int ring_line_addrencode (unsigned int id){`
66			`unsigned int y , x, l;`
67			`mesh_tori_addrencod_sep(id,&x,&y,&l);`
68			`return ring_line_addr_join(x,l);`
69			`}`
70	48	alirezamon
71	56	alirezamon
72	48	alirezamon	`void fmesh_addrencod_sep(unsigned int id, unsigned int x, unsigned int y, unsigned int *p){`
73			`unsigned int l, diff,mul,addrencode;`
74			`mul = T1T2T3;`
75			`if(id < mul) {`
76			`*y = ((id/T3) / T1 );`
77			`*x = ((id/T3) % T1 );`
78			`l = (id % T3);`
79			`*p = (l==0)? LOCAL : 4+l;`
80			`}else{`
81			`diff = id - mul ;`
82			`if( diff < T1) { //top mesh edge`
83			`*y = 0;`
84			`*x = diff;`
85			`*p = NORTH;`
86			`} else if ( diff < 2* T1) { //bottom mesh edge`
87			`*y = T2-1;`
88			`*x = diff-T1;`
89			`*p = SOUTH;`
90			`} else if ( diff < (2* T1) + T2 ) { //left mesh edge`
91			`y = diff - (2 T1);`
92			`*x = 0;`
93			`*p = WEST;`
94			`} else { //right mesh edge`
95			`y = diff - (2 T1) -T2;`
96			`*x = T1-1;`
97			`*p = EAST;`
98			`}`
99			`}`
100
101			`}`
102
103
104			`unsigned int fmesh_addrencode(unsigned int id){`
105			`//input integer in,nx,nxw,nl,nyw,ny;`
106			`unsigned int y, x, p, addrencode;`
107			`fmesh_addrencod_sep(id, &x, &y, &p);`
108			`addrencode = ( p<<(nxw+nyw) \| (y<<nxw) \| x);`
109			`return addrencode;`
110			`}`
111
112
113			`unsigned int fmesh_endp_addr_decoder (unsigned int code){`
114			`unsigned int x, y, p;`
115			`mesh_tori_addr_sep(code,&x,&y,&p);`
116			`if(p== LOCAL) return ((yT1)+x)T3;`
117			`if(p > SOUTH) return ((yT1)+x)T3+(p-SOUTH);`
118			`if(p== NORTH) return ((T1T2T3) + x);`
119			`if(p== SOUTH) return ((T1T2T3) + T1 + x);`
120			`if(p== WEST ) return ((T1T2T3) + 2*T1 + y);`
121			`if(p== EAST ) return ((T1T2T3) + 2*T1 + T2 + y);`
122			`return 0;//should not reach here`
123			`}`
124
125
126
127
128
129
130			`unsigned int mesh_tori_endp_addr_decoder (unsigned int code){`
131			`unsigned int x, y, l;`
132			`mesh_tori_addr_sep(code,&x,&y,&l);`
133			`//if(code==0x1a) printf("code=%x,x=%u,y=%u,l=%u\n",code,x,y,l);`
134			`return ((yT1)+x)T3+l;`
135			`}`
136
137	56	alirezamon	`unsigned int ring_line_endp_addr_decoder (unsigned int code){`
138			`unsigned int x, l;`
139			`ring_line_addr_sep(code,&x,&l);`
140			`//if(code==0x1a) printf("code=%x,x=%u,y=%u,l=%u\n",code,x,y,l);`
141			`return x*T3+l;`
142			`}`
143	48	alirezamon
144	56	alirezamon
145
146
147	48	alirezamon	`unsigned int endp_addr_encoder ( unsigned int id){`
148	56	alirezamon	`#if defined (IS_MESH) \|\| defined (IS_TORUS)`
149	48	alirezamon	`return mesh_tori_addrencode(id);`
150	56	alirezamon	`#elif defined (IS_LINE) \|\| defined (IS_RING )`
151			`return ring_line_addrencode(id);`
152			`#else`
153			`return fmesh_addrencode(id);`
154	48	alirezamon	`#endif`
155			`}`
156
157
158			`unsigned int endp_addr_decoder (unsigned int code){`
159	56	alirezamon	`#if defined (IS_MESH) \|\| defined (IS_TORUS)`
160	48	alirezamon	`return mesh_tori_endp_addr_decoder (code);`
161	56	alirezamon	`#elif defined (IS_LINE) \|\| defined (IS_RING )`
162			`return ring_line_endp_addr_decoder (code);`
163	48	alirezamon	`#endif`
164			`return fmesh_endp_addr_decoder (code);`
165			`}`
166
167
168	54	alirezamon	`void topology_connect_r2r (int n){`
169			`conect_r2r(1,r2r_cnt_all[n].r1,r2r_cnt_all[n].p1,1,r2r_cnt_all[n].r2,r2r_cnt_all[n].p2);`
170			`}`
171	48	alirezamon
172	54	alirezamon	`void topology_connect_r2e (int n){`
173			`connect_r2e(1,r2e_cnt_all[n].r1,r2e_cnt_all[n].p1,n);`
174			`}`
175	48	alirezamon
176
177	54	alirezamon
178
179
180
181
182
183
184			`void topology_connect_all_nodes_old (void){`
185
186	48	alirezamon
187			`unsigned int x,y,l;`
188	56	alirezamon	`#if defined (IS_LINE) \|\| defined (IS_RING )`
189			`#define R2R_CHANELS_MESH_TORI 2`
190			`for (x=0; x<T1; x=x+1) {`
191
192	54	alirezamon	`router1[x]->current_r_addr = x;`
193			`router1[x]->current_r_id = x;`
194	56	alirezamon	`if(x < T1-1){// not_last_node`
195	48	alirezamon	`//assign router_chan_in[x][FORWARD] = router_chan_out [(x+1)][BACKWARD];`
196			`conect_r2r(1,x,FORWARD,1,(x+1),BACKWARD);`
197
198			`} else { //last_node`
199
200			`#if defined (IS_LINE) // : line_last_x`
201			`//assign router_chan_in[x][FORWARD]= {SMARTFLIT_CHANEL_w{1'b0}};`
202	56	alirezamon	`connect_r2gnd(1,x,FORWARD);`
203	48	alirezamon	`#else // : ring_last_x`
204			`//assign router_chan_in[x][FORWARD]= router_chan_out [0][BACKWARD];`
205			`conect_r2r(1,x,FORWARD,1,0,BACKWARD);`
206			`#endif`
207			`}`
208	56	alirezamon
209	48	alirezamon	`if(x>0){// :not_first_x`
210			`//assign router_chan_in[x][BACKWARD]= router_chan_out [(x-1)][FORWARD];`
211			`conect_r2r(1,x,BACKWARD,1,(x-1),FORWARD);`
212
213			`}else {// :first_x`
214			`#if defined (IS_LINE) // : line_first_x`
215			`//assign router_chan_in[x][BACKWARD]={SMARTFLIT_CHANEL_w{1'b0}};`
216			`connect_r2gnd(1,x,BACKWARD);`
217			`#else // : ring_first_x`
218			`//assign router_chan_in[x][BACKWARD]= router_chan_out [(NX-1)][FORWARD];`
219			`conect_r2r(1,x,BACKWARD,1,(T1-1),FORWARD);`
220			`#endif`
221	56	alirezamon	`}`
222
223	48	alirezamon	`// connect other local ports`
224			`for (l=0; l<T3; l=l+1) {// :locals`
225	56	alirezamon	`unsigned int ENDPID = endp_id(x,0,l);`
226			`unsigned int LOCALP = (l==0) ? l : l + R2R_CHANELS_MESH_TORI; // first local port is connected to router port 0. The rest are connected at the }`
227	48	alirezamon	`//assign router_chan_in[x][LOCALP]= chan_in_all [ENDPID];`
228			`//assign chan_out_all [ENDPID] = router_chan_out[x][LOCALP];`
229			`connect_r2e(1,x,LOCALP,ENDPID);`
230	56	alirezamon	`er_addr [ENDPID] = x;`
231
232			`}// locals`
233			`}//x`
234	48	alirezamon
235			`#else // :mesh_torus`
236	56	alirezamon	`#define R2R_CHANELS_MESH_TORI 4`
237	48	alirezamon	`for (y=0; y<T2; y=y+1) {//: y_loop`
238			`for (x=0; x<T1; x=x+1) {// :x_loop`
239	56	alirezamon	`unsigned int R_ADDR = (y<<nxw) + x;`
240	48	alirezamon	`unsigned int ROUTER_NUM = (y * T1) + x;`
241			`//assign current_r_addr [ROUTER_NUM] = R_ADDR[RAw-1 :0];`
242	56	alirezamon	`router1[ROUTER_NUM]->current_r_addr = R_ADDR;`
243	54	alirezamon	`router1[ROUTER_NUM]->current_r_id = ROUTER_NUM;`
244	56	alirezamon
245	48	alirezamon	`if(x < T1-1) {//: not_last_x`
246			//assign router_chan_in[`router_id(x,y)][EAST]= router_chan_out [`router_id(x+1,y)][WEST];
247			`conect_r2r(1,router_id(x,y),EAST,1,router_id(x+1,y),WEST);`
248
249			`}else {// :last_x`
250			`#if defined (IS_MESH) // :last_x_mesh`
251			// assign router_chan_in[`router_id(x,y)][EAST] = {SMARTFLIT_CHANEL_w{1'b0}};
252			`connect_r2gnd(1,router_id(x,y),EAST);`
253			`#elif defined (IS_TORUS) // : last_x_torus`
254			//assign router_chan_in[`router_id(x,y)][EAST] = router_chan_out [`router_id(0,y)][WEST];
255			`conect_r2r(1,router_id(x,y),EAST,1,router_id(0,y),WEST);`
256			`#elif defined (IS_FMESH) //:last_x_fmesh`
257			`//connect to endp`
258			`unsigned int EAST_ID = T1T2T3 + 2*T1 + T2 + y;`
259			`connect_r2e(1,router_id(x,y),EAST,EAST_ID);`
260			`er_addr [EAST_ID] = R_ADDR;`
261			`#endif//topology`
262			`}`
263	56	alirezamon
264
265	48	alirezamon	`if(y>0) {// : not_first_y`
266			//assign router_chan_in[`router_id(x,y)][NORTH] = router_chan_out [`router_id(x,(y-1))][SOUTH];
267			`conect_r2r(1,router_id(x,y),NORTH,1,router_id(x,(y-1)),SOUTH);`
268			`}else {// :first_y`
269			`#if defined (IS_MESH) // : first_y_mesh`
270			//assign router_chan_in[`router_id(x,y)][NORTH] = {SMARTFLIT_CHANEL_w{1'b0}};
271	56	alirezamon	`connect_r2gnd(1,router_id(x,y),NORTH);`
272	48	alirezamon	`#elif defined (IS_TORUS)// :first_y_torus`
273			//assign router_chan_in[`router_id(x,y)][NORTH] = router_chan_out [`router_id(x,(T2-1))][SOUTH];
274			`conect_r2r(1,router_id(x,y),NORTH,1,router_id(x,(T2-1)),SOUTH);`
275			`#elif defined (IS_FMESH) // :first_y_fmesh`
276			`unsigned int NORTH_ID = T1T2T3 + x;`
277			`connect_r2e(1,router_id(x,y),NORTH,NORTH_ID);`
278			`er_addr [NORTH_ID] = R_ADDR;`
279			`#endif//topology`
280			`}//y>0`
281	56	alirezamon
282
283	48	alirezamon	`if(x>0){// :not_first_x`
284			//assign router_chan_in[`router_id(x,y)][WEST] = router_chan_out [`router_id((x-1),y)][EAST];
285			`conect_r2r(1,router_id(x,y),WEST,1,router_id((x-1),y),EAST);`
286			`}else {// :first_x`
287	56	alirezamon
288	48	alirezamon	`#if defined (IS_MESH) // :first_x_mesh`
289			//assign router_chan_in[`router_id(x,y)][WEST] = {SMARTFLIT_CHANEL_w{1'b0}};
290			`connect_r2gnd(1,router_id(x,y),WEST);`
291	56	alirezamon
292	48	alirezamon	`#elif defined (IS_TORUS) // :first_x_torus`
293			//assign router_chan_in[`router_id(x,y)][WEST] = router_chan_out [`router_id((NX-1),y)][EAST] ;
294			`conect_r2r(1,router_id(x,y),WEST,1,router_id((T1-1),y),EAST);`
295			`#elif defined (IS_FMESH) // :first_x_fmesh`
296			`unsigned int WEST_ID = T1T2T3 + 2*T1 + y;`
297			`connect_r2e(1,router_id(x,y),WEST,WEST_ID);`
298			`er_addr [WEST_ID] = R_ADDR;`
299			`#endif//topology`
300	56	alirezamon	`}`
301
302	48	alirezamon	`if(y < T2-1) {// : firsty`
303			//assign router_chan_in[`router_id(x,y)][SOUTH] = router_chan_out [`router_id(x,(y+1))][NORTH];
304			`conect_r2r(1,router_id(x,y),SOUTH,1,router_id(x,(y+1)),NORTH);`
305			`}else {// : lasty`
306	56	alirezamon
307	48	alirezamon	`#if defined (IS_MESH) // :ly_mesh`
308	56	alirezamon
309	48	alirezamon	//assign router_chan_in[`router_id(x,y)][SOUTH]= {SMARTFLIT_CHANEL_w{1'b0}};
310			`connect_r2gnd(1,router_id(x,y),SOUTH);`
311	56	alirezamon
312	48	alirezamon	`#elif defined (IS_TORUS) // :ly_torus`
313			//assign router_chan_in[`router_id(x,y)][SOUTH]= router_chan_out [`router_id(x,0)][NORTH];
314			`conect_r2r(1,router_id(x,y),SOUTH,1,router_id(x,0),NORTH);`
315			`#elif defined (IS_FMESH) // :ly_Fmesh`
316			`unsigned int SOUTH_ID = T1T2T3 + T1 + x;`
317			`connect_r2e(1,router_id(x,y),SOUTH,SOUTH_ID);`
318			`er_addr [SOUTH_ID] = R_ADDR;`
319			`#endif//topology`
320	56	alirezamon	`}`
321
322
323	48	alirezamon	`// endpoint(s) connection`
324			`// connect other local ports`
325			`for (l=0; l<T3; l=l+1) {// :locals`
326	56	alirezamon	`unsigned int ENDPID = endp_id(x,y,l);`
327			`unsigned int LOCALP = (l==0) ? l : l + R2R_CHANELS_MESH_TORI; // first local port is connected to router port 0. The rest are connected at the }`
328
329	48	alirezamon	//assign router_chan_in [`router_id(x,y)][LOCALP] = chan_in_all [ENDPID];
330			//assign chan_out_all [ENDPID] = router_chan_out [`router_id(x,y)][LOCALP];
331			`//assign er_addr [ENDPID] = R_ADDR;`
332	56	alirezamon	`connect_r2e(1,router_id(x,y),LOCALP,ENDPID);`
333			`er_addr [ENDPID] = R_ADDR;`
334			`}// locals`
335
336	48	alirezamon	`}//y`
337			`}//x`
338	56	alirezamon	`#endif`
339
340	48	alirezamon
341			`}`
342
343	54	alirezamon	`#define fill_r2r_cnt(T1,R1,P1,T2,R2,P2) (r2r_cnt_table_t){.id1=R1,.t1=T1,.r1=R1,.p1=P1,.id2=R2,.t2=T2,.r2=R2,.p2=P2}`
344	48	alirezamon
345			`void topology_init(void){`
346			`nxw=Log2(T1);`
347			`nyw=Log2(T2);`
348			`maskx = (0x1<<nxw)-1;`
349			`masky = (0x1<<nyw)-1;`
350	54	alirezamon	`unsigned int num=0;`
351			`unsigned int x,y,l;`
352			`#if defined (IS_LINE) \|\| defined (IS_RING )`
353			`#define R2R_CHANELS_MESH_TORI 2`
354			`for (x=0; x<T1; x=x+1) {`
355
356			`router1[x]->current_r_addr = x;`
357			`router1[x]->current_r_id = x;`
358			`if(x < T1-1){// not_last_node`
359			`//assign router_chan_in[x][FORWARD] = router_chan_out [(x+1)][BACKWARD];`
360			`//conect_r2r(1,x,FORWARD,1,(x+1),BACKWARD);`
361			`r2r_cnt_all[num]=fill_r2r_cnt(1,x,FORWARD,1,(x+1),BACKWARD);`
362			`num++;`
363			`} else { //last_node`
364			`#if defined (IS_LINE) // : line_last_x`
365			`//assign router_chan_in[x][FORWARD]= {SMARTFLIT_CHANEL_w{1'b0}};`
366			`connect_r2gnd(1,x,FORWARD);`
367			`#else // : ring_last_x`
368			`//assign router_chan_in[x][FORWARD]= router_chan_out [0][BACKWARD];`
369			`//conect_r2r(1,x,FORWARD,1,0,BACKWARD);`
370			`r2r_cnt_all[num]=fill_r2r_cnt(1,x,FORWARD,1,0,BACKWARD);`
371			`num++;`
372			`#endif`
373			`}`
374
375			`if(x>0){// :not_first_x`
376			`//assign router_chan_in[x][BACKWARD]= router_chan_out [(x-1)][FORWARD];`
377			`//conect_r2r(1,x,BACKWARD,1,(x-1),FORWARD);`
378			`r2r_cnt_all[num]=fill_r2r_cnt(1,x,BACKWARD,1,(x-1),FORWARD);`
379			`num++;`
380			`}else {// :first_x`
381			`#if defined (IS_LINE) // : line_first_x`
382			`//assign router_chan_in[x][BACKWARD]={SMARTFLIT_CHANEL_w{1'b0}};`
383			`connect_r2gnd(1,x,BACKWARD);`
384			`#else // : ring_first_x`
385			`//assign router_chan_in[x][BACKWARD]= router_chan_out [(NX-1)][FORWARD];`
386			`//conect_r2r(1,x,BACKWARD,1,(T1-1),FORWARD);`
387			`r2r_cnt_all[num]=fill_r2r_cnt(1,x,BACKWARD,1,(T1-1),FORWARD);`
388			`num++;`
389			`#endif`
390			`}`
391
392			`// connect other local ports`
393			`for (l=0; l<T3; l=l+1) {// :locals`
394			`unsigned int ENDPID = endp_id(x,0,l);`
395			`unsigned int LOCALP = (l==0) ? l : l + R2R_CHANELS_MESH_TORI; // first local port is connected to router port 0. The rest are connected at the }`
396			`//assign router_chan_in[x][LOCALP]= chan_in_all [ENDPID];`
397			`//assign chan_out_all [ENDPID] = router_chan_out[x][LOCALP];`
398			`//connect_r2e(1,x,LOCALP,ENDPID);`
399			`r2e_cnt_all[ENDPID].r1=x;`
400			`r2e_cnt_all[ENDPID].p1=LOCALP;`
401			`er_addr [ENDPID] = x;`
402
403			`}// locals`
404			`}//x`
405
406			`#else // :mesh_torus`
407			`#define R2R_CHANELS_MESH_TORI 4`
408			`for (y=0; y<T2; y=y+1) {//: y_loop`
409			`for (x=0; x<T1; x=x+1) {// :x_loop`
410			`unsigned int R_ADDR = (y<<nxw) + x;`
411			`unsigned int ROUTER_NUM = (y * T1) + x;`
412			`//assign current_r_addr [ROUTER_NUM] = R_ADDR[RAw-1 :0];`
413			`router1[ROUTER_NUM]->current_r_addr = R_ADDR;`
414			`router1[ROUTER_NUM]->current_r_id = ROUTER_NUM;`
415
416			`if(x < T1-1) {//: not_last_x`
417			//assign router_chan_in[`router_id(x,y)][EAST]= router_chan_out [`router_id(x+1,y)][WEST];
418			`//conect_r2r(1,router_id(x,y),EAST,1,router_id(x+1,y),WEST);`
419			`r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),EAST,1,router_id(x+1,y),WEST);`
420			`num++;`
421
422			`}else {// :last_x`
423			`#if defined (IS_MESH) // :last_x_mesh`
424			// assign router_chan_in[`router_id(x,y)][EAST] = {SMARTFLIT_CHANEL_w{1'b0}};
425			`connect_r2gnd(1,router_id(x,y),EAST);`
426			`#elif defined (IS_TORUS) // : last_x_torus`
427			//assign router_chan_in[`router_id(x,y)][EAST] = router_chan_out [`router_id(0,y)][WEST];
428			`//conect_r2r(1,router_id(x,y),EAST,1,router_id(0,y),WEST);`
429			`r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),EAST,1,router_id(0,y),WEST);`
430			`num++;`
431			`#elif defined (IS_FMESH) //:last_x_fmesh`
432			`//connect to endp`
433			`unsigned int EAST_ID = T1T2T3 + 2*T1 + T2 + y;`
434			`//connect_r2e(1,router_id(x,y),EAST,EAST_ID);`
435			`r2e_cnt_all[EAST_ID].r1=router_id(x,y);`
436			`r2e_cnt_all[EAST_ID].p1=EAST;`
437			`er_addr [EAST_ID] = R_ADDR;`
438			`#endif//topology`
439			`}`
440
441
442			`if(y>0) {// : not_first_y`
443			//assign router_chan_in[`router_id(x,y)][NORTH] = router_chan_out [`router_id(x,(y-1))][SOUTH];
444			`//conect_r2r(1,router_id(x,y),NORTH,1,router_id(x,(y-1)),SOUTH);`
445			`r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),NORTH,1,router_id(x,(y-1)),SOUTH);`
446			`num++;`
447			`}else {// :first_y`
448			`#if defined (IS_MESH) // : first_y_mesh`
449			//assign router_chan_in[`router_id(x,y)][NORTH] = {SMARTFLIT_CHANEL_w{1'b0}};
450			`connect_r2gnd(1,router_id(x,y),NORTH);`
451			`#elif defined (IS_TORUS)// :first_y_torus`
452			//assign router_chan_in[`router_id(x,y)][NORTH] = router_chan_out [`router_id(x,(T2-1))][SOUTH];
453			`//conect_r2r(1,router_id(x,y),NORTH,1,router_id(x,(T2-1)),SOUTH);`
454			`r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),NORTH,1,router_id(x,(T2-1)),SOUTH);`
455			`num++;`
456			`#elif defined (IS_FMESH) // :first_y_fmesh`
457			`unsigned int NORTH_ID = T1T2T3 + x;`
458			`//connect_r2e(1,router_id(x,y),NORTH,NORTH_ID);`
459			`r2e_cnt_all[NORTH_ID].r1=router_id(x,y);`
460			`r2e_cnt_all[NORTH_ID].p1=NORTH;`
461			`er_addr [NORTH_ID] = R_ADDR;`
462			`#endif//topology`
463			`}//y>0`
464
465
466			`if(x>0){// :not_first_x`
467			//assign router_chan_in[`router_id(x,y)][WEST] = router_chan_out [`router_id((x-1),y)][EAST];
468			`//conect_r2r(1,router_id(x,y),WEST,1,router_id((x-1),y),EAST);`
469			`r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),WEST,1,router_id((x-1),y),EAST);`
470			`num++;`
471
472			`}else {// :first_x`
473
474			`#if defined (IS_MESH) // :first_x_mesh`
475			//assign router_chan_in[`router_id(x,y)][WEST] = {SMARTFLIT_CHANEL_w{1'b0}};
476			`connect_r2gnd(1,router_id(x,y),WEST);`
477
478			`#elif defined (IS_TORUS) // :first_x_torus`
479			//assign router_chan_in[`router_id(x,y)][WEST] = router_chan_out [`router_id((NX-1),y)][EAST] ;
480			`//conect_r2r(1,router_id(x,y),WEST,1,router_id((T1-1),y),EAST);`
481			`r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),WEST,1,router_id((T1-1),y),EAST);`
482			`num++;`
483			`#elif defined (IS_FMESH) // :first_x_fmesh`
484			`unsigned int WEST_ID = T1T2T3 + 2*T1 + y;`
485			`//connect_r2e(1,router_id(x,y),WEST,WEST_ID);`
486			`r2e_cnt_all[WEST_ID].r1=router_id(x,y);`
487			`r2e_cnt_all[WEST_ID].p1=WEST;`
488			`er_addr [WEST_ID] = R_ADDR;`
489			`#endif//topology`
490			`}`
491
492			`if(y < T2-1) {// : firsty`
493			//assign router_chan_in[`router_id(x,y)][SOUTH] = router_chan_out [`router_id(x,(y+1))][NORTH];
494			`// conect_r2r(1,router_id(x,y),SOUTH,1,router_id(x,(y+1)),NORTH);`
495			`r2r_cnt_all[num]=fill_r2r_cnt(1,router_id(x,y),SOUTH,1,router_id(x,(y+1)),NORTH);`
496			`num++;`
497			`}else {// : lasty`
498
499			`#if defined (IS_MESH) // :ly_mesh`
500

Browse

Tools

Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

[/] [an-fpga-implementation-of-low-latency-noc-based-mpsoc/] [trunk/] [mpsoc/] [src_verilator/] [topology/] [mesh.h] - Blame information for rev 56