router.h

基于4个mips核的noc设计

/*
 *  TU Eindhoven
 *  Eindhoven, The Netherlands
 *
 *  Name            :   router.h
 *
 *  Author          :   [e-mail]
 *
 *  Date            :   13-09-2003
 *
 *  Function        :   Top-level module for router in torus network with E-cube routing
 *
 *
 */


#ifndef ROUTER_H_INCLUDED
#define ROUTER_H_INCLUDED

#include <systemc.h>
#include "net_dim.h"
#include "inctrl.h"
#include "switch.h"
#include "oqueue.h"
#include "oarbiter.h"

////////////////////////////////////////////////////////////////////////////////
// 1-dimension router
////////////////////////////////////////////////////////////////////////////////

SC_MODULE(ECUBE_ROUTER_1DIM)
{  
  sc_in<bool> clk, rst;
  sc_in< sc_uint<ADDRESS_LEN> > addr;
  
  sc_in< sc_bv<FLIT_LEN> > xin, din;
  sc_out< sc_bv<FLIT_LEN> > xout, dout;

  sc_in< bool > dreq_in, dack_in;
  sc_out< bool > dreq_out, dack_out;  
  sc_in< bool > x0req_in, x1req_in;
  sc_in< bool > x0ack_in, x1ack_in;
  sc_out< bool > x0req_out, x1req_out;
  sc_out< bool > x0ack_out, x1ack_out;
  
  INPUT_CTRL *x0inctrl, *x1inctrl, *dinctrl;
  CROSSBAR3x3 *swtch;
  OUTPUT_QUEUE *x0queue, *x1queue, *dqueue;
  OUTPUT_ARBITER *arbiter;
  
  sc_signal< sc_bv<FLIT_LEN> > data0in, data1in, data2in, data0out, data1out, data2out;
  sc_signal< sc_uint<2> > select0, select1, select2;
  sc_signal< bool > rqs0, rqs1, rqs2;
  sc_signal< bool > req0in, req1in, req2in, req0out, req1out, req2out;
  sc_signal< bool > ack0in, ack1in, ack2in, ack0out, ack1out, ack2out;

  sc_signal< sc_bv<FLIT_LEN> > arb_data0, arb_data1;
  sc_signal< bool > arb_req0, arb_req1, arb_ack0, arb_ack1;

  sc_signal<bool> vcc, gnd;
  
  SC_CTOR(ECUBE_ROUTER_1DIM)
	{
	  vcc = true;
	  gnd = false;
	  
	  x0inctrl = new INPUT_CTRL("x0inctrl");
	  x1inctrl = new INPUT_CTRL("x1inctrl");
	  dinctrl = new INPUT_CTRL("dinctrl");
	  
	  swtch = new CROSSBAR3x3("switch");
	  
	  x0queue = new OUTPUT_QUEUE("x0queue");
	  x1queue = new OUTPUT_QUEUE("x1queue");
	  dqueue = new OUTPUT_QUEUE("dqueue");
	  
	  arbiter = new OUTPUT_ARBITER("arbiter");
	  
	  x0inctrl->clk(clk);
	  x0inctrl->rst(rst);
	  x0inctrl->ch0(vcc); x0inctrl->ch1(gnd);
	  x0inctrl->my_address(addr);
	  x0inctrl->req(x0req_in);
	  x0inctrl->ack(x0ack_out);
	  x0inctrl->data(xin);
	  x0inctrl->data_out(data0in);
	  x0inctrl->out_select(select0);
	  x0inctrl->request_switch(rqs0);
	  x0inctrl->out_req(req0in);
	  x0inctrl->out_ack(ack0out);

	  x1inctrl->clk(clk);
	  x1inctrl->rst(rst);
	  x1inctrl->my_address(addr);
	  x1inctrl->ch0(gnd); x1inctrl->ch1(vcc);
	  x1inctrl->req(x1req_in);
	  x1inctrl->ack(x1ack_out);
	  x1inctrl->data(xin);
	  x1inctrl->data_out(data1in);
	  x1inctrl->out_select(select1);
	  x1inctrl->request_switch(rqs1);
	  x1inctrl->out_req(req1in);
	  x1inctrl->out_ack(ack1out);
	  
	  dinctrl->clk(clk);
	  dinctrl->rst(rst);
	  dinctrl->my_address(addr);
	  dinctrl->ch0(gnd); dinctrl->ch1(gnd);
	  dinctrl->req(dreq_in);
	  dinctrl->ack(dack_out);
	  dinctrl->data(din);
	  dinctrl->data_out(data2in);
	  dinctrl->out_select(select2);
	  dinctrl->request_switch(rqs2);
	  dinctrl->out_req(req2in);
	  dinctrl->out_ack(ack2out);
	  
	  swtch->clk(clk);
	  swtch->addr_0(select0);
	  swtch->addr_1(select1);
	  swtch->addr_2(select2);
	  swtch->conn_0(rqs0);
	  swtch->conn_1(rqs1);
	  swtch->conn_2(rqs2);
	  swtch->data_in_0(data0in);
	  swtch->data_in_1(data1in);
	  swtch->data_in_2(data2in);
	  swtch->req_in_0(req0in);
	  swtch->req_in_1(req1in);
	  swtch->req_in_2(req2in);
	  swtch->ack_in_0(ack0in);
	  swtch->ack_in_1(ack1in);
	  swtch->ack_in_2(ack2in);
	  swtch->data_out_0(data0out);
	  swtch->data_out_1(data1out);
	  swtch->data_out_2(data2out);
	  swtch->req_out_0(req0out);
	  swtch->req_out_1(req1out);
	  swtch->req_out_2(req2out);
	  swtch->ack_out_0(ack0out);
	  swtch->ack_out_1(ack1out);
	  swtch->ack_out_2(ack2out);


	  x0queue->clk(clk);
	  x0queue->rst(rst);
	  x0queue->ack(arb_ack0);
	  x0queue->req(arb_req0);
	  x0queue->data(arb_data0);
	  x0queue->req_in(req0out);
	  x0queue->ack_in(ack0in);
	  x0queue->data_in(data0out);

	  x1queue->clk(clk);
	  x1queue->rst(rst);
	  x1queue->ack(arb_ack1);
	  x1queue->req(arb_req1);
	  x1queue->data(arb_data1);
	  x1queue->req_in(req1out);
	  x1queue->ack_in(ack1in);
	  x1queue->data_in(data1out);

	  dqueue->clk(clk);
	  dqueue->rst(rst);
	  dqueue->ack(dack_in);
	  dqueue->req(dreq_out);
	  dqueue->data(dout);
	  dqueue->req_in(req2out);
	  dqueue->ack_in(ack2in);
	  dqueue->data_in(data2out);

	  arbiter->clk(clk);
	  arbiter->rst(rst);
	  arbiter->data0(arb_data0);
	  arbiter->data1(arb_data1);
	  arbiter->req0in(arb_req0);
	  arbiter->req1in(arb_req1);
	  arbiter->ack0out(arb_ack0);
	  arbiter->ack1out(arb_ack1);
	  arbiter->data(xout);
	  arbiter->req0out(x0req_out);
	  arbiter->req1out(x1req_out);
	  arbiter->ack0in(x0ack_in);
	  arbiter->ack1in(x1ack_in);
	}
  
};

////////////////////////////////////////////////////////////////////////////////
// a 2-dimension router
////////////////////////////////////////////////////////////////////////////////

SC_MODULE(ECUBE_ROUTER)
{
  sc_in<bool> clk, rst;
  sc_in< sc_uint<ADDRESS_LEN> > xaddr, yaddr;
  
  sc_in< sc_bv<FLIT_LEN> > xin, yin, din;
  sc_out< sc_bv<FLIT_LEN> > xout, yout, dout;

  sc_in< bool > dreq_in, dack_in;
  sc_out< bool > dreq_out, dack_out;  
  sc_in< bool > x0req_in, x1req_in;
  sc_in< bool > x0ack_in, x1ack_in;
  sc_out< bool > x0req_out, x1req_out;
  sc_out< bool > x0ack_out, x1ack_out;
  sc_in< bool > y0req_in, y1req_in;
  sc_in< bool > y0ack_in, y1ack_in;
  sc_out< bool > y0req_out, y1req_out;
  sc_out< bool > y0ack_out, y1ack_out;
  
  ECUBE_ROUTER_1DIM *xrouter, *yrouter;
  
  sc_signal< sc_bv<FLIT_LEN> > xydata;
  sc_signal< bool > xyreq, xyack;
  
  SC_CTOR(ECUBE_ROUTER)
	{
	  xrouter = new ECUBE_ROUTER_1DIM("xrouter");
	  yrouter = new ECUBE_ROUTER_1DIM("yrouter");
	  
	  xrouter->clk(clk);
 	  xrouter->rst(rst);
	  xrouter->addr(xaddr);
	  xrouter->xin(xin);
	  xrouter->din(din);
	  xrouter->xout(xout);
	  xrouter->dout(xydata);
	  xrouter->dreq_in(dreq_in);
	  xrouter->dack_in(xyack);
	  xrouter->dreq_out(xyreq);
	  xrouter->dack_out(dack_out);
	  xrouter->x0req_in(x0req_in);
	  xrouter->x1req_in(x1req_in);
	  xrouter->x0ack_in(x0ack_in);
	  xrouter->x1ack_in(x1ack_in);
	  xrouter->x0req_out(x0req_out);
	  xrouter->x1req_out(x1req_out);
	  xrouter->x0ack_out(x0ack_out);
	  xrouter->x1ack_out(x1ack_out);

	  yrouter->clk(clk);
	  yrouter->rst(rst);
	  yrouter->addr(yaddr);
	  yrouter->xin(yin);
	  yrouter->din(xydata);
	  yrouter->xout(yout);
	  yrouter->dout(dout);
	  yrouter->dreq_in(xyreq);
	  yrouter->dack_in(dack_in);
	  yrouter->dreq_out(dreq_out);
	  yrouter->dack_out(xyack);
	  yrouter->x0req_in(y0req_in);
	  yrouter->x1req_in(y1req_in);
	  yrouter->x0ack_in(y0ack_in);
	  yrouter->x1ack_in(y1ack_in);
	  yrouter->x0req_out(y0req_out);
	  yrouter->x1req_out(y1req_out);
	  yrouter->x0ack_out(y0ack_out);
	  yrouter->x1ack_out(y1ack_out);

	}
  
};

#endif