src/sim/ticked_object.hh

   1 /*
   2  * Copyright (c) 2013-2014, 2017 ARM Limited
   3  * All rights reserved
   4  *
   5  * The license below extends only to copyright in the software and shall
   6  * not be construed as granting a license to any other intellectual
   7  * property including but not limited to intellectual property relating
   8  * to a hardware implementation of the functionality of the software
   9  * licensed hereunder.  You may use the software subject to the license
  10  * terms below provided that you ensure that this notice is replicated
  11  * unmodified and in its entirety in all distributions of the software,
  12  * modified or unmodified, in source code or in binary form.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions are
  16  * met: redistributions of source code must retain the above copyright
  17  * notice, this list of conditions and the following disclaimer;
  18  * redistributions in binary form must reproduce the above copyright
  19  * notice, this list of conditions and the following disclaimer in the
  20  * documentation and/or other materials provided with the distribution;
  21  * neither the name of the copyright holders nor the names of its
  22  * contributors may be used to endorse or promote products derived from
  23  * this software without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 /**
  39  * @file
  40  *
  41  *  Base classes for ClockedObjects which have evaluate functions to
  42  *  look like clock ticking operations.  TickedObject attaches gem5's event
  43  *  queue to Ticked to apply actual scheduling.
  44  */
  45
  46 #ifndef __SIM_TICKED_OBJECT_HH__
  47 #define __SIM_TICKED_OBJECT_HH__
  48
  49 #include "sim/clocked_object.hh"
  50
  51 class TickedObjectParams;
  52
  53 /** Ticked attaches gem5's event queue/scheduler to evaluate
  54  *  calls and provides a start/stop interface to ticking.
  55  *
  56  *  Ticked is not a ClockedObject but can be attached to one by
  57  *  inheritance and by calling regStats, serialize/unserialize */
  58 class Ticked : public Serializable
  59 {
  60   protected:
  61     /** ClockedObject who is responsible for this Ticked's actions/stats */
  62     ClockedObject &object;
  63
  64     /** The wrapper for processClockEvent */
  65     EventFunctionWrapper event;
  66
  67     /** Evaluate and reschedule */
  68     void processClockEvent();
  69
  70     /** Have I been started? and am not stopped */
  71     bool running;
  72
  73     /** Time of last stop event to calculate run time */
  74     Cycles lastStopped;
  75
  76   private:
  77     /** Locally allocated stats */
  78     Stats::Scalar *numCyclesLocal;
  79
  80   protected:
  81     /** Total number of cycles either ticked or spend stopped */
  82     Stats::Scalar &numCycles;
  83
  84     /** Number of cycles ticked */
  85     Stats::Scalar tickCycles;
  86
  87     /** Number of cycles stopped */
  88     Stats::Formula idleCycles;
  89
  90   public:
  91     Ticked(ClockedObject &object_,
  92         Stats::Scalar *imported_num_cycles = NULL,
  93         Event::Priority priority = Event::CPU_Tick_Pri);
  94
  95     virtual ~Ticked() { }
  96
  97     /** Register {num,ticks}Cycles if necessary.  If numCycles is
  98      *  imported, be sure to register it *before* calling this regStats */
  99     void regStats();
 100
 101     /** Start ticking */
 102     void
 103     start()
 104     {
 105         if (!running) {
 106             if (!event.scheduled())
 107                 object.schedule(event, object.clockEdge(Cycles(1)));
 108             running = true;
 109             numCycles += cyclesSinceLastStopped();
 110             countCycles(cyclesSinceLastStopped());
 111         }
 112     }
 113
 114     /** How long have we been stopped for? */
 115     Cycles
 116     cyclesSinceLastStopped() const
 117     {
 118         return object.curCycle() - lastStopped;
 119     }
 120
 121     /** Reset stopped time to current time */
 122     void
 123     resetLastStopped()
 124     {
 125         lastStopped = object.curCycle();
 126     }
 127
 128     /** Cancel the next tick event and issue no more */
 129     void
 130     stop()
 131     {
 132         if (running) {
 133             if (event.scheduled())
 134                 object.deschedule(event);
 135             running = false;
 136             resetLastStopped();
 137         }
 138     }
 139
 140     /** Checkpoint lastStopped */
 141     void serialize(CheckpointOut &cp) const override;
 142     void unserialize(CheckpointIn &cp) override;
 143
 144     /** Action to call on the clock tick */
 145     virtual void evaluate() = 0;
 146
 147     /**
 148      * Callback to handle cycle statistics and probes.
 149      *
 150      * This callback is called at the beginning of a new cycle active
 151      * cycle and when restarting the ticked object. The delta
 152      * parameter indicates the number of cycles elapsed since the
 153      * previous call is normally '1' unless the object has been
 154      * stopped and restarted.
 155      *
 156      * @param delta Number of cycles since the previous call.
 157      */
 158     virtual void countCycles(Cycles delta) {}
 159 };
 160
 161 /** TickedObject attaches Ticked to ClockedObject and can be used as
 162  *  a base class where ticked operation */
 163 class TickedObject : public ClockedObject, public Ticked
 164 {
 165   public:
 166     TickedObject(const TickedObjectParams &params,
 167         Event::Priority priority = Event::CPU_Tick_Pri);
 168
 169     /** Disambiguate to make these functions overload correctly */
 170     using ClockedObject::regStats;
 171     using ClockedObject::serialize;
 172     using ClockedObject::unserialize;
 173
 174     /** Pass on regStats, serialize etc. onto Ticked */
 175     void regStats() override;
 176     void serialize(CheckpointOut &cp) const override;
 177     void unserialize(CheckpointIn &cp) override;
 178 };
 179
 180 #endif /* __SIM_TICKED_OBJECT_HH__ */