src/mem/ruby/network/garnet/README.txt

   1 README for Garnet3.0
   2 Written By: Tushar Krishna (tushar@ece.gatech.edu)
   3 Last Updated: Sep 9, 2020
   4 -------------------------------------------------------
   5
   6 Garnet Network Parameters and Setup:
   7 - GarnetNetwork.py
   8     * defaults can be overwritten from command line (see configs/network/Network.py)
   9 - GarnetNetwork.hh/cc
  10     * sets up the routers and links
  11     * collects stats
  12
  13
  14 CODE FLOW
  15 - NetworkInterface.cc::wakeup()
  16     * Every NI connected to one coherence protocol controller on one end, and one router on the other.
  17     * receives messages from coherence protocol buffer in appropriate vnet and converts them into network packets and sends them into the network.
  18         * garnet adds the ability to capture a network trace at this point.
  19     * receives flits from the network, extracts the protocol message and sends it to the coherence protocol buffer in appropriate vnet.
  20     * manages flow-control (i.e., credits) with its attached router.
  21     * The consuming flit/credit output link of the NI is put in the global event queue with a timestamp set to next cycle.
  22       The eventqueue calls the wakeup function in the consumer.
  23
  24 - NetworkLink.cc::wakeup()
  25     * receives flits from NI/router and sends it to NI/router after m_latency cycles delay
  26         * Default latency value for every link can be set from command line (see configs/network/Network.py)
  27         * Per link latency can be overwritten in the topology file
  28     * The consumer of the link (NI/router) is put in the global event queue with a timestamp set after m_latency cycles.
  29       The eventqueue calls the wakeup function in the consumer.
  30
  31 - Router.cc::wakeup()
  32     * Loop through all InputUnits and call their wakeup()
  33     * Loop through all OutputUnits and call their wakeup()
  34     * Call SwitchAllocator's wakeup()
  35     * Call CrossbarSwitch's wakeup()
  36     * The router's wakeup function is called whenever any of its modules (InputUnit, OutputUnit, SwitchAllocator, CrossbarSwitch) have
  37       a ready flit/credit to act upon this cycle.
  38
  39 - InputUnit.cc::wakeup()
  40     * Read input flit from upstream router if it is ready for this cycle
  41     * For HEAD/HEAD_TAIL flits, perform route computation, and update route in the VC.
  42     * Buffer the flit for (m_latency - 1) cycles and mark it valid for SwitchAllocation starting that cycle.
  43         * Default latency for every router can be set from command line (see configs/network/Network.py)
  44         * Per router latency (i.e., num pipeline stages) can be set in the topology file
  45
  46 - OutputUnit.cc::wakeup()
  47     * Read input credit from downstream router if it is ready for this cycle
  48     * Increment the credit in the appropriate output VC state.
  49     * Mark output VC as free if the credit carries is_free_signal as true
  50
  51 - SwitchAllocator.cc::wakeup()
  52     * Note: SwitchAllocator performs VC arbitration and selection within it.
  53     * SA-I (or SA-i): Loop through all input VCs at every input port, and select one in a round robin manner.
  54         * For HEAD/HEAD_TAIL flits only select an input VC whose output port has at least one free output VC.
  55         * For BODY/TAIL flits, only select an input VC that has credits in its output VC.
  56     * Place a request for the output port from this VC.
  57     * SA-II (or SA-o): Loop through all output ports, and select one input VC (that placed a request during SA-I) as the winner for this output port in a round robin manner.
  58         * For HEAD/HEAD_TAIL flits, perform outvc allocation (i.e., select a free VC from the output port).
  59         * For BODY/TAIL flits, decrement a credit in the output vc.
  60     * Read the flit out from the input VC, and send it to the CrossbarSwitch
  61     * Send a increment_credit signal to the upstream router for this input VC.
  62         * for HEAD_TAIL/TAIL flits, mark is_free_signal as true in the credit.
  63         * The input unit sends the credit out on the credit link to the upstream router.
  64     * Reschedule the Router to wakeup next cycle for any flits ready for SA next cycle.
  65
  66 - CrossbarSwitch.cc::wakeup()
  67     * Loop through all input ports, and send the winning flit out of its output port onto the output link.
  68     * The consuming flit output link of the router is put in the global event queue with a timestamp set to next cycle.
  69       The eventqueue calls the wakeup function in the consumer.
  70
  71
  72 If a clock domain crossing(CDC) or Serializer-Deserializer unit is
  73 instantiated, then the Network Brisge takes over the flit in HeteroGarnet.
  74 - NetworkBridge::wakeup()
  75     * Check if SerDes is enabled and do appropriate calculations for
  76     serializing or deserializing the flits
  77     * Check if CDC is enabled and schedule all the flits according
  78     to the consumers clock domain.
  79