2 * Copyright (c) 2006-2009 The Regents of The University of Michigan
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.
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.
31 #ifndef __BASE__CP_ANNOTATE_HH__
32 #define __BASE__CP_ANNOTATE_HH__
39 #include "base/hashmap.hh"
40 #include "base/loader/symtab.hh"
41 #include "base/trace.hh"
42 #include "base/types.hh"
43 #include "config/cp_annotate.hh"
44 #include "config/the_isa.hh"
45 #include "sim/serialize.hh"
46 #include "sim/startup.hh"
47 #include "sim/system.hh"
50 #include "params/CPA.hh"
71 static CPA *cpa() { return NULL; }
72 static bool available() { return false; }
73 bool enabled() { return false; }
74 void swSmBegin(ThreadContext *tc) { return; }
75 void swSmEnd(ThreadContext *tc) { return; }
76 void swExplictBegin(ThreadContext *tc) { return; }
77 void swAutoBegin(ThreadContext *tc, Addr next_pc) { return; }
78 void swEnd(ThreadContext *tc) { return; }
79 void swQ(ThreadContext *tc) { return; }
80 void swDq(ThreadContext *tc) { return; }
81 void swPq(ThreadContext *tc) { return; }
82 void swRq(ThreadContext *tc) { return; }
83 void swWf(ThreadContext *tc) { return; }
84 void swWe(ThreadContext *tc) { return; }
85 void swSq(ThreadContext *tc) { return; }
86 void swAq(ThreadContext *tc) { return; }
87 void swLink(ThreadContext *tc) { return; }
88 void swIdentify(ThreadContext *tc) { return; }
89 uint64_t swGetId(ThreadContext *tc) { return 0; }
90 void swSyscallLink(ThreadContext *tc) { return; }
91 void hwBegin(flags f, System *sys, uint64_t frame, std::string sm,
92 std::string st) { return; }
93 void hwQ(flags f, System *sys, uint64_t frame, std::string sm,
94 std::string q, uint64_t qid, System *q_sys = NULL,
95 int32_t count = 1) { return; }
96 void hwDq(flags f, System *sys, uint64_t frame, std::string sm,
97 std::string q, uint64_t qid, System *q_sys = NULL,
98 int32_t count = 1) { return; }
99 void hwPq(flags f, System *sys, uint64_t frame, std::string sm,
100 std::string q, uint64_t qid, System *q_sys = NULL,
101 int32_t count = 1) { return; }
102 void hwRq(flags f, System *sys, uint64_t frame, std::string sm,
103 std::string q, uint64_t qid, System *q_sys = NULL,
104 int32_t count = 1) { return; }
105 void hwWf(flags f, System *sys, uint64_t frame, std::string sm,
106 std::string q, uint64_t qid, System *q_sys = NULL,
107 int32_t count = 1) { return; }
108 void hwWe(flags f, System *sys, uint64_t frame, std::string sm,
109 std::string q, uint64_t qid, System *q_sys = NULL,
110 int32_t count = 1) { return; }
113 class CPA : SimObject
116 typedef CPAParams Params;
118 /** The known operations that are written to the annotation output file. */
121 OP_WAIT_EMPTY = 0x02,
125 OP_SIZE_QUEUE = 0x08,
132 /** Flags for the various options.*/
136 /* operation was done on hardware */
138 /* operation should cause a warning when encountered */
140 /* Queue like a stack, not a queue */
142 /* Mark HW state as waiting for some non-resource constraint
143 * (e.g. wait because SM only starts after 10 items are queued) */
145 /* operation is linking to another state machine */
147 /* queue should be completely cleared/reset before executing this
158 return dynamic_cast<const Params *>(_params);
161 /* struct that is written to the annotation output file */
162 struct AnnotateData : public RefCounted {
174 void serialize(std::ostream &os);
175 void unserialize(Checkpoint *cp, const std::string §ion);
179 typedef RefCountingPtr<AnnotateData> AnnDataPtr;
181 /* header for the annotation file */
182 struct AnnotateHeader {
193 std::vector<uint64_t> annotateIdx;
195 // number of state machines encountered in the simulation
197 // number of states encountered in the simulation
199 // number of states/queues for a given state machine/system respectively
200 std::vector<int> numSt, numQ;
201 // number of systems in the simulation
203 // number of queues in the state machine
205 // maximum connection id assigned so far
208 // Convert state strings into state ids
209 typedef m5::hash_map<std::string, int> SCache;
210 typedef std::vector<SCache> StCache;
212 // Convert sm and queue name,id into queue id
213 typedef std::pair<std::string, uint64_t> Id;
214 typedef m5::hash_map<Id, int> IdHCache;
215 typedef std::vector<IdHCache> IdCache;
217 // Hold mapping of sm and queues to output python
218 typedef std::vector<std::pair<int, Id> > IdMap;
220 // System pointer to name,id
221 typedef std::map<System*, std::pair<std::string, int> > NameCache;
223 // array of systems each of which is a stack of running sm
224 typedef std::pair<int, uint64_t> StackId;
225 typedef std::map<StackId, std::vector<int> > SmStack;
227 // map of each context and if it's currently in explict state mode
228 // states are not automatically updated until it leaves
229 typedef std::map<StackId, bool> SwExpl;
231 typedef std::map<int,int> IMap;
232 // List of annotate records have not been written/completed yet
233 typedef std::list<AnnDataPtr> AnnotateList;
235 // Maintain link state information
236 typedef std::map<int, int> LinkMap;
239 typedef m5::hash_map<Id, AnnDataPtr> ScHCache;
240 typedef std::vector<ScHCache> ScCache;
245 // vector indexed by queueid to find current number of elements and bytes
246 std::vector<int> qSize;
247 std::vector<int32_t> qBytes;
250 // Turn state machine string into state machine id (small int)
251 // Used for outputting key to convert id back into string
253 // Turn state machine id, state name into state id (small int)
255 // turn system, queue, and queue identify into qid (small int)
256 // turn system, state, and context into state machine id (small int)
257 IdCache qCache, smCache;
258 //Link state machines accross system calls
260 // System pointer to name,id
262 // Stack of state machines currently nested (should unwind correctly)
264 // Map of currently outstanding links
266 // If the state machine is currently exculding automatic changes
268 // Last state that a given state machine was in
270 // Hold mapping of sm and queues to output python
272 // Items still in queue, used for sanity checking
273 std::vector<AnnotateList> qData;
275 void doDq(System *sys, int flags, int cpu, int sm, std::string q, int qi,
277 void doQ(System *sys, int flags, int cpu, int sm, std::string q, int qi,
280 void doSwSmEnd(System *sys, int cpuid, std::string sm, uint64_t frame);
282 // Turn a system id, state machine string, state machine id into a small int
283 // for annotation output
285 getSm(int sysi, std::string si, uint64_t id)
288 Id smid = Id(si, id);
290 smi = smCache[sysi-1][smid];
292 smCache[sysi-1][smid] = smi = ++numSm;
294 smMap.push_back(std::make_pair<int, Id>(sysi, smid));
299 // Turn a state machine string, state string into a small int
300 // for annotation output
302 getSt(std::string sm, std::string s)
308 smi = smtCache[sm] = ++numSmt;
310 while (stCache.size() < smi) {
311 //stCache.resize(sm);
312 stCache.push_back(SCache());
315 //assert(stCache.size() == sm);
316 //assert(numSt.size() == sm);
317 sti = stCache[smi-1][s];
319 stCache[smi-1][s] = sti = ++numSt[smi-1];
323 // Turn state machine pointer into a smal int for annotation output
327 NameCache::iterator i = nameCache.find(s);
328 if (i == nameCache.end()) {
329 nameCache[s] = std::make_pair<std::string,int>(s->name(), ++numSys);
330 i = nameCache.find(s);
331 // might need to put smstackid into map here, but perhaps not
332 //smStack.push_back(std::vector<int>());
333 //swExpl.push_back(false);
335 qCache.push_back(IdHCache());
336 smCache.push_back(IdHCache());
337 scLinks.push_back(ScHCache());
339 return i->second.second;
342 // Turn queue name, and queue context into small int for
345 getQ(int sys, std::string q, uint64_t id)
350 qi = qCache[sys-1][qid];
352 qi = qCache[sys-1][qid] = ++numQs;
356 qData.push_back(AnnotateList());
358 qMap.push_back(std::make_pair<int, Id>(sys, qid));
363 void swBegin(System *sys, int cpuid, std::string st, uint64_t frame,
364 bool expl = false, int flags = FL_NONE);
366 AnnDataPtr add(int t, int f, int c, int sm, int stq, int32_t data=0);
372 /** Only allow one CPA object in a system. It doesn't make sense to have
373 * more that one per simulation because if a part of the system was
374 * important it would have annotations and queues, and with more than one
375 * object none of the sanity checking for queues will work. */
380 std::map<std::string, SymbolTable*> userApp;
383 static CPA *cpa() { return _cpa; }
384 void swSmBegin(ThreadContext *tc);
385 void swSmEnd(ThreadContext *tc);
386 void swExplictBegin(ThreadContext *tc);
387 void swAutoBegin(ThreadContext *tc, Addr next_pc);
388 void swEnd(ThreadContext *tc);
389 void swQ(ThreadContext *tc);
390 void swDq(ThreadContext *tc);
391 void swPq(ThreadContext *tc);
392 void swRq(ThreadContext *tc);
393 void swWf(ThreadContext *tc);
394 void swWe(ThreadContext *tc);
395 void swSq(ThreadContext *tc);
396 void swAq(ThreadContext *tc);
397 void swLink(ThreadContext *tc);
398 void swIdentify(ThreadContext *tc);
399 uint64_t swGetId(ThreadContext *tc);
400 void swSyscallLink(ThreadContext *tc);
402 inline void hwBegin(flags f, System *sys, uint64_t frame, std::string sm,
408 int sysi = getSys(sys);
409 int smi = getSm(sysi, sm, frame);
410 add(OP_BEGIN, FL_HW | f, 0, smi, getSt(sm, st));
412 warn("BAD state encountered: at cycle %d: %s\n", curTick, st);
415 inline void hwQ(flags f, System *sys, uint64_t frame, std::string sm,
416 std::string q, uint64_t qid, System *q_sys = NULL, int32_t count = 1)
421 int sysi = getSys(sys);
422 int qi = getQ(q_sys ? getSys(q_sys) : sysi, q, qid);
423 DPRINTFS(AnnotateQ, sys,
424 "hwQ: %s[%#x] cur size %d %d bytes: %d adding: %d\n",
425 q, qid, qSize[qi-1], qData[qi-1].size(), qBytes[qi-1], count);
426 doQ(sys, FL_HW | f, 0, getSm(sysi, sm, frame), q, qi, count);
430 inline void hwDq(flags f, System *sys, uint64_t frame, std::string sm,
431 std::string q, uint64_t qid, System *q_sys = NULL, int32_t count = 1)
436 int sysi = getSys(sys);
437 int qi = getQ(q_sys ? getSys(q_sys) : sysi, q, qid);
438 DPRINTFS(AnnotateQ, sys,
439 "hwDQ: %s[%#x] cur size %d %d bytes: %d removing: %d\n",
440 q, qid, qSize[qi-1], qData[qi-1].size(), qBytes[qi-1], count);
441 doDq(sys, FL_HW | f, 0, getSm(sysi,sm, frame), q, qi, count);
444 inline void hwPq(flags f, System *sys, uint64_t frame, std::string sm,
445 std::string q, uint64_t qid, System *q_sys = NULL, int32_t count = 1)
450 int sysi = getSys(sys);
451 int qi = getQ(q_sys ? getSys(q_sys) : sysi, q, qid);
452 DPRINTFS(AnnotateQ, sys,
453 "hwPQ: %s[%#x] cur size %d %d bytes: %d peeking: %d\n",
454 q, qid, qSize[qi-1], qData[qi-1].size(), qBytes[qi-1], count);
455 add(OP_PEEK, FL_HW | f, 0, getSm(sysi, sm, frame), qi, count);
458 inline void hwRq(flags f, System *sys, uint64_t frame, std::string sm,
459 std::string q, uint64_t qid, System *q_sys = NULL, int32_t count = 1)
464 int sysi = getSys(sys);
465 int qi = getQ(q_sys ? getSys(q_sys) : sysi, q, qid);
466 DPRINTFS(AnnotateQ, sys,
467 "hwRQ: %s[%#x] cur size %d %d bytes: %d reserving: %d\n",
468 q, qid, qSize[qi-1], qData[qi-1].size(), qBytes[qi-1], count);
469 add(OP_RESERVE, FL_HW | f, 0, getSm(sysi, sm, frame), qi, count);
472 inline void hwWf(flags f, System *sys, uint64_t frame, std::string sm,
473 std::string q, uint64_t qid, System *q_sys = NULL, int32_t count = 1)
478 int sysi = getSys(sys);
479 int qi = getQ(q_sys ? getSys(q_sys) : sysi, q, qid);
480 add(OP_WAIT_FULL, FL_HW | f, 0, getSm(sysi, sm, frame), qi, count);
483 inline void hwWe(flags f, System *sys, uint64_t frame, std::string sm,
484 std::string q, uint64_t qid, System *q_sys = NULL, int32_t count = 1)
489 int sysi = getSys(sys);
490 int qi = getQ(q_sys ? getSys(q_sys) : sysi, q, qid);
491 add(OP_WAIT_EMPTY, FL_HW | f, 0, getSm(sysi, sm, frame), qi, count);
498 // This code is ISA specific and will need to be changed
499 // if the annotation code is used for something other than Alpha
500 inline uint64_t getFrame(ThreadContext *tc)
501 { return (tc->readMiscRegNoEffect(TheISA::IPR_PALtemp23) &
504 static bool available() { return true; }
517 void serialize(std::ostream &os);
518 void unserialize(Checkpoint *cp, const std::string §ion);
521 #endif // !CP_ANNOTATE
523 #endif //__BASE__CP_ANNOTATE_HH__