1/*
2 * Copyright (c) 2011-2012, 2014 ARM Limited
3 * Copyright (c) 2013 Advanced Micro Devices, Inc.
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 * Copyright (c) 2005-2006 The Regents of The University of Michigan
16 * All rights reserved.
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions are
20 * met: redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer;
22 * redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution;
25 * neither the name of the copyright holders nor the names of its
26 * contributors may be used to endorse or promote products derived from
27 * this software without specific prior written permission.
28 *
29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 *
41 * Authors: Korey Sewell
42 */
43
44#ifndef __CPU_O3_LSQ_IMPL_HH__
45#define __CPU_O3_LSQ_IMPL_HH__
46
47#include <algorithm>
48#include <list>
49#include <string>
50
| 1/*
2 * Copyright (c) 2011-2012, 2014 ARM Limited
3 * Copyright (c) 2013 Advanced Micro Devices, Inc.
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 * Copyright (c) 2005-2006 The Regents of The University of Michigan
16 * All rights reserved.
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions are
20 * met: redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer;
22 * redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution;
25 * neither the name of the copyright holders nor the names of its
26 * contributors may be used to endorse or promote products derived from
27 * this software without specific prior written permission.
28 *
29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 *
41 * Authors: Korey Sewell
42 */
43
44#ifndef __CPU_O3_LSQ_IMPL_HH__
45#define __CPU_O3_LSQ_IMPL_HH__
46
47#include <algorithm>
48#include <list>
49#include <string>
50
|
| 51#include "base/logging.hh"
|
51#include "cpu/o3/lsq.hh"
52#include "debug/Drain.hh"
53#include "debug/Fetch.hh"
54#include "debug/LSQ.hh"
55#include "debug/Writeback.hh"
56#include "params/DerivO3CPU.hh"
57
58using namespace std;
59
60template <class Impl>
61LSQ<Impl>::LSQ(O3CPU *cpu_ptr, IEW *iew_ptr, DerivO3CPUParams *params)
62 : cpu(cpu_ptr), iewStage(iew_ptr),
63 LQEntries(params->LQEntries),
64 SQEntries(params->SQEntries),
65 numThreads(params->numThreads)
66{
67 assert(numThreads > 0 && numThreads <= Impl::MaxThreads);
68
69 //**********************************************/
70 //************ Handle SMT Parameters ***********/
71 //**********************************************/
72 std::string policy = params->smtLSQPolicy;
73
74 //Convert string to lowercase
75 std::transform(policy.begin(), policy.end(), policy.begin(),
76 (int(*)(int)) tolower);
77
78 //Figure out fetch policy
79 if (policy == "dynamic") {
80 lsqPolicy = Dynamic;
81
82 maxLQEntries = LQEntries;
83 maxSQEntries = SQEntries;
84
85 DPRINTF(LSQ, "LSQ sharing policy set to Dynamic\n");
86 } else if (policy == "partitioned") {
87 lsqPolicy = Partitioned;
88
89 //@todo:make work if part_amt doesnt divide evenly.
90 maxLQEntries = LQEntries / numThreads;
91 maxSQEntries = SQEntries / numThreads;
92
93 DPRINTF(Fetch, "LSQ sharing policy set to Partitioned: "
94 "%i entries per LQ | %i entries per SQ\n",
95 maxLQEntries,maxSQEntries);
96 } else if (policy == "threshold") {
97 lsqPolicy = Threshold;
98
99 assert(params->smtLSQThreshold > LQEntries);
100 assert(params->smtLSQThreshold > SQEntries);
101
102 //Divide up by threshold amount
103 //@todo: Should threads check the max and the total
104 //amount of the LSQ
105 maxLQEntries = params->smtLSQThreshold;
106 maxSQEntries = params->smtLSQThreshold;
107
108 DPRINTF(LSQ, "LSQ sharing policy set to Threshold: "
109 "%i entries per LQ | %i entries per SQ\n",
110 maxLQEntries,maxSQEntries);
111 } else {
| 52#include "cpu/o3/lsq.hh"
53#include "debug/Drain.hh"
54#include "debug/Fetch.hh"
55#include "debug/LSQ.hh"
56#include "debug/Writeback.hh"
57#include "params/DerivO3CPU.hh"
58
59using namespace std;
60
61template <class Impl>
62LSQ<Impl>::LSQ(O3CPU *cpu_ptr, IEW *iew_ptr, DerivO3CPUParams *params)
63 : cpu(cpu_ptr), iewStage(iew_ptr),
64 LQEntries(params->LQEntries),
65 SQEntries(params->SQEntries),
66 numThreads(params->numThreads)
67{
68 assert(numThreads > 0 && numThreads <= Impl::MaxThreads);
69
70 //**********************************************/
71 //************ Handle SMT Parameters ***********/
72 //**********************************************/
73 std::string policy = params->smtLSQPolicy;
74
75 //Convert string to lowercase
76 std::transform(policy.begin(), policy.end(), policy.begin(),
77 (int(*)(int)) tolower);
78
79 //Figure out fetch policy
80 if (policy == "dynamic") {
81 lsqPolicy = Dynamic;
82
83 maxLQEntries = LQEntries;
84 maxSQEntries = SQEntries;
85
86 DPRINTF(LSQ, "LSQ sharing policy set to Dynamic\n");
87 } else if (policy == "partitioned") {
88 lsqPolicy = Partitioned;
89
90 //@todo:make work if part_amt doesnt divide evenly.
91 maxLQEntries = LQEntries / numThreads;
92 maxSQEntries = SQEntries / numThreads;
93
94 DPRINTF(Fetch, "LSQ sharing policy set to Partitioned: "
95 "%i entries per LQ | %i entries per SQ\n",
96 maxLQEntries,maxSQEntries);
97 } else if (policy == "threshold") {
98 lsqPolicy = Threshold;
99
100 assert(params->smtLSQThreshold > LQEntries);
101 assert(params->smtLSQThreshold > SQEntries);
102
103 //Divide up by threshold amount
104 //@todo: Should threads check the max and the total
105 //amount of the LSQ
106 maxLQEntries = params->smtLSQThreshold;
107 maxSQEntries = params->smtLSQThreshold;
108
109 DPRINTF(LSQ, "LSQ sharing policy set to Threshold: "
110 "%i entries per LQ | %i entries per SQ\n",
111 maxLQEntries,maxSQEntries);
112 } else {
|
112 assert(0 && "Invalid LSQ Sharing Policy.Options Are:{Dynamic,"
113 "Partitioned, Threshold}");
| 113 panic("Invalid LSQ sharing policy. Options are: Dynamic, "
114 "Partitioned, Threshold");
|
114 }
115
116 //Initialize LSQs
117 thread = new LSQUnit[numThreads];
118 for (ThreadID tid = 0; tid < numThreads; tid++) {
119 thread[tid].init(cpu, iew_ptr, params, this,
120 maxLQEntries, maxSQEntries, tid);
121 thread[tid].setDcachePort(&cpu_ptr->getDataPort());
122 }
123}
124
125
126template<class Impl>
127std::string
128LSQ<Impl>::name() const
129{
130 return iewStage->name() + ".lsq";
131}
132
133template<class Impl>
134void
135LSQ<Impl>::regStats()
136{
137 //Initialize LSQs
138 for (ThreadID tid = 0; tid < numThreads; tid++) {
139 thread[tid].regStats();
140 }
141}
142
143template<class Impl>
144void
145LSQ<Impl>::setActiveThreads(list<ThreadID> *at_ptr)
146{
147 activeThreads = at_ptr;
148 assert(activeThreads != 0);
149}
150
151template <class Impl>
152void
153LSQ<Impl>::drainSanityCheck() const
154{
155 assert(isDrained());
156
157 for (ThreadID tid = 0; tid < numThreads; tid++)
158 thread[tid].drainSanityCheck();
159}
160
161template <class Impl>
162bool
163LSQ<Impl>::isDrained() const
164{
165 bool drained(true);
166
167 if (!lqEmpty()) {
168 DPRINTF(Drain, "Not drained, LQ not empty.\n");
169 drained = false;
170 }
171
172 if (!sqEmpty()) {
173 DPRINTF(Drain, "Not drained, SQ not empty.\n");
174 drained = false;
175 }
176
177 return drained;
178}
179
180template <class Impl>
181void
182LSQ<Impl>::takeOverFrom()
183{
184 for (ThreadID tid = 0; tid < numThreads; tid++) {
185 thread[tid].takeOverFrom();
186 }
187}
188
189template <class Impl>
190int
191LSQ<Impl>::entryAmount(ThreadID num_threads)
192{
193 if (lsqPolicy == Partitioned) {
194 return LQEntries / num_threads;
195 } else {
196 return 0;
197 }
198}
199
200template <class Impl>
201void
202LSQ<Impl>::resetEntries()
203{
204 if (lsqPolicy != Dynamic || numThreads > 1) {
205 int active_threads = activeThreads->size();
206
207 int maxEntries;
208
209 if (lsqPolicy == Partitioned) {
210 maxEntries = LQEntries / active_threads;
211 } else if (lsqPolicy == Threshold && active_threads == 1) {
212 maxEntries = LQEntries;
213 } else {
214 maxEntries = LQEntries;
215 }
216
217 list<ThreadID>::iterator threads = activeThreads->begin();
218 list<ThreadID>::iterator end = activeThreads->end();
219
220 while (threads != end) {
221 ThreadID tid = *threads++;
222
223 resizeEntries(maxEntries, tid);
224 }
225 }
226}
227
228template<class Impl>
229void
230LSQ<Impl>::removeEntries(ThreadID tid)
231{
232 thread[tid].clearLQ();
233 thread[tid].clearSQ();
234}
235
236template<class Impl>
237void
238LSQ<Impl>::resizeEntries(unsigned size, ThreadID tid)
239{
240 thread[tid].resizeLQ(size);
241 thread[tid].resizeSQ(size);
242}
243
244template<class Impl>
245void
246LSQ<Impl>::tick()
247{
248 list<ThreadID>::iterator threads = activeThreads->begin();
249 list<ThreadID>::iterator end = activeThreads->end();
250
251 while (threads != end) {
252 ThreadID tid = *threads++;
253
254 thread[tid].tick();
255 }
256}
257
258template<class Impl>
259void
260LSQ<Impl>::insertLoad(const DynInstPtr &load_inst)
261{
262 ThreadID tid = load_inst->threadNumber;
263
264 thread[tid].insertLoad(load_inst);
265}
266
267template<class Impl>
268void
269LSQ<Impl>::insertStore(const DynInstPtr &store_inst)
270{
271 ThreadID tid = store_inst->threadNumber;
272
273 thread[tid].insertStore(store_inst);
274}
275
276template<class Impl>
277Fault
278LSQ<Impl>::executeLoad(const DynInstPtr &inst)
279{
280 ThreadID tid = inst->threadNumber;
281
282 return thread[tid].executeLoad(inst);
283}
284
285template<class Impl>
286Fault
287LSQ<Impl>::executeStore(const DynInstPtr &inst)
288{
289 ThreadID tid = inst->threadNumber;
290
291 return thread[tid].executeStore(inst);
292}
293
294template<class Impl>
295void
296LSQ<Impl>::writebackStores()
297{
298 list<ThreadID>::iterator threads = activeThreads->begin();
299 list<ThreadID>::iterator end = activeThreads->end();
300
301 while (threads != end) {
302 ThreadID tid = *threads++;
303
304 if (numStoresToWB(tid) > 0) {
305 DPRINTF(Writeback,"[tid:%i] Writing back stores. %i stores "
306 "available for Writeback.\n", tid, numStoresToWB(tid));
307 }
308
309 thread[tid].writebackStores();
310 }
311}
312
313template<class Impl>
314bool
315LSQ<Impl>::violation()
316{
317 /* Answers: Does Anybody Have a Violation?*/
318 list<ThreadID>::iterator threads = activeThreads->begin();
319 list<ThreadID>::iterator end = activeThreads->end();
320
321 while (threads != end) {
322 ThreadID tid = *threads++;
323
324 if (thread[tid].violation())
325 return true;
326 }
327
328 return false;
329}
330
331template <class Impl>
332void
333LSQ<Impl>::recvReqRetry()
334{
335 iewStage->cacheUnblocked();
336
337 for (ThreadID tid : *activeThreads) {
338 thread[tid].recvRetry();
339 }
340}
341
342template <class Impl>
343bool
344LSQ<Impl>::recvTimingResp(PacketPtr pkt)
345{
346 if (pkt->isError())
347 DPRINTF(LSQ, "Got error packet back for address: %#X\n",
348 pkt->getAddr());
349
350 thread[cpu->contextToThread(pkt->req->contextId())]
351 .completeDataAccess(pkt);
352
353 if (pkt->isInvalidate()) {
354 // This response also contains an invalidate; e.g. this can be the case
355 // if cmd is ReadRespWithInvalidate.
356 //
357 // The calling order between completeDataAccess and checkSnoop matters.
358 // By calling checkSnoop after completeDataAccess, we ensure that the
359 // fault set by checkSnoop is not lost. Calling writeback (more
360 // specifically inst->completeAcc) in completeDataAccess overwrites
361 // fault, and in case this instruction requires squashing (as
362 // determined by checkSnoop), the ReExec fault set by checkSnoop would
363 // be lost otherwise.
364
365 DPRINTF(LSQ, "received invalidation with response for addr:%#x\n",
366 pkt->getAddr());
367
368 for (ThreadID tid = 0; tid < numThreads; tid++) {
369 thread[tid].checkSnoop(pkt);
370 }
371 }
372
373 delete pkt;
374 return true;
375}
376
377template <class Impl>
378void
379LSQ<Impl>::recvTimingSnoopReq(PacketPtr pkt)
380{
381 DPRINTF(LSQ, "received pkt for addr:%#x %s\n", pkt->getAddr(),
382 pkt->cmdString());
383
384 // must be a snoop
385 if (pkt->isInvalidate()) {
386 DPRINTF(LSQ, "received invalidation for addr:%#x\n",
387 pkt->getAddr());
388 for (ThreadID tid = 0; tid < numThreads; tid++) {
389 thread[tid].checkSnoop(pkt);
390 }
391 }
392}
393
394template<class Impl>
395int
396LSQ<Impl>::getCount()
397{
398 unsigned total = 0;
399
400 list<ThreadID>::iterator threads = activeThreads->begin();
401 list<ThreadID>::iterator end = activeThreads->end();
402
403 while (threads != end) {
404 ThreadID tid = *threads++;
405
406 total += getCount(tid);
407 }
408
409 return total;
410}
411
412template<class Impl>
413int
414LSQ<Impl>::numLoads()
415{
416 unsigned total = 0;
417
418 list<ThreadID>::iterator threads = activeThreads->begin();
419 list<ThreadID>::iterator end = activeThreads->end();
420
421 while (threads != end) {
422 ThreadID tid = *threads++;
423
424 total += numLoads(tid);
425 }
426
427 return total;
428}
429
430template<class Impl>
431int
432LSQ<Impl>::numStores()
433{
434 unsigned total = 0;
435
436 list<ThreadID>::iterator threads = activeThreads->begin();
437 list<ThreadID>::iterator end = activeThreads->end();
438
439 while (threads != end) {
440 ThreadID tid = *threads++;
441
442 total += thread[tid].numStores();
443 }
444
445 return total;
446}
447
448template<class Impl>
449unsigned
450LSQ<Impl>::numFreeLoadEntries()
451{
452 unsigned total = 0;
453
454 list<ThreadID>::iterator threads = activeThreads->begin();
455 list<ThreadID>::iterator end = activeThreads->end();
456
457 while (threads != end) {
458 ThreadID tid = *threads++;
459
460 total += thread[tid].numFreeLoadEntries();
461 }
462
463 return total;
464}
465
466template<class Impl>
467unsigned
468LSQ<Impl>::numFreeStoreEntries()
469{
470 unsigned total = 0;
471
472 list<ThreadID>::iterator threads = activeThreads->begin();
473 list<ThreadID>::iterator end = activeThreads->end();
474
475 while (threads != end) {
476 ThreadID tid = *threads++;
477
478 total += thread[tid].numFreeStoreEntries();
479 }
480
481 return total;
482}
483
484template<class Impl>
485unsigned
486LSQ<Impl>::numFreeLoadEntries(ThreadID tid)
487{
488 return thread[tid].numFreeLoadEntries();
489}
490
491template<class Impl>
492unsigned
493LSQ<Impl>::numFreeStoreEntries(ThreadID tid)
494{
495 return thread[tid].numFreeStoreEntries();
496}
497
498template<class Impl>
499bool
500LSQ<Impl>::isFull()
501{
502 list<ThreadID>::iterator threads = activeThreads->begin();
503 list<ThreadID>::iterator end = activeThreads->end();
504
505 while (threads != end) {
506 ThreadID tid = *threads++;
507
508 if (!(thread[tid].lqFull() || thread[tid].sqFull()))
509 return false;
510 }
511
512 return true;
513}
514
515template<class Impl>
516bool
517LSQ<Impl>::isFull(ThreadID tid)
518{
519 //@todo: Change to Calculate All Entries for
520 //Dynamic Policy
521 if (lsqPolicy == Dynamic)
522 return isFull();
523 else
524 return thread[tid].lqFull() || thread[tid].sqFull();
525}
526
527template<class Impl>
528bool
529LSQ<Impl>::isEmpty() const
530{
531 return lqEmpty() && sqEmpty();
532}
533
534template<class Impl>
535bool
536LSQ<Impl>::lqEmpty() const
537{
538 list<ThreadID>::const_iterator threads = activeThreads->begin();
539 list<ThreadID>::const_iterator end = activeThreads->end();
540
541 while (threads != end) {
542 ThreadID tid = *threads++;
543
544 if (!thread[tid].lqEmpty())
545 return false;
546 }
547
548 return true;
549}
550
551template<class Impl>
552bool
553LSQ<Impl>::sqEmpty() const
554{
555 list<ThreadID>::const_iterator threads = activeThreads->begin();
556 list<ThreadID>::const_iterator end = activeThreads->end();
557
558 while (threads != end) {
559 ThreadID tid = *threads++;
560
561 if (!thread[tid].sqEmpty())
562 return false;
563 }
564
565 return true;
566}
567
568template<class Impl>
569bool
570LSQ<Impl>::lqFull()
571{
572 list<ThreadID>::iterator threads = activeThreads->begin();
573 list<ThreadID>::iterator end = activeThreads->end();
574
575 while (threads != end) {
576 ThreadID tid = *threads++;
577
578 if (!thread[tid].lqFull())
579 return false;
580 }
581
582 return true;
583}
584
585template<class Impl>
586bool
587LSQ<Impl>::lqFull(ThreadID tid)
588{
589 //@todo: Change to Calculate All Entries for
590 //Dynamic Policy
591 if (lsqPolicy == Dynamic)
592 return lqFull();
593 else
594 return thread[tid].lqFull();
595}
596
597template<class Impl>
598bool
599LSQ<Impl>::sqFull()
600{
601 list<ThreadID>::iterator threads = activeThreads->begin();
602 list<ThreadID>::iterator end = activeThreads->end();
603
604 while (threads != end) {
605 ThreadID tid = *threads++;
606
607 if (!sqFull(tid))
608 return false;
609 }
610
611 return true;
612}
613
614template<class Impl>
615bool
616LSQ<Impl>::sqFull(ThreadID tid)
617{
618 //@todo: Change to Calculate All Entries for
619 //Dynamic Policy
620 if (lsqPolicy == Dynamic)
621 return sqFull();
622 else
623 return thread[tid].sqFull();
624}
625
626template<class Impl>
627bool
628LSQ<Impl>::isStalled()
629{
630 list<ThreadID>::iterator threads = activeThreads->begin();
631 list<ThreadID>::iterator end = activeThreads->end();
632
633 while (threads != end) {
634 ThreadID tid = *threads++;
635
636 if (!thread[tid].isStalled())
637 return false;
638 }
639
640 return true;
641}
642
643template<class Impl>
644bool
645LSQ<Impl>::isStalled(ThreadID tid)
646{
647 if (lsqPolicy == Dynamic)
648 return isStalled();
649 else
650 return thread[tid].isStalled();
651}
652
653template<class Impl>
654bool
655LSQ<Impl>::hasStoresToWB()
656{
657 list<ThreadID>::iterator threads = activeThreads->begin();
658 list<ThreadID>::iterator end = activeThreads->end();
659
660 while (threads != end) {
661 ThreadID tid = *threads++;
662
663 if (hasStoresToWB(tid))
664 return true;
665 }
666
667 return false;
668}
669
670template<class Impl>
671bool
672LSQ<Impl>::willWB()
673{
674 list<ThreadID>::iterator threads = activeThreads->begin();
675 list<ThreadID>::iterator end = activeThreads->end();
676
677 while (threads != end) {
678 ThreadID tid = *threads++;
679
680 if (willWB(tid))
681 return true;
682 }
683
684 return false;
685}
686
687template<class Impl>
688void
689LSQ<Impl>::dumpInsts() const
690{
691 list<ThreadID>::const_iterator threads = activeThreads->begin();
692 list<ThreadID>::const_iterator end = activeThreads->end();
693
694 while (threads != end) {
695 ThreadID tid = *threads++;
696
697 thread[tid].dumpInsts();
698 }
699}
700
701#endif//__CPU_O3_LSQ_IMPL_HH__
| 115 }
116
117 //Initialize LSQs
118 thread = new LSQUnit[numThreads];
119 for (ThreadID tid = 0; tid < numThreads; tid++) {
120 thread[tid].init(cpu, iew_ptr, params, this,
121 maxLQEntries, maxSQEntries, tid);
122 thread[tid].setDcachePort(&cpu_ptr->getDataPort());
123 }
124}
125
126
127template<class Impl>
128std::string
129LSQ<Impl>::name() const
130{
131 return iewStage->name() + ".lsq";
132}
133
134template<class Impl>
135void
136LSQ<Impl>::regStats()
137{
138 //Initialize LSQs
139 for (ThreadID tid = 0; tid < numThreads; tid++) {
140 thread[tid].regStats();
141 }
142}
143
144template<class Impl>
145void
146LSQ<Impl>::setActiveThreads(list<ThreadID> *at_ptr)
147{
148 activeThreads = at_ptr;
149 assert(activeThreads != 0);
150}
151
152template <class Impl>
153void
154LSQ<Impl>::drainSanityCheck() const
155{
156 assert(isDrained());
157
158 for (ThreadID tid = 0; tid < numThreads; tid++)
159 thread[tid].drainSanityCheck();
160}
161
162template <class Impl>
163bool
164LSQ<Impl>::isDrained() const
165{
166 bool drained(true);
167
168 if (!lqEmpty()) {
169 DPRINTF(Drain, "Not drained, LQ not empty.\n");
170 drained = false;
171 }
172
173 if (!sqEmpty()) {
174 DPRINTF(Drain, "Not drained, SQ not empty.\n");
175 drained = false;
176 }
177
178 return drained;
179}
180
181template <class Impl>
182void
183LSQ<Impl>::takeOverFrom()
184{
185 for (ThreadID tid = 0; tid < numThreads; tid++) {
186 thread[tid].takeOverFrom();
187 }
188}
189
190template <class Impl>
191int
192LSQ<Impl>::entryAmount(ThreadID num_threads)
193{
194 if (lsqPolicy == Partitioned) {
195 return LQEntries / num_threads;
196 } else {
197 return 0;
198 }
199}
200
201template <class Impl>
202void
203LSQ<Impl>::resetEntries()
204{
205 if (lsqPolicy != Dynamic || numThreads > 1) {
206 int active_threads = activeThreads->size();
207
208 int maxEntries;
209
210 if (lsqPolicy == Partitioned) {
211 maxEntries = LQEntries / active_threads;
212 } else if (lsqPolicy == Threshold && active_threads == 1) {
213 maxEntries = LQEntries;
214 } else {
215 maxEntries = LQEntries;
216 }
217
218 list<ThreadID>::iterator threads = activeThreads->begin();
219 list<ThreadID>::iterator end = activeThreads->end();
220
221 while (threads != end) {
222 ThreadID tid = *threads++;
223
224 resizeEntries(maxEntries, tid);
225 }
226 }
227}
228
229template<class Impl>
230void
231LSQ<Impl>::removeEntries(ThreadID tid)
232{
233 thread[tid].clearLQ();
234 thread[tid].clearSQ();
235}
236
237template<class Impl>
238void
239LSQ<Impl>::resizeEntries(unsigned size, ThreadID tid)
240{
241 thread[tid].resizeLQ(size);
242 thread[tid].resizeSQ(size);
243}
244
245template<class Impl>
246void
247LSQ<Impl>::tick()
248{
249 list<ThreadID>::iterator threads = activeThreads->begin();
250 list<ThreadID>::iterator end = activeThreads->end();
251
252 while (threads != end) {
253 ThreadID tid = *threads++;
254
255 thread[tid].tick();
256 }
257}
258
259template<class Impl>
260void
261LSQ<Impl>::insertLoad(const DynInstPtr &load_inst)
262{
263 ThreadID tid = load_inst->threadNumber;
264
265 thread[tid].insertLoad(load_inst);
266}
267
268template<class Impl>
269void
270LSQ<Impl>::insertStore(const DynInstPtr &store_inst)
271{
272 ThreadID tid = store_inst->threadNumber;
273
274 thread[tid].insertStore(store_inst);
275}
276
277template<class Impl>
278Fault
279LSQ<Impl>::executeLoad(const DynInstPtr &inst)
280{
281 ThreadID tid = inst->threadNumber;
282
283 return thread[tid].executeLoad(inst);
284}
285
286template<class Impl>
287Fault
288LSQ<Impl>::executeStore(const DynInstPtr &inst)
289{
290 ThreadID tid = inst->threadNumber;
291
292 return thread[tid].executeStore(inst);
293}
294
295template<class Impl>
296void
297LSQ<Impl>::writebackStores()
298{
299 list<ThreadID>::iterator threads = activeThreads->begin();
300 list<ThreadID>::iterator end = activeThreads->end();
301
302 while (threads != end) {
303 ThreadID tid = *threads++;
304
305 if (numStoresToWB(tid) > 0) {
306 DPRINTF(Writeback,"[tid:%i] Writing back stores. %i stores "
307 "available for Writeback.\n", tid, numStoresToWB(tid));
308 }
309
310 thread[tid].writebackStores();
311 }
312}
313
314template<class Impl>
315bool
316LSQ<Impl>::violation()
317{
318 /* Answers: Does Anybody Have a Violation?*/
319 list<ThreadID>::iterator threads = activeThreads->begin();
320 list<ThreadID>::iterator end = activeThreads->end();
321
322 while (threads != end) {
323 ThreadID tid = *threads++;
324
325 if (thread[tid].violation())
326 return true;
327 }
328
329 return false;
330}
331
332template <class Impl>
333void
334LSQ<Impl>::recvReqRetry()
335{
336 iewStage->cacheUnblocked();
337
338 for (ThreadID tid : *activeThreads) {
339 thread[tid].recvRetry();
340 }
341}
342
343template <class Impl>
344bool
345LSQ<Impl>::recvTimingResp(PacketPtr pkt)
346{
347 if (pkt->isError())
348 DPRINTF(LSQ, "Got error packet back for address: %#X\n",
349 pkt->getAddr());
350
351 thread[cpu->contextToThread(pkt->req->contextId())]
352 .completeDataAccess(pkt);
353
354 if (pkt->isInvalidate()) {
355 // This response also contains an invalidate; e.g. this can be the case
356 // if cmd is ReadRespWithInvalidate.
357 //
358 // The calling order between completeDataAccess and checkSnoop matters.
359 // By calling checkSnoop after completeDataAccess, we ensure that the
360 // fault set by checkSnoop is not lost. Calling writeback (more
361 // specifically inst->completeAcc) in completeDataAccess overwrites
362 // fault, and in case this instruction requires squashing (as
363 // determined by checkSnoop), the ReExec fault set by checkSnoop would
364 // be lost otherwise.
365
366 DPRINTF(LSQ, "received invalidation with response for addr:%#x\n",
367 pkt->getAddr());
368
369 for (ThreadID tid = 0; tid < numThreads; tid++) {
370 thread[tid].checkSnoop(pkt);
371 }
372 }
373
374 delete pkt;
375 return true;
376}
377
378template <class Impl>
379void
380LSQ<Impl>::recvTimingSnoopReq(PacketPtr pkt)
381{
382 DPRINTF(LSQ, "received pkt for addr:%#x %s\n", pkt->getAddr(),
383 pkt->cmdString());
384
385 // must be a snoop
386 if (pkt->isInvalidate()) {
387 DPRINTF(LSQ, "received invalidation for addr:%#x\n",
388 pkt->getAddr());
389 for (ThreadID tid = 0; tid < numThreads; tid++) {
390 thread[tid].checkSnoop(pkt);
391 }
392 }
393}
394
395template<class Impl>
396int
397LSQ<Impl>::getCount()
398{
399 unsigned total = 0;
400
401 list<ThreadID>::iterator threads = activeThreads->begin();
402 list<ThreadID>::iterator end = activeThreads->end();
403
404 while (threads != end) {
405 ThreadID tid = *threads++;
406
407 total += getCount(tid);
408 }
409
410 return total;
411}
412
413template<class Impl>
414int
415LSQ<Impl>::numLoads()
416{
417 unsigned total = 0;
418
419 list<ThreadID>::iterator threads = activeThreads->begin();
420 list<ThreadID>::iterator end = activeThreads->end();
421
422 while (threads != end) {
423 ThreadID tid = *threads++;
424
425 total += numLoads(tid);
426 }
427
428 return total;
429}
430
431template<class Impl>
432int
433LSQ<Impl>::numStores()
434{
435 unsigned total = 0;
436
437 list<ThreadID>::iterator threads = activeThreads->begin();
438 list<ThreadID>::iterator end = activeThreads->end();
439
440 while (threads != end) {
441 ThreadID tid = *threads++;
442
443 total += thread[tid].numStores();
444 }
445
446 return total;
447}
448
449template<class Impl>
450unsigned
451LSQ<Impl>::numFreeLoadEntries()
452{
453 unsigned total = 0;
454
455 list<ThreadID>::iterator threads = activeThreads->begin();
456 list<ThreadID>::iterator end = activeThreads->end();
457
458 while (threads != end) {
459 ThreadID tid = *threads++;
460
461 total += thread[tid].numFreeLoadEntries();
462 }
463
464 return total;
465}
466
467template<class Impl>
468unsigned
469LSQ<Impl>::numFreeStoreEntries()
470{
471 unsigned total = 0;
472
473 list<ThreadID>::iterator threads = activeThreads->begin();
474 list<ThreadID>::iterator end = activeThreads->end();
475
476 while (threads != end) {
477 ThreadID tid = *threads++;
478
479 total += thread[tid].numFreeStoreEntries();
480 }
481
482 return total;
483}
484
485template<class Impl>
486unsigned
487LSQ<Impl>::numFreeLoadEntries(ThreadID tid)
488{
489 return thread[tid].numFreeLoadEntries();
490}
491
492template<class Impl>
493unsigned
494LSQ<Impl>::numFreeStoreEntries(ThreadID tid)
495{
496 return thread[tid].numFreeStoreEntries();
497}
498
499template<class Impl>
500bool
501LSQ<Impl>::isFull()
502{
503 list<ThreadID>::iterator threads = activeThreads->begin();
504 list<ThreadID>::iterator end = activeThreads->end();
505
506 while (threads != end) {
507 ThreadID tid = *threads++;
508
509 if (!(thread[tid].lqFull() || thread[tid].sqFull()))
510 return false;
511 }
512
513 return true;
514}
515
516template<class Impl>
517bool
518LSQ<Impl>::isFull(ThreadID tid)
519{
520 //@todo: Change to Calculate All Entries for
521 //Dynamic Policy
522 if (lsqPolicy == Dynamic)
523 return isFull();
524 else
525 return thread[tid].lqFull() || thread[tid].sqFull();
526}
527
528template<class Impl>
529bool
530LSQ<Impl>::isEmpty() const
531{
532 return lqEmpty() && sqEmpty();
533}
534
535template<class Impl>
536bool
537LSQ<Impl>::lqEmpty() const
538{
539 list<ThreadID>::const_iterator threads = activeThreads->begin();
540 list<ThreadID>::const_iterator end = activeThreads->end();
541
542 while (threads != end) {
543 ThreadID tid = *threads++;
544
545 if (!thread[tid].lqEmpty())
546 return false;
547 }
548
549 return true;
550}
551
552template<class Impl>
553bool
554LSQ<Impl>::sqEmpty() const
555{
556 list<ThreadID>::const_iterator threads = activeThreads->begin();
557 list<ThreadID>::const_iterator end = activeThreads->end();
558
559 while (threads != end) {
560 ThreadID tid = *threads++;
561
562 if (!thread[tid].sqEmpty())
563 return false;
564 }
565
566 return true;
567}
568
569template<class Impl>
570bool
571LSQ<Impl>::lqFull()
572{
573 list<ThreadID>::iterator threads = activeThreads->begin();
574 list<ThreadID>::iterator end = activeThreads->end();
575
576 while (threads != end) {
577 ThreadID tid = *threads++;
578
579 if (!thread[tid].lqFull())
580 return false;
581 }
582
583 return true;
584}
585
586template<class Impl>
587bool
588LSQ<Impl>::lqFull(ThreadID tid)
589{
590 //@todo: Change to Calculate All Entries for
591 //Dynamic Policy
592 if (lsqPolicy == Dynamic)
593 return lqFull();
594 else
595 return thread[tid].lqFull();
596}
597
598template<class Impl>
599bool
600LSQ<Impl>::sqFull()
601{
602 list<ThreadID>::iterator threads = activeThreads->begin();
603 list<ThreadID>::iterator end = activeThreads->end();
604
605 while (threads != end) {
606 ThreadID tid = *threads++;
607
608 if (!sqFull(tid))
609 return false;
610 }
611
612 return true;
613}
614
615template<class Impl>
616bool
617LSQ<Impl>::sqFull(ThreadID tid)
618{
619 //@todo: Change to Calculate All Entries for
620 //Dynamic Policy
621 if (lsqPolicy == Dynamic)
622 return sqFull();
623 else
624 return thread[tid].sqFull();
625}
626
627template<class Impl>
628bool
629LSQ<Impl>::isStalled()
630{
631 list<ThreadID>::iterator threads = activeThreads->begin();
632 list<ThreadID>::iterator end = activeThreads->end();
633
634 while (threads != end) {
635 ThreadID tid = *threads++;
636
637 if (!thread[tid].isStalled())
638 return false;
639 }
640
641 return true;
642}
643
644template<class Impl>
645bool
646LSQ<Impl>::isStalled(ThreadID tid)
647{
648 if (lsqPolicy == Dynamic)
649 return isStalled();
650 else
651 return thread[tid].isStalled();
652}
653
654template<class Impl>
655bool
656LSQ<Impl>::hasStoresToWB()
657{
658 list<ThreadID>::iterator threads = activeThreads->begin();
659 list<ThreadID>::iterator end = activeThreads->end();
660
661 while (threads != end) {
662 ThreadID tid = *threads++;
663
664 if (hasStoresToWB(tid))
665 return true;
666 }
667
668 return false;
669}
670
671template<class Impl>
672bool
673LSQ<Impl>::willWB()
674{
675 list<ThreadID>::iterator threads = activeThreads->begin();
676 list<ThreadID>::iterator end = activeThreads->end();
677
678 while (threads != end) {
679 ThreadID tid = *threads++;
680
681 if (willWB(tid))
682 return true;
683 }
684
685 return false;
686}
687
688template<class Impl>
689void
690LSQ<Impl>::dumpInsts() const
691{
692 list<ThreadID>::const_iterator threads = activeThreads->begin();
693 list<ThreadID>::const_iterator end = activeThreads->end();
694
695 while (threads != end) {
696 ThreadID tid = *threads++;
697
698 thread[tid].dumpInsts();
699 }
700}
701
702#endif//__CPU_O3_LSQ_IMPL_HH__
|