protected int deflPriority(Flit f1, Flit f2)
{
if (f1 == null && f2 == null)
{
return(0);
}
else if (f1 == null)
{
return(1);
}
else if (f2 == null)
{
return(-1);
}
int ret;
switch (Config.resubmitBy)
{
case "Random": ret = (1 == Simulator.rand.Next(2)) ? -1 : 1;
break;
case "Bias": ret = -1;
break;
default: throw new Exception("Not a resubmit scheme");
}
return(ret);
}
public override void InjectFlit(Flit f)
{
if (m_injectSlot == null)
m_injectSlot = f;
else
throw new Exception("Could not inject flit!");
}
protected override void statsEjectFlit(Flit f)
{
//if (f.packet.src.ID == 3) Console.WriteLine("eject flit: packet {0}, seq {1}",
// f.packet.ID, f.flitNr)
// per-flit latency stats
ulong net_latency = Simulator.CurrentRound - f.injectionTime;
ulong total_latency = Simulator.CurrentRound - f.packet.creationTime;
ulong inj_latency = total_latency - net_latency;
Simulator.stats.flit_inj_latency.Add(inj_latency);
Simulator.stats.flit_net_latency.Add(net_latency);
Simulator.stats.flit_total_latency.Add(inj_latency);
Simulator.stats.eject_flit.Add();
Simulator.stats.eject_flit_bydest[f.packet.dest.ID].Add();
int minpath = Math.Abs(f.packet.ringdest.x - f.packet.ringsrc.x) + Math.Abs(f.packet.ringdest.y - f.packet.ringsrc.y);
Simulator.stats.minpath.Add(minpath);
Simulator.stats.minpath_bysrc[f.packet.src.ID].Add(minpath);
//f.dumpDeflections();
Simulator.stats.deflect_perdist[f.distance].Add(f.nrOfDeflections);
if (f.nrOfDeflections != 0)
{
Simulator.stats.deflect_perflit_byreq[f.packet.requesterID].Add(f.nrOfDeflections);
}
}
Flit ejectLocal()
{
// eject locally-destined flit (highest-ranked, if multiple)
Flit ret = null;
int flitsTryToEject = 0;
int bestDir = -1;
// Check both directions
for (int dir = 0; dir < 2; dir++)
{
if (linkIn[dir] != null && linkIn[dir].Out != null &&
linkIn[dir].Out.state != Flit.State.Placeholder &&
linkIn[dir].Out.dest.ID == ID)
{
ret = linkIn[dir].Out;
bestDir = dir;
flitsTryToEject++;
}
}
if (bestDir != -1)
{
linkIn[bestDir].Out = null;
}
Simulator.stats.flitsTryToEject[flitsTryToEject].Add();
#if debug
if (ret != null)
{
Console.WriteLine("ejecting flit {0} flitnr {1} at node {2} cyc {3}", ret.packet.ID, ret.flitNr, coord, Simulator.CurrentRound);
}
#endif
return(ret);
}
protected override int dimension_order_route(Flit f)
{
if (f.packet.ringdest.x < ringCoord.x)
{
return(Simulator.DIR_LEFT);
}
else if (f.packet.ringdest.x > ringCoord.x)
{
return(Simulator.DIR_RIGHT);
}
else if (f.packet.ringdest.y < ringCoord.y)
{
return(Simulator.DIR_DOWN);
}
else if (f.packet.ringdest.y > ringCoord.y)
{
return(Simulator.DIR_UP);
}
else if (f.packet.ringdest.z > ringCoord.z)
{
return(Simulator.DIR_CW);
}
else if (f.packet.ringdest.z < ringCoord.z)
{
return(Simulator.DIR_CCW);
}
else //if the destination's coordinates are equal to the router's coordinates
{
return(Simulator.DIR_CW);
}
}
void swap(int dir1, int dir2)
{
Flit tempFlit = input[dir1];
input[dir1] = input[dir2];
input[dir2] = tempFlit;
}
protected void acceptFlit(Flit f)
{
statsEjectFlit(f);
if (f.packet.nrOfArrivedFlits + 1 == f.packet.nrOfFlits)
statsEjectPacket(f.packet);
m_n.receiveFlit(f);
}
public override int rankFlits(Flit f1, Flit f2)
{
// rule 1: older batch (lower batchID) is greater
int cmp1 = 0;
if (f1.packet.batchID != f2.packet.batchID)
cmp1 = - cmp(f1.packet.batchID, f2.packet.batchID);
// rule 2: higher STC priority is greater
int cmp2 = 0;
if (f1.packet.requesterID != -1 &&
f2.packet.requesterID != -1 &&
f1.packet.requesterID != f2.packet.requesterID)
cmp2 = cmp(stc.priorities[f1.packet.requesterID], stc.priorities[f2.packet.requesterID]);
// rule 3: older packet is greater
int cmp3 = cmp(f1.packet.creationTime, f2.packet.creationTime);
// rule 4: packet ID
int cmp4 = cmp(f1.packet.ID, f2.packet.ID);
// rule 5: lower-sequence flit is greater
int cmp5 = cmp(f1.flitNr, f2.flitNr);
if (cmp1 != 0) return cmp1;
if (cmp2 != 0) return cmp2;
if (cmp3 != 0) return cmp3;
if (cmp4 != 0) return cmp4;
return cmp5;
}
public override void InjectFlit(Flit f)
{
Simulator.stats.afc_vnet[f.packet.getClass()].Add();
if (m_buffered)
{
AFCBufferSlot slot = getFreeBufferSlot(f);
f.enterBuffer = Simulator.CurrentRound;
m_buf[4, f.packet.getClass()].Enqueue(slot);
m_buf_occupancy++;
Simulator.stats.afc_buf_write.Add();
Simulator.stats.afc_buf_write_bysrc[ID].Add();
}
else
{
if (m_injectSlot != null)
{
throw new Exception("Trying to inject twice in one cycle");
}
m_injectSlot = f;
}
}
public void doStep()
{
if (m_delay > 0)
{
Out = m_fifo [0];
for (int i = 0; i < m_delay - 1; i++)
m_fifo[i] = m_fifo[i + 1];
m_fifo [m_delay - 1] = In;
SideBandOut[0] = m_sideband_fifo[0][0];
SideBandOut[1] = m_sideband_fifo[0][1];
for (int i = 0; i < m_delay - 1; i++)
{
m_sideband_fifo[i][0] = m_sideband_fifo[i + 1][0];
m_sideband_fifo[i][1] = m_sideband_fifo[i + 1][1];
}
m_sideband_fifo[m_delay - 1][0] = SideBandIn[0];
m_sideband_fifo[m_delay - 1][1] = SideBandIn[1];
}
else
{
Out = In;
SideBandOut[1] = SideBandIn[1];
SideBandOut[0] = SideBandIn[0];
}
SideBandIn[0] = -1;
SideBandIn[1] = -1;
In = null;
}
// return the next VC the flit wants to go.
// 0 : ring buffer or injection buffer, VC0
// 1 : ring buffer or injection buffer, VC1
// 2 : cross buffer, VC0
// 3 : cross buffer, VC1
public int getClass(Flit f)
{
int curRouter = ID % 4;
int destRouter = (f.packet.dest.ID / 4 == ID / 4) ? f.packet.dest.ID % 4 : 4;
if (ID / 4 == f.packet.dest.ID / 4 || curRouter != 3)
{
if (destRouter > curRouter)
{
return(1);
}
else
{
return(0);
}
}
else
{
if (f.packet.dest.ID / 4 > ID / 4)
{
return(3);
}
else
{
return(2);
}
}
}
public void doStep()
{
if (m_delay > 0)
{
Out = m_fifo[0];
for (int i = 0; i < m_delay - 1; i++)
{
m_fifo[i] = m_fifo[i + 1];
}
m_fifo[m_delay - 1] = In;
SideBandOut = m_sideband_fifo[0];
for (int i = 0; i < m_delay - 1; i++)
{
m_sideband_fifo[i] = m_sideband_fifo[i + 1];
}
m_sideband_fifo[m_delay - 1] = SideBandIn;
}
else
{
Out = In;
SideBandOut = SideBandIn;
}
In = null;
SideBandIn = null;
}
public override void InjectFlit(Flit f)
{
if (Config.afc_real_classes)
{
Simulator.stats.afc_vnet[f.packet.getClass()].Add();
}
else
{
Simulator.stats.afc_vnet[this.ID].Add();
}
if (m_buffered)
{
AFCBufferSlot slot = getFreeBufferSlot(f);
m_buf[LOCAL_INDEX, f.packet.getClass()].Enqueue(slot);
m_buf_occupancy++;
Simulator.stats.afc_buf_write.Add();
Simulator.stats.afc_buf_write_bysrc[ID].Add();
}
else
{
if (m_injectSlot != null)
{
throw new Exception("Trying to inject twice in one cycle");
}
m_injectSlot = f;
}
}
protected virtual void statsInjectFlit(Flit f)
{
//if (f.packet.src.ID == 3) Console.WriteLine("inject flit: packet {0}, seq {1}",
// f.packet.ID, f.flitNr);
Simulator.stats.inject_flit.Add();
if (f.isHeadFlit)
{
Simulator.stats.inject_flit_head.Add();
}
if (f.packet != null)
{
Simulator.stats.inject_flit_bysrc[f.packet.src.ID].Add();
//Simulator.stats.inject_flit_srcdest[f.packet.src.ID, f.packet.dest.ID].Add();
}
if (f.packet != null && f.packet.injectionTime == ulong.MaxValue)
{
f.packet.injectionTime = Simulator.CurrentRound;
}
f.injectionTime = Simulator.CurrentRound;
ulong hoq = Simulator.CurrentRound - m_lastInj;
m_lastInj = Simulator.CurrentRound;
Simulator.stats.hoq_latency.Add(hoq);
Simulator.stats.hoq_latency_bysrc[coord.ID].Add(hoq);
}
Flit ejectLocalNew()
{
for (int dir = 0; dir < TOTAL_DIR; dir++)
{
if (linkIn[dir] != null && linkIn[dir].Out != null &&
linkIn[dir].Out.dest.ID == ID &&
m_ej[dir] == null)
{
m_ej[dir] = linkIn[dir].Out;
linkIn[dir].Out = null;
}
}
m_ej_rr++;
m_ej_rr %= TOTAL_DIR;
Flit ret = null;
if (m_ej[m_ej_rr] != null)
{
ret = m_ej[m_ej_rr];
m_ej[m_ej_rr] = null;
}
return(ret);
}
public Router_SortNet(Coord myCoord)
: base(myCoord)
{
m_injectSlot = null;
m_injectSlot2 = null;
if (Config.sortnet_full)
{
m_sort = new SortNet_COW(new SortNode.Rank(rank));
}
else
{
if (Config.bFtfly)
{
m_sort = new SortNet_CALF_FBFLY(new SortNode.Rank(rank), this);
}
else
{
m_sort = new SortNet_CALF(new SortNode.Rank(rank));
}
}
if (!Config.edge_loop)
{
throw new Exception("SortNet (CALF) router does not support mesh without edge loop. Use -edge_loop option.");
}
}
void printFlits()
{
for (int i = 0; i < Config.N; i++)
{
int from, to;
Flit f = nodeRouters[i].linkIn[CW].Out;
if (f == null)
{
from = -1; to = -1;
}
else
{
from = f.packet.src.ID; to = f.packet.dest.ID;
}
Console.WriteLine("nodeID:{0} from {1} to {2}", i, from, to);
}
for (int i = 0; i < Config.N; i++)
{
for (int dir = 2; dir <= 3; dir++)
{
int from, to;
Flit f = switchRouters[i].linkIn[dir].Out;
if (f == null)
{
from = -1; to = -1;
}
else
{
from = f.packet.src.ID; to = f.packet.dest.ID;
}
Console.WriteLine("SwitchID:{0}, from{1}, to{2}", i, from, to);
}
}
}
public override int rank(Flit f1, Flit f2)
{
if (Config.bLowMPKIPrio)
{
bool f1Low = (Simulator.controller.MPKI[f1.packet.src.ID] <= Config.lowMPKIPrio) ? true : false;
bool f2Low = (Simulator.controller.MPKI[f2.packet.src.ID] <= Config.lowMPKIPrio) ? true : false;
if (f1Low && f2Low)
{
return(0);
}
else if (f1Low && !f2Low)
{
return(-1);
}
else if (!f1Low && f2Low)
{
return(1);
}
else
{
return(Router_Flit_OldestFirst._rank(f1, f2));
}
}
else
{
return(Router_Flit_OldestFirst._rank(f1, f2));
}
}
protected static void statsDeflectionInfection(Flit f1, Flit f2, bool cure1, bool cure2, bool infect1, bool infect2)
{
if (f1 != null)
{
if (cure1)
{
Simulator.stats.cureCount.Add();
}
if (infect1)
{
Simulator.stats.infectCount.Add();
}
}
if (f2 != null)
{
if (cure2)
{
Simulator.stats.cureCount.Add();
}
if (infect2)
{
Simulator.stats.infectCount.Add();
}
}
}
public override bool canInjectFlit(Flit f)
{
for (int i = 0; i < _nic_count; i++)
if (_nics[i].Inject == null)
return true;
return false;
}
protected Flit ejectLocal()
{
// eject locally-destined flit (highest-ranked, if multiple)
Flit ret = null;
int bestDir = -1;
for (int dir = 0; dir < TOTAL_DIR; dir++)
{
if (linkIn[dir] != null && linkIn[dir].Out != null &&
linkIn[dir].Out.state != Flit.State.Placeholder &&
linkIn[dir].Out.dest.ID == ID &&
(ret == null || rank(linkIn[dir].Out, ret) < 0))
{
ret = linkIn[dir].Out;
bestDir = dir;
}
}
if (bestDir != -1)
{
linkIn[bestDir].Out = null;
}
ret = handleGolden(ret);
return(ret);
}
// credit request from our local-ring interface
protected bool getCredit_local(Flit f, int bubble)
{
MyTracer.trace(f, "getCredit local", _coord);
if (_coord.routeG(f.bufrings_coord))
{
MyTracer.trace(f, "getCredit local LG", _coord);
//if (f.packet.ID == MyTracer.id) Console.WriteLine("credits {0} bubble {1}", _creditLG, bubble);
if (_creditLG > bubble)
{
_creditLG--;
return(true);
}
else
{
return(false);
}
}
else
{
MyTracer.trace(f, "getCredit local L", _coord);
if (_creditL > bubble)
{
_creditL--;
return(true);
}
else
{
return(false);
}
}
}
// credit request from our global-ring interface
protected bool getCredit_global(Flit f, int bubble)
{
MyTracer.trace(f, "getCredit global", _coord);
if (!_coord.routeL(f.bufrings_coord))
{
if (_creditG > bubble)
{
_creditG--;
return(true);
}
else
{
return(false);
}
}
else
{
if (_creditGL > bubble)
{
_creditGL--;
return(true);
}
else
{
return(false);
}
}
}
public Router_SortNet(Coord myCoord)
: base(myCoord)
{
m_injectSlot = null;
m_injectSlot2 = null;
ejectBuffer = new Queue <Flit> [4];
for (int n = 0; n < 4; n++)
{
ejectBuffer[n] = new Queue <Flit>();
}
if (Config.sortnet_full)
{
m_sort = new SortNet_COW(new SortNode.Rank(rank));
}
else
{
m_sort = new SortNet_CALF(new SortNode.Rank(rank));
}
if (!Config.edge_loop)
{
throw new Exception("SortNet (CALF) router does not support mesh without edge loop. Use -edge_loop option.");
}
}
void nuke()
{
Console.WriteLine("NUKE! Cycle {0}.", Simulator.CurrentRound);
Simulator.stats.bufrings_nuke.Add();
// first, collect all flits from the network and reset credits, etc
Queue <Flit> flits = new Queue <Flit>();
foreach (BufRingNetwork_NIC nic in _nics)
{
nic.nuke(flits);
}
foreach (BufRingNetwork_IRI iri in _iris)
{
iri.nuke(flits);
}
foreach (Link l in links)
{
if (l.Out != null)
{
flits.Enqueue(l.Out);
l.Out = null;
}
}
// now deliver all collected flits
while (flits.Count > 0)
{
Flit f = flits.Dequeue();
_routers[f.packet.dest.ID].acceptFlit(f);
}
}
public int goldenLevel(Flit f)
{
int node_mshr;
getFlitInfo(f, out node_mshr);
int lvl = (node_mshr - m_goldenPeriod);
int totalmshrs = 0;
if (String.Compare(Config.mshrSizeList, "") != 0)
{
for (int i = 0; i < Config.N; i++)
{
totalmshrs += Config.mshrsList[i];
}
}
else
{
totalmshrs = Config.mshrs * Config.N;
}
if (lvl < 0)
{
lvl += totalmshrs;
}
lvl %= totalmshrs;
return(lvl);
}
Flit ejectLocal()
{
// eject locally-destined flit (highest-ranked, if multiple)
Flit ret = null;
int flitsTryToEject = 0;
for (int dir = 0; dir < 4; dir++)
{
if (linkIn[dir] != null && linkIn[dir].Out != null && linkIn[dir].Out.dest.ID == ID)
{
flitsTryToEject++;
}
}
Simulator.stats.flitsTryToEject[flitsTryToEject].Add();
int bestDir = -1;
for (int dir = 0; dir < 4; dir++)
{
if (linkIn[dir] != null && linkIn[dir].Out != null &&
linkIn[dir].Out.state != Flit.State.Placeholder &&
linkIn[dir].Out.dest.ID == ID &&
(ret == null || rank(linkIn[dir].Out, ret) < 0))
{
ret = linkIn[dir].Out;
bestDir = dir;
}
}
if (bestDir != -1)
{
linkIn[bestDir].Out = null;
}
return(ret);
}
public Flit getReceivedFlit()
{
Flit f = receivedFlit;
receivedFlit = null;
return(f);
}
public Router_LinkedRings(Coord myCoord)
: base(myCoord)
{
m_injectSlot = null;
m_injectSlot2 = null;
}
/* Tells if a flit wants to turn */
bool wantToTurn(Flit f, int dir)
{
bool wantToTurn = false;
switch (dir)
{
case Simulator.DIR_UP:
wantToTurn = (coord.y == f.packet.dest.y);
break;
case Simulator.DIR_DOWN:
wantToTurn = (coord.y == f.packet.dest.y);
break;
case Simulator.DIR_LEFT:
wantToTurn = (coord.x == f.packet.dest.x);
break;
case Simulator.DIR_RIGHT:
wantToTurn = (coord.x == f.packet.dest.x);
break;
default:
throw new Exception("Not a direction");
}
return(wantToTurn);
}
public Golden()
{
int L = Config.network_nrX + Config.network_nrY;
// TODO: scale L when rescuers?
m_epochLen = (int)(Config.gp_epoch * L);
if (Config.resubmitBuffer && Config.redirection)
{
m_epochLen = m_epochLen * 2 + (int)Config.sizeOfRSBuffer * ((int)Config.redirection_threshold + 1);
}
m_nRescuers = Config.gp_rescuers;
int n = Simulator.network.injectFlits(m_nRescuers, delegate()
{
Flit f = new Flit(null, 0);
f.state = Flit.State.Placeholder;
return(f);
});
if (n < m_nRescuers)
{
throw new Exception("was not able to initialize all rescuers");
}
}
public Router_Flit(Coord myCoord)
: base(myCoord)
{
m_injectSlot = null;
m_injectSlot2 = null;
rBuf = new ResubBuffer();
}
// Only one inject Slot now.
//TODO: Create 2 injuct Slots, one for clockwise network, one for counter-clockwise network
public override bool canInjectFlit(Flit f)
{
if (throttle[ID])
return false;
bool can;
if (f.parity == 0)
{
if (m_injectSlot_CW != null)
f.timeWaitToInject ++;
can = m_injectSlot_CW == null;
}
else if (f.parity == 1)
{
if (m_injectSlot_CCW != null)
f.timeWaitToInject ++;
can = m_injectSlot_CCW == null;
}
else if (f.parity == -1)
{
if (m_injectSlot_CW != null && m_injectSlot_CCW != null)
f.timeWaitToInject ++;
can = (m_injectSlot_CW == null || m_injectSlot_CCW == null);
}
else throw new Exception("Unkown parity value!");
if (!can)
{
starveCounter ++;
Simulator.stats.injStarvation.Add();
}
if (starveCounter == Config.starveThreshold)
starved[ID] = true;
return can;
}
Flit ejectLocal()
{
// eject locally-destined flit (highest-ranked, if multiple)
Flit ret = null;
int bestDir = -1;
for (int dir = 0; dir < 4; dir++)
{
if (linkIn[dir] != null && linkIn[dir].Out != null &&
linkIn[dir].Out.state != Flit.State.Placeholder &&
linkIn[dir].Out.dest.ID == ID &&
(ret == null || rank(linkIn[dir].Out, ret) < 0))
{
ret = linkIn[dir].Out;
bestDir = dir;
}
}
if (bestDir != -1)
{
linkIn[bestDir].Out = null;
}
#if DEBUG
if (ret != null)
{
Console.WriteLine("| ejecting flit {0}.{1} at node {2} cyc {3}", ret.packet.ID, ret.flitNr, coord, Simulator.CurrentRound);
}
#endif
return(ret);
}
public Router_Flit(Coord myCoord)
: base(myCoord)
{
m_injectSlot = null;
m_injectSlot2 = null;
rBuf = new ResubBuffer();
}
Flit ejectLocalNew()
{
for (int dir = 0; dir < 4; dir++)
{
if (linkIn[dir] != null && linkIn[dir].Out != null &&
linkIn[dir].Out.dest.ID == ID &&
m_ej[dir] == null)
{
m_ej[dir] = linkIn[dir].Out;
linkIn[dir].Out = null;
}
}
m_ej_rr++; m_ej_rr %= 4;
Flit ret = null;
if (m_ej[m_ej_rr] != null)
{
ret = m_ej[m_ej_rr];
m_ej[m_ej_rr] = null;
}
#if DEBUG
if (ret != null)
{
Console.WriteLine("| ejecting flit {0}.{1} at node {2} cyc {3}", ret.packet.ID, ret.flitNr, coord, Simulator.CurrentRound);
}
#endif
return(ret);
}
protected override void _doStep()
{
int slots = freeSpace();
Flit[] input = new Flit[slots];
int idx = 0;
for (int i = 0; i < 4; i++)
{
if (linkIn[i] != null && linkIn[i].Out != null)
{
if (idx == slots)
{
throw new Exception("got too many flits");
}
input[idx++] = linkIn[i].Out;
linkIn[i].Out = null;
}
}
if (idx < slots && m_injectSlot != null)
{
input[idx++] = m_injectSlot;
m_injectSlot = null;
}
}
public override void InjectFlit(Flit f)
{
int m_class = getClass(f) % 2;
injBuffer[m_class].Enqueue(f);
statsInjectFlit(f);
}
public override bool canInjectFlit(Flit f)
{
int m_class = getClass(f) % 2;
if (injBuffer[m_class].Count == depth)
return false;
else
return true;
}
public static ulong age(Flit f)
{
if (Config.net_age_arbitration)
return Simulator.CurrentRound - f.packet.injectionTime;
else
return (Simulator.CurrentRound - f.packet.creationTime) /
(ulong)Config.cheap_of;
}
public void enqueue(Flit f)
{
if (buf.Count == bufSize)
throw new Exception("Cannot enqueue into the ring buffer due to size limit.");
buf.Enqueue(f);
Simulator.stats.totalBufferEnqCount.Add();
}
public Router_Flit(Coord myCoord)
: base(myCoord)
{
m_injectSlot = null;
m_injectSlot2 = null;
ejectBuffer = new Queue<Flit>[4];
for (int n = 0; n < 4; n++)
ejectBuffer[n] = new Queue<Flit>();
}
public bool getCredit(Flit f, object sender, int bubble)
{
if (_credits > bubble) {
_credits--;
return true;
}
else
return false;
}
public Router_RoR(Coord myCoord)
: base(myCoord)
{
if (!Config.torus && !Config.edge_loop)
throw new Exception("Rings of Rings must be a torus or edge-loop. Set Config.torus or Config.edge_loop to true");
m_injectSlot = null;
m_injectSlot2 = null;
}
public override void InjectFlit(Flit f)
{
int baseIdx = Simulator.rand.Next(_nic_count);
for (int i = 0; i < _nic_count; i++)
if (_nics[(i+baseIdx)%_nic_count].Inject == null) {
_nics[(i+baseIdx)%_nic_count].Inject = f;
return;
}
throw new Exception("Could not inject flit -- no free slots!");
}
private int oldestFirst(Flit f1, Flit f2)
{
if(f1.injectionTime > f2.injectionTime)
return -1;
else if(f1.injectionTime < f2.injectionTime)
return 1;
else
return (Config.RSBuffer_randomVariant) ? (Simulator.rand.Next(0,3) - 1) : 0;
}
public void visitFlits(Flit.Visitor fv)
{
for (int i = 0; i < m_delay; i++)
if (m_fifo[i] != null)
fv(m_fifo[i]);
if (Out != null)
fv(Out);
if (In != null)
fv(In);
}
public Router_Node(Coord myCoord)
: base(myCoord)
{
// the node Router is just a Rong node. A Flit gets ejected or moves straight forward
linkOut = new Link[2];
linkIn = new Link[2];
m_injectSlot_CW = null;
m_injectSlot_CCW = null;
throttle[ID] = false;
starved[ID] = false;
starveCounter = 0;
}
AFCBufferSlot getFreeBufferSlot(Flit f)
{
if (m_freeAFCSlots.Count > 0)
{
AFCBufferSlot s = m_freeAFCSlots.Dequeue();
s.flit = f;
s.getNewTimeStamp();
return s;
}
else
return new AFCBufferSlot(f);
}
public void flush()
{
for (int i = 0; i < m_delay; i++)
{
m_fifo[i] = null;
m_sideband_fifo[i] = null;
}
Out = null;
In = null;
SideBandOut = null;
SideBandIn = null;
}
public Router_Node(RC_Coord RC_c, Coord c) : base(c)
{
linkOut = new Link[2];
linkIn = new Link[2];
m_injectSlot_CW = null;
m_injectSlot_CCW = null;
ejectBuffer = new Queue<Flit> [2];
for (int i = 0; i < 2; i++)
ejectBuffer[i] = new Queue<Flit>();
throttle[ID] = false;
starved[ID] = false;
starveCounter = 0;
}
public Router_AFC(Coord myCoord)
: base(myCoord)
{
m_injectSlot = null;
m_buf = new MinHeap<AFCBufferSlot>[5, Config.afc_vnets];
for (int pc = 0; pc < 5; pc++)
for (int i = 0; i < Config.afc_vnets; i++)
m_buf[pc, i] = new MinHeap<AFCBufferSlot>();
m_buffered = false;
m_buf_occupancy = 0;
}
public static void trace(Flit f, string loc, BufRingMultiNetwork_Coord c)
{
//return;
if (f.packet.ID >= id && f.packet.ID < id2 && f.flitNr == 0) {
BufRingMultiNetwork_Coord srcC = new BufRingMultiNetwork_Coord(f.packet.src.ID, Config.bufrings_levels - 1);
BufRingMultiNetwork_Coord destC = new BufRingMultiNetwork_Coord(f.packet.dest.ID,
Config.bufrings_levels - 1);
Console.WriteLine("cycle {0} flit {3}.0 (src {4} dest {5} ID {6}) at coord {1} loc {2}",
Simulator.CurrentRound, c, loc, f.packet.ID,
srcC, destC, f.packet.dest.ID);
}
}
protected override void _doStep()
{
Flit eject = ejectLocal();
if (eject != null)
acceptFlit(eject);
if (linkIn[0].Out != null)
{
linkOut[0].In = linkIn[0].Out;
linkIn[0].Out = null;
}
if (m_injectSlot != null && linkOut[0].In == null)
{
linkOut[0].In = m_injectSlot;
m_injectSlot = null;
}
}
protected override void _doStep()
{
int slots = freeSpace();
Flit[] input = new Flit[slots];
int idx = 0;
for (int i = 0; i < 4; i++)
if (linkIn[i] != null && linkIn[i].Out != null)
{
if (idx == slots) throw new Exception("got too many flits");
input[idx++] = linkIn[i].Out;
linkIn[i].Out = null;
}
if (idx < slots && m_injectSlot != null)
{
input[idx++] = m_injectSlot;
m_injectSlot = null;
}
}
public Golden()
{
int L = Config.network_nrX + Config.network_nrY;
// TODO: scale L when rescuers?
m_epochLen = (int)(Config.gp_epoch * L);
m_nRescuers = Config.gp_rescuers;
int n = Simulator.network.injectFlits(m_nRescuers, delegate()
{
Flit f = new Flit(null, 0);
f.state = Flit.State.Placeholder;
return f;
});
if (n < m_nRescuers)
throw new Exception("was not able to initialize all rescuers");
}
Flit handleGolden(Flit f)
{
if (f == null)
return f;
if (f.state == Flit.State.Normal)
return f;
if (f.state == Flit.State.Rescuer)
{
if (m_injectSlot == null)
{
m_injectSlot = f;
f.state = Flit.State.Placeholder;
}
else
m_injectSlot.state = Flit.State.Carrier;
return null;
}
if (f.state == Flit.State.Carrier)
{
f.state = Flit.State.Normal;
Flit newPlaceholder = new Flit(null, 0);
newPlaceholder.state = Flit.State.Placeholder;
if (m_injectSlot != null)
m_injectSlot2 = newPlaceholder;
else
m_injectSlot = newPlaceholder;
return f;
}
if (f.state == Flit.State.Placeholder)
throw new Exception("Placeholder should never be ejected!");
return null;
}
public void doStep()
{
if (m_delay > 0)
{
Out = m_fifo[0];
for (int i = 0; i < m_delay - 1; i++)
m_fifo[i] = m_fifo[i + 1];
m_fifo[m_delay - 1] = In;
SideBandOut = m_sideband_fifo[0];
for (int i = 0; i < m_delay - 1; i++)
m_sideband_fifo[i] = m_sideband_fifo[i + 1];
m_sideband_fifo[m_delay - 1] = SideBandIn;
}
else
{
Out = In;
SideBandOut = SideBandIn;
}
In = null;
SideBandIn = null;
}
private bool productiveRouter(Flit f, int port)
{
int currentX=-1, currentY=-1;
if (ID == 0 && port == 0 ||
ID == 1 && port == 1 ||
ID == 7 && port == 1 ||
ID == 6 && port == 0)
{ currentX = 0; currentY = 0;}
if (ID == 0 && port == 1 ||
ID == 3 && port == 1 ||
ID == 1 && port == 0 ||
ID == 2 && port == 0)
{ currentX = 0; currentY = 1;}
if (ID == 3 && port == 0 ||
ID == 4 && port == 1 ||
ID == 2 && port == 1 ||
ID == 5 && port == 0)
{ currentX = 1; currentY = 1;}
if (ID == 7 && port == 0 ||
ID == 5 && port == 1 ||
ID == 6 && port == 1 ||
ID == 4 && port == 0)
{ currentX = 1; currentY = 0;}
int destCluster = f.packet.dest.ID/4;
int destCX = destCluster / 2;
int destCY = (destCluster == 0 || destCluster == 3)? 0:1;
if (ID == 0 || ID == 1 || ID == 4 || ID == 5)
{
return destCY != currentY;
}
else
{
return destCX != currentX;
}
}
public override int rank(Flit f1, Flit f2)
{
return Router_Flit_GP._rank(f1, f2);
}
