public Router(RingCoord rc, bool isNode)
{
int id = RingCoord.getIDfromRingID(rc.ID);
coord = new Coord(id);
if(isNode)
m_n = Simulator.network.nodes[ID];
routerName = "Router";
neighbors = 0;
m_lastInj = 0;
last_starve = 0;
starve_interval = 0;
qlen_win = new int[AVG_QLEN_WIN];
}
public static RingRouter makeNodeRouter(RingCoord rc)
{
return new RingRouter_Simple(rc, true);
}
public void setup()
{
routers = new Router[Config.N * (1 + ((Config.RingRouter) ? Config.nrConnections : 0))];
nodes = new Node[Config.N];
links = new List<Link>();
cache = new CmpCache();
ringRouter = new RingRouter[Config.N * (1 + Config.nrConnections)];
/*if(Config.disjointRings)
{
bool ignoreCase = true;
if (String.Compare(Config.disjointConnection, "mesh", ignoreCase) == 0)
connector = new RingRouter[Config.N]; // Fix later
else if (String.Compare(Config.disjointConnection, "torus", ignoreCase) == 0)
connector = new RingRouter[Config.N];
else if (String.Compare(Config.disjointConnection, "ring", ignoreCase) == 0)
connector = new RingRouter[Config.N]; // Fix later
}*/
ParseFinish(Config.finish);
workload = new Workload(Config.traceFilenames);
mapping = new NodeMapping_AllCPU_SharedCache();
// create routers and nodes
for (int n = 0; n < Config.N; n++)
{
Coord c = new Coord(n);
nodes[n] = new Node(mapping, c);
if (!Config.RingRouter)
{
routers[n] = MakeRouter(c);
nodes[n].setRouter(routers[n]);
routers[n].setNode(nodes[n]);
}
}
/*if (Config.disjointRings)
for (int n = 0; n < 8; n++)
{
connectors[n] = MakeConnector(n);
}
*/
// create the Golden manager
golden = new Golden();
if (Config.RouterEvaluation)
return;
/*
* Ring width = node width of each ring
* Ring height = node height of each ring
* NrConnections = number of connections routers per node
*
*/
if (Config.RingRouter)
{
int nrPlaceholdersPerNetwork = Config.nrPlaceholders / 2;
int nrNodesPerRing = (Config.ringWidth * 2 + Config.ringHeight * 2 - 4);
int nrConnectPerRing = nrNodesPerRing * Config.nrConnections;
int nrItemInRing = nrConnectPerRing + nrNodesPerRing;
#if DEBUG
Console.WriteLine("NrNodesPerRing = {0}, NrConectPerRing = {1}, NrItemInRing = {2}", nrNodesPerRing, nrConnectPerRing, nrItemInRing);
#endif
int prevID = -1;
// TODO: Check edge conditions of for loops. Currently only using for 2x2 ring.
bool clockwise = false;
for (int y = 0; y < Config.network_nrY / Config.ringHeight; y++) {
for (int x = 0; x < Config.network_nrX / Config.ringWidth; x++) {
if (Config.alternateDir)
{
clockwise = !clockwise;
}
else
{
clockwise = true;
}
prevID = -1;
for (int z = 0; z < nrItemInRing; z++)
{
int ringID = RingCoord.getIDfromXYZ(x, y, z);
int nodeID = RingCoord.getIDfromRingID(ringID);
RingCoord rc = new RingCoord(ringID);
#if DEBUG
Console.WriteLine("ringID = {0}, nodeID = {1}, prevID = {2}", ringID, nodeID, prevID);
#endif
ringRouter[ringID] = makeNodeRouter(rc);
ringRouter[ringID].clockwise = clockwise;
routers[nodeID] = ringRouter[ringID];
nodes[nodeID].setRouter(ringRouter[ringID]);
ringRouter[ringID].setNode(nodes[nodeID]);
// Link them up if its not the first node in the loop
if (prevID != -1)
{
Link prev = new Link(Config.router.linkLatency - 1);
links.Add(prev);
#if DEBUG
Console.WriteLine("Connecting prev{0} & current{1} with link {2}", prevID, ringID, prev);
#endif
if (clockwise)
{
ringRouter[prevID].linkOut[Simulator.DIR_CW] = prev;
ringRouter[ringID].linkIn[Simulator.DIR_CCW] = prev;
}
else
{
ringRouter[prevID].linkIn[Simulator.DIR_CW] = prev;
ringRouter[ringID].linkOut[Simulator.DIR_CCW] = prev;
}
}
prevID = ringID;
// Connection routers
for (int i = 0; i < Config.nrConnections; i++)
{
z++;
int connectID = RingCoord.getIDfromXYZ(x, y, z);
int connect2ID = RingCoord.getIDfromRingID(connectID);
RingCoord connectRC = new RingCoord(connectID);
ringRouter[connectID] = makeConnection(connectRC);
ringRouter[connectID].clockwise = clockwise;
routers[connect2ID] = ringRouter[connectID];
Link prev_link = new Link(Config.router.linkLatency - 1);
links.Add(prev_link);
#if DEBUG
Console.WriteLine("Connecting prev{0} & connect{1} with link {2}", prevID, connectID, prev_link);
#endif
if (clockwise)
{
ringRouter[prevID].linkOut[Simulator.DIR_CW] = prev_link;
ringRouter[connectID].linkIn[Simulator.DIR_CCW] = prev_link;
}
else
{
ringRouter[prevID].linkIn[Simulator.DIR_CW] = prev_link;
ringRouter[connectID].linkOut[Simulator.DIR_CCW] = prev_link;
}
prevID = connectID;
}
}
// Finish ring
int startID = RingCoord.getIDfromXYZ(x, y, 0);
Link finish_link = new Link(Config.router.linkLatency - 1);
links.Add(finish_link);
#if DEBUG
Console.WriteLine("Finishing connecting prev{0} & start{1} with link {2}", prevID, startID, finish_link);
#endif
if (clockwise)
{
ringRouter[prevID].linkOut[Simulator.DIR_CW] = finish_link;
ringRouter[startID].linkIn[Simulator.DIR_CCW] = finish_link;
}
else
{
ringRouter[prevID].linkIn[Simulator.DIR_CW] = finish_link;
ringRouter[startID].linkOut[Simulator.DIR_CCW] = finish_link;
}
}
}
if (Config.nrConnections > 1)
throw new Exception("Check the rest of the code before you continue making more connections");
#if DEBUG
Console.WriteLine("Starting connections....");
#endif
int connectionDir, oppDir;
int oppX;
int oppY;
int oppZ;
int currentID, oppID;
for (int y = 0; y < Config.network_nrY / Config.ringHeight; y++) {
for (int x = 0; x < Config.network_nrX / Config.ringWidth; x++) {
for (int z = 0; z < nrItemInRing; z++) {
for (int i = 0; i < Config.nrConnections; i++) {
//TODO: reconfigure for more than a 4x4 network and/or more connections
z++;
connectionDir = -1;
oppDir = -1;
currentID = -1;
oppID = -1;
oppX = x;
oppY = y;
oppZ = z + 4;
if(oppZ > nrItemInRing)
oppZ -= nrItemInRing;
currentID = RingCoord.getIDfromXYZ(x, y, z);
#if DEBUG
Console.WriteLine("Current Coord ({0},{1},{2})", x, y, z);
#endif
int switchNum = (z - 1) / 2;
switch (switchNum)
{
case 0: connectionDir = Simulator.DIR_UP;
oppDir = Simulator.DIR_DOWN;
oppY = y - 1;
#if DEBUG
Console.WriteLine("0");
#endif
if (oppY < 0)
{
oppY = Config.network_nrY / Config.ringHeight - 1;
// ensure no duplication by handling a link at the lexicographically
// first router
if (oppX < x || (oppX == x && oppY < y)) continue;
if (!Config.torus)
{
//Lower the link latency because this router is not being used
oppID = RingCoord.getIDfromXYZ(oppX, oppY, oppZ);
int nextZ = ((z + 1) > nrItemInRing - 1) ? 0 : z+1;
int prevZ = ((z - 1) < 0) ? nrItemInRing - 1 : z-1;
int nextID = RingCoord.getIDfromXYZ(x, y, nextZ);
int previousID = RingCoord.getIDfromXYZ(x, y, prevZ);
#if DEBUG
Console.WriteLine("opp({0},{1},{2})\tnextID {3}, currentID {4}, previousID {5}", oppX, oppY, oppZ, nextID, currentID, previousID);
#endif
if (ringRouter[nextID].clockwise) {
ringRouter[nextID].linkIn[Simulator.DIR_CCW] = ringRouter[previousID].linkOut[Simulator.DIR_CW];
ringRouter[currentID].linkIn[Simulator.DIR_CCW] = ringRouter[currentID].linkOut[Simulator.DIR_CW];
}
else {
ringRouter[previousID].linkIn[Simulator.DIR_CW] = ringRouter[nextID].linkOut[Simulator.DIR_CCW];
ringRouter[currentID].linkIn[Simulator.DIR_CW] = ringRouter[currentID].linkOut[Simulator.DIR_CCW];
}
nextZ = ((oppZ + 1) > nrItemInRing - 1) ? 0 : oppZ+1;
prevZ = ((oppZ - 1) < 0) ? nrItemInRing - 1 : oppZ-1;
nextID = RingCoord.getIDfromXYZ(oppX, oppY, nextZ);
previousID = RingCoord.getIDfromXYZ(oppX, oppY, prevZ);
#if DEBUG
Console.WriteLine("opp({0},{1},{2})\tnextID {3}, oppID {4}, previousID {5}", oppX, oppY, oppZ, nextID, oppID, previousID);
#endif
if (ringRouter[nextID].clockwise) {
ringRouter[nextID].linkIn[Simulator.DIR_CCW] = ringRouter[previousID].linkOut[Simulator.DIR_CW];
ringRouter[oppID].linkIn[Simulator.DIR_CCW] = ringRouter[oppID].linkOut[Simulator.DIR_CW];
}
else {
ringRouter[previousID].linkIn[Simulator.DIR_CW] = ringRouter[nextID].linkOut[Simulator.DIR_CCW];
ringRouter[oppID].linkIn[Simulator.DIR_CW] = ringRouter[oppID].linkOut[Simulator.DIR_CCW];
}
ringRouter[currentID] = null;
ringRouter[oppID] = null;
continue;
}
}
break;
case 1: connectionDir = Simulator.DIR_RIGHT;
oppDir = Simulator.DIR_LEFT;
oppX = x + 1;
#if DEBUG
Console.WriteLine("1");
#endif
if (oppX >= Config.network_nrX / Config.ringWidth)
{
oppX = 0;
// ensure no duplication by handling a link at the lexicographically
// first router
if (oppX < x || (oppX == x && oppY < y)) continue;
if (!Config.torus)
{
//Lower the link latency because this router is not being used
oppID = RingCoord.getIDfromXYZ(oppX, oppY, oppZ);
int nextZ = ((z + 1) > nrItemInRing - 1) ? 0 : z+1;
int prevZ = ((z - 1) < 0) ? nrItemInRing - 1 : z-1;
int nextID = RingCoord.getIDfromXYZ(x, y, nextZ);
int previousID = RingCoord.getIDfromXYZ(x, y, prevZ);
#if DEBUG
Console.WriteLine("opp({0},{1},{2})\tnextID {3}, currentID {4}, previousID {5}", oppX, oppY, oppZ, nextID, currentID, previousID);
#endif
if (ringRouter[nextID].clockwise) {
ringRouter[nextID].linkIn[Simulator.DIR_CCW] = ringRouter[previousID].linkOut[Simulator.DIR_CW];
ringRouter[currentID].linkIn[Simulator.DIR_CCW] = ringRouter[currentID].linkOut[Simulator.DIR_CW];
}
else {
ringRouter[previousID].linkIn[Simulator.DIR_CW] = ringRouter[nextID].linkOut[Simulator.DIR_CCW];
ringRouter[currentID].linkIn[Simulator.DIR_CW] = ringRouter[currentID].linkOut[Simulator.DIR_CCW];
}
nextZ = ((oppZ + 1) > nrItemInRing - 1) ? 0 : oppZ+1;
prevZ = ((oppZ - 1) < 0) ? nrItemInRing - 1 : oppZ-1;
nextID = RingCoord.getIDfromXYZ(oppX, oppY, nextZ);
previousID = RingCoord.getIDfromXYZ(oppX, oppY, prevZ);
#if DEBUG
Console.WriteLine("opp({0},{1},{2})\tnextID {3}, oppID {4}, previousID {5}", oppX, oppY, oppZ, nextID, oppID, previousID);
#endif
if (ringRouter[nextID].clockwise) {
ringRouter[nextID].linkIn[Simulator.DIR_CCW] = ringRouter[previousID].linkOut[Simulator.DIR_CW];
ringRouter[oppID].linkIn[Simulator.DIR_CCW] = ringRouter[oppID].linkOut[Simulator.DIR_CW];
}
else {
ringRouter[previousID].linkIn[Simulator.DIR_CW] = ringRouter[nextID].linkOut[Simulator.DIR_CCW];
ringRouter[oppID].linkIn[Simulator.DIR_CW] = ringRouter[oppID].linkOut[Simulator.DIR_CCW];
}
ringRouter[currentID] = null;
ringRouter[oppID] = null;
continue;
}
}
break;
case 2: connectionDir = Simulator.DIR_DOWN;
oppDir = Simulator.DIR_UP;
oppY = y + 1;
#if DEBUG
Console.WriteLine("2");
#endif
if (oppY >= Config.network_nrY / Config.ringHeight)
{
oppY = 0;
// ensure no duplication by handling a link at the lexicographically
// first router
if (oppX < x || (oppX == x && oppY < y)) continue;
if (!Config.torus)
{
//Lower the link latency because this router is not being used
oppID = RingCoord.getIDfromXYZ(oppX, oppY, oppZ);
int nextZ = ((z + 1) > nrItemInRing - 1) ? 0 : z+1;
int prevZ = ((z - 1) < 0) ? nrItemInRing - 1 : z-1;
int nextID = RingCoord.getIDfromXYZ(x, y, nextZ);
int previousID = RingCoord.getIDfromXYZ(x, y, prevZ);
#if DEBUG
Console.WriteLine("opp({0},{1},{2})\tnextID {3}, currentID {4}, previousID {5}", oppX, oppY, oppZ, nextID, currentID, previousID);
#endif
if (ringRouter[nextID].clockwise) {
ringRouter[nextID].linkIn[Simulator.DIR_CCW] = ringRouter[previousID].linkOut[Simulator.DIR_CW];
ringRouter[currentID].linkIn[Simulator.DIR_CCW] = ringRouter[currentID].linkOut[Simulator.DIR_CW];
}
else {
ringRouter[previousID].linkIn[Simulator.DIR_CW] = ringRouter[nextID].linkOut[Simulator.DIR_CCW];
ringRouter[currentID].linkIn[Simulator.DIR_CW] = ringRouter[currentID].linkOut[Simulator.DIR_CCW];
}
nextZ = ((oppZ + 1) > nrItemInRing - 1) ? 0 : oppZ+1;
prevZ = ((oppZ - 1) < 0) ? nrItemInRing - 1 : oppZ-1;
nextID = RingCoord.getIDfromXYZ(oppX, oppY, nextZ);
previousID = RingCoord.getIDfromXYZ(oppX, oppY, prevZ);
#if DEBUG
Console.WriteLine("opp({0},{1},{2})\tnextID {3}, oppID {4}, previousID {5}", oppX, oppY, oppZ, nextID, oppID, previousID);
#endif
if (ringRouter[nextID].clockwise) {
ringRouter[nextID].linkIn[Simulator.DIR_CCW] = ringRouter[previousID].linkOut[Simulator.DIR_CW];
ringRouter[oppID].linkIn[Simulator.DIR_CCW] = ringRouter[oppID].linkOut[Simulator.DIR_CW];
}
else {
ringRouter[previousID].linkIn[Simulator.DIR_CW] = ringRouter[nextID].linkOut[Simulator.DIR_CCW];
ringRouter[oppID].linkIn[Simulator.DIR_CW] = ringRouter[oppID].linkOut[Simulator.DIR_CCW];
}
ringRouter[currentID] = null;
ringRouter[oppID] = null;
continue;
}
}
break;
case 3: connectionDir = Simulator.DIR_LEFT;
#if DEBUG
Console.WriteLine("3");
#endif
oppDir = Simulator.DIR_RIGHT;
oppX = x - 1;
if (oppX < 0)
{
oppX = Config.network_nrX / Config.ringWidth - 1;
// ensure no duplication by handling a link at the lexicographically
// first router
if (oppX < x || (oppX == x && oppY < y)) continue;
if (!Config.torus)
{
//Lower the link latency because this router is not being used
oppID = RingCoord.getIDfromXYZ(oppX, oppY, oppZ);
int nextZ = ((z + 1) > nrItemInRing - 1) ? 0 : z+1;
int prevZ = ((z - 1) < 0) ? nrItemInRing - 1 : z-1;
int nextID = RingCoord.getIDfromXYZ(x, y, nextZ);
int previousID = RingCoord.getIDfromXYZ(x, y, prevZ);
#if DEBUG
Console.WriteLine("opp({0},{1},{2})\tnextID {3}, currentID {4}, previousID {5}", oppX, oppY, oppZ, nextID, currentID, previousID);
#endif
if (ringRouter[nextID].clockwise) {
ringRouter[nextID].linkIn[Simulator.DIR_CCW] = ringRouter[previousID].linkOut[Simulator.DIR_CW];
ringRouter[currentID].linkIn[Simulator.DIR_CCW] = ringRouter[currentID].linkOut[Simulator.DIR_CW];
}
else {
ringRouter[previousID].linkIn[Simulator.DIR_CW] = ringRouter[nextID].linkOut[Simulator.DIR_CCW];
ringRouter[currentID].linkIn[Simulator.DIR_CW] = ringRouter[currentID].linkOut[Simulator.DIR_CCW];
}
nextZ = ((oppZ + 1) > nrItemInRing - 1) ? 0 : oppZ+1;
prevZ = ((oppZ - 1) < 0) ? nrItemInRing - 1 : oppZ-1;
nextID = RingCoord.getIDfromXYZ(oppX, oppY, nextZ);
previousID = RingCoord.getIDfromXYZ(oppX, oppY, prevZ);
#if DEBUG
Console.WriteLine("opp({0},{1},{2})\tnextID {3}, oppID {4}, previousID {5}", oppX, oppY, oppZ, nextID, oppID, previousID);
#endif
if (ringRouter[nextID].clockwise) {
ringRouter[nextID].linkIn[Simulator.DIR_CCW] = ringRouter[previousID].linkOut[Simulator.DIR_CW];
ringRouter[oppID].linkIn[Simulator.DIR_CCW] = ringRouter[oppID].linkOut[Simulator.DIR_CW];
}
else {
ringRouter[previousID].linkIn[Simulator.DIR_CW] = ringRouter[nextID].linkOut[Simulator.DIR_CCW];
ringRouter[oppID].linkIn[Simulator.DIR_CW] = ringRouter[oppID].linkOut[Simulator.DIR_CCW];
}
ringRouter[currentID] = null;
ringRouter[oppID] = null;
continue;
}
}
break;
default: throw new Exception("Ring too big for current system");
}
oppID = RingCoord.getIDfromXYZ(oppX, oppY, oppZ);
// ensure no duplication by handling a link at the lexicographically
// first router
if (oppX < x || (oppX == x && oppY < y)) continue;
#if DEBUG
Console.WriteLine("Creating normal link\topp({0},{1},{2})\toppID {3} dir {4} : oppdir {5}", oppX, oppY, oppZ, oppID, connectionDir, oppDir);
#endif
Link linkA = new Link(Config.router.linkLatency - 1);
Link linkB = new Link(Config.router.linkLatency - 1);
links.Add(linkA);
links.Add(linkB);
#if DEBUG
Console.WriteLine("-------------------------------------------current{0} opp{1}", currentID, oppID);
#endif
((Connector)ringRouter[currentID]).connectionDirection = connectionDir;
((Connector)ringRouter[oppID]).connectionDirection = oppDir;
ringRouter[currentID].linkOut[connectionDir] = linkA;
ringRouter[oppID].linkIn[oppDir] = linkA;
ringRouter[currentID].linkIn[connectionDir] = linkB;
ringRouter[oppID].linkOut[oppDir] = linkB;
if (nrPlaceholdersPerNetwork > 0) {
((Connector)ringRouter[currentID]).injectPlaceholder = 2;
nrPlaceholdersPerNetwork--;
}
}
}
}
}
#if DEBUG
//Verification
for (int y = 0; y < Config.network_nrY / Config.ringHeight; y++) {
for (int x = 0; x < Config.network_nrX / Config.ringWidth; x++) {
Console.WriteLine("");
for (int z = 0; z < nrItemInRing; z++) {
int tempID = RingCoord.getIDfromXYZ(x, y, z);
if (ringRouter[tempID] == null) continue;
if(z % 2 == 0) Console.WriteLine("Node with clockwise = {0}", ringRouter[tempID].clockwise);
if(z % 2 == 1) Console.WriteLine("Connector with direction {0}", ((Connector)ringRouter[tempID]).connectionDirection);
if (ringRouter[tempID].clockwise) {
for (int dir = 5; dir >= 0; dir--) {
if(ringRouter[tempID].linkIn[dir] != null)
Console.WriteLine("{0} | ID:{1}, \tLinkIn Direction {2}, \tLink: {3}\t|", ringRouter[tempID], tempID, dir, ringRouter[tempID].linkIn[dir]);
}
for (int dir = 0; dir < 6; dir++) {
if(ringRouter[tempID].linkOut[dir] != null)
Console.WriteLine("{0} | ID:{1}, \tLinkOut Direction {2}, \tLink: {3}\t|", ringRouter[tempID], tempID, dir, ringRouter[tempID].linkOut[dir]);
}
}
else {
for (int dir = 5; dir >= 0; dir--) {
if(ringRouter[tempID].linkOut[dir] != null)
Console.WriteLine("{0} | ID:{1}, \tLinkOut Direction {2}, \tLink: {3}\t|", ringRouter[tempID], tempID, dir, ringRouter[tempID].linkOut[dir]);
}
for (int dir = 0; dir < 6; dir++) {
if(ringRouter[tempID].linkIn[dir] != null)
Console.WriteLine("{0} | ID:{1}, \tLinkIn Direction {2}, \tLink: {3}\t|", ringRouter[tempID], tempID, dir, ringRouter[tempID].linkIn[dir]);
}
}
}
}
}
#endif
return;
}
/*
if (Config.DisjointRings)
{
if (Config.SeperateConnect)
{
if (Config.network_nrX != Config.network_nrY)
throw new Exception("Only works with square networks");
// Designed for ringSize of 2
// And square network
// TODO: work on different dimensions
int ringLength = Config.ringSize;
int netXLength = Config.network_nrX;
int netYLength = Config.network_nrY;
int numRings = (netYLength / ringLength) * (netXLength / ringLength);
int numRingNodes = (ringLength * ringLength);
int dirOut = 1;
int dirIn = 0;
int dirInject = 2;
int dirEject = 3;
Link A_B = new Link(Config.router.linkLatency - 1);
Link B_Z1A = new Link(Config.router.linkLatency - 1);
Link Z1A_C = new Link(Config.router.linkLatency - 1);
Link C_Z4B = new Link(Config.router.linkLatency - 1);
Link Z4B_D = new Link(Config.router.linkLatency - 1);
Link D_A = new Link(Config.router.linkLatency - 1);
Link E_F = new Link(Config.router.linkLatency - 1);
Link F_G = new Link(Config.router.linkLatency - 1);
Link G_Z2A = new Link(Config.router.linkLatency - 1);
Link Z2A_H = new Link(Config.router.linkLatency - 1);
Link H_Z1B = new Link(Config.router.linkLatency - 1);
Link Z1B_E = new Link(Config.router.linkLatency - 1);
Link M_Z2B = new Link(Config.router.linkLatency - 1);
Link Z2B_N = new Link(Config.router.linkLatency - 1);
Link N_O = new Link(Config.router.linkLatency - 1);
Link O_P = new Link(Config.router.linkLatency - 1);
Link P_Z3A = new Link(Config.router.linkLatency - 1);
Link Z3A_M = new Link(Config.router.linkLatency - 1);
Link I_Z4A = new Link(Config.router.linkLatency - 1);
Link Z4A_J = new Link(Config.router.linkLatency - 1);
Link J_Z3B = new Link(Config.router.linkLatency - 1);
Link Z3B_K = new Link(Config.router.linkLatency - 1);
Link K_L = new Link(Config.router.linkLatency - 1);
Link L_I = new Link(Config.router.linkLatency - 1);
Link A_B1 = new Link(Config.router.linkLatency - 1);
Link B_A1 = new Link(Config.router.linkLatency - 1);
Link A_B2 = new Link(Config.router.linkLatency - 1);
Link B_A2 = new Link(Config.router.linkLatency - 1);
Link A_B3 = new Link(Config.router.linkLatency - 1);
Link B_A3 = new Link(Config.router.linkLatency - 1);
Link A_B4 = new Link(Config.router.linkLatency - 1);
Link B_A4 = new Link(Config.router.linkLatency - 1);
links.Add(A_B);
links.Add(B_Z1A);
links.Add(Z1A_C);
links.Add(C_Z4B);
links.Add(Z4B_D);
links.Add(D_A);
links.Add(E_F);
links.Add(F_G);
links.Add(G_Z2A);
links.Add(Z2A_H);
links.Add(H_Z1B);
links.Add(Z1B_E);
links.Add(M_Z2B);
links.Add(Z2B_N);
links.Add(N_O);
links.Add(O_P);
links.Add(P_Z3A);
links.Add(Z3A_M);
links.Add(I_Z4A);
links.Add(Z4A_J);
links.Add(J_Z3B);
links.Add(Z3B_K);
links.Add(K_L);
links.Add(L_I);
links.Add(A_B1);
links.Add(B_A1);
links.Add(A_B2);
links.Add(B_A2);
links.Add(A_B3);
links.Add(B_A3);
links.Add(A_B4);
links.Add(B_A4);
int A = Coord.getIDfromXY(0, 0);
int B = Coord.getIDfromXY(1, 0);
int C = Coord.getIDfromXY(1, 1);
int D = Coord.getIDfromXY(0, 1);
int E = Coord.getIDfromXY(2, 0);
int F = Coord.getIDfromXY(3, 0);
int G = Coord.getIDfromXY(3, 1);
int H = Coord.getIDfromXY(2, 1);
int I = Coord.getIDfromXY(0, 2);
int J = Coord.getIDfromXY(1, 2);
int K = Coord.getIDfromXY(1, 3);
int L = Coord.getIDfromXY(0, 3);
int M = Coord.getIDfromXY(2, 2);
int N = Coord.getIDfromXY(3, 2);
int O = Coord.getIDfromXY(3, 3);
int P = Coord.getIDfromXY(2, 3);
int Z1A = 0;
int Z1B = 1;
int Z2A = 2;
int Z2B = 3;
int Z3A = 4;
int Z3B = 5;
int Z4A = 6;
int Z4B = 7;
routers[A].linkIn[dirIn] = D_A;
routers[A].linkOut[dirOut] = A_B;
routers[A].neigh[dirIn] = routers[D];
routers[A].neigh[dirOut] = routers[B];
routers[A].neighbors = 2;
routers[B].linkIn[dirIn] = A_B;
routers[B].linkOut[dirOut] = B_Z1A;
routers[B].neigh[dirIn] = routers[A];
routers[B].neigh[dirOut] = connectors[Z1A];
routers[B].neighbors = 2;
routers[C].linkIn[dirIn] = Z1A_C;
routers[C].linkOut[dirOut] = C_Z4B;
routers[C].neigh[dirIn] = connectors[Z1A];
routers[C].neigh[dirOut] = connectors[Z4B];
routers[C].neighbors = 2;
routers[D].linkIn[dirIn] = Z4B_D;
routers[D].linkOut[dirOut] = D_A;
routers[D].neigh[dirIn] = connectors[Z4B];
routers[D].neigh[dirOut] = routers[A];
routers[D].neighbors = 2;
if (Config.sameDir)
{
routers[E].linkIn[dirIn] = Z1B_E;
routers[E].linkOut[dirOut] = E_F;
routers[E].neigh[dirIn] = connectors[Z1B];
routers[E].neigh[dirOut] = routers[F];
routers[E].neighbors = 2;
routers[F].linkIn[dirIn] = E_F;
routers[F].linkOut[dirOut] = F_G;
routers[F].neigh[dirIn] = routers[E];
routers[F].neigh[dirOut] = routers[G];
routers[F].neighbors = 2;
routers[G].linkIn[dirIn] = F_G;
routers[G].linkOut[dirOut] = G_Z2A;
routers[G].neigh[dirIn] = routers[F];
routers[G].neigh[dirOut] = connectors[Z2A];
routers[G].neighbors = 2;
routers[H].linkIn[dirIn] = Z2A_H;
routers[H].linkOut[dirOut] = H_Z1B;
routers[H].neigh[dirIn] = connectors[Z2A];
routers[H].neigh[dirOut] = connectors[Z1B];
routers[H].neighbors = 2;
routers[I].linkIn[dirIn] = L_I;
routers[I].linkOut[dirOut] = I_Z4A;
routers[I].neigh[dirIn] = routers[L];
routers[I].neigh[dirOut] = connectors[Z4A];
routers[I].neighbors = 2;
routers[J].linkIn[dirIn] = Z4A_J;
routers[J].linkOut[dirOut] = J_Z3B;
routers[J].neigh[dirIn] = connectors[Z4A];
routers[J].neigh[dirOut] = connectors[Z3B];
routers[J].neighbors = 2;
routers[K].linkIn[dirIn] = Z3B_K;
routers[K].linkOut[dirOut] = K_L;
routers[K].neigh[dirIn] = connectors[Z3B];
routers[K].neigh[dirOut] = routers[L];
routers[K].neighbors = 2;
routers[L].linkIn[dirIn] = K_L;
routers[L].linkOut[dirOut] = L_I;
routers[L].neigh[dirIn] = routers[K];
routers[L].neigh[dirOut] = routers[I];
routers[L].neighbors = 2;
}
else
{
routers[E].linkIn[dirIn] = E_F;
routers[E].linkOut[dirOut] = Z1B_E;
routers[E].neigh[dirIn] = routers[F];
routers[E].neigh[dirOut] = connectors[Z1B];
routers[E].neighbors = 2;
routers[F].linkIn[dirIn] = F_G;
routers[F].linkOut[dirOut] = E_F;
routers[F].neigh[dirIn] = routers[G];
routers[F].neigh[dirOut] = routers[E];
routers[F].neighbors = 2;
routers[G].linkIn[dirIn] = G_Z2A;
routers[G].linkOut[dirOut] = F_G;
routers[G].neigh[dirIn] = connectors[Z2A];
routers[G].neigh[dirOut] = routers[F];
routers[G].neighbors = 2;
routers[H].linkIn[dirIn] = H_Z1B;
routers[H].linkOut[dirOut] = Z2A_H;
routers[H].neigh[dirIn] = connectors[Z1B];
routers[H].neigh[dirOut] = connectors[Z2A];
routers[H].neighbors = 2;
routers[I].linkIn[dirIn] = I_Z4A;
routers[I].linkOut[dirOut] = L_I;
routers[I].neigh[dirIn] = connectors[Z4A];
routers[I].neigh[dirOut] = routers[L];
routers[I].neighbors = 2;
routers[J].linkIn[dirIn] = J_Z3B;
routers[J].linkOut[dirOut] = Z4A_J;
routers[J].neigh[dirIn] = connectors[Z3B];
routers[J].neigh[dirOut] = connectors[Z4A];
routers[J].neighbors = 2;
routers[K].linkIn[dirIn] = K_L;
routers[K].linkOut[dirOut] = Z3B_K;
routers[K].neigh[dirIn] = routers[L];
routers[K].neigh[dirOut] = connectors[Z3B];
routers[K].neighbors = 2;
routers[L].linkIn[dirIn] = L_I;
routers[L].linkOut[dirOut] = K_L;
routers[L].neigh[dirIn] = routers[I];
routers[L].neigh[dirOut] = routers[K];
routers[L].neighbors = 2;
}
routers[M].linkIn[dirIn] = Z3A_M;
routers[M].linkOut[dirOut] = M_Z2B;
routers[M].neigh[dirIn] = connectors[Z3A];
routers[M].neigh[dirOut] = connectors[Z2B];
routers[M].neighbors = 2;
routers[N].linkIn[dirIn] = Z2B_N;
routers[N].linkOut[dirOut] = N_O;
routers[N].neigh[dirIn] = connectors[Z2B];
routers[N].neigh[dirOut] = routers[O];
routers[N].neighbors = 2;
routers[O].linkIn[dirIn] = N_O;
routers[O].linkOut[dirOut] = O_P;
routers[O].neigh[dirIn] = routers[N];
routers[O].neigh[dirOut] = routers[P];
routers[O].neighbors = 2;
routers[P].linkIn[dirIn] = O_P;
routers[P].linkOut[dirOut] = P_Z3A;
routers[P].neigh[dirIn] = routers[O];
routers[P].neigh[dirOut] = connectors[Z3A];
routers[P].neighbors = 2;
// Connectors
connectors[Z1A].linkIn[dirIn] = B_Z1A;
connectors[Z1A].linkOut[dirOut] = Z1A_C;
connectors[Z1A].neigh[dirIn] = routers[B];
connectors[Z1A].neigh[dirOut] = routers[C];
connectors[Z1A].neighbors += 2;
connectors[Z2B].linkIn[dirIn] = M_Z2B;
connectors[Z2B].linkOut[dirOut] = Z2B_N;
connectors[Z2B].neigh[dirIn] = routers[M];
connectors[Z2B].neigh[dirOut] = routers[N];
connectors[Z2B].neighbors += 2;
connectors[Z3A].linkIn[dirIn] = P_Z3A;
connectors[Z3A].linkOut[dirOut] = Z3A_M;
connectors[Z3A].neigh[dirIn] = routers[P];
connectors[Z3A].neigh[dirOut] = routers[M];
connectors[Z3A].neighbors += 2;
connectors[Z4B].linkIn[dirIn] = C_Z4B;
connectors[Z4B].linkOut[dirOut] = Z4B_D;
connectors[Z4B].neigh[dirIn] = routers[C];
connectors[Z4B].neigh[dirOut] = routers[D];
connectors[Z4B].neighbors += 2;
if (Config.sameDir)
{
connectors[Z1B].linkIn[dirIn] = H_Z1B;
connectors[Z1B].linkOut[dirOut] = Z1B_E;
connectors[Z1B].neigh[dirIn] = routers[H];
connectors[Z1B].neigh[dirOut] = routers[E];
connectors[Z1B].neighbors += 2;
connectors[Z2A].linkIn[dirIn] = G_Z2A;
connectors[Z2A].linkOut[dirOut] = Z2A_H;
connectors[Z2A].neigh[dirIn] = routers[G];
connectors[Z2A].neigh[dirOut] = routers[H];
connectors[Z2A].neighbors += 2;
connectors[Z4A].linkIn[dirIn] = I_Z4A;
connectors[Z4A].linkOut[dirOut] = Z4A_J;
connectors[Z4A].neigh[dirIn] = routers[I];
connectors[Z4A].neigh[dirOut] = routers[J];
connectors[Z4A].neighbors += 2;
connectors[Z3B].linkIn[dirIn] = J_Z3B;
connectors[Z3B].linkOut[dirOut] = Z3B_K;
connectors[Z3B].neigh[dirIn] = routers[J];
connectors[Z3B].neigh[dirOut] = routers[K];
connectors[Z3B].neighbors += 2;
}
else
{
connectors[Z1B].linkIn[dirIn] = Z1B_E;
connectors[Z1B].linkOut[dirOut] = H_Z1B;
connectors[Z1B].neigh[dirIn] = routers[E];
connectors[Z1B].neigh[dirOut] = routers[H];
connectors[Z1B].neighbors += 2;
connectors[Z2A].linkIn[dirIn] = Z2A_H;
connectors[Z2A].linkOut[dirOut] = G_Z2A;
connectors[Z2A].neigh[dirIn] = routers[H];
connectors[Z2A].neigh[dirOut] = routers[G];
connectors[Z2A].neighbors += 2;
connectors[Z4A].linkIn[dirIn] = Z4A_J;
connectors[Z4A].linkOut[dirOut] = I_Z4A;
connectors[Z4A].neigh[dirIn] = routers[J];
connectors[Z4A].neigh[dirOut] = routers[I];
connectors[Z4A].neighbors += 2;
connectors[Z3B].linkIn[dirIn] = Z3B_K;
connectors[Z3B].linkOut[dirOut] = J_Z3B;
connectors[Z3B].neigh[dirIn] = routers[K];
connectors[Z3B].neigh[dirOut] = routers[J];
connectors[Z3B].neighbors += 2;
}
connectors[Z1A].linkIn[dirInject] = B_A1;
connectors[Z1A].linkOut[dirEject] = A_B1;
connectors[Z1A].neigh[dirIn] = connectors[Z1B];
connectors[Z1A].neigh[dirOut] = connectors[Z1B];
connectors[Z1A].neighbors += 2;
connectors[Z1B].linkIn[dirInject] = A_B1;
connectors[Z1B].linkOut[dirEject] = B_A1;
connectors[Z1B].neigh[dirIn] = connectors[Z1A];
connectors[Z1B].neigh[dirOut] = connectors[Z1A];
connectors[Z1B].neighbors += 2;
connectors[Z2A].linkIn[dirInject] = B_A2;
connectors[Z2A].linkOut[dirEject] = A_B2;
connectors[Z2A].neigh[dirIn] = connectors[Z2B];
connectors[Z2A].neigh[dirOut] = connectors[Z2B];
connectors[Z2A].neighbors += 2;
connectors[Z2B].linkIn[dirInject] = A_B2;
connectors[Z2B].linkOut[dirEject] = B_A2;
connectors[Z2B].neigh[dirIn] = connectors[Z2A];
connectors[Z2B].neigh[dirOut] = connectors[Z2A];
connectors[Z2B].neighbors += 2;
connectors[Z3A].linkIn[dirInject] = B_A3;
connectors[Z3A].linkOut[dirEject] = A_B3;
connectors[Z3A].neigh[dirIn] = connectors[Z3B];
connectors[Z3A].neigh[dirOut] = connectors[Z3B];
connectors[Z3A].neighbors += 2;
connectors[Z3B].linkIn[dirInject] = A_B3;
connectors[Z3B].linkOut[dirEject] = B_A3;
connectors[Z3B].neigh[dirIn] = connectors[Z3A];
connectors[Z3B].neigh[dirOut] = connectors[Z3A];
connectors[Z3B].neighbors += 2;
connectors[Z4A].linkIn[dirInject] = B_A4;
connectors[Z4A].linkOut[dirEject] = A_B4;
connectors[Z4A].neigh[dirIn] = connectors[Z4B];
connectors[Z4A].neigh[dirOut] = connectors[Z4B];
connectors[Z4A].neighbors += 2;
connectors[Z4B].linkIn[dirInject] = A_B4;
connectors[Z4B].linkOut[dirEject] = B_A4;
connectors[Z4B].neigh[dirIn] = connectors[Z4A];
connectors[Z4B].neigh[dirOut] = connectors[Z4A];
connectors[Z4B].neighbors += 2;
return;
}
}
/*
if (Config.StreetRings)
{
// connect the network with Links
for (int n = 0; n < Config.N; n++)
{
int x, y;
Coord.getXYfromID(n, out x, out y);
// inter-router links
for (int dir = 0; dir < 2; dir++)
{
int oppDir = (dir + 2) % 4; // direction from neighbor's perspective
// determine neighbor's coordinates
int x_, y_;
switch (x % 2)
{
case 0:
switch (dir)
{
case 0: x_ = x; y_ = y + 1; break;
case 1: x_ = x; y_ = y - 1; break;
default: continue;
}
break;
case 1:
switch (dir)
{
case 0: x_ = x; y_ = y - 1; break;
case 1: x_ = x; y_ = y + 1; break;
default: continue;
}
break;
}
// ensure no duplication by handling a link at the lexicographically
// first router
if (x_ < x || (x_ == x && y_ < y)) continue;
// Link param is *extra* latency (over the standard 1 cycle)
Link dirA = new Link(Config.router.linkLatency - 1);
Link dirB = new Link(Config.router.linkLatency - 1);
links.Add(dirA);
links.Add(dirB);
// link 'em up
routers[Coord.getIDfromXY(x, y)].linkOut[dir] = dirA;
routers[Coord.getIDfromXY(x_, y_)].linkIn[oppDir] = dirA;
routers[Coord.getIDfromXY(x, y)].linkIn[dir] = dirB;
routers[Coord.getIDfromXY(x_, y_)].linkOut[oppDir] = dirB;
routers[Coord.getIDfromXY(x, y)].neighbors++;
routers[Coord.getIDfromXY(x_, y_)].neighbors++;
routers[Coord.getIDfromXY(x, y)].neigh[dir] = routers[Coord.getIDfromXY(x_, y_)];
routers[Coord.getIDfromXY(x_, y_)].neigh[oppDir] = routers[Coord.getIDfromXY(x, y)];
}
}
}
*/
// connect the network with Links
for (int n = 0; n < Config.N; n++)
{
int x, y;
Coord.getXYfromID(n, out x, out y);
int ID = n;
// inter-router links
for (int dir = 0; dir < 4; dir++)
{
int oppDir = (dir + 2) % 4; // direction from neighbor's perspective
// determine neighbor's coordinates
int x_, y_;
switch (dir)
{
case Simulator.DIR_UP: x_ = x; y_ = y + 1; break;
case Simulator.DIR_DOWN: x_ = x; y_ = y - 1; break;
case Simulator.DIR_RIGHT: x_ = x + 1; y_ = y; break;
case Simulator.DIR_LEFT: x_ = x - 1; y_ = y; break;
default: continue;
}
// If we are a torus, we manipulate x_ and y_
if(Config.torus)
{
if(x_ < 0)
x_ += X;
else if(x_ >= X)
x_ -= X;
if(y_ < 0)
y_ += Y;
else if(y_ >= Y)
y_ -= Y;
}
// mesh, not torus: detect edge
else if (x_ < 0 || x_ >= X || y_ < 0 || y_ >= Y)
{
if (Config.edge_loop)
{
Link edgeL = new Link(Config.router.linkLatency - 1);
links.Add(edgeL);
routers[ID].linkOut[dir] = edgeL;
routers[ID].linkIn[dir] = edgeL;
routers[ID].neighbors++;
routers[ID].neigh[dir] =
routers[ID];
}
continue;
}
// ensure no duplication by handling a link at the lexicographically
// first router
if (x_ < x || (x_ == x && y_ < y)) continue;
// Link param is *extra* latency (over the standard 1 cycle)
Link dirA = new Link(Config.router.linkLatency - 1);
Link dirB = new Link(Config.router.linkLatency - 1);
links.Add(dirA);
links.Add(dirB);
int oppID = Coord.getIDfromXY(x_, y_);
// link 'em up
routers[ID].linkOut[dir] = dirA;
routers[oppID].linkIn[oppDir] = dirA;
routers[ID].linkIn[dir] = dirB;
routers[oppID].linkOut[oppDir] = dirB;
routers[ID].neighbors++;
routers[oppID].neighbors++;
routers[ID].neigh[dir] = routers[oppID];
routers[oppID].neigh[oppDir] = routers[ID];
if (Config.router.algorithm == RouterAlgorithm.DR_SCARAB)
{
for (int wireNr = 0; wireNr < Config.nack_nr; wireNr++)
{
Link nackA = new Link(Config.nack_linkLatency - 1);
Link nackB = new Link(Config.nack_linkLatency - 1);
links.Add(nackA);
links.Add(nackB);
((Router_SCARAB)routers[Coord.getIDfromXY(x, y)]).nackOut[dir * Config.nack_nr + wireNr] = nackA;
((Router_SCARAB)routers[Coord.getIDfromXY(x_, y_)]).nackIn[oppDir * Config.nack_nr + wireNr] = nackA;
((Router_SCARAB)routers[Coord.getIDfromXY(x, y)]).nackIn[dir * Config.nack_nr + wireNr] = nackB;
((Router_SCARAB)routers[Coord.getIDfromXY(x_, y_)]).nackOut[oppDir * Config.nack_nr + wireNr] = nackB;
}
}
}
}
if (Config.torus)
for (int i = 0; i < Config.N; i++)
if (routers[i].neighbors < 4)
throw new Exception("torus construction not successful!");
}
public static RingRouter makeConnection(RingCoord rc)
{
switch (Config.router.connectionalgorithm)
{
case ConnectorAlgorithm.DIRECT_LINK:
return new Connector(rc, false);
//case ConnectorAlgorithm.RING_LINK:
// return new Connector_Ring(rc);
default: throw new Exception("Invalid connector");
}
}
