Sequencer.cc revision 10954
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" 416154Snate@binkert.org#include "mem/ruby/system/Sequencer.hh" 426154Snate@binkert.org#include "mem/ruby/system/System.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; 616876Ssteve.reinhardt@amd.com m_max_outstanding_requests = p->max_outstanding_requests; 626876Ssteve.reinhardt@amd.com m_deadlock_threshold = p->deadlock_threshold; 636899SBrad.Beckmann@amd.com 646876Ssteve.reinhardt@amd.com assert(m_max_outstanding_requests > 0); 656876Ssteve.reinhardt@amd.com assert(m_deadlock_threshold > 0); 666876Ssteve.reinhardt@amd.com assert(m_instCache_ptr != NULL); 676876Ssteve.reinhardt@amd.com assert(m_dataCache_ptr != NULL); 688171Stushar@csail.mit.edu 698171Stushar@csail.mit.edu m_usingNetworkTester = p->using_network_tester; 706145Snate@binkert.org} 716145Snate@binkert.org 727039Snate@binkert.orgSequencer::~Sequencer() 737039Snate@binkert.org{ 746145Snate@binkert.org} 756145Snate@binkert.org 767039Snate@binkert.orgvoid 777039Snate@binkert.orgSequencer::wakeup() 787039Snate@binkert.org{ 7910913Sandreas.sandberg@arm.com assert(drainState() != DrainState::Draining); 809245Shestness@cs.wisc.edu 817039Snate@binkert.org // Check for deadlock of any of the requests 829501Snilay@cs.wisc.edu Cycles current_time = curCycle(); 836145Snate@binkert.org 847039Snate@binkert.org // Check across all outstanding requests 857039Snate@binkert.org int total_outstanding = 0; 866285Snate@binkert.org 877455Snate@binkert.org RequestTable::iterator read = m_readRequestTable.begin(); 887455Snate@binkert.org RequestTable::iterator read_end = m_readRequestTable.end(); 897455Snate@binkert.org for (; read != read_end; ++read) { 907455Snate@binkert.org SequencerRequest* request = read->second; 917455Snate@binkert.org if (current_time - request->issue_time < m_deadlock_threshold) 927455Snate@binkert.org continue; 937455Snate@binkert.org 947805Snilay@cs.wisc.edu panic("Possible Deadlock detected. Aborting!\n" 957921SBrad.Beckmann@amd.com "version: %d request.paddr: 0x%x m_readRequestTable: %d " 967805Snilay@cs.wisc.edu "current time: %u issue_time: %d difference: %d\n", m_version, 978615Snilay@cs.wisc.edu Address(request->pkt->getAddr()), m_readRequestTable.size(), 989467Smalek.musleh@gmail.com current_time * clockPeriod(), request->issue_time * clockPeriod(), 999467Smalek.musleh@gmail.com (current_time * clockPeriod()) - (request->issue_time * clockPeriod())); 1006145Snate@binkert.org } 1016145Snate@binkert.org 1027455Snate@binkert.org RequestTable::iterator write = m_writeRequestTable.begin(); 1037455Snate@binkert.org RequestTable::iterator write_end = m_writeRequestTable.end(); 1047455Snate@binkert.org for (; write != write_end; ++write) { 1057455Snate@binkert.org SequencerRequest* request = write->second; 1067455Snate@binkert.org if (current_time - request->issue_time < m_deadlock_threshold) 1077455Snate@binkert.org continue; 1087455Snate@binkert.org 1097805Snilay@cs.wisc.edu panic("Possible Deadlock detected. Aborting!\n" 1107921SBrad.Beckmann@amd.com "version: %d request.paddr: 0x%x m_writeRequestTable: %d " 1117805Snilay@cs.wisc.edu "current time: %u issue_time: %d difference: %d\n", m_version, 1128615Snilay@cs.wisc.edu Address(request->pkt->getAddr()), m_writeRequestTable.size(), 1139467Smalek.musleh@gmail.com current_time * clockPeriod(), request->issue_time * clockPeriod(), 1149467Smalek.musleh@gmail.com (current_time * clockPeriod()) - (request->issue_time * clockPeriod())); 1156145Snate@binkert.org } 1166285Snate@binkert.org 1177039Snate@binkert.org total_outstanding += m_writeRequestTable.size(); 1187039Snate@binkert.org total_outstanding += m_readRequestTable.size(); 1196145Snate@binkert.org 1207039Snate@binkert.org assert(m_outstanding_count == total_outstanding); 1217039Snate@binkert.org 1227039Snate@binkert.org if (m_outstanding_count > 0) { 1237039Snate@binkert.org // If there are still outstanding requests, keep checking 1249465Snilay@cs.wisc.edu schedule(deadlockCheckEvent, clockEdge(m_deadlock_threshold)); 1257039Snate@binkert.org } 1266145Snate@binkert.org} 1276145Snate@binkert.org 12810012Snilay@cs.wisc.eduvoid Sequencer::resetStats() 1299598Snilay@cs.wisc.edu{ 13010012Snilay@cs.wisc.edu m_latencyHist.reset(); 13110012Snilay@cs.wisc.edu m_hitLatencyHist.reset(); 13210012Snilay@cs.wisc.edu m_missLatencyHist.reset(); 1339773Snilay@cs.wisc.edu for (int i = 0; i < RubyRequestType_NUM; i++) { 13410012Snilay@cs.wisc.edu m_typeLatencyHist[i]->reset(); 13510012Snilay@cs.wisc.edu m_hitTypeLatencyHist[i]->reset(); 13610012Snilay@cs.wisc.edu m_missTypeLatencyHist[i]->reset(); 1379773Snilay@cs.wisc.edu for (int j = 0; j < MachineType_NUM; j++) { 13810012Snilay@cs.wisc.edu m_hitTypeMachLatencyHist[i][j]->reset(); 13910012Snilay@cs.wisc.edu m_missTypeMachLatencyHist[i][j]->reset(); 1409773Snilay@cs.wisc.edu } 1419773Snilay@cs.wisc.edu } 1429773Snilay@cs.wisc.edu 14310012Snilay@cs.wisc.edu for (int i = 0; i < MachineType_NUM; i++) { 14410012Snilay@cs.wisc.edu m_missMachLatencyHist[i]->reset(); 14510012Snilay@cs.wisc.edu m_hitMachLatencyHist[i]->reset(); 1469773Snilay@cs.wisc.edu 14710012Snilay@cs.wisc.edu m_IssueToInitialDelayHist[i]->reset(); 14810012Snilay@cs.wisc.edu m_InitialToForwardDelayHist[i]->reset(); 14910012Snilay@cs.wisc.edu m_ForwardToFirstResponseDelayHist[i]->reset(); 15010012Snilay@cs.wisc.edu m_FirstResponseToCompletionDelayHist[i]->reset(); 1519773Snilay@cs.wisc.edu 1529773Snilay@cs.wisc.edu m_IncompleteTimes[i] = 0; 1539773Snilay@cs.wisc.edu } 1549598Snilay@cs.wisc.edu} 1559598Snilay@cs.wisc.edu 1567039Snate@binkert.orgvoid 1577039Snate@binkert.orgSequencer::printProgress(ostream& out) const 1587039Snate@binkert.org{ 1597039Snate@binkert.org#if 0 1607039Snate@binkert.org int total_demand = 0; 1617039Snate@binkert.org out << "Sequencer Stats Version " << m_version << endl; 16210919Sbrandon.potter@amd.com out << "Current time = " << m_ruby_system->getTime() << endl; 1637039Snate@binkert.org out << "---------------" << endl; 1647039Snate@binkert.org out << "outstanding requests" << endl; 1656145Snate@binkert.org 1667455Snate@binkert.org out << "proc " << m_Read 1677455Snate@binkert.org << " version Requests = " << m_readRequestTable.size() << endl; 1686145Snate@binkert.org 1697039Snate@binkert.org // print the request table 1707455Snate@binkert.org RequestTable::iterator read = m_readRequestTable.begin(); 1717455Snate@binkert.org RequestTable::iterator read_end = m_readRequestTable.end(); 1727455Snate@binkert.org for (; read != read_end; ++read) { 1737455Snate@binkert.org SequencerRequest* request = read->second; 1747039Snate@binkert.org out << "\tRequest[ " << i << " ] = " << request->type 1757039Snate@binkert.org << " Address " << rkeys[i] 1767039Snate@binkert.org << " Posted " << request->issue_time 1777039Snate@binkert.org << " PF " << PrefetchBit_No << endl; 1786145Snate@binkert.org total_demand++; 1797039Snate@binkert.org } 1806145Snate@binkert.org 1817455Snate@binkert.org out << "proc " << m_version 1827455Snate@binkert.org << " Write Requests = " << m_writeRequestTable.size << endl; 1836285Snate@binkert.org 1847039Snate@binkert.org // print the request table 1857455Snate@binkert.org RequestTable::iterator write = m_writeRequestTable.begin(); 1867455Snate@binkert.org RequestTable::iterator write_end = m_writeRequestTable.end(); 1877455Snate@binkert.org for (; write != write_end; ++write) { 1887455Snate@binkert.org SequencerRequest* request = write->second; 1897039Snate@binkert.org out << "\tRequest[ " << i << " ] = " << request.getType() 1907039Snate@binkert.org << " Address " << wkeys[i] 1917039Snate@binkert.org << " Posted " << request.getTime() 1927039Snate@binkert.org << " PF " << request.getPrefetch() << endl; 1937039Snate@binkert.org if (request.getPrefetch() == PrefetchBit_No) { 1947039Snate@binkert.org total_demand++; 1957039Snate@binkert.org } 1967039Snate@binkert.org } 1977039Snate@binkert.org 1987039Snate@binkert.org out << endl; 1997039Snate@binkert.org 2007039Snate@binkert.org out << "Total Number Outstanding: " << m_outstanding_count << endl 2017039Snate@binkert.org << "Total Number Demand : " << total_demand << endl 2027039Snate@binkert.org << "Total Number Prefetches : " << m_outstanding_count - total_demand 2037039Snate@binkert.org << endl << endl << endl; 2047039Snate@binkert.org#endif 2056145Snate@binkert.org} 2066145Snate@binkert.org 2076145Snate@binkert.org// Insert the request on the correct request table. Return true if 2086145Snate@binkert.org// the entry was already present. 2098615Snilay@cs.wisc.eduRequestStatus 2108615Snilay@cs.wisc.eduSequencer::insertRequest(PacketPtr pkt, RubyRequestType request_type) 2117039Snate@binkert.org{ 2128641Snate@binkert.org assert(m_outstanding_count == 2138641Snate@binkert.org (m_writeRequestTable.size() + m_readRequestTable.size())); 2146145Snate@binkert.org 2157039Snate@binkert.org // See if we should schedule a deadlock check 2169342SAndreas.Sandberg@arm.com if (!deadlockCheckEvent.scheduled() && 21710913Sandreas.sandberg@arm.com drainState() != DrainState::Draining) { 2189465Snilay@cs.wisc.edu schedule(deadlockCheckEvent, clockEdge(m_deadlock_threshold)); 2197039Snate@binkert.org } 2206145Snate@binkert.org 2218615Snilay@cs.wisc.edu Address line_addr(pkt->getAddr()); 2227039Snate@binkert.org line_addr.makeLineAddress(); 2239224Sandreas.hansson@arm.com // Create a default entry, mapping the address to NULL, the cast is 2249224Sandreas.hansson@arm.com // there to make gcc 4.4 happy 2259224Sandreas.hansson@arm.com RequestTable::value_type default_entry(line_addr, 2269224Sandreas.hansson@arm.com (SequencerRequest*) NULL); 2279224Sandreas.hansson@arm.com 2288615Snilay@cs.wisc.edu if ((request_type == RubyRequestType_ST) || 2298615Snilay@cs.wisc.edu (request_type == RubyRequestType_RMW_Read) || 2308615Snilay@cs.wisc.edu (request_type == RubyRequestType_RMW_Write) || 2318615Snilay@cs.wisc.edu (request_type == RubyRequestType_Load_Linked) || 2328615Snilay@cs.wisc.edu (request_type == RubyRequestType_Store_Conditional) || 2338615Snilay@cs.wisc.edu (request_type == RubyRequestType_Locked_RMW_Read) || 2348615Snilay@cs.wisc.edu (request_type == RubyRequestType_Locked_RMW_Write) || 2358615Snilay@cs.wisc.edu (request_type == RubyRequestType_FLUSH)) { 2368615Snilay@cs.wisc.edu 2378615Snilay@cs.wisc.edu // Check if there is any outstanding read request for the same 2388615Snilay@cs.wisc.edu // cache line. 2398615Snilay@cs.wisc.edu if (m_readRequestTable.count(line_addr) > 0) { 24010012Snilay@cs.wisc.edu m_store_waiting_on_load++; 2418615Snilay@cs.wisc.edu return RequestStatus_Aliased; 2428615Snilay@cs.wisc.edu } 2438615Snilay@cs.wisc.edu 2447455Snate@binkert.org pair<RequestTable::iterator, bool> r = 2459224Sandreas.hansson@arm.com m_writeRequestTable.insert(default_entry); 2468615Snilay@cs.wisc.edu if (r.second) { 2478615Snilay@cs.wisc.edu RequestTable::iterator i = r.first; 2489465Snilay@cs.wisc.edu i->second = new SequencerRequest(pkt, request_type, curCycle()); 2498615Snilay@cs.wisc.edu m_outstanding_count++; 2508615Snilay@cs.wisc.edu } else { 2518615Snilay@cs.wisc.edu // There is an outstanding write request for the cache line 25210012Snilay@cs.wisc.edu m_store_waiting_on_store++; 2538615Snilay@cs.wisc.edu return RequestStatus_Aliased; 2548615Snilay@cs.wisc.edu } 2558615Snilay@cs.wisc.edu } else { 2568615Snilay@cs.wisc.edu // Check if there is any outstanding write request for the same 2578615Snilay@cs.wisc.edu // cache line. 2588615Snilay@cs.wisc.edu if (m_writeRequestTable.count(line_addr) > 0) { 25910012Snilay@cs.wisc.edu m_load_waiting_on_store++; 2608615Snilay@cs.wisc.edu return RequestStatus_Aliased; 2618615Snilay@cs.wisc.edu } 2627039Snate@binkert.org 2637455Snate@binkert.org pair<RequestTable::iterator, bool> r = 2649224Sandreas.hansson@arm.com m_readRequestTable.insert(default_entry); 2657039Snate@binkert.org 2668615Snilay@cs.wisc.edu if (r.second) { 2678615Snilay@cs.wisc.edu RequestTable::iterator i = r.first; 2689465Snilay@cs.wisc.edu i->second = new SequencerRequest(pkt, request_type, curCycle()); 2698615Snilay@cs.wisc.edu m_outstanding_count++; 2708615Snilay@cs.wisc.edu } else { 2718615Snilay@cs.wisc.edu // There is an outstanding read request for the cache line 27210012Snilay@cs.wisc.edu m_load_waiting_on_load++; 2738615Snilay@cs.wisc.edu return RequestStatus_Aliased; 2747039Snate@binkert.org } 2756145Snate@binkert.org } 2766145Snate@binkert.org 27710012Snilay@cs.wisc.edu m_outstandReqHist.sample(m_outstanding_count); 2788641Snate@binkert.org assert(m_outstanding_count == 2798641Snate@binkert.org (m_writeRequestTable.size() + m_readRequestTable.size())); 2806145Snate@binkert.org 2818615Snilay@cs.wisc.edu return RequestStatus_Ready; 2826145Snate@binkert.org} 2836145Snate@binkert.org 2847039Snate@binkert.orgvoid 2857455Snate@binkert.orgSequencer::markRemoved() 2867455Snate@binkert.org{ 2877455Snate@binkert.org m_outstanding_count--; 2887455Snate@binkert.org assert(m_outstanding_count == 2897455Snate@binkert.org m_writeRequestTable.size() + m_readRequestTable.size()); 2907455Snate@binkert.org} 2917455Snate@binkert.org 2927455Snate@binkert.orgvoid 2937039Snate@binkert.orgSequencer::removeRequest(SequencerRequest* srequest) 2947039Snate@binkert.org{ 2957039Snate@binkert.org assert(m_outstanding_count == 2967039Snate@binkert.org m_writeRequestTable.size() + m_readRequestTable.size()); 2976145Snate@binkert.org 2988615Snilay@cs.wisc.edu Address line_addr(srequest->pkt->getAddr()); 2997039Snate@binkert.org line_addr.makeLineAddress(); 3008615Snilay@cs.wisc.edu if ((srequest->m_type == RubyRequestType_ST) || 3018615Snilay@cs.wisc.edu (srequest->m_type == RubyRequestType_RMW_Read) || 3028615Snilay@cs.wisc.edu (srequest->m_type == RubyRequestType_RMW_Write) || 3038615Snilay@cs.wisc.edu (srequest->m_type == RubyRequestType_Load_Linked) || 3048615Snilay@cs.wisc.edu (srequest->m_type == RubyRequestType_Store_Conditional) || 3058615Snilay@cs.wisc.edu (srequest->m_type == RubyRequestType_Locked_RMW_Read) || 3068615Snilay@cs.wisc.edu (srequest->m_type == RubyRequestType_Locked_RMW_Write)) { 3077455Snate@binkert.org m_writeRequestTable.erase(line_addr); 3087039Snate@binkert.org } else { 3097455Snate@binkert.org m_readRequestTable.erase(line_addr); 3107039Snate@binkert.org } 3116285Snate@binkert.org 3127455Snate@binkert.org markRemoved(); 3136145Snate@binkert.org} 3146145Snate@binkert.org 3159563Sgope@wisc.eduvoid 3169563Sgope@wisc.eduSequencer::invalidateSC(const Address& address) 3179563Sgope@wisc.edu{ 3189563Sgope@wisc.edu RequestTable::iterator i = m_writeRequestTable.find(address); 3199563Sgope@wisc.edu if (i != m_writeRequestTable.end()) { 3209563Sgope@wisc.edu SequencerRequest* request = i->second; 3219563Sgope@wisc.edu // The controller has lost the coherence permissions, hence the lock 3229563Sgope@wisc.edu // on the cache line maintained by the cache should be cleared. 3239563Sgope@wisc.edu if (request->m_type == RubyRequestType_Store_Conditional) { 3249563Sgope@wisc.edu m_dataCache_ptr->clearLocked(address); 3259563Sgope@wisc.edu } 3269563Sgope@wisc.edu } 3279563Sgope@wisc.edu} 3289563Sgope@wisc.edu 3297560SBrad.Beckmann@amd.combool 3307560SBrad.Beckmann@amd.comSequencer::handleLlsc(const Address& address, SequencerRequest* request) 3317550SBrad.Beckmann@amd.com{ 3327560SBrad.Beckmann@amd.com // 3337560SBrad.Beckmann@amd.com // The success flag indicates whether the LLSC operation was successful. 3347560SBrad.Beckmann@amd.com // LL ops will always succeed, but SC may fail if the cache line is no 3357560SBrad.Beckmann@amd.com // longer locked. 3367560SBrad.Beckmann@amd.com // 3377560SBrad.Beckmann@amd.com bool success = true; 3388615Snilay@cs.wisc.edu if (request->m_type == RubyRequestType_Store_Conditional) { 3397550SBrad.Beckmann@amd.com if (!m_dataCache_ptr->isLocked(address, m_version)) { 3407550SBrad.Beckmann@amd.com // 3417550SBrad.Beckmann@amd.com // For failed SC requests, indicate the failure to the cpu by 3427550SBrad.Beckmann@amd.com // setting the extra data to zero. 3437550SBrad.Beckmann@amd.com // 3448615Snilay@cs.wisc.edu request->pkt->req->setExtraData(0); 3457560SBrad.Beckmann@amd.com success = false; 3467550SBrad.Beckmann@amd.com } else { 3477550SBrad.Beckmann@amd.com // 3487550SBrad.Beckmann@amd.com // For successful SC requests, indicate the success to the cpu by 34910917Sbrandon.potter@amd.com // setting the extra data to one. 3507550SBrad.Beckmann@amd.com // 3518615Snilay@cs.wisc.edu request->pkt->req->setExtraData(1); 3527550SBrad.Beckmann@amd.com } 3537560SBrad.Beckmann@amd.com // 3547560SBrad.Beckmann@amd.com // Independent of success, all SC operations must clear the lock 3557560SBrad.Beckmann@amd.com // 3567550SBrad.Beckmann@amd.com m_dataCache_ptr->clearLocked(address); 3578615Snilay@cs.wisc.edu } else if (request->m_type == RubyRequestType_Load_Linked) { 3587550SBrad.Beckmann@amd.com // 3597550SBrad.Beckmann@amd.com // Note: To fully follow Alpha LLSC semantics, should the LL clear any 3607550SBrad.Beckmann@amd.com // previously locked cache lines? 3617550SBrad.Beckmann@amd.com // 3627550SBrad.Beckmann@amd.com m_dataCache_ptr->setLocked(address, m_version); 3638615Snilay@cs.wisc.edu } else if ((m_dataCache_ptr->isTagPresent(address)) && 3648615Snilay@cs.wisc.edu (m_dataCache_ptr->isLocked(address, m_version))) { 3657550SBrad.Beckmann@amd.com // 3667550SBrad.Beckmann@amd.com // Normal writes should clear the locked address 3677550SBrad.Beckmann@amd.com // 3687550SBrad.Beckmann@amd.com m_dataCache_ptr->clearLocked(address); 3697550SBrad.Beckmann@amd.com } 3707560SBrad.Beckmann@amd.com return success; 3717550SBrad.Beckmann@amd.com} 3727550SBrad.Beckmann@amd.com 3737550SBrad.Beckmann@amd.comvoid 3749773Snilay@cs.wisc.eduSequencer::recordMissLatency(const Cycles cycles, const RubyRequestType type, 3759773Snilay@cs.wisc.edu const MachineType respondingMach, 3769773Snilay@cs.wisc.edu bool isExternalHit, Cycles issuedTime, 3779773Snilay@cs.wisc.edu Cycles initialRequestTime, 3789773Snilay@cs.wisc.edu Cycles forwardRequestTime, 3799773Snilay@cs.wisc.edu Cycles firstResponseTime, Cycles completionTime) 3807039Snate@binkert.org{ 38110012Snilay@cs.wisc.edu m_latencyHist.sample(cycles); 38210012Snilay@cs.wisc.edu m_typeLatencyHist[type]->sample(cycles); 3839773Snilay@cs.wisc.edu 3849773Snilay@cs.wisc.edu if (isExternalHit) { 38510012Snilay@cs.wisc.edu m_missLatencyHist.sample(cycles); 38610012Snilay@cs.wisc.edu m_missTypeLatencyHist[type]->sample(cycles); 3879773Snilay@cs.wisc.edu 3889773Snilay@cs.wisc.edu if (respondingMach != MachineType_NUM) { 38910012Snilay@cs.wisc.edu m_missMachLatencyHist[respondingMach]->sample(cycles); 39010012Snilay@cs.wisc.edu m_missTypeMachLatencyHist[type][respondingMach]->sample(cycles); 3919773Snilay@cs.wisc.edu 3929773Snilay@cs.wisc.edu if ((issuedTime <= initialRequestTime) && 3939773Snilay@cs.wisc.edu (initialRequestTime <= forwardRequestTime) && 3949773Snilay@cs.wisc.edu (forwardRequestTime <= firstResponseTime) && 3959773Snilay@cs.wisc.edu (firstResponseTime <= completionTime)) { 3969773Snilay@cs.wisc.edu 39710012Snilay@cs.wisc.edu m_IssueToInitialDelayHist[respondingMach]->sample( 3989773Snilay@cs.wisc.edu initialRequestTime - issuedTime); 39910012Snilay@cs.wisc.edu m_InitialToForwardDelayHist[respondingMach]->sample( 4009773Snilay@cs.wisc.edu forwardRequestTime - initialRequestTime); 40110012Snilay@cs.wisc.edu m_ForwardToFirstResponseDelayHist[respondingMach]->sample( 4029773Snilay@cs.wisc.edu firstResponseTime - forwardRequestTime); 40310012Snilay@cs.wisc.edu m_FirstResponseToCompletionDelayHist[respondingMach]->sample( 4049773Snilay@cs.wisc.edu completionTime - firstResponseTime); 4059773Snilay@cs.wisc.edu } else { 4069773Snilay@cs.wisc.edu m_IncompleteTimes[respondingMach]++; 4079773Snilay@cs.wisc.edu } 4089773Snilay@cs.wisc.edu } 4099773Snilay@cs.wisc.edu } else { 41010012Snilay@cs.wisc.edu m_hitLatencyHist.sample(cycles); 41110012Snilay@cs.wisc.edu m_hitTypeLatencyHist[type]->sample(cycles); 4129773Snilay@cs.wisc.edu 4139773Snilay@cs.wisc.edu if (respondingMach != MachineType_NUM) { 41410012Snilay@cs.wisc.edu m_hitMachLatencyHist[respondingMach]->sample(cycles); 41510012Snilay@cs.wisc.edu m_hitTypeMachLatencyHist[type][respondingMach]->sample(cycles); 4169773Snilay@cs.wisc.edu } 4179773Snilay@cs.wisc.edu } 4187546SBrad.Beckmann@amd.com} 4197546SBrad.Beckmann@amd.com 4207546SBrad.Beckmann@amd.comvoid 4219773Snilay@cs.wisc.eduSequencer::writeCallback(const Address& address, DataBlock& data, 4229773Snilay@cs.wisc.edu const bool externalHit, const MachineType mach, 4239773Snilay@cs.wisc.edu const Cycles initialRequestTime, 4249773Snilay@cs.wisc.edu const Cycles forwardRequestTime, 4259773Snilay@cs.wisc.edu const Cycles firstResponseTime) 4267565SBrad.Beckmann@amd.com{ 4277039Snate@binkert.org assert(address == line_address(address)); 4287455Snate@binkert.org assert(m_writeRequestTable.count(line_address(address))); 4296145Snate@binkert.org 4307455Snate@binkert.org RequestTable::iterator i = m_writeRequestTable.find(address); 4317455Snate@binkert.org assert(i != m_writeRequestTable.end()); 4327455Snate@binkert.org SequencerRequest* request = i->second; 4336145Snate@binkert.org 4347455Snate@binkert.org m_writeRequestTable.erase(i); 4357455Snate@binkert.org markRemoved(); 4366846Spdudnik@cs.wisc.edu 4378615Snilay@cs.wisc.edu assert((request->m_type == RubyRequestType_ST) || 4388615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_ATOMIC) || 4398615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_RMW_Read) || 4408615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_RMW_Write) || 4418615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_Load_Linked) || 4428615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_Store_Conditional) || 4438615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_Locked_RMW_Read) || 4448615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_Locked_RMW_Write) || 4458615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_FLUSH)); 4468184Ssomayeh@cs.wisc.edu 4477550SBrad.Beckmann@amd.com // 4487550SBrad.Beckmann@amd.com // For Alpha, properly handle LL, SC, and write requests with respect to 4497550SBrad.Beckmann@amd.com // locked cache blocks. 4507550SBrad.Beckmann@amd.com // 4518171Stushar@csail.mit.edu // Not valid for Network_test protocl 4528171Stushar@csail.mit.edu // 4538171Stushar@csail.mit.edu bool success = true; 4548171Stushar@csail.mit.edu if(!m_usingNetworkTester) 4558171Stushar@csail.mit.edu success = handleLlsc(address, request); 4567550SBrad.Beckmann@amd.com 4578615Snilay@cs.wisc.edu if (request->m_type == RubyRequestType_Locked_RMW_Read) { 4587039Snate@binkert.org m_controller->blockOnQueue(address, m_mandatory_q_ptr); 4598615Snilay@cs.wisc.edu } else if (request->m_type == RubyRequestType_Locked_RMW_Write) { 4607039Snate@binkert.org m_controller->unblock(address); 4617039Snate@binkert.org } 4626863Sdrh5@cs.wisc.edu 4639773Snilay@cs.wisc.edu hitCallback(request, data, success, mach, externalHit, 4647565SBrad.Beckmann@amd.com initialRequestTime, forwardRequestTime, firstResponseTime); 4656145Snate@binkert.org} 4666145Snate@binkert.org 4677039Snate@binkert.orgvoid 4689773Snilay@cs.wisc.eduSequencer::readCallback(const Address& address, DataBlock& data, 4699773Snilay@cs.wisc.edu bool externalHit, const MachineType mach, 4709507Snilay@cs.wisc.edu Cycles initialRequestTime, 4719507Snilay@cs.wisc.edu Cycles forwardRequestTime, 4729507Snilay@cs.wisc.edu Cycles firstResponseTime) 4737565SBrad.Beckmann@amd.com{ 4747039Snate@binkert.org assert(address == line_address(address)); 4757455Snate@binkert.org assert(m_readRequestTable.count(line_address(address))); 4766145Snate@binkert.org 4777455Snate@binkert.org RequestTable::iterator i = m_readRequestTable.find(address); 4787455Snate@binkert.org assert(i != m_readRequestTable.end()); 4797455Snate@binkert.org SequencerRequest* request = i->second; 4807455Snate@binkert.org 4817455Snate@binkert.org m_readRequestTable.erase(i); 4827455Snate@binkert.org markRemoved(); 4836145Snate@binkert.org 4848615Snilay@cs.wisc.edu assert((request->m_type == RubyRequestType_LD) || 4858615Snilay@cs.wisc.edu (request->m_type == RubyRequestType_IFETCH)); 4866285Snate@binkert.org 4879773Snilay@cs.wisc.edu hitCallback(request, data, true, mach, externalHit, 4887565SBrad.Beckmann@amd.com initialRequestTime, forwardRequestTime, firstResponseTime); 4896145Snate@binkert.org} 4906145Snate@binkert.org 4917039Snate@binkert.orgvoid 4929773Snilay@cs.wisc.eduSequencer::hitCallback(SequencerRequest* srequest, DataBlock& data, 4939773Snilay@cs.wisc.edu bool llscSuccess, 4949773Snilay@cs.wisc.edu const MachineType mach, const bool externalHit, 4959773Snilay@cs.wisc.edu const Cycles initialRequestTime, 4969773Snilay@cs.wisc.edu const Cycles forwardRequestTime, 4979773Snilay@cs.wisc.edu const Cycles firstResponseTime) 4987039Snate@binkert.org{ 4998615Snilay@cs.wisc.edu PacketPtr pkt = srequest->pkt; 5008615Snilay@cs.wisc.edu Address request_address(pkt->getAddr()); 5018615Snilay@cs.wisc.edu Address request_line_address(pkt->getAddr()); 5027039Snate@binkert.org request_line_address.makeLineAddress(); 5038615Snilay@cs.wisc.edu RubyRequestType type = srequest->m_type; 5049507Snilay@cs.wisc.edu Cycles issued_time = srequest->issue_time; 5056145Snate@binkert.org 5067039Snate@binkert.org // Set this cache entry to the most recently used 5077039Snate@binkert.org if (type == RubyRequestType_IFETCH) { 5088828Snilay@cs.wisc.edu m_instCache_ptr->setMRU(request_line_address); 5097039Snate@binkert.org } else { 5108828Snilay@cs.wisc.edu m_dataCache_ptr->setMRU(request_line_address); 5117039Snate@binkert.org } 5126145Snate@binkert.org 5139465Snilay@cs.wisc.edu assert(curCycle() >= issued_time); 5149773Snilay@cs.wisc.edu Cycles total_latency = curCycle() - issued_time; 5156145Snate@binkert.org 5169773Snilay@cs.wisc.edu // Profile the latency for all demand accesses. 5179773Snilay@cs.wisc.edu recordMissLatency(total_latency, type, mach, externalHit, issued_time, 5189773Snilay@cs.wisc.edu initialRequestTime, forwardRequestTime, 5199773Snilay@cs.wisc.edu firstResponseTime, curCycle()); 5206285Snate@binkert.org 5219773Snilay@cs.wisc.edu DPRINTFR(ProtocolTrace, "%15s %3s %10s%20s %6s>%-6s %s %d cycles\n", 5229773Snilay@cs.wisc.edu curTick(), m_version, "Seq", 5239773Snilay@cs.wisc.edu llscSuccess ? "Done" : "SC_Failed", "", "", 5249773Snilay@cs.wisc.edu request_address, total_latency); 5256285Snate@binkert.org 52610562Sandreas.hansson@arm.com // update the data unless it is a non-data-carrying flush 52710837Sjthestness@gmail.com if (RubySystem::getWarmupEnabled()) { 52810563Sandreas.hansson@arm.com data.setData(pkt->getConstPtr<uint8_t>(), 5298688Snilay@cs.wisc.edu request_address.getOffset(), pkt->getSize()); 53010562Sandreas.hansson@arm.com } else if (!pkt->isFlush()) { 5317039Snate@binkert.org if ((type == RubyRequestType_LD) || 5327039Snate@binkert.org (type == RubyRequestType_IFETCH) || 5337039Snate@binkert.org (type == RubyRequestType_RMW_Read) || 5347908Shestness@cs.utexas.edu (type == RubyRequestType_Locked_RMW_Read) || 5357907Shestness@cs.utexas.edu (type == RubyRequestType_Load_Linked)) { 53610562Sandreas.hansson@arm.com memcpy(pkt->getPtr<uint8_t>(), 5378615Snilay@cs.wisc.edu data.getData(request_address.getOffset(), pkt->getSize()), 5388615Snilay@cs.wisc.edu pkt->getSize()); 53910954SBrad.Beckmann@amd.com DPRINTF(RubySequencer, "read data %s\n", data); 5407039Snate@binkert.org } else { 54110563Sandreas.hansson@arm.com data.setData(pkt->getConstPtr<uint8_t>(), 5428615Snilay@cs.wisc.edu request_address.getOffset(), pkt->getSize()); 54310954SBrad.Beckmann@amd.com DPRINTF(RubySequencer, "set data %s\n", data); 5447039Snate@binkert.org } 5457039Snate@binkert.org } 5467023SBrad.Beckmann@amd.com 5477039Snate@binkert.org // If using the RubyTester, update the RubyTester sender state's 5487039Snate@binkert.org // subBlock with the recieved data. The tester will later access 5497039Snate@binkert.org // this state. 5507039Snate@binkert.org if (m_usingRubyTester) { 55110657Sandreas.hansson@arm.com DPRINTF(RubySequencer, "hitCallback %s 0x%x using RubyTester\n", 55210657Sandreas.hansson@arm.com pkt->cmdString(), pkt->getAddr()); 5537039Snate@binkert.org RubyTester::SenderState* testerSenderState = 55410089Sandreas.hansson@arm.com pkt->findNextSenderState<RubyTester::SenderState>(); 55510089Sandreas.hansson@arm.com assert(testerSenderState); 5569542Sandreas.hansson@arm.com testerSenderState->subBlock.mergeFrom(data); 5577039Snate@binkert.org } 5587023SBrad.Beckmann@amd.com 5597039Snate@binkert.org delete srequest; 5608688Snilay@cs.wisc.edu 56110919Sbrandon.potter@amd.com RubySystem *rs = m_ruby_system; 56210837Sjthestness@gmail.com if (RubySystem::getWarmupEnabled()) { 5639632Sjthestness@gmail.com assert(pkt->req); 5649632Sjthestness@gmail.com delete pkt->req; 5658688Snilay@cs.wisc.edu delete pkt; 56610919Sbrandon.potter@amd.com rs->m_cache_recorder->enqueueNextFetchRequest(); 56710837Sjthestness@gmail.com } else if (RubySystem::getCooldownEnabled()) { 5688688Snilay@cs.wisc.edu delete pkt; 56910919Sbrandon.potter@amd.com rs->m_cache_recorder->enqueueNextFlushRequest(); 5708688Snilay@cs.wisc.edu } else { 5718688Snilay@cs.wisc.edu ruby_hit_callback(pkt); 5728688Snilay@cs.wisc.edu } 5736285Snate@binkert.org} 5746285Snate@binkert.org 5757039Snate@binkert.orgbool 5767039Snate@binkert.orgSequencer::empty() const 5777039Snate@binkert.org{ 5787455Snate@binkert.org return m_writeRequestTable.empty() && m_readRequestTable.empty(); 5796145Snate@binkert.org} 5806145Snate@binkert.org 5817039Snate@binkert.orgRequestStatus 5828615Snilay@cs.wisc.eduSequencer::makeRequest(PacketPtr pkt) 5837039Snate@binkert.org{ 5848615Snilay@cs.wisc.edu if (m_outstanding_count >= m_max_outstanding_requests) { 5858615Snilay@cs.wisc.edu return RequestStatus_BufferFull; 5868615Snilay@cs.wisc.edu } 5878615Snilay@cs.wisc.edu 5888615Snilay@cs.wisc.edu RubyRequestType primary_type = RubyRequestType_NULL; 5898615Snilay@cs.wisc.edu RubyRequestType secondary_type = RubyRequestType_NULL; 5908615Snilay@cs.wisc.edu 5918615Snilay@cs.wisc.edu if (pkt->isLLSC()) { 5928615Snilay@cs.wisc.edu // 5938615Snilay@cs.wisc.edu // Alpha LL/SC instructions need to be handled carefully by the cache 5948615Snilay@cs.wisc.edu // coherence protocol to ensure they follow the proper semantics. In 5958615Snilay@cs.wisc.edu // particular, by identifying the operations as atomic, the protocol 5968615Snilay@cs.wisc.edu // should understand that migratory sharing optimizations should not 5978615Snilay@cs.wisc.edu // be performed (i.e. a load between the LL and SC should not steal 5988615Snilay@cs.wisc.edu // away exclusive permission). 5998615Snilay@cs.wisc.edu // 6008615Snilay@cs.wisc.edu if (pkt->isWrite()) { 6018615Snilay@cs.wisc.edu DPRINTF(RubySequencer, "Issuing SC\n"); 6028615Snilay@cs.wisc.edu primary_type = RubyRequestType_Store_Conditional; 6038615Snilay@cs.wisc.edu } else { 6048615Snilay@cs.wisc.edu DPRINTF(RubySequencer, "Issuing LL\n"); 6058615Snilay@cs.wisc.edu assert(pkt->isRead()); 6068615Snilay@cs.wisc.edu primary_type = RubyRequestType_Load_Linked; 6078615Snilay@cs.wisc.edu } 6088615Snilay@cs.wisc.edu secondary_type = RubyRequestType_ATOMIC; 60910760Ssteve.reinhardt@amd.com } else if (pkt->req->isLockedRMW()) { 6108615Snilay@cs.wisc.edu // 6118615Snilay@cs.wisc.edu // x86 locked instructions are translated to store cache coherence 6128615Snilay@cs.wisc.edu // requests because these requests should always be treated as read 6138615Snilay@cs.wisc.edu // exclusive operations and should leverage any migratory sharing 6148615Snilay@cs.wisc.edu // optimization built into the protocol. 6158615Snilay@cs.wisc.edu // 6168615Snilay@cs.wisc.edu if (pkt->isWrite()) { 6178615Snilay@cs.wisc.edu DPRINTF(RubySequencer, "Issuing Locked RMW Write\n"); 6188615Snilay@cs.wisc.edu primary_type = RubyRequestType_Locked_RMW_Write; 6198615Snilay@cs.wisc.edu } else { 6208615Snilay@cs.wisc.edu DPRINTF(RubySequencer, "Issuing Locked RMW Read\n"); 6218615Snilay@cs.wisc.edu assert(pkt->isRead()); 6228615Snilay@cs.wisc.edu primary_type = RubyRequestType_Locked_RMW_Read; 6238615Snilay@cs.wisc.edu } 6248615Snilay@cs.wisc.edu secondary_type = RubyRequestType_ST; 6258615Snilay@cs.wisc.edu } else { 6268615Snilay@cs.wisc.edu if (pkt->isRead()) { 6278615Snilay@cs.wisc.edu if (pkt->req->isInstFetch()) { 6288615Snilay@cs.wisc.edu primary_type = secondary_type = RubyRequestType_IFETCH; 6298615Snilay@cs.wisc.edu } else { 6308615Snilay@cs.wisc.edu bool storeCheck = false; 63110467Sandreas.hansson@arm.com // only X86 need the store check 63210467Sandreas.hansson@arm.com if (system->getArch() == Arch::X86ISA) { 63310467Sandreas.hansson@arm.com uint32_t flags = pkt->req->getFlags(); 63410467Sandreas.hansson@arm.com storeCheck = flags & 63510467Sandreas.hansson@arm.com (X86ISA::StoreCheck << X86ISA::FlagShift); 63610467Sandreas.hansson@arm.com } 6378615Snilay@cs.wisc.edu if (storeCheck) { 6388615Snilay@cs.wisc.edu primary_type = RubyRequestType_RMW_Read; 6398615Snilay@cs.wisc.edu secondary_type = RubyRequestType_ST; 6408615Snilay@cs.wisc.edu } else { 6418615Snilay@cs.wisc.edu primary_type = secondary_type = RubyRequestType_LD; 6428615Snilay@cs.wisc.edu } 6438615Snilay@cs.wisc.edu } 6448615Snilay@cs.wisc.edu } else if (pkt->isWrite()) { 6458615Snilay@cs.wisc.edu // 6468615Snilay@cs.wisc.edu // Note: M5 packets do not differentiate ST from RMW_Write 6478615Snilay@cs.wisc.edu // 6488615Snilay@cs.wisc.edu primary_type = secondary_type = RubyRequestType_ST; 6498615Snilay@cs.wisc.edu } else if (pkt->isFlush()) { 6508615Snilay@cs.wisc.edu primary_type = secondary_type = RubyRequestType_FLUSH; 6518615Snilay@cs.wisc.edu } else { 6528615Snilay@cs.wisc.edu panic("Unsupported ruby packet type\n"); 6538615Snilay@cs.wisc.edu } 6548615Snilay@cs.wisc.edu } 6558615Snilay@cs.wisc.edu 6568615Snilay@cs.wisc.edu RequestStatus status = insertRequest(pkt, primary_type); 6577039Snate@binkert.org if (status != RequestStatus_Ready) 6587039Snate@binkert.org return status; 6596349Spdudnik@gmail.com 6608615Snilay@cs.wisc.edu issueRequest(pkt, secondary_type); 6616145Snate@binkert.org 6627039Snate@binkert.org // TODO: issue hardware prefetches here 6637039Snate@binkert.org return RequestStatus_Issued; 6646145Snate@binkert.org} 6656145Snate@binkert.org 6667039Snate@binkert.orgvoid 6678615Snilay@cs.wisc.eduSequencer::issueRequest(PacketPtr pkt, RubyRequestType secondary_type) 6687039Snate@binkert.org{ 6699216Sandreas.hansson@arm.com assert(pkt != NULL); 6708615Snilay@cs.wisc.edu int proc_id = -1; 6719216Sandreas.hansson@arm.com if (pkt->req->hasContextId()) { 6728615Snilay@cs.wisc.edu proc_id = pkt->req->contextId(); 6737039Snate@binkert.org } 6746285Snate@binkert.org 6758615Snilay@cs.wisc.edu // If valid, copy the pc to the ruby request 6768615Snilay@cs.wisc.edu Addr pc = 0; 6778615Snilay@cs.wisc.edu if (pkt->req->hasPC()) { 6788615Snilay@cs.wisc.edu pc = pkt->req->getPC(); 6797039Snate@binkert.org } 6806285Snate@binkert.org 68110562Sandreas.hansson@arm.com // check if the packet has data as for example prefetch and flush 68210562Sandreas.hansson@arm.com // requests do not 68310472Sandreas.hansson@arm.com std::shared_ptr<RubyRequest> msg = 68410472Sandreas.hansson@arm.com std::make_shared<RubyRequest>(clockEdge(), pkt->getAddr(), 68510562Sandreas.hansson@arm.com pkt->isFlush() ? 68610562Sandreas.hansson@arm.com nullptr : pkt->getPtr<uint8_t>(), 68710472Sandreas.hansson@arm.com pkt->getSize(), pc, secondary_type, 68810472Sandreas.hansson@arm.com RubyAccessMode_Supervisor, pkt, 68910472Sandreas.hansson@arm.com PrefetchBit_No, proc_id); 6906285Snate@binkert.org 6918266Sksewell@umich.edu DPRINTFR(ProtocolTrace, "%15s %3s %10s%20s %6s>%-6s %s %s\n", 6928266Sksewell@umich.edu curTick(), m_version, "Seq", "Begin", "", "", 6938615Snilay@cs.wisc.edu msg->getPhysicalAddress(), 6948615Snilay@cs.wisc.edu RubyRequestType_to_string(secondary_type)); 6956285Snate@binkert.org 6969499Snilay@cs.wisc.edu Cycles latency(0); // initialzed to an null value 6976285Snate@binkert.org 6988615Snilay@cs.wisc.edu if (secondary_type == RubyRequestType_IFETCH) 6997039Snate@binkert.org latency = m_instCache_ptr->getLatency(); 7007039Snate@binkert.org else 7017039Snate@binkert.org latency = m_dataCache_ptr->getLatency(); 7026285Snate@binkert.org 7037039Snate@binkert.org // Send the message to the cache controller 7047039Snate@binkert.org assert(latency > 0); 7056145Snate@binkert.org 7067039Snate@binkert.org assert(m_mandatory_q_ptr != NULL); 7077039Snate@binkert.org m_mandatory_q_ptr->enqueue(msg, latency); 7086145Snate@binkert.org} 7096145Snate@binkert.org 7107455Snate@binkert.orgtemplate <class KEY, class VALUE> 7117455Snate@binkert.orgstd::ostream & 7127455Snate@binkert.orgoperator<<(ostream &out, const m5::hash_map<KEY, VALUE> &map) 7137455Snate@binkert.org{ 7147455Snate@binkert.org typename m5::hash_map<KEY, VALUE>::const_iterator i = map.begin(); 7157455Snate@binkert.org typename m5::hash_map<KEY, VALUE>::const_iterator end = map.end(); 7167455Snate@binkert.org 7177455Snate@binkert.org out << "["; 7187455Snate@binkert.org for (; i != end; ++i) 7197455Snate@binkert.org out << " " << i->first << "=" << i->second; 7207455Snate@binkert.org out << " ]"; 7217455Snate@binkert.org 7227455Snate@binkert.org return out; 7237455Snate@binkert.org} 7247455Snate@binkert.org 7257039Snate@binkert.orgvoid 7267039Snate@binkert.orgSequencer::print(ostream& out) const 7277039Snate@binkert.org{ 7287039Snate@binkert.org out << "[Sequencer: " << m_version 7297039Snate@binkert.org << ", outstanding requests: " << m_outstanding_count 7307039Snate@binkert.org << ", read request table: " << m_readRequestTable 7317039Snate@binkert.org << ", write request table: " << m_writeRequestTable 7327039Snate@binkert.org << "]"; 7337039Snate@binkert.org} 7347039Snate@binkert.org 7357039Snate@binkert.org// this can be called from setState whenever coherence permissions are 7367039Snate@binkert.org// upgraded when invoked, coherence violations will be checked for the 7377039Snate@binkert.org// given block 7387039Snate@binkert.orgvoid 7397039Snate@binkert.orgSequencer::checkCoherence(const Address& addr) 7407039Snate@binkert.org{ 7416145Snate@binkert.org#ifdef CHECK_COHERENCE 74210919Sbrandon.potter@amd.com m_ruby_system->checkGlobalCoherenceInvariant(addr); 7436145Snate@binkert.org#endif 7446145Snate@binkert.org} 7458717Snilay@cs.wisc.edu 7468717Snilay@cs.wisc.eduvoid 7479104Shestness@cs.utexas.eduSequencer::recordRequestType(SequencerRequestType requestType) { 7489104Shestness@cs.utexas.edu DPRINTF(RubyStats, "Recorded statistic: %s\n", 7499104Shestness@cs.utexas.edu SequencerRequestType_to_string(requestType)); 7509104Shestness@cs.utexas.edu} 7519104Shestness@cs.utexas.edu 7529104Shestness@cs.utexas.edu 7539104Shestness@cs.utexas.eduvoid 7548717Snilay@cs.wisc.eduSequencer::evictionCallback(const Address& address) 7558717Snilay@cs.wisc.edu{ 7568717Snilay@cs.wisc.edu ruby_eviction_callback(address); 7578717Snilay@cs.wisc.edu} 75810012Snilay@cs.wisc.edu 75910012Snilay@cs.wisc.eduvoid 76010012Snilay@cs.wisc.eduSequencer::regStats() 76110012Snilay@cs.wisc.edu{ 76210012Snilay@cs.wisc.edu m_store_waiting_on_load 76310012Snilay@cs.wisc.edu .name(name() + ".store_waiting_on_load") 76410012Snilay@cs.wisc.edu .desc("Number of times a store aliased with a pending load") 76510012Snilay@cs.wisc.edu .flags(Stats::nozero); 76610012Snilay@cs.wisc.edu m_store_waiting_on_store 76710012Snilay@cs.wisc.edu .name(name() + ".store_waiting_on_store") 76810012Snilay@cs.wisc.edu .desc("Number of times a store aliased with a pending store") 76910012Snilay@cs.wisc.edu .flags(Stats::nozero); 77010012Snilay@cs.wisc.edu m_load_waiting_on_load 77110012Snilay@cs.wisc.edu .name(name() + ".load_waiting_on_load") 77210012Snilay@cs.wisc.edu .desc("Number of times a load aliased with a pending load") 77310012Snilay@cs.wisc.edu .flags(Stats::nozero); 77410012Snilay@cs.wisc.edu m_load_waiting_on_store 77510012Snilay@cs.wisc.edu .name(name() + ".load_waiting_on_store") 77610012Snilay@cs.wisc.edu .desc("Number of times a load aliased with a pending store") 77710012Snilay@cs.wisc.edu .flags(Stats::nozero); 77810012Snilay@cs.wisc.edu 77910012Snilay@cs.wisc.edu // These statistical variables are not for display. 78010012Snilay@cs.wisc.edu // The profiler will collate these across different 78110012Snilay@cs.wisc.edu // sequencers and display those collated statistics. 78210012Snilay@cs.wisc.edu m_outstandReqHist.init(10); 78310012Snilay@cs.wisc.edu m_latencyHist.init(10); 78410012Snilay@cs.wisc.edu m_hitLatencyHist.init(10); 78510012Snilay@cs.wisc.edu m_missLatencyHist.init(10); 78610012Snilay@cs.wisc.edu 78710012Snilay@cs.wisc.edu for (int i = 0; i < RubyRequestType_NUM; i++) { 78810012Snilay@cs.wisc.edu m_typeLatencyHist.push_back(new Stats::Histogram()); 78910012Snilay@cs.wisc.edu m_typeLatencyHist[i]->init(10); 79010012Snilay@cs.wisc.edu 79110012Snilay@cs.wisc.edu m_hitTypeLatencyHist.push_back(new Stats::Histogram()); 79210012Snilay@cs.wisc.edu m_hitTypeLatencyHist[i]->init(10); 79310012Snilay@cs.wisc.edu 79410012Snilay@cs.wisc.edu m_missTypeLatencyHist.push_back(new Stats::Histogram()); 79510012Snilay@cs.wisc.edu m_missTypeLatencyHist[i]->init(10); 79610012Snilay@cs.wisc.edu } 79710012Snilay@cs.wisc.edu 79810012Snilay@cs.wisc.edu for (int i = 0; i < MachineType_NUM; i++) { 79910012Snilay@cs.wisc.edu m_hitMachLatencyHist.push_back(new Stats::Histogram()); 80010012Snilay@cs.wisc.edu m_hitMachLatencyHist[i]->init(10); 80110012Snilay@cs.wisc.edu 80210012Snilay@cs.wisc.edu m_missMachLatencyHist.push_back(new Stats::Histogram()); 80310012Snilay@cs.wisc.edu m_missMachLatencyHist[i]->init(10); 80410012Snilay@cs.wisc.edu 80510012Snilay@cs.wisc.edu m_IssueToInitialDelayHist.push_back(new Stats::Histogram()); 80610012Snilay@cs.wisc.edu m_IssueToInitialDelayHist[i]->init(10); 80710012Snilay@cs.wisc.edu 80810012Snilay@cs.wisc.edu m_InitialToForwardDelayHist.push_back(new Stats::Histogram()); 80910012Snilay@cs.wisc.edu m_InitialToForwardDelayHist[i]->init(10); 81010012Snilay@cs.wisc.edu 81110012Snilay@cs.wisc.edu m_ForwardToFirstResponseDelayHist.push_back(new Stats::Histogram()); 81210012Snilay@cs.wisc.edu m_ForwardToFirstResponseDelayHist[i]->init(10); 81310012Snilay@cs.wisc.edu 81410012Snilay@cs.wisc.edu m_FirstResponseToCompletionDelayHist.push_back(new Stats::Histogram()); 81510012Snilay@cs.wisc.edu m_FirstResponseToCompletionDelayHist[i]->init(10); 81610012Snilay@cs.wisc.edu } 81710012Snilay@cs.wisc.edu 81810012Snilay@cs.wisc.edu for (int i = 0; i < RubyRequestType_NUM; i++) { 81910012Snilay@cs.wisc.edu m_hitTypeMachLatencyHist.push_back(std::vector<Stats::Histogram *>()); 82010012Snilay@cs.wisc.edu m_missTypeMachLatencyHist.push_back(std::vector<Stats::Histogram *>()); 82110012Snilay@cs.wisc.edu 82210012Snilay@cs.wisc.edu for (int j = 0; j < MachineType_NUM; j++) { 82310012Snilay@cs.wisc.edu m_hitTypeMachLatencyHist[i].push_back(new Stats::Histogram()); 82410012Snilay@cs.wisc.edu m_hitTypeMachLatencyHist[i][j]->init(10); 82510012Snilay@cs.wisc.edu 82610012Snilay@cs.wisc.edu m_missTypeMachLatencyHist[i].push_back(new Stats::Histogram()); 82710012Snilay@cs.wisc.edu m_missTypeMachLatencyHist[i][j]->init(10); 82810012Snilay@cs.wisc.edu } 82910012Snilay@cs.wisc.edu } 83010012Snilay@cs.wisc.edu} 831