src/mem/ruby/network/simple/Throttle.hh

   1 /*
   2  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * The class to implement bandwidth and latency throttle. An instance
  31  * of consumer class that can be woke up. It is only used to control
  32  * bandwidth at output port of a switch. And the throttle is added
  33  * *after* the output port, means the message is put in the output
  34  * port of the PerfectSwitch (a intermediateBuffers) first, then go
  35  * through the Throttle.
  36  */
  37
  38 #ifndef __MEM_RUBY_NETWORK_SIMPLE_THROTTLE_HH__
  39 #define __MEM_RUBY_NETWORK_SIMPLE_THROTTLE_HH__
  40
  41 #include <iostream>
  42 #include <string>
  43 #include <vector>
  44
  45 #include "mem/ruby/common/Consumer.hh"
  46 #include "mem/ruby/common/Global.hh"
  47 #include "mem/ruby/network/Network.hh"
  48 #include "mem/ruby/system/System.hh"
  49
  50 class MessageBuffer;
  51
  52 class Throttle : public Consumer
  53 {
  54   public:
  55     Throttle(int sID, NodeID node, Cycles link_latency,
  56              int link_bandwidth_multiplier, int endpoint_bandwidth,
  57              ClockedObject *em);
  58     Throttle(NodeID node, Cycles link_latency, int link_bandwidth_multiplier,
  59              int endpoint_bandwidth, ClockedObject *em);
  60     ~Throttle() {}
  61
  62     std::string name()
  63     { return csprintf("Throttle-%i", m_sID); }
  64
  65     void addLinks(const std::vector<MessageBuffer*>& in_vec,
  66                   const std::vector<MessageBuffer*>& out_vec);
  67     void wakeup();
  68
  69     // The average utilization (a fraction) since last clearStats()
  70     const Stats::Scalar & getUtilization() const
  71     { return m_link_utilization; }
  72     const Stats::Vector & getMsgCount(unsigned int type) const
  73     { return m_msg_counts[type]; }
  74
  75     int getLinkBandwidth() const
  76     { return m_endpoint_bandwidth * m_link_bandwidth_multiplier; }
  77
  78     Cycles getLatency() const { return m_link_latency; }
  79
  80     void clearStats();
  81     void collateStats();
  82     void regStats(std::string name);
  83     void print(std::ostream& out) const;
  84
  85   private:
  86     void init(NodeID node, Cycles link_latency, int link_bandwidth_multiplier,
  87               int endpoint_bandwidth);
  88     void addVirtualNetwork(MessageBuffer* in_ptr, MessageBuffer* out_ptr);
  89
  90     // Private copy constructor and assignment operator
  91     Throttle(const Throttle& obj);
  92     Throttle& operator=(const Throttle& obj);
  93
  94     std::vector<MessageBuffer*> m_in;
  95     std::vector<MessageBuffer*> m_out;
  96     unsigned int m_vnets;
  97     std::vector<int> m_units_remaining;
  98     int m_sID;
  99     NodeID m_node;
 100     int m_link_bandwidth_multiplier;
 101     Cycles m_link_latency;
 102     int m_wakeups_wo_switch;
 103     int m_endpoint_bandwidth;
 104
 105     // Statistical variables
 106     Stats::Scalar m_link_utilization;
 107     Stats::Vector m_msg_counts[MessageSizeType_NUM];
 108     Stats::Formula m_msg_bytes[MessageSizeType_NUM];
 109
 110     double m_link_utilization_proxy;
 111 };
 112
 113 inline std::ostream&
 114 operator<<(std::ostream& out, const Throttle& obj)
 115 {
 116     obj.print(out);
 117     out << std::flush;
 118     return out;
 119 }
 120
 121 #endif // __MEM_RUBY_NETWORK_SIMPLE_THROTTLE_HH__