ticked_object.hh revision 10259:ebb376f73dd2 
1/*
2 * Copyright (c) 2013-2014 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 * Authors: Andrew Bardsley
38 */
39
40/**
41 * @file
42 *
43 *  Base classes for ClockedObjects which have evaluate functions to
44 *  look like clock ticking operations.  TickedObject attaches gem5's event
45 *  queue to Ticked to apply actual scheduling.
46 */
47
48#ifndef __SIM_TICKED_OBJECT_HH__
49#define __SIM_TICKED_OBJECT_HH__
50
51#include "params/TickedObject.hh"
52#include "sim/clocked_object.hh"
53
54/** Ticked attaches gem5's event queue/scheduler to evaluate
55 *  calls and provides a start/stop interface to ticking.
56 *
57 *  Ticked is not a ClockedObject but can be attached to one by
58 *  inheritance and by calling regStats, serialize/unserialize */
59class Ticked
60{
61  protected:
62    /** An event to call process periodically */
63    class ClockEvent : public Event
64    {
65      public:
66        Ticked &owner;
67
68        ClockEvent(Ticked &owner_, Priority priority) :
69            Event(priority),
70            owner(owner_)
71        { }
72
73        /** Evaluate and reschedule */
74        void
75        process()
76        {
77            ++owner.tickCycles;
78            ++owner.numCycles;
79            owner.evaluate();
80            if (owner.running) {
81                owner.object.schedule(this,
82                    owner.object.clockEdge(Cycles(1)));
83            }
84        }
85    };
86
87    friend class ClockEvent;
88
89    /** ClockedObject who is responsible for this Ticked's actions/stats */
90    ClockedObject &object;
91
92    /** The single instance of ClockEvent used */
93    ClockEvent event;
94
95    /** Have I been started? and am not stopped */
96    bool running;
97
98    /** Time of last stop event to calculate run time */
99    Cycles lastStopped;
100
101  private:
102    /** Locally allocated stats */
103    Stats::Scalar *numCyclesLocal;
104
105  protected:
106    /** Total number of cycles either ticked or spend stopped */
107    Stats::Scalar &numCycles;
108
109    /** Number of cycles ticked */
110    Stats::Scalar tickCycles;
111
112    /** Number of cycles stopped */
113    Stats::Formula idleCycles;
114
115  public:
116    Ticked(ClockedObject &object_,
117        Stats::Scalar *imported_num_cycles = NULL,
118        Event::Priority priority = Event::CPU_Tick_Pri);
119
120    virtual ~Ticked() { }
121
122    /** Register {num,ticks}Cycles if necessary.  If numCycles is
123     *  imported, be sure to register it *before* calling this regStats */
124    void regStats();
125
126    /** Start ticking */
127    void
128    start()
129    {
130        if (!running) {
131            if (!event.scheduled())
132                object.schedule(event, object.clockEdge(Cycles(1)));
133            running = true;
134            numCycles += cyclesSinceLastStopped();
135        }
136    }
137
138    /** How long have we been stopped for? */
139    Cycles
140    cyclesSinceLastStopped() const
141    {
142        return object.curCycle() - lastStopped;
143    }
144
145    /** Reset stopped time to current time */
146    void
147    resetLastStopped()
148    {
149        lastStopped = object.curCycle();
150    }
151
152    /** Cancel the next tick event and issue no more */
153    void
154    stop()
155    {
156        if (running) {
157            if (event.scheduled())
158                object.deschedule(event);
159            running = false;
160            resetLastStopped();
161        }
162    }
163
164    /** Checkpoint lastStopped */
165    void serialize(std::ostream &os);
166    void unserialize(Checkpoint *cp, const std::string &section);
167
168    /** Action to call on the clock tick */
169    virtual void evaluate() = 0;
170};
171
172/** TickedObject attaches Ticked to ClockedObject and can be used as
173 *  a base class where ticked operation */
174class TickedObject : public ClockedObject, public Ticked
175{
176  public:
177    TickedObject(TickedObjectParams *params,
178        Event::Priority priority = Event::CPU_Tick_Pri);
179
180    /** Disambiguate to make these functions overload correctly */
181    using ClockedObject::regStats;
182    using ClockedObject::serialize;
183    using ClockedObject::unserialize;
184
185    /** Pass on regStats, serialize etc. onto Ticked */
186    void regStats();
187    void serialize(std::ostream &os);
188    void unserialize(Checkpoint *cp, const std::string &section);
189};
190
191#endif /* __SIM_TICKED_OBJECT_HH__ */
192