public override bool canInjectFlit(Flit f)
 {
     for (int i = 0; i < _nic_count; i++)
         if (_nics[i].Inject == null)
             return true;
     return false;
 }

        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;
        }

        // 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;
        }

 protected void acceptFlit(Flit f)
 {
    	statsEjectFlit(f);
     if (f.packet.nrOfArrivedFlits + 1 == f.packet.nrOfFlits)
         statsEjectPacket(f.packet);
     m_n.receiveFlit(f);
 }

 public Router_Flit(Coord myCoord)
     : base(myCoord)
 {
     m_injectSlot  = null;
     m_injectSlot2 = null;
     rBuf = new ResubBuffer();
 }

 public override void InjectFlit(Flit f)
 {
     if (m_injectSlot == null)
         m_injectSlot = f;
     else
         throw new Exception("Could not inject flit!");
 }

 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 override bool canInjectFlit(Flit f)
		{
			int m_class  = getClass(f) % 2;
			if (injBuffer[m_class].Count == depth)
				return false;
			else
				return true;
		}

        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;
 }

		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 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!");
 }

        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);
        }

 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 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;
        }

        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");
        }