src/sim/clock_domain.hh

   1 /*
   2  * Copyright (c) 2013 ARM Limited
   3  * Copyright (c) 2013 Cornell University
   4  * All rights reserved
   5  *
   6  * The license below extends only to copyright in the software and shall
   7  * not be construed as granting a license to any other intellectual
   8  * property including but not limited to intellectual property relating
   9  * to a hardware implementation of the functionality of the software
  10  * licensed hereunder.  You may use the software subject to the license
  11  * terms below provided that you ensure that this notice is replicated
  12  * unmodified and in its entirety in all distributions of the software,
  13  * modified or unmodified, in source code or in binary form.
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions are
  17  * met: redistributions of source code must retain the above copyright
  18  * notice, this list of conditions and the following disclaimer;
  19  * redistributions in binary form must reproduce the above copyright
  20  * notice, this list of conditions and the following disclaimer in the
  21  * documentation and/or other materials provided with the distribution;
  22  * neither the name of the copyright holders nor the names of its
  23  * contributors may be used to endorse or promote products derived from
  24  * this software without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  27  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  28  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  29  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  30  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  31  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  32  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  33  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  34  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  35  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  36  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37  *
  38  * Authors: Vasileios Spiliopoulos
  39  *          Akash Bagdia
  40  *          Christopher Torng
  41  */
  42
  43 /**
  44  * @file
  45  * ClockDomain declarations.
  46  */
  47
  48 #ifndef __SIM_CLOCK_DOMAIN_HH__
  49 #define __SIM_CLOCK_DOMAIN_HH__
  50
  51 #include <algorithm>
  52
  53 #include "base/statistics.hh"
  54 #include "params/ClockDomain.hh"
  55 #include "params/DerivedClockDomain.hh"
  56 #include "params/SrcClockDomain.hh"
  57 #include "sim/sim_object.hh"
  58
  59 /**
  60  * Forward declaration
  61  */
  62 class DerivedClockDomain;
  63 class VoltageDomain;
  64 class ClockedObject;
  65
  66 /**
  67  * The ClockDomain provides clock to group of clocked objects bundled
  68  * under the same clock domain. The clock domains, in turn, are
  69  * grouped into voltage domains. The clock domains provide support for
  70  * a hierarchial structure with source and derived domains.
  71  */
  72 class ClockDomain : public SimObject
  73 {
  74
  75   protected:
  76
  77     /**
  78      * Pre-computed clock period in ticks. This is populated by the
  79      * inheriting classes based on how their period is determined.
  80      */
  81     Tick _clockPeriod;
  82
  83     /**
  84      * Voltage domain this clock domain belongs to
  85      */
  86     VoltageDomain *_voltageDomain;
  87
  88     /**
  89      * Pointers to potential derived clock domains so we can propagate
  90      * changes.
  91      */
  92     std::vector<DerivedClockDomain*> children;
  93
  94     /**
  95      * Pointers to members of this clock domain, so that when the clock
  96      * period changes, we can update each member's tick.
  97      */
  98     std::vector<ClockedObject*> members;
  99
 100   public:
 101
 102     typedef ClockDomainParams Params;
 103     ClockDomain(const Params *p, VoltageDomain *voltage_domain) :
 104         SimObject(p),
 105         _clockPeriod(0),
 106         _voltageDomain(voltage_domain) {}
 107
 108     /**
 109      * Get the clock period.
 110      *
 111      * @return Clock period in ticks
 112      */
 113     inline Tick clockPeriod() const { return _clockPeriod; }
 114
 115     /**
 116      * Register a ClockedObject to this ClockDomain.
 117      *
 118      * @param ClockedObject to add as a member
 119      */
 120     void registerWithClockDomain(ClockedObject *c)
 121     {
 122         assert(c != NULL);
 123         assert(std::find(members.begin(), members.end(), c) == members.end());
 124         members.push_back(c);
 125     }
 126
 127     /**
 128      * Get the voltage domain.
 129      *
 130      * @return Voltage domain this clock domain belongs to
 131      */
 132     inline VoltageDomain *voltageDomain() const { return _voltageDomain; }
 133
 134
 135     /**
 136      * Get the current voltage this clock domain operates at.
 137      *
 138      * @return Voltage applied to the clock domain
 139      */
 140     inline double voltage() const;
 141
 142     /**
 143      * Add a derived domain.
 144      *
 145      * @param Derived domain to add as a child
 146      */
 147     void addDerivedDomain(DerivedClockDomain *clock_domain)
 148     { children.push_back(clock_domain); }
 149
 150 };
 151
 152 /**
 153  * The source clock domains provides the notion of a clock domain that is
 154  * connected to a tunable clock source. It maintains the clock period and
 155  * provides methods for setting/getting the clock.
 156  */
 157 class SrcClockDomain : public ClockDomain
 158 {
 159
 160   public:
 161
 162     typedef SrcClockDomainParams Params;
 163     SrcClockDomain(const Params *p);
 164
 165     /**
 166      * Set new clock value
 167      * @param clock The new clock period in ticks
 168      */
 169     void clockPeriod(Tick clock_period);
 170
 171     // Explicitly import the otherwise hidden clockPeriod
 172     using ClockDomain::clockPeriod;
 173 };
 174
 175 /**
 176  * The derived clock domains provides the notion of a clock domain
 177  * that is connected to a parent clock domain that can either be a
 178  * source clock domain or a derived clock domain. It maintains the
 179  * clock divider and provides methods for getting the clock.
 180  */
 181 class DerivedClockDomain: public ClockDomain
 182 {
 183
 184   public:
 185
 186     typedef DerivedClockDomainParams Params;
 187     DerivedClockDomain(const Params *p);
 188
 189     /**
 190      * Called by the parent clock domain to propagate changes. This
 191      * also involves propagating the change further to any children of
 192      * the derived domain itself.
 193      */
 194     void updateClockPeriod();
 195
 196   private:
 197
 198     /**
 199      * Reference to the parent clock domain this clock domain derives
 200      * its clock period from
 201      */
 202     ClockDomain &parent;
 203
 204     /**
 205      * Local clock divider of the domain
 206      */
 207     const uint64_t clockDivider;
 208 };
 209
 210 #endif