Sequencer.cc revision 11111
16145Snate@binkert.org/* 26145Snate@binkert.org * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood 36145Snate@binkert.org * All rights reserved. 46145Snate@binkert.org * 56145Snate@binkert.org * Redistribution and use in source and binary forms, with or without 66145Snate@binkert.org * modification, are permitted provided that the following conditions are 76145Snate@binkert.org * met: redistributions of source code must retain the above copyright 86145Snate@binkert.org * notice, this list of conditions and the following disclaimer; 96145Snate@binkert.org * redistributions in binary form must reproduce the above copyright 106145Snate@binkert.org * notice, this list of conditions and the following disclaimer in the 116145Snate@binkert.org * documentation and/or other materials provided with the distribution; 126145Snate@binkert.org * neither the name of the copyright holders nor the names of its 136145Snate@binkert.org * contributors may be used to endorse or promote products derived from 146145Snate@binkert.org * this software without specific prior written permission. 156145Snate@binkert.org * 166145Snate@binkert.org * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 176145Snate@binkert.org * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 186145Snate@binkert.org * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 196145Snate@binkert.org * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 206145Snate@binkert.org * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 216145Snate@binkert.org * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 226145Snate@binkert.org * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 236145Snate@binkert.org * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 246145Snate@binkert.org * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 256145Snate@binkert.org * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 266145Snate@binkert.org * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 276145Snate@binkert.org */ 286145Snate@binkert.org 2910467Sandreas.hansson@arm.com#include "arch/x86/ldstflags.hh" 308229Snate@binkert.org#include "base/misc.hh" 317056Snate@binkert.org#include "base/str.hh" 327632SBrad.Beckmann@amd.com#include "cpu/testers/rubytest/RubyTester.hh" 338232Snate@binkert.org#include "debug/MemoryAccess.hh" 348232Snate@binkert.org#include "debug/ProtocolTrace.hh" 358615Snilay@cs.wisc.edu#include "debug/RubySequencer.hh" 369104Shestness@cs.utexas.edu#include "debug/RubyStats.hh" 378615Snilay@cs.wisc.edu#include "mem/protocol/PrefetchBit.hh" 388615Snilay@cs.wisc.edu#include "mem/protocol/RubyAccessMode.hh" 397039Snate@binkert.org#include "mem/ruby/profiler/Profiler.hh" 408229Snate@binkert.org#include "mem/ruby/slicc_interface/RubyRequest.hh" 4111108Sdavid.hashe@amd.com#include "mem/ruby/system/RubySystem.hh" 426154Snate@binkert.org#include "mem/ruby/system/Sequencer.hh" 437550SBrad.Beckmann@amd.com#include "mem/packet.hh" 4410467Sandreas.hansson@arm.com#include "sim/system.hh" 456876Ssteve.reinhardt@amd.com 467055Snate@binkert.orgusing namespace std; 477055Snate@binkert.org 486876Ssteve.reinhardt@amd.comSequencer * 496876Ssteve.reinhardt@amd.comRubySequencerParams::create() 506285Snate@binkert.org{ 516876Ssteve.reinhardt@amd.com return new Sequencer(this); 526285Snate@binkert.org} 537039Snate@binkert.org 546876Ssteve.reinhardt@amd.comSequencer::Sequencer(const Params *p) 5510012Snilay@cs.wisc.edu : RubyPort(p), m_IncompleteTimes(MachineType_NUM), deadlockCheckEvent(this) 566876Ssteve.reinhardt@amd.com{ 576876Ssteve.reinhardt@amd.com m_outstanding_count = 0; 586285Snate@binkert.org 596876Ssteve.reinhardt@amd.com m_instCache_ptr = p->icache; 606876Ssteve.reinhardt@amd.com m_dataCache_ptr = p->dcache; 6111019Sjthestness@gmail.com m_data_cache_hit_latency = p->dcache_hit_latency; 6211019Sjthestness@gmail.com m_inst_cache_hit_latency = p->icache_hit_latency; 636876Ssteve.reinhardt@amd.com m_max_outstanding_requests = p->max_outstanding_requests; 646876Ssteve.reinhardt@amd.com m_deadlock_threshold = p->deadlock_threshold; 656899SBrad.Beckmann@amd.com 666876Ssteve.reinhardt@amd.com assert(m_max_outstanding_requests > 0); 676876Ssteve.reinhardt@amd.com assert(m_deadlock_threshold > 0); 686876Ssteve.reinhardt@amd.com assert(m_instCache_ptr != NULL); 696876Ssteve.reinhardt@amd.com assert(m_dataCache_ptr != NULL); 7011019Sjthestness@gmail.com assert(m_data_cache_hit_latency > 0); 7111019Sjthestness@gmail.com assert(m_inst_cache_hit_latency > 0); 728171Stushar@csail.mit.edu 738171Stushar@csail.mit.edu m_usingNetworkTester = p->using_network_tester; 746145Snate@binkert.org} 756145Snate@binkert.org 767039Snate@binkert.orgSequencer::~Sequencer() 777039Snate@binkert.org{ 786145Snate@binkert.org} 796145Snate@binkert.org 807039Snate@binkert.orgvoid 817039Snate@binkert.orgSequencer::wakeup() 827039Snate@binkert.org{ 8310913Sandreas.sandberg@arm.com assert(drainState() != DrainState::Draining); 849245Shestness@cs.wisc.edu 857039Snate@binkert.org // Check for deadlock of any of the requests 869501Snilay@cs.wisc.edu Cycles current_time = curCycle(); 876145Snate@binkert.org 887039Snate@binkert.org // Check across all outstanding requests 897039Snate@binkert.org int total_outstanding = 0; 906285Snate@binkert.org 917455Snate@binkert.org RequestTable::iterator read = m_readRequestTable.begin(); 927455Snate@binkert.org RequestTable::iterator read_end = m_readRequestTable.end(); 937455Snate@binkert.org for (; read != read_end; ++read) { 947455Snate@binkert.org SequencerRequest* request = read->second; 957455Snate@binkert.org if (current_time - request->issue_time < m_deadlock_threshold) 967455Snate@binkert.org continue; 977455Snate@binkert.org 987805Snilay@cs.wisc.edu panic("Possible Deadlock detected. Aborting!\n" 9911025Snilay@cs.wisc.edu "version: %d request.paddr: 0x%x m_readRequestTable: %d " 10011025Snilay@cs.wisc.edu "current time: %u issue_time: %d difference: %d\n", m_version, 10111025Snilay@cs.wisc.edu request->pkt->getAddr(), m_readRequestTable.size(), 1029467Smalek.musleh@gmail.com current_time * clockPeriod(), request->issue_time * clockPeriod(), 1039467Smalek.musleh@gmail.com (current_time * clockPeriod()) - (request->issue_time * clockPeriod())); 1046145Snate@binkert.org } 1056145Snate@binkert.org 1067455Snate@binkert.org RequestTable::iterator write = m_writeRequestTable.begin(); 1077455Snate@binkert.org RequestTable::iterator write_end = m_writeRequestTable.end(); 1087455Snate@binkert.org for (; write != write_end; ++write) { 1097455Snate@binkert.org SequencerRequest* request = write->second; 1107455Snate@binkert.org if (current_time - request->issue_time < m_deadlock_threshold) 1117455Snate@binkert.org continue; 1127455Snate@binkert.org 1137805Snilay@cs.wisc.edu panic("Possible Deadlock detected. Aborting!\n" 11411025Snilay@cs.wisc.edu "version: %d request.paddr: 0x%x m_writeRequestTable: %d " 11511025Snilay@cs.wisc.edu "current time: %u issue_time: %d difference: %d\n", m_version, 11611025Snilay@cs.wisc.edu request->pkt->getAddr(), m_writeRequestTable.size(), 1179467Smalek.musleh@gmail.com current_time * clockPeriod(), request->issue_time * clockPeriod(), 1189467Smalek.musleh@gmail.com (current_time * clockPeriod()) - (request->issue_time * clockPeriod())); 1196145Snate@binkert.org } 1206285Snate@binkert.org 1217039Snate@binkert.org total_outstanding += m_writeRequestTable.size(); 1227039Snate@binkert.org total_outstanding += m_readRequestTable.size(); 1236145Snate@binkert.org 1247039Snate@binkert.org assert(m_outstanding_count == total_outstanding); 1257039Snate@binkert.org 1267039Snate@binkert.org if (m_outstanding_count > 0) { 1277039Snate@binkert.org // If there are still outstanding requests, keep checking 1289465Snilay@cs.wisc.edu schedule(deadlockCheckEvent, clockEdge(m_deadlock_threshold)); 1297039Snate@binkert.org } 1306145Snate@binkert.org} 1316145Snate@binkert.org 13210012Snilay@cs.wisc.eduvoid Sequencer::resetStats() 1339598Snilay@cs.wisc.edu{ 13410012Snilay@cs.wisc.edu m_latencyHist.reset(); 13510012Snilay@cs.wisc.edu m_hitLatencyHist.reset(); 13610012Snilay@cs.wisc.edu m_missLatencyHist.reset(); 1379773Snilay@cs.wisc.edu for (int i = 0; i < RubyRequestType_NUM; i++) { 13810012Snilay@cs.wisc.edu m_typeLatencyHist[i]->reset(); 13910012Snilay@cs.wisc.edu m_hitTypeLatencyHist[i]->reset(); 14010012Snilay@cs.wisc.edu m_missTypeLatencyHist[i]->reset(); 1419773Snilay@cs.wisc.edu for (int j = 0; j < MachineType_NUM; j++) { 14210012Snilay@cs.wisc.edu m_hitTypeMachLatencyHist[i][j]->reset(); 14310012Snilay@cs.wisc.edu m_missTypeMachLatencyHist[i][j]->reset(); 1449773Snilay@cs.wisc.edu } 1459773Snilay@cs.wisc.edu } 1469773Snilay@cs.wisc.edu 14710012Snilay@cs.wisc.edu for (int i = 0; i < MachineType_NUM; i++) { 14810012Snilay@cs.wisc.edu m_missMachLatencyHist[i]->reset(); 14910012Snilay@cs.wisc.edu m_hitMachLatencyHist[i]->reset(); 1509773Snilay@cs.wisc.edu 15110012Snilay@cs.wisc.edu m_IssueToInitialDelayHist[i]->reset(); 15210012Snilay@cs.wisc.edu m_InitialToForwardDelayHist[i]->reset(); 15310012Snilay@cs.wisc.edu m_ForwardToFirstResponseDelayHist[i]->reset(); 15410012Snilay@cs.wisc.edu m_FirstResponseToCompletionDelayHist[i]->reset(); 1559773Snilay@cs.wisc.edu 1569773Snilay@cs.wisc.edu m_IncompleteTimes[i] = 0; 1579773Snilay@cs.wisc.edu } 1589598Snilay@cs.wisc.edu} 1599598Snilay@cs.wisc.edu 1606145Snate@binkert.org// Insert the request on the correct request table. Return true if 1616145Snate@binkert.org// the entry was already present. 1628615Snilay@cs.wisc.eduRequestStatus 1638615Snilay@cs.wisc.eduSequencer::insertRequest(PacketPtr pkt, RubyRequestType request_type) 1647039Snate@binkert.org{ 1658641Snate@binkert.org assert(m_outstanding_count == 1668641Snate@binkert.org (m_writeRequestTable.size() + m_readRequestTable.size())); 1676145Snate@binkert.org 1687039Snate@binkert.org // See if we should schedule a deadlock check 1699342SAndreas.Sandberg@arm.com if (!deadlockCheckEvent.scheduled() && 17010913Sandreas.sandberg@arm.com drainState() != DrainState::Draining) { 1719465Snilay@cs.wisc.edu schedule(deadlockCheckEvent, clockEdge(m_deadlock_threshold)); 1727039Snate@binkert.org } 1736145Snate@binkert.org 17411025Snilay@cs.wisc.edu Addr line_addr = makeLineAddress(pkt->getAddr()); 1759224Sandreas.hansson@arm.com // Create a default entry, mapping the address to NULL, the cast is 1769224Sandreas.hansson@arm.com // there to make gcc 4.4 happy 1779224Sandreas.hansson@arm.com RequestTable::value_type default_entry(line_addr, 1789224Sandreas.hansson@arm.com (SequencerRequest*) NULL); 1799224Sandreas.hansson@arm.com 1808615Snilay@cs.wisc.edu if ((request_type == RubyRequestType_ST) || 1818615Snilay@cs.wisc.edu (request_type == RubyRequestType_RMW_Read) || 1828615Snilay@cs.wisc.edu (request_type == RubyRequestType_RMW_Write) || 1838615Snilay@cs.wisc.edu (request_type == RubyRequestType_Load_Linked) || 1848615Snilay@cs.wisc.edu (request_type == RubyRequestType_Store_Conditional) || 1858615Snilay@cs.wisc.edu (request_type == RubyRequestType_Locked_RMW_Read) || 1868615Snilay@cs.wisc.edu (request_type == RubyRequestType_Locked_RMW_Write) || 1878615Snilay@cs.wisc.edu (request_type == RubyRequestType_FLUSH)) { 1888615Snilay@cs.wisc.edu 1898615Snilay@cs.wisc.edu // Check if there is any outstanding read request for the same 1908615Snilay@cs.wisc.edu // cache line. 1918615Snilay@cs.wisc.edu if (m_readRequestTable.count(line_addr) > 0) { 19210012Snilay@cs.wisc.edu m_store_waiting_on_load++; 1938615Snilay@cs.wisc.edu return RequestStatus_Aliased; 1948615Snilay@cs.wisc.edu } 1958615Snilay@cs.wisc.edu 1967455Snate@binkert.org pair<RequestTable::iterator, bool> r = 1979224Sandreas.hansson@arm.com m_writeRequestTable.insert(default_entry); 1988615Snilay@cs.wisc.edu if (r.second) { 1998615Snilay@cs.wisc.edu RequestTable::iterator i = r.first; 2009465Snilay@cs.wisc.edu i->second = new SequencerRequest(pkt, request_type, curCycle()); 2018615Snilay@cs.wisc.edu m_outstanding_count++; 2028615Snilay@cs.wisc.edu } else { 2038615Snilay@cs.wisc.edu // There is an outstanding write request for the cache line 20410012Snilay@cs.wisc.edu m_store_waiting_on_store++; 2058615Snilay@cs.wisc.edu return RequestStatus_Aliased; 2068615Snilay@cs.wisc.edu } 2078615Snilay@cs.wisc.edu } else { 2088615Snilay@cs.wisc.edu // Check if there is any outstanding write request for the same 2098615Snilay@cs.wisc.edu // cache line. 2108615Snilay@cs.wisc.edu if (m_writeRequestTable.count(line_addr) > 0) { 21110012Snilay@cs.wisc.edu m_load_waiting_on_store++; 2128615Snilay@cs.wisc.edu return RequestStatus_Aliased; 2138615Snilay@cs.wisc.edu } 2147039Snate@binkert.org 2157455Snate@binkert.org pair<RequestTable::iterator, bool> r = 2169224Sandreas.hansson@arm.com m_readRequestTable.insert(default_entry); 2177039Snate@binkert.org 2188615Snilay@cs.wisc.edu if (r.second) { 2198615Snilay@cs.wisc.edu RequestTable::iterator i = r.first; 2209465Snilay@cs.wisc.edu i->second = new SequencerRequest(pkt, request_type, curCycle()); 2218615Snilay@cs.wisc.edu m_outstanding_count++; 2228615Snilay@cs.wisc.edu } else { 2238615Snilay@cs.wisc.edu // There is an outstanding read request for the cache line 22410012Snilay@cs.wisc.edu m_load_waiting_on_load++; 2258615Snilay@cs.wisc.edu return RequestStatus_Aliased; 2267039Snate@binkert.org } 2276145Snate@binkert.org } 2286145Snate@binkert.org 22910012Snilay@cs.wisc.edu m_outstandReqHist.sample(m_outstanding_count); 2308641Snate@binkert.org assert(m_outstanding_count == 2318641Snate@binkert.org (m_writeRequestTable.size() + m_readRequestTable.size())); 2326145Snate@binkert.org 2338615Snilay@cs.wisc.edu return RequestStatus_Ready; 2346145Snate@binkert.org} 2356145Snate@binkert.org 2367039Snate@binkert.orgvoid 2377455Snate@binkert.orgSequencer::markRemoved() 2387455Snate@binkert.org{ 2397455Snate@binkert.org m_outstanding_count--; 2407455Snate@binkert.org assert(m_outstanding_count == 2417455Snate@binkert.org m_writeRequestTable.size() + m_readRequestTable.size()); 2427455Snate@binkert.org} 2437455Snate@binkert.org 2447455Snate@binkert.orgvoid 24511025Snilay@cs.wisc.eduSequencer::invalidateSC(Addr address) 2469563Sgope@wisc.edu{ 24711059Snilay@cs.wisc.edu AbstractCacheEntry *e = m_dataCache_ptr->lookup(address); 24811059Snilay@cs.wisc.edu // The controller has lost the coherence permissions, hence the lock 24911059Snilay@cs.wisc.edu // on the cache line maintained by the cache should be cleared. 25011059Snilay@cs.wisc.edu if (e && e->isLocked(m_version)) { 25111059Snilay@cs.wisc.edu e->clearLocked(); 2529563Sgope@wisc.edu } 2539563Sgope@wisc.edu} 2549563Sgope@wisc.edu 2557560SBrad.Beckmann@amd.combool 25611025Snilay@cs.wisc.eduSequencer::handleLlsc(Addr address, SequencerRequest* request) 2577550SBrad.Beckmann@amd.com{ 25811059Snilay@cs.wisc.edu AbstractCacheEntry *e = m_dataCache_ptr->lookup(address); 25911059Snilay@cs.wisc.edu if (!e) 26011059Snilay@cs.wisc.edu return true; 26111059Snilay@cs.wisc.edu 2627560SBrad.Beckmann@amd.com // The success flag indicates whether the LLSC operation was successful. 2637560SBrad.Beckmann@amd.com // LL ops will always succeed, but SC may fail if the cache line is no 2647560SBrad.Beckmann@amd.com // longer locked. 2657560SBrad.Beckmann@amd.com bool success = true; 2668615Snilay@cs.wisc.edu if (request->m_type == RubyRequestType_Store_Conditional) { 26711059Snilay@cs.wisc.edu if (!e->isLocked(m_version)) { 2687550SBrad.Beckmann@amd.com // 2697550SBrad.Beckmann@amd.com // For failed SC requests, indicate the failure to the cpu by 2707550SBrad.Beckmann@amd.com // setting the extra data to zero. 2717550SBrad.Beckmann@amd.com // 2728615Snilay@cs.wisc.edu request->pkt->req->setExtraData(0); 2737560SBrad.Beckmann@amd.com success = false; 2747550SBrad.Beckmann@amd.com } else { 2757550SBrad.Beckmann@amd.com // 2767550SBrad.Beckmann@amd.com // For successful SC requests, indicate the success to the cpu by 27710917Sbrandon.potter@amd.com // setting the extra data to one. 2787550SBrad.Beckmann@amd.com // 2798615Snilay@cs.wisc.edu request->pkt->req->setExtraData(1); 2807550SBrad.Beckmann@amd.com } 2817560SBrad.Beckmann@amd.com // 2827560SBrad.Beckmann@amd.com // Independent of success, all SC operations must clear the lock 2837560SBrad.Beckmann@amd.com // 28411059Snilay@cs.wisc.edu e->clearLocked(); 2858615Snilay@cs.wisc.edu } else if (request->m_type == RubyRequestType_Load_Linked) { 2867550SBrad.Beckmann@amd.com // 2877550SBrad.Beckmann@amd.com // Note: To fully follow Alpha LLSC semantics, should the LL clear any 2887550SBrad.Beckmann@amd.com // previously locked cache lines? 2897550SBrad.Beckmann@amd.com // 29011059Snilay@cs.wisc.edu e->setLocked(m_version); 29111059Snilay@cs.wisc.edu } else if (e->isLocked(m_version)) { 2927550SBrad.Beckmann@amd.com // 2937550SBrad.Beckmann@amd.com // Normal writes should clear the locked address 2947550SBrad.Beckmann@amd.com // 29511059Snilay@cs.wisc.edu e->clearLocked(); 2967550SBrad.Beckmann@amd.com } 2977560SBrad.Beckmann@amd.com return success; 2987550SBrad.Beckmann@amd.com} 2997550SBrad.Beckmann@amd.com 3007550SBrad.Beckmann@amd.comvoid 3019773Snilay@cs.wisc.eduSequencer::recordMissLatency(const Cycles cycles, const RubyRequestType type, 3029773Snilay@cs.wisc.edu const MachineType respondingMach, 3039773Snilay@cs.wisc.edu bool isExternalHit, Cycles issuedTime, 3049773Snilay@cs.wisc.edu Cycles initialRequestTime, 3059773Snilay@cs.wisc.edu Cycles forwardRequestTime, 3069773Snilay@cs.wisc.edu Cycles firstResponseTime, Cycles completionTime) 3077039Snate@binkert.org{ 30810012Snilay@cs.wisc.edu m_latencyHist.sample(cycles); 30910012Snilay@cs.wisc.edu m_typeLatencyHist[type]->sample(cycles); 3109773Snilay@cs.wisc.edu 3119773Snilay@cs.wisc.edu if (isExternalHit) { 31210012Snilay@cs.wisc.edu m_missLatencyHist.sample(cycles); 31310012Snilay@cs.wisc.edu m_missTypeLatencyHist[type]->sample(cycles); 3149773Snilay@cs.wisc.edu 3159773Snilay@cs.wisc.edu if (respondingMach != MachineType_NUM) { 31610012Snilay@cs.wisc.edu m_missMachLatencyHist[respondingMach]->sample(cycles); 31710012Snilay@cs.wisc.edu m_missTypeMachLatencyHist[type][respondingMach]->sample(cycles); 3189773Snilay@cs.wisc.edu 3199773Snilay@cs.wisc.edu if ((issuedTime <= initialRequestTime) && 3209773Snilay@cs.wisc.edu (initialRequestTime <= forwardRequestTime) && 3219773Snilay@cs.wisc.edu (forwardRequestTime <= firstResponseTime) && 3229773Snilay@cs.wisc.edu (firstResponseTime <= completionTime)) { 3239773Snilay@cs.wisc.edu 32410012Snilay@cs.wisc.edu m_IssueToInitialDelayHist[respondingMach]->sample( 3259773Snilay@cs.wisc.edu initialRequestTime - issuedTime); 32610012Snilay@cs.wisc.edu m_InitialToForwardDelayHist[respondingMach]->sample( 3279773Snilay@cs.wisc.edu forwardRequestTime - initialRequestTime); 32810012Snilay@cs.wisc.edu m_ForwardToFirstResponseDelayHist[respondingMach]->sample( 3299773Snilay@cs.wisc.edu firstResponseTime - forwardRequestTime); 33010012Snilay@cs.wisc.edu m_FirstResponseToCompletionDelayHist[respondingMach]->sample( 3319773Snilay@cs.wisc.edu completionTime - firstResponseTime); 3329773Snilay@cs.wisc.edu } else { 3339773Snilay@cs.wisc.edu m_IncompleteTimes[respondingMach]++; 3349773Snilay@cs.wisc.edu } 3359773Snilay@cs.wisc.edu } 3369773Snilay@cs.wisc.edu } else { 33710012Snilay@cs.wisc.edu m_hitLatencyHist.sample(cycles); 33810012Snilay@cs.wisc.edu m_hitTypeLatencyHist[type]->sample(cycles); 3399773Snilay@cs.wisc.edu 3409773Snilay@cs.wisc.edu if (respondingMach != MachineType_NUM) { 34110012Snilay@cs.wisc.edu m_hitMachLatencyHist[respondingMach]->sample(cycles); 34210012Snilay@cs.wisc.edu m_hitTypeMachLatencyHist[type][respondingMach]->sample(cycles); 3439773Snilay@cs.wisc.edu } 3449773Snilay@cs.wisc.edu } 3457546SBrad.Beckmann@amd.com} 3467546SBrad.Beckmann@amd.com 3477546SBrad.Beckmann@amd.comvoid 34811025Snilay@cs.wisc.eduSequencer::writeCallback(Addr address, DataBlock& data, 3499773Snilay@cs.wisc.edu const bool externalHit, const MachineType mach, 3509773Snilay@cs.wisc.edu const Cycles initialRequestTime, 3519773Snilay@cs.wisc.edu const Cycles forwardRequestTime, 3529773Snilay@cs.wisc.edu const Cycles firstResponseTime) 3537565SBrad.Beckmann@amd.com{ 35411025Snilay@cs.wisc.edu assert(address == makeLineAddress(address)); 35511025Snilay@cs.wisc.edu assert(m_writeRequestTable.count(makeLineAddress(address))); 3566145Snate@binkert.org 3577455Snate@binkert.org RequestTable::iterator i = m_writeRequestTable.find(address); 3587455Snate@binkert.org assert(i != m_writeRequestTable.end()); 3597455Snate@binkert.org SequencerRequest* request = i->second; 3606145Snate@binkert.org 3617455Snate@binkert.org m_writeRequestTable.erase(i); 3627455Snate@binkert.org markRemoved(); 3636846Spdudnik@cs.wisc.edu 3648615Snilay@cs.wisc.edu assert((request->m_type == RubyRequestType_ST) || 3658615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_ATOMIC) || 3668615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_RMW_Read) || 3678615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_RMW_Write) || 3688615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_Load_Linked) || 3698615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_Store_Conditional) || 3708615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_Locked_RMW_Read) || 3718615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_Locked_RMW_Write) || 3728615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_FLUSH)); 3738184Ssomayeh@cs.wisc.edu 3747550SBrad.Beckmann@amd.com // 3757550SBrad.Beckmann@amd.com // For Alpha, properly handle LL, SC, and write requests with respect to 3767550SBrad.Beckmann@amd.com // locked cache blocks. 3777550SBrad.Beckmann@amd.com // 3788171Stushar@csail.mit.edu // Not valid for Network_test protocl 3798171Stushar@csail.mit.edu // 3808171Stushar@csail.mit.edu bool success = true; 3818171Stushar@csail.mit.edu if(!m_usingNetworkTester) 3828171Stushar@csail.mit.edu success = handleLlsc(address, request); 3837550SBrad.Beckmann@amd.com 3848615Snilay@cs.wisc.edu if (request->m_type == RubyRequestType_Locked_RMW_Read) { 3857039Snate@binkert.org m_controller->blockOnQueue(address, m_mandatory_q_ptr); 3868615Snilay@cs.wisc.edu } else if (request->m_type == RubyRequestType_Locked_RMW_Write) { 3877039Snate@binkert.org m_controller->unblock(address); 3887039Snate@binkert.org } 3896863Sdrh5@cs.wisc.edu 3909773Snilay@cs.wisc.edu hitCallback(request, data, success, mach, externalHit, 3917565SBrad.Beckmann@amd.com initialRequestTime, forwardRequestTime, firstResponseTime); 3926145Snate@binkert.org} 3936145Snate@binkert.org 3947039Snate@binkert.orgvoid 39511025Snilay@cs.wisc.eduSequencer::readCallback(Addr address, DataBlock& data, 3969773Snilay@cs.wisc.edu bool externalHit, const MachineType mach, 3979507Snilay@cs.wisc.edu Cycles initialRequestTime, 3989507Snilay@cs.wisc.edu Cycles forwardRequestTime, 3999507Snilay@cs.wisc.edu Cycles firstResponseTime) 4007565SBrad.Beckmann@amd.com{ 40111025Snilay@cs.wisc.edu assert(address == makeLineAddress(address)); 40211025Snilay@cs.wisc.edu assert(m_readRequestTable.count(makeLineAddress(address))); 4036145Snate@binkert.org 4047455Snate@binkert.org RequestTable::iterator i = m_readRequestTable.find(address); 4057455Snate@binkert.org assert(i != m_readRequestTable.end()); 4067455Snate@binkert.org SequencerRequest* request = i->second; 4077455Snate@binkert.org 4087455Snate@binkert.org m_readRequestTable.erase(i); 4097455Snate@binkert.org markRemoved(); 4106145Snate@binkert.org 4118615Snilay@cs.wisc.edu assert((request->m_type == RubyRequestType_LD) || 4128615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_IFETCH)); 4136285Snate@binkert.org 4149773Snilay@cs.wisc.edu hitCallback(request, data, true, mach, externalHit, 4157565SBrad.Beckmann@amd.com initialRequestTime, forwardRequestTime, firstResponseTime); 4166145Snate@binkert.org} 4176145Snate@binkert.org 4187039Snate@binkert.orgvoid 4199773Snilay@cs.wisc.eduSequencer::hitCallback(SequencerRequest* srequest, DataBlock& data, 4209773Snilay@cs.wisc.edu bool llscSuccess, 4219773Snilay@cs.wisc.edu const MachineType mach, const bool externalHit, 4229773Snilay@cs.wisc.edu const Cycles initialRequestTime, 4239773Snilay@cs.wisc.edu const Cycles forwardRequestTime, 4249773Snilay@cs.wisc.edu const Cycles firstResponseTime) 4257039Snate@binkert.org{ 42611087Snilay@cs.wisc.edu warn_once("Replacement policy updates recently became the responsibility " 42711087Snilay@cs.wisc.edu "of SLICC state machines. Make sure to setMRU() near callbacks " 42811087Snilay@cs.wisc.edu "in .sm files!"); 42911087Snilay@cs.wisc.edu 4308615Snilay@cs.wisc.edu PacketPtr pkt = srequest->pkt; 43111025Snilay@cs.wisc.edu Addr request_address(pkt->getAddr()); 4328615Snilay@cs.wisc.edu RubyRequestType type = srequest->m_type; 4339507Snilay@cs.wisc.edu Cycles issued_time = srequest->issue_time; 4346145Snate@binkert.org 4359465Snilay@cs.wisc.edu assert(curCycle() >= issued_time); 4369773Snilay@cs.wisc.edu Cycles total_latency = curCycle() - issued_time; 4376145Snate@binkert.org 4389773Snilay@cs.wisc.edu // Profile the latency for all demand accesses. 4399773Snilay@cs.wisc.edu recordMissLatency(total_latency, type, mach, externalHit, issued_time, 4409773Snilay@cs.wisc.edu initialRequestTime, forwardRequestTime, 4419773Snilay@cs.wisc.edu firstResponseTime, curCycle()); 4426285Snate@binkert.org 44311025Snilay@cs.wisc.edu DPRINTFR(ProtocolTrace, "%15s %3s %10s%20s %6s>%-6s %#x %d cycles\n", 4449773Snilay@cs.wisc.edu curTick(), m_version, "Seq", 4459773Snilay@cs.wisc.edu llscSuccess ? "Done" : "SC_Failed", "", "", 4469773Snilay@cs.wisc.edu request_address, total_latency); 4476285Snate@binkert.org 44810562Sandreas.hansson@arm.com // update the data unless it is a non-data-carrying flush 44910837Sjthestness@gmail.com if (RubySystem::getWarmupEnabled()) { 45010563Sandreas.hansson@arm.com data.setData(pkt->getConstPtr<uint8_t>(), 45111025Snilay@cs.wisc.edu getOffset(request_address), pkt->getSize()); 45210562Sandreas.hansson@arm.com } else if (!pkt->isFlush()) { 4537039Snate@binkert.org if ((type == RubyRequestType_LD) || 4547039Snate@binkert.org (type == RubyRequestType_IFETCH) || 4557039Snate@binkert.org (type == RubyRequestType_RMW_Read) || 4567908Shestness@cs.utexas.edu (type == RubyRequestType_Locked_RMW_Read) || 4577907Shestness@cs.utexas.edu (type == RubyRequestType_Load_Linked)) { 45810562Sandreas.hansson@arm.com memcpy(pkt->getPtr<uint8_t>(), 45911025Snilay@cs.wisc.edu data.getData(getOffset(request_address), pkt->getSize()), 4608615Snilay@cs.wisc.edu pkt->getSize()); 46110954SBrad.Beckmann@amd.com DPRINTF(RubySequencer, "read data %s\n", data); 4627039Snate@binkert.org } else { 46310563Sandreas.hansson@arm.com data.setData(pkt->getConstPtr<uint8_t>(), 46411025Snilay@cs.wisc.edu getOffset(request_address), pkt->getSize()); 46510954SBrad.Beckmann@amd.com DPRINTF(RubySequencer, "set data %s\n", data); 4667039Snate@binkert.org } 4677039Snate@binkert.org } 4687023SBrad.Beckmann@amd.com 4697039Snate@binkert.org // If using the RubyTester, update the RubyTester sender state's 4707039Snate@binkert.org // subBlock with the recieved data. The tester will later access 4717039Snate@binkert.org // this state. 4727039Snate@binkert.org if (m_usingRubyTester) { 47310657Sandreas.hansson@arm.com DPRINTF(RubySequencer, "hitCallback %s 0x%x using RubyTester\n", 47410657Sandreas.hansson@arm.com pkt->cmdString(), pkt->getAddr()); 4757039Snate@binkert.org RubyTester::SenderState* testerSenderState = 47610089Sandreas.hansson@arm.com pkt->findNextSenderState<RubyTester::SenderState>(); 47710089Sandreas.hansson@arm.com assert(testerSenderState); 4789542Sandreas.hansson@arm.com testerSenderState->subBlock.mergeFrom(data); 4797039Snate@binkert.org } 4807023SBrad.Beckmann@amd.com 4817039Snate@binkert.org delete srequest; 4828688Snilay@cs.wisc.edu 48310919Sbrandon.potter@amd.com RubySystem *rs = m_ruby_system; 48410837Sjthestness@gmail.com if (RubySystem::getWarmupEnabled()) { 4859632Sjthestness@gmail.com assert(pkt->req); 4869632Sjthestness@gmail.com delete pkt->req; 4878688Snilay@cs.wisc.edu delete pkt; 48810919Sbrandon.potter@amd.com rs->m_cache_recorder->enqueueNextFetchRequest(); 48910837Sjthestness@gmail.com } else if (RubySystem::getCooldownEnabled()) { 4908688Snilay@cs.wisc.edu delete pkt; 49110919Sbrandon.potter@amd.com rs->m_cache_recorder->enqueueNextFlushRequest(); 4928688Snilay@cs.wisc.edu } else { 4938688Snilay@cs.wisc.edu ruby_hit_callback(pkt); 4948688Snilay@cs.wisc.edu } 4956285Snate@binkert.org} 4966285Snate@binkert.org 4977039Snate@binkert.orgbool 4987039Snate@binkert.orgSequencer::empty() const 4997039Snate@binkert.org{ 5007455Snate@binkert.org return m_writeRequestTable.empty() && m_readRequestTable.empty(); 5016145Snate@binkert.org} 5026145Snate@binkert.org 5037039Snate@binkert.orgRequestStatus 5048615Snilay@cs.wisc.eduSequencer::makeRequest(PacketPtr pkt) 5057039Snate@binkert.org{ 5068615Snilay@cs.wisc.edu if (m_outstanding_count >= m_max_outstanding_requests) { 5078615Snilay@cs.wisc.edu return RequestStatus_BufferFull; 5088615Snilay@cs.wisc.edu } 5098615Snilay@cs.wisc.edu 5108615Snilay@cs.wisc.edu RubyRequestType primary_type = RubyRequestType_NULL; 5118615Snilay@cs.wisc.edu RubyRequestType secondary_type = RubyRequestType_NULL; 5128615Snilay@cs.wisc.edu 5138615Snilay@cs.wisc.edu if (pkt->isLLSC()) { 5148615Snilay@cs.wisc.edu // 5158615Snilay@cs.wisc.edu // Alpha LL/SC instructions need to be handled carefully by the cache 5168615Snilay@cs.wisc.edu // coherence protocol to ensure they follow the proper semantics. In 5178615Snilay@cs.wisc.edu // particular, by identifying the operations as atomic, the protocol 5188615Snilay@cs.wisc.edu // should understand that migratory sharing optimizations should not 5198615Snilay@cs.wisc.edu // be performed (i.e. a load between the LL and SC should not steal 5208615Snilay@cs.wisc.edu // away exclusive permission). 5218615Snilay@cs.wisc.edu // 5228615Snilay@cs.wisc.edu if (pkt->isWrite()) { 5238615Snilay@cs.wisc.edu DPRINTF(RubySequencer, "Issuing SC\n"); 5248615Snilay@cs.wisc.edu primary_type = RubyRequestType_Store_Conditional; 5258615Snilay@cs.wisc.edu } else { 5268615Snilay@cs.wisc.edu DPRINTF(RubySequencer, "Issuing LL\n"); 5278615Snilay@cs.wisc.edu assert(pkt->isRead()); 5288615Snilay@cs.wisc.edu primary_type = RubyRequestType_Load_Linked; 5298615Snilay@cs.wisc.edu } 5308615Snilay@cs.wisc.edu secondary_type = RubyRequestType_ATOMIC; 53110760Ssteve.reinhardt@amd.com } else if (pkt->req->isLockedRMW()) { 5328615Snilay@cs.wisc.edu // 5338615Snilay@cs.wisc.edu // x86 locked instructions are translated to store cache coherence 5348615Snilay@cs.wisc.edu // requests because these requests should always be treated as read 5358615Snilay@cs.wisc.edu // exclusive operations and should leverage any migratory sharing 5368615Snilay@cs.wisc.edu // optimization built into the protocol. 5378615Snilay@cs.wisc.edu // 5388615Snilay@cs.wisc.edu if (pkt->isWrite()) { 5398615Snilay@cs.wisc.edu DPRINTF(RubySequencer, "Issuing Locked RMW Write\n"); 5408615Snilay@cs.wisc.edu primary_type = RubyRequestType_Locked_RMW_Write; 5418615Snilay@cs.wisc.edu } else { 5428615Snilay@cs.wisc.edu DPRINTF(RubySequencer, "Issuing Locked RMW Read\n"); 5438615Snilay@cs.wisc.edu assert(pkt->isRead()); 5448615Snilay@cs.wisc.edu primary_type = RubyRequestType_Locked_RMW_Read; 5458615Snilay@cs.wisc.edu } 5468615Snilay@cs.wisc.edu secondary_type = RubyRequestType_ST; 5478615Snilay@cs.wisc.edu } else { 5488615Snilay@cs.wisc.edu if (pkt->isRead()) { 5498615Snilay@cs.wisc.edu if (pkt->req->isInstFetch()) { 5508615Snilay@cs.wisc.edu primary_type = secondary_type = RubyRequestType_IFETCH; 5518615Snilay@cs.wisc.edu } else { 5528615Snilay@cs.wisc.edu bool storeCheck = false; 55310467Sandreas.hansson@arm.com // only X86 need the store check 55410467Sandreas.hansson@arm.com if (system->getArch() == Arch::X86ISA) { 55510467Sandreas.hansson@arm.com uint32_t flags = pkt->req->getFlags(); 55610467Sandreas.hansson@arm.com storeCheck = flags & 55710467Sandreas.hansson@arm.com (X86ISA::StoreCheck << X86ISA::FlagShift); 55810467Sandreas.hansson@arm.com } 5598615Snilay@cs.wisc.edu if (storeCheck) { 5608615Snilay@cs.wisc.edu primary_type = RubyRequestType_RMW_Read; 5618615Snilay@cs.wisc.edu secondary_type = RubyRequestType_ST; 5628615Snilay@cs.wisc.edu } else { 5638615Snilay@cs.wisc.edu primary_type = secondary_type = RubyRequestType_LD; 5648615Snilay@cs.wisc.edu } 5658615Snilay@cs.wisc.edu } 5668615Snilay@cs.wisc.edu } else if (pkt->isWrite()) { 5678615Snilay@cs.wisc.edu // 5688615Snilay@cs.wisc.edu // Note: M5 packets do not differentiate ST from RMW_Write 5698615Snilay@cs.wisc.edu // 5708615Snilay@cs.wisc.edu primary_type = secondary_type = RubyRequestType_ST; 5718615Snilay@cs.wisc.edu } else if (pkt->isFlush()) { 5728615Snilay@cs.wisc.edu primary_type = secondary_type = RubyRequestType_FLUSH; 5738615Snilay@cs.wisc.edu } else { 5748615Snilay@cs.wisc.edu panic("Unsupported ruby packet type\n"); 5758615Snilay@cs.wisc.edu } 5768615Snilay@cs.wisc.edu } 5778615Snilay@cs.wisc.edu 5788615Snilay@cs.wisc.edu RequestStatus status = insertRequest(pkt, primary_type); 5797039Snate@binkert.org if (status != RequestStatus_Ready) 5807039Snate@binkert.org return status; 5816349Spdudnik@gmail.com 5828615Snilay@cs.wisc.edu issueRequest(pkt, secondary_type); 5836145Snate@binkert.org 5847039Snate@binkert.org // TODO: issue hardware prefetches here 5857039Snate@binkert.org return RequestStatus_Issued; 5866145Snate@binkert.org} 5876145Snate@binkert.org 5887039Snate@binkert.orgvoid 5898615Snilay@cs.wisc.eduSequencer::issueRequest(PacketPtr pkt, RubyRequestType secondary_type) 5907039Snate@binkert.org{ 5919216Sandreas.hansson@arm.com assert(pkt != NULL); 59211005Sandreas.sandberg@arm.com ContextID proc_id = pkt->req->hasContextId() ? 59311005Sandreas.sandberg@arm.com pkt->req->contextId() : InvalidContextID; 5946285Snate@binkert.org 5958615Snilay@cs.wisc.edu // If valid, copy the pc to the ruby request 5968615Snilay@cs.wisc.edu Addr pc = 0; 5978615Snilay@cs.wisc.edu if (pkt->req->hasPC()) { 5988615Snilay@cs.wisc.edu pc = pkt->req->getPC(); 5997039Snate@binkert.org } 6006285Snate@binkert.org 60110562Sandreas.hansson@arm.com // check if the packet has data as for example prefetch and flush 60210562Sandreas.hansson@arm.com // requests do not 60310472Sandreas.hansson@arm.com std::shared_ptr<RubyRequest> msg = 60410472Sandreas.hansson@arm.com std::make_shared<RubyRequest>(clockEdge(), pkt->getAddr(), 60510562Sandreas.hansson@arm.com pkt->isFlush() ? 60610562Sandreas.hansson@arm.com nullptr : pkt->getPtr<uint8_t>(), 60710472Sandreas.hansson@arm.com pkt->getSize(), pc, secondary_type, 60810472Sandreas.hansson@arm.com RubyAccessMode_Supervisor, pkt, 60910472Sandreas.hansson@arm.com PrefetchBit_No, proc_id); 6106285Snate@binkert.org 61111025Snilay@cs.wisc.edu DPRINTFR(ProtocolTrace, "%15s %3s %10s%20s %6s>%-6s %#x %s\n", 6128266Sksewell@umich.edu curTick(), m_version, "Seq", "Begin", "", "", 6138615Snilay@cs.wisc.edu msg->getPhysicalAddress(), 6148615Snilay@cs.wisc.edu RubyRequestType_to_string(secondary_type)); 6156285Snate@binkert.org 61611019Sjthestness@gmail.com // The Sequencer currently assesses instruction and data cache hit latency 61711019Sjthestness@gmail.com // for the top-level caches at the beginning of a memory access. 61811019Sjthestness@gmail.com // TODO: Eventually, this latency should be moved to represent the actual 61911019Sjthestness@gmail.com // cache access latency portion of the memory access. This will require 62011019Sjthestness@gmail.com // changing cache controller protocol files to assess the latency on the 62111019Sjthestness@gmail.com // access response path. 62211019Sjthestness@gmail.com Cycles latency(0); // Initialize to zero to catch misconfigured latency 6238615Snilay@cs.wisc.edu if (secondary_type == RubyRequestType_IFETCH) 62411019Sjthestness@gmail.com latency = m_inst_cache_hit_latency; 6257039Snate@binkert.org else 62611019Sjthestness@gmail.com latency = m_data_cache_hit_latency; 6276285Snate@binkert.org 6287039Snate@binkert.org // Send the message to the cache controller 6297039Snate@binkert.org assert(latency > 0); 6306145Snate@binkert.org 6317039Snate@binkert.org assert(m_mandatory_q_ptr != NULL); 63211111Snilay@cs.wisc.edu m_mandatory_q_ptr->enqueue(msg, clockEdge(), cyclesToTicks(latency)); 6336145Snate@binkert.org} 6346145Snate@binkert.org 6357455Snate@binkert.orgtemplate <class KEY, class VALUE> 6367455Snate@binkert.orgstd::ostream & 6377455Snate@binkert.orgoperator<<(ostream &out, const m5::hash_map<KEY, VALUE> &map) 6387455Snate@binkert.org{ 6397455Snate@binkert.org typename m5::hash_map<KEY, VALUE>::const_iterator i = map.begin(); 6407455Snate@binkert.org typename m5::hash_map<KEY, VALUE>::const_iterator end = map.end(); 6417455Snate@binkert.org 6427455Snate@binkert.org out << "["; 6437455Snate@binkert.org for (; i != end; ++i) 6447455Snate@binkert.org out << " " << i->first << "=" << i->second; 6457455Snate@binkert.org out << " ]"; 6467455Snate@binkert.org 6477455Snate@binkert.org return out; 6487455Snate@binkert.org} 6497455Snate@binkert.org 6507039Snate@binkert.orgvoid 6517039Snate@binkert.orgSequencer::print(ostream& out) const 6527039Snate@binkert.org{ 6537039Snate@binkert.org out << "[Sequencer: " << m_version 6547039Snate@binkert.org << ", outstanding requests: " << m_outstanding_count 6557039Snate@binkert.org << ", read request table: " << m_readRequestTable 6567039Snate@binkert.org << ", write request table: " << m_writeRequestTable 6577039Snate@binkert.org << "]"; 6587039Snate@binkert.org} 6597039Snate@binkert.org 6607039Snate@binkert.org// this can be called from setState whenever coherence permissions are 6617039Snate@binkert.org// upgraded when invoked, coherence violations will be checked for the 6627039Snate@binkert.org// given block 6637039Snate@binkert.orgvoid 66411025Snilay@cs.wisc.eduSequencer::checkCoherence(Addr addr) 6657039Snate@binkert.org{ 6666145Snate@binkert.org#ifdef CHECK_COHERENCE 66710919Sbrandon.potter@amd.com m_ruby_system->checkGlobalCoherenceInvariant(addr); 6686145Snate@binkert.org#endif 6696145Snate@binkert.org} 6708717Snilay@cs.wisc.edu 6718717Snilay@cs.wisc.eduvoid 6729104Shestness@cs.utexas.eduSequencer::recordRequestType(SequencerRequestType requestType) { 6739104Shestness@cs.utexas.edu DPRINTF(RubyStats, "Recorded statistic: %s\n", 6749104Shestness@cs.utexas.edu SequencerRequestType_to_string(requestType)); 6759104Shestness@cs.utexas.edu} 6769104Shestness@cs.utexas.edu 6779104Shestness@cs.utexas.edu 6789104Shestness@cs.utexas.eduvoid 67911025Snilay@cs.wisc.eduSequencer::evictionCallback(Addr address) 6808717Snilay@cs.wisc.edu{ 6818717Snilay@cs.wisc.edu ruby_eviction_callback(address); 6828717Snilay@cs.wisc.edu} 68310012Snilay@cs.wisc.edu 68410012Snilay@cs.wisc.eduvoid 68510012Snilay@cs.wisc.eduSequencer::regStats() 68610012Snilay@cs.wisc.edu{ 68710012Snilay@cs.wisc.edu m_store_waiting_on_load 68810012Snilay@cs.wisc.edu .name(name() + ".store_waiting_on_load") 68910012Snilay@cs.wisc.edu .desc("Number of times a store aliased with a pending load") 69010012Snilay@cs.wisc.edu .flags(Stats::nozero); 69110012Snilay@cs.wisc.edu m_store_waiting_on_store 69210012Snilay@cs.wisc.edu .name(name() + ".store_waiting_on_store") 69310012Snilay@cs.wisc.edu .desc("Number of times a store aliased with a pending store") 69410012Snilay@cs.wisc.edu .flags(Stats::nozero); 69510012Snilay@cs.wisc.edu m_load_waiting_on_load 69610012Snilay@cs.wisc.edu .name(name() + ".load_waiting_on_load") 69710012Snilay@cs.wisc.edu .desc("Number of times a load aliased with a pending load") 69810012Snilay@cs.wisc.edu .flags(Stats::nozero); 69910012Snilay@cs.wisc.edu m_load_waiting_on_store 70010012Snilay@cs.wisc.edu .name(name() + ".load_waiting_on_store") 70110012Snilay@cs.wisc.edu .desc("Number of times a load aliased with a pending store") 70210012Snilay@cs.wisc.edu .flags(Stats::nozero); 70310012Snilay@cs.wisc.edu 70410012Snilay@cs.wisc.edu // These statistical variables are not for display. 70510012Snilay@cs.wisc.edu // The profiler will collate these across different 70610012Snilay@cs.wisc.edu // sequencers and display those collated statistics. 70710012Snilay@cs.wisc.edu m_outstandReqHist.init(10); 70810012Snilay@cs.wisc.edu m_latencyHist.init(10); 70910012Snilay@cs.wisc.edu m_hitLatencyHist.init(10); 71010012Snilay@cs.wisc.edu m_missLatencyHist.init(10); 71110012Snilay@cs.wisc.edu 71210012Snilay@cs.wisc.edu for (int i = 0; i < RubyRequestType_NUM; i++) { 71310012Snilay@cs.wisc.edu m_typeLatencyHist.push_back(new Stats::Histogram()); 71410012Snilay@cs.wisc.edu m_typeLatencyHist[i]->init(10); 71510012Snilay@cs.wisc.edu 71610012Snilay@cs.wisc.edu m_hitTypeLatencyHist.push_back(new Stats::Histogram()); 71710012Snilay@cs.wisc.edu m_hitTypeLatencyHist[i]->init(10); 71810012Snilay@cs.wisc.edu 71910012Snilay@cs.wisc.edu m_missTypeLatencyHist.push_back(new Stats::Histogram()); 72010012Snilay@cs.wisc.edu m_missTypeLatencyHist[i]->init(10); 72110012Snilay@cs.wisc.edu } 72210012Snilay@cs.wisc.edu 72310012Snilay@cs.wisc.edu for (int i = 0; i < MachineType_NUM; i++) { 72410012Snilay@cs.wisc.edu m_hitMachLatencyHist.push_back(new Stats::Histogram()); 72510012Snilay@cs.wisc.edu m_hitMachLatencyHist[i]->init(10); 72610012Snilay@cs.wisc.edu 72710012Snilay@cs.wisc.edu m_missMachLatencyHist.push_back(new Stats::Histogram()); 72810012Snilay@cs.wisc.edu m_missMachLatencyHist[i]->init(10); 72910012Snilay@cs.wisc.edu 73010012Snilay@cs.wisc.edu m_IssueToInitialDelayHist.push_back(new Stats::Histogram()); 73110012Snilay@cs.wisc.edu m_IssueToInitialDelayHist[i]->init(10); 73210012Snilay@cs.wisc.edu 73310012Snilay@cs.wisc.edu m_InitialToForwardDelayHist.push_back(new Stats::Histogram()); 73410012Snilay@cs.wisc.edu m_InitialToForwardDelayHist[i]->init(10); 73510012Snilay@cs.wisc.edu 73610012Snilay@cs.wisc.edu m_ForwardToFirstResponseDelayHist.push_back(new Stats::Histogram()); 73710012Snilay@cs.wisc.edu m_ForwardToFirstResponseDelayHist[i]->init(10); 73810012Snilay@cs.wisc.edu 73910012Snilay@cs.wisc.edu m_FirstResponseToCompletionDelayHist.push_back(new Stats::Histogram()); 74010012Snilay@cs.wisc.edu m_FirstResponseToCompletionDelayHist[i]->init(10); 74110012Snilay@cs.wisc.edu } 74210012Snilay@cs.wisc.edu 74310012Snilay@cs.wisc.edu for (int i = 0; i < RubyRequestType_NUM; i++) { 74410012Snilay@cs.wisc.edu m_hitTypeMachLatencyHist.push_back(std::vector<Stats::Histogram *>()); 74510012Snilay@cs.wisc.edu m_missTypeMachLatencyHist.push_back(std::vector<Stats::Histogram *>()); 74610012Snilay@cs.wisc.edu 74710012Snilay@cs.wisc.edu for (int j = 0; j < MachineType_NUM; j++) { 74810012Snilay@cs.wisc.edu m_hitTypeMachLatencyHist[i].push_back(new Stats::Histogram()); 74910012Snilay@cs.wisc.edu m_hitTypeMachLatencyHist[i][j]->init(10); 75010012Snilay@cs.wisc.edu 75110012Snilay@cs.wisc.edu m_missTypeMachLatencyHist[i].push_back(new Stats::Histogram()); 75210012Snilay@cs.wisc.edu m_missTypeMachLatencyHist[i][j]->init(10); 75310012Snilay@cs.wisc.edu } 75410012Snilay@cs.wisc.edu } 75510012Snilay@cs.wisc.edu} 756