lsq_impl.hh revision 13449:2f7efa89c58b
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"
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 {
113        panic("Invalid LSQ sharing policy. Options are: Dynamic, "
114                    "Partitioned, Threshold");
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__
703