src/mem/ruby/slicc_interface/AbstractController.hh

   1 /*
   2  * Copyright (c) 2009 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 #ifndef __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCONTROLLER_HH__
  30 #define __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCONTROLLER_HH__
  31
  32 #include <iostream>
  33 #include <string>
  34
  35 #include "base/callback.hh"
  36 #include "mem/protocol/AccessPermission.hh"
  37 #include "mem/ruby/common/Address.hh"
  38 #include "mem/ruby/common/Consumer.hh"
  39 #include "mem/ruby/common/DataBlock.hh"
  40 #include "mem/ruby/common/Histogram.hh"
  41 #include "mem/ruby/common/MachineID.hh"
  42 #include "mem/ruby/network/MessageBuffer.hh"
  43 #include "mem/ruby/network/Network.hh"
  44 #include "mem/ruby/system/CacheRecorder.hh"
  45 #include "mem/packet.hh"
  46 #include "params/RubyController.hh"
  47 #include "sim/clocked_object.hh"
  48
  49 class Network;
  50
  51 class AbstractController : public ClockedObject, public Consumer
  52 {
  53   public:
  54     typedef RubyControllerParams Params;
  55     AbstractController(const Params *p);
  56     void init();
  57     const Params *params() const { return (const Params *)_params; }
  58
  59     const NodeID getVersion() const { return m_machineID.getNum(); }
  60     const MachineType getType() const { return m_machineID.getType(); }
  61
  62     void initNetworkPtr(Network* net_ptr) { m_net_ptr = net_ptr; }
  63
  64     // return instance name
  65     void blockOnQueue(Address, MessageBuffer*);
  66     void unblock(Address);
  67
  68     virtual MessageBuffer* getMandatoryQueue() const = 0;
  69     virtual AccessPermission getAccessPermission(const Address& addr) = 0;
  70     virtual DataBlock& getDataBlock(const Address& addr) = 0;
  71
  72     virtual void print(std::ostream & out) const = 0;
  73     virtual void wakeup() = 0;
  74     virtual void resetStats() = 0;
  75     virtual void regStats();
  76
  77     virtual void recordCacheTrace(int cntrl, CacheRecorder* tr) = 0;
  78     virtual Sequencer* getSequencer() const = 0;
  79
  80     //! These functions are used by ruby system to read/write the message
  81     //! queues that exist with in the controller.
  82     //! The boolean return value indicates if the read was performed
  83     //! successfully.
  84     virtual bool functionalReadBuffers(PacketPtr&) = 0;
  85     //! The return value indicates the number of messages written with the
  86     //! data from the packet.
  87     virtual uint32_t functionalWriteBuffers(PacketPtr&) = 0;
  88
  89     //! Function for enqueuing a prefetch request
  90     virtual void enqueuePrefetch(const Address&, const RubyRequestType&)
  91     { fatal("Prefetches not implemented!");}
  92
  93     //! Function for collating statistics from all the controllers of this
  94     //! particular type. This function should only be called from the
  95     //! version 0 of this controller type.
  96     virtual void collateStats()
  97     {fatal("collateStats() should be overridden!");}
  98
  99   public:
 100     MachineID getMachineID() const { return m_machineID; }
 101
 102     Stats::Histogram& getDelayHist() { return m_delayHistogram; }
 103     Stats::Histogram& getDelayVCHist(uint32_t index)
 104     { return *(m_delayVCHistogram[index]); }
 105
 106     MessageBuffer *getPeerQueue(uint32_t pid)
 107     {
 108         std::map<uint32_t, MessageBuffer *>::iterator it =
 109                                         peerQueueMap.find(pid);
 110         assert(it != peerQueueMap.end());
 111         return (*it).second;
 112     }
 113
 114   protected:
 115     //! Profiles original cache requests including PUTs
 116     void profileRequest(const std::string &request);
 117     //! Profiles the delay associated with messages.
 118     void profileMsgDelay(uint32_t virtualNetwork, Cycles delay);
 119
 120     //! Function for connecting peer controllers
 121     void connectWithPeer(AbstractController *);
 122     virtual void getQueuesFromPeer(AbstractController *)
 123     { fatal("getQueuesFromPeer() should be called only if implemented!"); }
 124
 125     void stallBuffer(MessageBuffer* buf, Address addr);
 126     void wakeUpBuffers(Address addr);
 127     void wakeUpAllBuffers(Address addr);
 128     void wakeUpAllBuffers();
 129
 130   protected:
 131     NodeID m_version;
 132     MachineID m_machineID;
 133     NodeID m_clusterID;
 134
 135     Network* m_net_ptr;
 136     bool m_is_blocking;
 137     std::map<Address, MessageBuffer*> m_block_map;
 138
 139     typedef std::vector<MessageBuffer*> MsgVecType;
 140     typedef std::map< Address, MsgVecType* > WaitingBufType;
 141     WaitingBufType m_waiting_buffers;
 142
 143     unsigned int m_in_ports;
 144     unsigned int m_cur_in_port;
 145     int m_number_of_TBEs;
 146     int m_transitions_per_cycle;
 147     unsigned int m_buffer_size;
 148     Cycles m_recycle_latency;
 149
 150     //! Map from physical network number to the Message Buffer.
 151     std::map<uint32_t, MessageBuffer*> peerQueueMap;
 152
 153     //! Counter for the number of cycles when the transitions carried out
 154     //! were equal to the maximum allowed
 155     Stats::Scalar m_fully_busy_cycles;
 156
 157     //! Histogram for profiling delay for the messages this controller
 158     //! cares for
 159     Stats::Histogram m_delayHistogram;
 160     std::vector<Stats::Histogram *> m_delayVCHistogram;
 161
 162     //! Callback class used for collating statistics from all the
 163     //! controller of this type.
 164     class StatsCallback : public Callback
 165     {
 166       private:
 167         AbstractController *ctr;
 168
 169       public:
 170         virtual ~StatsCallback() {}
 171         StatsCallback(AbstractController *_ctr) : ctr(_ctr) {}
 172         void process() {ctr->collateStats();}
 173     };
 174 };
 175
 176 #endif // __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCONTROLLER_HH__