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     //! Set the message buffer with given name.
 100     virtual void setNetQueue(const std::string& name, MessageBuffer *b) = 0;
 101
 102   public:
 103     MachineID getMachineID() const { return m_machineID; }
 104
 105     Stats::Histogram& getDelayHist() { return m_delayHistogram; }
 106     Stats::Histogram& getDelayVCHist(uint32_t index)
 107     { return *(m_delayVCHistogram[index]); }
 108
 109   protected:
 110     //! Profiles original cache requests including PUTs
 111     void profileRequest(const std::string &request);
 112     //! Profiles the delay associated with messages.
 113     void profileMsgDelay(uint32_t virtualNetwork, Cycles delay);
 114
 115     void stallBuffer(MessageBuffer* buf, Address addr);
 116     void wakeUpBuffers(Address addr);
 117     void wakeUpAllBuffers(Address addr);
 118     void wakeUpAllBuffers();
 119
 120   protected:
 121     NodeID m_version;
 122     MachineID m_machineID;
 123     NodeID m_clusterID;
 124
 125     Network* m_net_ptr;
 126     bool m_is_blocking;
 127     std::map<Address, MessageBuffer*> m_block_map;
 128
 129     typedef std::vector<MessageBuffer*> MsgVecType;
 130     typedef std::map< Address, MsgVecType* > WaitingBufType;
 131     WaitingBufType m_waiting_buffers;
 132
 133     unsigned int m_in_ports;
 134     unsigned int m_cur_in_port;
 135     int m_number_of_TBEs;
 136     int m_transitions_per_cycle;
 137     unsigned int m_buffer_size;
 138     Cycles m_recycle_latency;
 139
 140     //! Counter for the number of cycles when the transitions carried out
 141     //! were equal to the maximum allowed
 142     Stats::Scalar m_fully_busy_cycles;
 143
 144     //! Histogram for profiling delay for the messages this controller
 145     //! cares for
 146     Stats::Histogram m_delayHistogram;
 147     std::vector<Stats::Histogram *> m_delayVCHistogram;
 148
 149     //! Callback class used for collating statistics from all the
 150     //! controller of this type.
 151     class StatsCallback : public Callback
 152     {
 153       private:
 154         AbstractController *ctr;
 155
 156       public:
 157         virtual ~StatsCallback() {}
 158         StatsCallback(AbstractController *_ctr) : ctr(_ctr) {}
 159         void process() {ctr->collateStats();}
 160     };
 161 };
 162
 163 #endif // __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCONTROLLER_HH__