diff -r eb00b7a967bb -r bd183992b333 src/mem/protocol/MI_example-cache.sm --- a/src/mem/protocol/MI_example-cache.sm Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/protocol/MI_example-cache.sm Tue Jun 04 18:19:26 2013 -0500 @@ -176,18 +176,6 @@ return getCacheEntry(addr).DataBlk; } - GenericMachineType getNondirectHitMachType(MachineID sender) { - if (machineIDToMachineType(sender) == MachineType:L1Cache) { - // - // NOTE direct local hits should not call this - // - return GenericMachineType:L1Cache_wCC; - } else { - return ConvertMachToGenericMach(machineIDToMachineType(sender)); - } - } - - // NETWORK PORTS out_port(requestNetwork_out, RequestMsg, requestFromCache); @@ -346,36 +334,30 @@ action(r_load_hit, "r", desc="Notify sequencer the load completed.") { assert(is_valid(cache_entry)); DPRINTF(RubySlicc,"%s\n", cache_entry.DataBlk); - sequencer.readCallback(address, - GenericMachineType:L1Cache, - cache_entry.DataBlk); + sequencer.readCallback(address, cache_entry.DataBlk, MachineType:L1Cache); } action(rx_load_hit, "rx", desc="External load completed.") { peek(responseNetwork_in, ResponseMsg) { assert(is_valid(cache_entry)); DPRINTF(RubySlicc,"%s\n", cache_entry.DataBlk); - sequencer.readCallback(address, - getNondirectHitMachType(in_msg.Sender), - cache_entry.DataBlk); + sequencer.readCallback(address, cache_entry.DataBlk, + machineIDToMachineType(in_msg.Sender), true); } } action(s_store_hit, "s", desc="Notify sequencer that store completed.") { assert(is_valid(cache_entry)); DPRINTF(RubySlicc,"%s\n", cache_entry.DataBlk); - sequencer.writeCallback(address, - GenericMachineType:L1Cache, - cache_entry.DataBlk); + sequencer.writeCallback(address, cache_entry.DataBlk, MachineType:L1Cache); } action(sx_store_hit, "sx", desc="External store completed.") { peek(responseNetwork_in, ResponseMsg) { assert(is_valid(cache_entry)); DPRINTF(RubySlicc,"%s\n", cache_entry.DataBlk); - sequencer.writeCallback(address, - getNondirectHitMachType(in_msg.Sender), - cache_entry.DataBlk); + sequencer.writeCallback(address, cache_entry.DataBlk, + machineIDToMachineType(in_msg.Sender), true); } } diff -r eb00b7a967bb -r bd183992b333 src/mem/protocol/MOESI_CMP_token-L1cache.sm --- a/src/mem/protocol/MOESI_CMP_token-L1cache.sm Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/protocol/MOESI_CMP_token-L1cache.sm Tue Jun 04 18:19:26 2013 -0500 @@ -399,26 +399,21 @@ } } - GenericMachineType getNondirectHitMachType(Address addr, MachineID sender) { + // NOTE: direct local hits should not call this function + bool isExternalHit(Address addr, MachineID sender) { if (machineIDToMachineType(sender) == MachineType:L1Cache) { - // - // NOTE direct local hits should not call this - // - return GenericMachineType:L1Cache_wCC; + return true; } else if (machineIDToMachineType(sender) == MachineType:L2Cache) { - if (sender == (mapAddressToRange(addr, - MachineType:L2Cache, - l2_select_low_bit, - l2_select_num_bits))) { + if (sender == mapAddressToRange(addr, MachineType:L2Cache, + l2_select_low_bit, l2_select_num_bits)) { + return false; + } else { + return true; + } + } - return GenericMachineType:L2Cache; - } else { - return GenericMachineType:L2Cache_wCC; - } - } else { - return ConvertMachToGenericMach(machineIDToMachineType(sender)); - } + return true; } bool okToIssueStarving(Address addr, MachineID machinID) { @@ -1289,10 +1284,8 @@ DPRINTF(RubySlicc, "Address: %s, Data Block: %s\n", address, cache_entry.DataBlk); - sequencer.readCallback(address, - GenericMachineType:L1Cache, - cache_entry.DataBlk); - + sequencer.readCallback(address, cache_entry.DataBlk, + MachineType:L1Cache, false); } action(x_external_load_hit, "x", desc="Notify sequencer the load completed.") { @@ -1300,11 +1293,9 @@ DPRINTF(RubySlicc, "Address: %s, Data Block: %s\n", address, cache_entry.DataBlk); peek(responseNetwork_in, ResponseMsg) { - - sequencer.readCallback(address, - getNondirectHitMachType(address, in_msg.Sender), - cache_entry.DataBlk); - + sequencer.readCallback(address, cache_entry.DataBlk, + machineIDToMachineType(in_msg.Sender), + isExternalHit(address, in_msg.Sender)); } } @@ -1313,10 +1304,8 @@ DPRINTF(RubySlicc, "Address: %s, Data Block: %s\n", address, cache_entry.DataBlk); - sequencer.writeCallback(address, - GenericMachineType:L1Cache, - cache_entry.DataBlk); - + sequencer.writeCallback(address, cache_entry.DataBlk, + MachineType:L1Cache, false); cache_entry.Dirty := true; DPRINTF(RubySlicc, "%s\n", cache_entry.DataBlk); } @@ -1326,11 +1315,9 @@ DPRINTF(RubySlicc, "Address: %s, Data Block: %s\n", address, cache_entry.DataBlk); peek(responseNetwork_in, ResponseMsg) { - - sequencer.writeCallback(address, - getNondirectHitMachType(address, in_msg.Sender), - cache_entry.DataBlk); - + sequencer.writeCallback(address, cache_entry.DataBlk, + machineIDToMachineType(in_msg.Sender), + isExternalHit(address, in_msg.Sender)); } cache_entry.Dirty := true; DPRINTF(RubySlicc, "%s\n", cache_entry.DataBlk); diff -r eb00b7a967bb -r bd183992b333 src/mem/protocol/MOESI_hammer-cache.sm --- a/src/mem/protocol/MOESI_hammer-cache.sm Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/protocol/MOESI_hammer-cache.sm Tue Jun 04 18:19:26 2013 -0500 @@ -33,7 +33,7 @@ * Brad Beckmann */ -machine(L1Cache, "AMD Hammer-like protocol") +machine({L1Cache, L2Cache}, "AMD Hammer-like protocol") : Sequencer * sequencer, CacheMemory * L1Icache, CacheMemory * L1Dcache, @@ -288,24 +288,12 @@ } } - GenericMachineType getNondirectHitMachType(Address addr, MachineID sender) { - if (machineIDToMachineType(sender) == MachineType:L1Cache) { - // - // NOTE direct local hits should not call this - // - return GenericMachineType:L1Cache_wCC; - } else { - return ConvertMachToGenericMach(machineIDToMachineType(sender)); - } - } - - GenericMachineType testAndClearLocalHit(Entry cache_entry) { + MachineType testAndClearLocalHit(Entry cache_entry) { if (is_valid(cache_entry) && cache_entry.FromL2) { cache_entry.FromL2 := false; - return GenericMachineType:L2Cache; - } else { - return GenericMachineType:L1Cache; + return MachineType:L2Cache; } + return MachineType:L1Cache; } bool IsAtomicAccessed(Entry cache_entry) { @@ -853,8 +841,8 @@ action(h_load_hit, "h", desc="Notify sequencer the load completed.") { assert(is_valid(cache_entry)); DPRINTF(RubySlicc, "%s\n", cache_entry.DataBlk); - sequencer.readCallback(address, testAndClearLocalHit(cache_entry), - cache_entry.DataBlk); + sequencer.readCallback(address, cache_entry.DataBlk, + testAndClearLocalHit(cache_entry), false); } action(hx_external_load_hit, "hx", desc="load required external msgs") { @@ -863,12 +851,11 @@ DPRINTF(RubySlicc, "%s\n", cache_entry.DataBlk); peek(responseToCache_in, ResponseMsg) { - sequencer.readCallback(address, - getNondirectHitMachType(in_msg.Address, in_msg.Sender), - cache_entry.DataBlk, - tbe.InitialRequestTime, - tbe.ForwardRequestTime, - tbe.FirstResponseTime); + sequencer.readCallback(address, cache_entry.DataBlk, + machineIDToMachineType(in_msg.Sender), + machineIDToMachineType(in_msg.Sender) == MachineType:L1Cache, + tbe.InitialRequestTime, tbe.ForwardRequestTime, + tbe.FirstResponseTime); } } @@ -876,8 +863,8 @@ assert(is_valid(cache_entry)); DPRINTF(RubySlicc, "%s\n", cache_entry.DataBlk); peek(mandatoryQueue_in, RubyRequest) { - sequencer.writeCallback(address, testAndClearLocalHit(cache_entry), - cache_entry.DataBlk); + sequencer.writeCallback(address, cache_entry.DataBlk, + testAndClearLocalHit(cache_entry), false); cache_entry.Dirty := true; if (in_msg.Type == RubyRequestType:ATOMIC) { @@ -889,7 +876,7 @@ action(hh_flush_hit, "\hf", desc="Notify sequencer that flush completed.") { assert(is_valid(tbe)); DPRINTF(RubySlicc, "%s\n", tbe.DataBlk); - sequencer.writeCallback(address, GenericMachineType:L1Cache,tbe.DataBlk); + sequencer.writeCallback(address, tbe.DataBlk, MachineType:L1Cache, false); } action(sx_external_store_hit, "sx", desc="store required external msgs.") { @@ -898,12 +885,11 @@ DPRINTF(RubySlicc, "%s\n", cache_entry.DataBlk); peek(responseToCache_in, ResponseMsg) { - sequencer.writeCallback(address, - getNondirectHitMachType(address, in_msg.Sender), - cache_entry.DataBlk, - tbe.InitialRequestTime, - tbe.ForwardRequestTime, - tbe.FirstResponseTime); + sequencer.writeCallback(address, cache_entry.DataBlk, + machineIDToMachineType(in_msg.Sender), + machineIDToMachineType(in_msg.Sender) == MachineType:L1Cache, + tbe.InitialRequestTime, tbe.ForwardRequestTime, + tbe.FirstResponseTime); } DPRINTF(RubySlicc, "%s\n", cache_entry.DataBlk); cache_entry.Dirty := true; @@ -914,12 +900,10 @@ assert(is_valid(tbe)); DPRINTF(RubySlicc, "%s\n", cache_entry.DataBlk); - sequencer.writeCallback(address, - getNondirectHitMachType(address, tbe.LastResponder), - cache_entry.DataBlk, - tbe.InitialRequestTime, - tbe.ForwardRequestTime, - tbe.FirstResponseTime); + sequencer.writeCallback(address, cache_entry.DataBlk, + machineIDToMachineType(tbe.LastResponder), + machineIDToMachineType(tbe.LastResponder) == MachineType:L1Cache, + tbe.InitialRequestTime, tbe.ForwardRequestTime, tbe.FirstResponseTime); cache_entry.Dirty := true; } diff -r eb00b7a967bb -r bd183992b333 src/mem/protocol/RubySlicc_ComponentMapping.sm --- a/src/mem/protocol/RubySlicc_ComponentMapping.sm Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/protocol/RubySlicc_ComponentMapping.sm Tue Jun 04 18:19:26 2013 -0500 @@ -38,4 +38,3 @@ NodeID machineIDToNodeID(MachineID machID); NodeID machineIDToVersion(MachineID machID); MachineType machineIDToMachineType(MachineID machID); -GenericMachineType ConvertMachToGenericMach(MachineType machType); diff -r eb00b7a967bb -r bd183992b333 src/mem/protocol/RubySlicc_Exports.sm --- a/src/mem/protocol/RubySlicc_Exports.sm Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/protocol/RubySlicc_Exports.sm Tue Jun 04 18:19:26 2013 -0500 @@ -168,18 +168,6 @@ Default, desc="Replace this with access_types passed to the DMA Ruby object"; } -enumeration(GenericMachineType, desc="...", default="GenericMachineType_NULL") { - L1Cache, desc="L1 Cache Mach"; - L2Cache, desc="L2 Cache Mach"; - L3Cache, desc="L3 Cache Mach"; - Directory, desc="Directory Mach"; - DMA, desc="DMA Mach"; - Collector, desc="Collector Mach"; - L1Cache_wCC, desc="L1 Cache Mach with Cache Coherence (used for miss latency profile)"; - L2Cache_wCC, desc="L1 Cache Mach with Cache Coherence (used for miss latency profile)"; - NULL, desc="null mach type"; -} - // MessageSizeType enumeration(MessageSizeType, default="MessageSizeType_Undefined", desc="...") { Undefined, desc="Undefined"; diff -r eb00b7a967bb -r bd183992b333 src/mem/protocol/RubySlicc_Types.sm --- a/src/mem/protocol/RubySlicc_Types.sm Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/protocol/RubySlicc_Types.sm Tue Jun 04 18:19:26 2013 -0500 @@ -97,17 +97,18 @@ structure (Sequencer, external = "yes") { void readCallback(Address, DataBlock); - void readCallback(Address, GenericMachineType, DataBlock); - void readCallback(Address, GenericMachineType, DataBlock, + void readCallback(Address, DataBlock, MachineType); + void readCallback(Address, DataBlock, MachineType, bool); + void readCallback(Address, DataBlock, MachineType, bool, Cycles, Cycles, Cycles); void writeCallback(Address, DataBlock); - void writeCallback(Address, GenericMachineType, DataBlock); - void writeCallback(Address, GenericMachineType, DataBlock, + void writeCallback(Address, DataBlock, MachineType); + void writeCallback(Address, DataBlock, MachineType, bool); + void writeCallback(Address, DataBlock, MachineType, bool, Cycles, Cycles, Cycles); void checkCoherence(Address); - void profileNack(Address, int, int, uint64); void evictionCallback(Address); void recordRequestType(SequencerRequestType); bool checkResourceAvailable(CacheResourceType, Address); diff -r eb00b7a967bb -r bd183992b333 src/mem/ruby/common/Histogram.cc --- a/src/mem/ruby/common/Histogram.cc Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/ruby/common/Histogram.cc Tue Jun 04 18:19:26 2013 -0500 @@ -124,7 +124,12 @@ uint32_t t_bins = m_data.size(); if (hist.getBins() != t_bins) { - fatal("Histograms with different number of bins cannot be combined!"); + if (m_count == 0) { + m_data.resize(hist.getBins()); + } else { + fatal("Histograms with different number of bins " + "cannot be combined!"); + } } m_max = max(m_max, hist.getMax()); diff -r eb00b7a967bb -r bd183992b333 src/mem/ruby/profiler/Profiler.hh --- a/src/mem/ruby/profiler/Profiler.hh Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/ruby/profiler/Profiler.hh Tue Jun 04 18:19:26 2013 -0500 @@ -52,7 +52,6 @@ #include "base/hashmap.hh" #include "mem/protocol/AccessType.hh" -#include "mem/protocol/GenericMachineType.hh" #include "mem/protocol/PrefetchBit.hh" #include "mem/protocol/RubyAccessMode.hh" #include "mem/protocol/RubyRequestType.hh" @@ -110,21 +109,7 @@ void controllerBusy(MachineID machID); void bankBusy(); - - void missLatency(Cycles t, RubyRequestType type, - const GenericMachineType respondingMach); - - void missLatencyWcc(Cycles issuedTime, Cycles initialRequestTime, - Cycles forwardRequestTime, Cycles firstResponseTime, - Cycles completionTime); - void missLatencyDir(Cycles issuedTime, Cycles initialRequestTime, - Cycles forwardRequestTime, Cycles firstResponseTime, - Cycles completionTime); - - void swPrefetchLatency(Cycles t, RubyRequestType type, - const GenericMachineType respondingMach); - void print(std::ostream& out) const; void rubyWatch(int proc); @@ -141,6 +126,7 @@ void printRequestProfile(std::ostream &out) const; void printDelayProfile(std::ostream &out) const; void printOutstandingReqProfile(std::ostream &out) const; + void printMissLatencyProfile(std::ostream &out) const; private: // Private copy constructor and assignment operator @@ -161,27 +147,6 @@ int64 m_cache_to_cache; int64 m_memory_to_cache; - std::vector m_missLatencyHistograms; - std::vector m_machLatencyHistograms; - std::vector< std::vector > m_missMachLatencyHistograms; - Histogram m_wCCIssueToInitialRequestHistogram; - Histogram m_wCCInitialRequestToForwardRequestHistogram; - Histogram m_wCCForwardRequestToFirstResponseHistogram; - Histogram m_wCCFirstResponseToCompleteHistogram; - int64 m_wCCIncompleteTimes; - Histogram m_dirIssueToInitialRequestHistogram; - Histogram m_dirInitialRequestToForwardRequestHistogram; - Histogram m_dirForwardRequestToFirstResponseHistogram; - Histogram m_dirFirstResponseToCompleteHistogram; - int64 m_dirIncompleteTimes; - - Histogram m_allMissLatencyHistogram; - - Histogram m_allSWPrefetchLatencyHistogram; - Histogram m_SWPrefetchL2MissLatencyHistogram; - std::vector m_SWPrefetchLatencyHistograms; - std::vector m_SWPrefetchMachLatencyHistograms; - Histogram m_average_latency_estimate; m5::hash_set
m_watch_address_set; diff -r eb00b7a967bb -r bd183992b333 src/mem/ruby/profiler/Profiler.cc --- a/src/mem/ruby/profiler/Profiler.cc Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/ruby/profiler/Profiler.cc Tue Jun 04 18:19:26 2013 -0500 @@ -213,6 +213,113 @@ } void +Profiler::printMissLatencyProfile(ostream &out) const +{ + // Collate the miss latencies histograms from all the + // sequencers + Histogram all_miss_latency_hist; + std::vector miss_latency_hist(RubyRequestType_NUM); + std::vector mach_latency_hist(MachineType_NUM); + std::vector > miss_mach_latency_hist( + RubyRequestType_NUM, + std::vector(MachineType_NUM)); + + std::vector issue_to_initial_delay_hist(MachineType_NUM); + std::vector initial_to_forward_delay_hist(MachineType_NUM); + std::vector forward_to_first_response_delay_hist( + MachineType_NUM); + std::vector first_response_to_completion_delay_hist( + MachineType_NUM); + std::vector incomplete_times(MachineType_NUM); + + for (uint32_t i = 0; i < MachineType_NUM; i++) { + for (map::iterator it = + g_abs_controls[i].begin(); + it != g_abs_controls[i].end(); ++it) { + + AbstractController *ctr = (*it).second; + Sequencer *seq = ctr->getSequencer(); + if (seq != NULL) { + // add all the miss latencies + all_miss_latency_hist.add(seq->getAllMissLatencyHist()); + + // add the per request type miss latencies + for (uint32_t j = 0; j < RubyRequestType_NUM; ++j) { + miss_latency_hist[j].add(seq->getMissLatencyHist(j)); + } + + // add the per machine type miss latencies + for (uint32_t j = 0; j < MachineType_NUM; ++j) { + mach_latency_hist[j].add(seq->getMachLatencyHist(j)); + issue_to_initial_delay_hist[j].add( + seq->getIssueToInitialDelayHist(MachineType(j))); + + initial_to_forward_delay_hist[j].add( + seq->getInitialToForwardDelayHist(MachineType(j))); + forward_to_first_response_delay_hist[j].add(seq-> + getForwardRequestToFirstResponseHist(MachineType(j))); + + first_response_to_completion_delay_hist[j].add(seq-> + getFirstResponseToCompletionDelayHist(MachineType(j))); + incomplete_times[j] += + seq->getIncompleteTimes(MachineType(j)); + } + + // add the per (request, machine) type miss latencies + for (uint32_t j = 0; j < RubyRequestType_NUM; j++) { + for (uint32_t k = 0; k < MachineType_NUM; k++) { + miss_mach_latency_hist[j][k].add( + seq->getMissMachLatencyHist(j,k)); + } + } + } + } + } + + out << "miss_latency: " << all_miss_latency_hist << endl; + + for (int i = 0; i < RubyRequestType_NUM; i++) { + if (miss_latency_hist[i].size() > 0) { + out << "miss_latency_" << RubyRequestType(i) << ": " + << miss_latency_hist[i] << endl; + } + } + + for (int i = 0; i < MachineType_NUM; i++) { + if (mach_latency_hist[i].size() > 0) { + out << "miss_latency_" << MachineType(i) << ": " + << mach_latency_hist[i] << endl; + + out << "miss_latency_" << MachineType(i) + << "::issue_to_initial: " + << issue_to_initial_delay_hist[i] << endl; + out << "miss_latency_" << MachineType(i) + << "::initial_to_forward: " + << initial_to_forward_delay_hist[i] << endl; + out << "miss_latency_" << MachineType(i) + << "::forward_to_first_response: " + << forward_to_first_response_delay_hist[i] << endl; + out << "miss_latency_" << MachineType(i) + << "::first_response_to_completion: " + << first_response_to_completion_delay_hist[i] << endl; + out << "incomplete_times: " << incomplete_times[i] << endl; + } + } + + for (int i = 0; i < RubyRequestType_NUM; i++) { + for (int j = 0; j < MachineType_NUM; j++) { + if (miss_mach_latency_hist[i][j].size() > 0) { + out << "miss_latency_" << RubyRequestType(i) + << "_" << MachineType(j) << ": " + << miss_mach_latency_hist[i][j] << endl; + } + } + } + + out << endl; +} + +void Profiler::printStats(ostream& out, bool short_stats) { out << endl; @@ -296,68 +403,7 @@ if (!short_stats) { out << "All Non-Zero Cycle Demand Cache Accesses" << endl; out << "----------------------------------------" << endl; - out << "miss_latency: " << m_allMissLatencyHistogram << endl; - for (int i = 0; i < m_missLatencyHistograms.size(); i++) { - if (m_missLatencyHistograms[i].size() > 0) { - out << "miss_latency_" << RubyRequestType(i) << ": " - << m_missLatencyHistograms[i] << endl; - } - } - for (int i = 0; i < m_machLatencyHistograms.size(); i++) { - if (m_machLatencyHistograms[i].size() > 0) { - out << "miss_latency_" << GenericMachineType(i) << ": " - << m_machLatencyHistograms[i] << endl; - } - } - - out << "miss_latency_wCC_issue_to_initial_request: " - << m_wCCIssueToInitialRequestHistogram << endl; - out << "miss_latency_wCC_initial_forward_request: " - << m_wCCInitialRequestToForwardRequestHistogram << endl; - out << "miss_latency_wCC_forward_to_first_response: " - << m_wCCForwardRequestToFirstResponseHistogram << endl; - out << "miss_latency_wCC_first_response_to_completion: " - << m_wCCFirstResponseToCompleteHistogram << endl; - out << "imcomplete_wCC_Times: " << m_wCCIncompleteTimes << endl; - out << "miss_latency_dir_issue_to_initial_request: " - << m_dirIssueToInitialRequestHistogram << endl; - out << "miss_latency_dir_initial_forward_request: " - << m_dirInitialRequestToForwardRequestHistogram << endl; - out << "miss_latency_dir_forward_to_first_response: " - << m_dirForwardRequestToFirstResponseHistogram << endl; - out << "miss_latency_dir_first_response_to_completion: " - << m_dirFirstResponseToCompleteHistogram << endl; - out << "imcomplete_dir_Times: " << m_dirIncompleteTimes << endl; - - for (int i = 0; i < m_missMachLatencyHistograms.size(); i++) { - for (int j = 0; j < m_missMachLatencyHistograms[i].size(); j++) { - if (m_missMachLatencyHistograms[i][j].size() > 0) { - out << "miss_latency_" << RubyRequestType(i) - << "_" << GenericMachineType(j) << ": " - << m_missMachLatencyHistograms[i][j] << endl; - } - } - } - - out << endl; - - out << "All Non-Zero Cycle SW Prefetch Requests" << endl; - out << "------------------------------------" << endl; - out << "prefetch_latency: " << m_allSWPrefetchLatencyHistogram << endl; - for (int i = 0; i < m_SWPrefetchLatencyHistograms.size(); i++) { - if (m_SWPrefetchLatencyHistograms[i].size() > 0) { - out << "prefetch_latency_" << RubyRequestType(i) << ": " - << m_SWPrefetchLatencyHistograms[i] << endl; - } - } - for (int i = 0; i < m_SWPrefetchMachLatencyHistograms.size(); i++) { - if (m_SWPrefetchMachLatencyHistograms[i].size() > 0) { - out << "prefetch_latency_" << GenericMachineType(i) << ": " - << m_SWPrefetchMachLatencyHistograms[i] << endl; - } - } - out << "prefetch_latency_L2Miss:" - << m_SWPrefetchL2MissLatencyHistogram << endl; + printMissLatencyProfile(out); if (m_all_sharing_histogram.size() > 0) { out << "all_sharing: " << m_all_sharing_histogram << endl; @@ -434,44 +480,6 @@ m_real_time_start_time = time(NULL); m_busyBankCount = 0; - - m_missLatencyHistograms.resize(RubyRequestType_NUM); - for (int i = 0; i < m_missLatencyHistograms.size(); i++) { - m_missLatencyHistograms[i].clear(200); - } - m_machLatencyHistograms.resize(GenericMachineType_NUM+1); - for (int i = 0; i < m_machLatencyHistograms.size(); i++) { - m_machLatencyHistograms[i].clear(200); - } - m_missMachLatencyHistograms.resize(RubyRequestType_NUM); - for (int i = 0; i < m_missLatencyHistograms.size(); i++) { - m_missMachLatencyHistograms[i].resize(GenericMachineType_NUM+1); - for (int j = 0; j < m_missMachLatencyHistograms[i].size(); j++) { - m_missMachLatencyHistograms[i][j].clear(200); - } - } - m_allMissLatencyHistogram.clear(200); - m_wCCIssueToInitialRequestHistogram.clear(200); - m_wCCInitialRequestToForwardRequestHistogram.clear(200); - m_wCCForwardRequestToFirstResponseHistogram.clear(200); - m_wCCFirstResponseToCompleteHistogram.clear(200); - m_wCCIncompleteTimes = 0; - m_dirIssueToInitialRequestHistogram.clear(200); - m_dirInitialRequestToForwardRequestHistogram.clear(200); - m_dirForwardRequestToFirstResponseHistogram.clear(200); - m_dirFirstResponseToCompleteHistogram.clear(200); - m_dirIncompleteTimes = 0; - - m_SWPrefetchLatencyHistograms.resize(RubyRequestType_NUM); - for (int i = 0; i < m_SWPrefetchLatencyHistograms.size(); i++) { - m_SWPrefetchLatencyHistograms[i].clear(200); - } - m_SWPrefetchMachLatencyHistograms.resize(GenericMachineType_NUM+1); - for (int i = 0; i < m_SWPrefetchMachLatencyHistograms.size(); i++) { - m_SWPrefetchMachLatencyHistograms[i].clear(200); - } - m_allSWPrefetchLatencyHistogram.clear(200); - m_read_sharing_histogram.clear(); m_write_sharing_histogram.clear(); m_all_sharing_histogram.clear(); @@ -530,85 +538,6 @@ m_busyBankCount++; } -// non-zero cycle demand request -void -Profiler::missLatency(Cycles cycles, - RubyRequestType type, - const GenericMachineType respondingMach) -{ - m_allMissLatencyHistogram.add(cycles); - m_missLatencyHistograms[type].add(cycles); - m_machLatencyHistograms[respondingMach].add(cycles); - m_missMachLatencyHistograms[type][respondingMach].add(cycles); -} - -void -Profiler::missLatencyWcc(Cycles issuedTime, - Cycles initialRequestTime, - Cycles forwardRequestTime, - Cycles firstResponseTime, - Cycles completionTime) -{ - if ((issuedTime <= initialRequestTime) && - (initialRequestTime <= forwardRequestTime) && - (forwardRequestTime <= firstResponseTime) && - (firstResponseTime <= completionTime)) { - m_wCCIssueToInitialRequestHistogram.add(initialRequestTime - issuedTime); - - m_wCCInitialRequestToForwardRequestHistogram.add(forwardRequestTime - - initialRequestTime); - - m_wCCForwardRequestToFirstResponseHistogram.add(firstResponseTime - - forwardRequestTime); - - m_wCCFirstResponseToCompleteHistogram.add(completionTime - - firstResponseTime); - } else { - m_wCCIncompleteTimes++; - } -} - -void -Profiler::missLatencyDir(Cycles issuedTime, - Cycles initialRequestTime, - Cycles forwardRequestTime, - Cycles firstResponseTime, - Cycles completionTime) -{ - if ((issuedTime <= initialRequestTime) && - (initialRequestTime <= forwardRequestTime) && - (forwardRequestTime <= firstResponseTime) && - (firstResponseTime <= completionTime)) { - m_dirIssueToInitialRequestHistogram.add(initialRequestTime - issuedTime); - - m_dirInitialRequestToForwardRequestHistogram.add(forwardRequestTime - - initialRequestTime); - - m_dirForwardRequestToFirstResponseHistogram.add(firstResponseTime - - forwardRequestTime); - - m_dirFirstResponseToCompleteHistogram.add(completionTime - - firstResponseTime); - } else { - m_dirIncompleteTimes++; - } -} - -// non-zero cycle prefetch request -void -Profiler::swPrefetchLatency(Cycles cycles, RubyRequestType type, - const GenericMachineType respondingMach) -{ - m_allSWPrefetchLatencyHistogram.add(cycles); - m_SWPrefetchLatencyHistograms[type].add(cycles); - m_SWPrefetchMachLatencyHistograms[respondingMach].add(cycles); - - if (respondingMach == GenericMachineType_Directory || - respondingMach == GenericMachineType_NUM) { - m_SWPrefetchL2MissLatencyHistogram.add(cycles); - } -} - // Helper function static double process_memory_total() diff -r eb00b7a967bb -r bd183992b333 src/mem/ruby/system/Sequencer.hh --- a/src/mem/ruby/system/Sequencer.hh Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/ruby/system/Sequencer.hh Tue Jun 04 18:19:26 2013 -0500 @@ -32,7 +32,7 @@ #include #include "base/hashmap.hh" -#include "mem/protocol/GenericMachineType.hh" +#include "mem/protocol/MachineType.hh" #include "mem/protocol/RubyRequestType.hh" #include "mem/protocol/SequencerRequestType.hh" #include "mem/ruby/common/Address.hh" @@ -65,36 +65,24 @@ // Public Methods void wakeup(); // Used only for deadlock detection - void printProgress(std::ostream& out) const; - void clearStats(); - void writeCallback(const Address& address, DataBlock& data); - void writeCallback(const Address& address, - GenericMachineType mach, - DataBlock& data); - - void writeCallback(const Address& address, - GenericMachineType mach, DataBlock& data, - Cycles initialRequestTime, - Cycles forwardRequestTime, - Cycles firstResponseTime); - - void readCallback(const Address& address, DataBlock& data); + const MachineType mach = MachineType_NUM, + const bool externalHit = false, + const Cycles initialRequestTime = Cycles(0), + const Cycles forwardRequestTime = Cycles(0), + const Cycles firstResponseTime = Cycles(0)); void readCallback(const Address& address, - GenericMachineType mach, - DataBlock& data); - - void readCallback(const Address& address, - GenericMachineType mach, DataBlock& data, - Cycles initialRequestTime, - Cycles forwardRequestTime, - Cycles firstResponseTime); + const MachineType mach = MachineType_NUM, + const bool externalHit = false, + const Cycles initialRequestTime = Cycles(0), + const Cycles forwardRequestTime = Cycles(0), + const Cycles firstResponseTime = Cycles(0)); RequestStatus makeRequest(PacketPtr pkt); bool empty() const; @@ -117,20 +105,50 @@ void recordRequestType(SequencerRequestType requestType); Histogram& getOutstandReqHist() { return m_outstandReqHist; } + Histogram& getAllMissLatencyHist() { return m_allMissLatencyHist; } + + Histogram& getMissLatencyHist(uint32_t t) + { return m_missLatencyHist[t]; } + + Histogram& getMachLatencyHist(uint32_t t) + { return m_machLatencyHist[t]; } + + Histogram& getMissMachLatencyHist(uint32_t r, uint32_t t) + { return m_missMachLatencyHist[r][t]; } + + Histogram& getIssueToInitialDelayHist(uint32_t t) + { return m_IssueToInitialDelayHist[t]; } + + Histogram& getInitialToForwardDelayHist(const MachineType t) + { return m_InitialToForwardDelayHist[t]; } + + Histogram& getForwardRequestToFirstResponseHist(const MachineType t) + { return m_ForwardToFirstResponseDelayHist[t]; } + + Histogram& getFirstResponseToCompletionDelayHist(const MachineType t) + { return m_FirstResponseToCompletionDelayHist[t]; } + + const uint64_t getIncompleteTimes(const MachineType t) const + { return m_IncompleteTimes[t]; } private: void issueRequest(PacketPtr pkt, RubyRequestType type); - void hitCallback(SequencerRequest* request, - GenericMachineType mach, - DataBlock& data, - bool success, - Cycles initialRequestTime, - Cycles forwardRequestTime, - Cycles firstResponseTime); + void hitCallback(SequencerRequest* request, DataBlock& data, + bool llscSuccess, + const MachineType mach, const bool externalHit, + const Cycles initialRequestTime, + const Cycles forwardRequestTime, + const Cycles firstResponseTime); + + void recordMissLatency(const Cycles t, const RubyRequestType type, + const MachineType respondingMach, + bool isExternalHit, Cycles issuedTime, + Cycles initialRequestTime, + Cycles forwardRequestTime, Cycles firstResponseTime, + Cycles completionTime); RequestStatus insertRequest(PacketPtr pkt, RubyRequestType request_type); - bool handleLlsc(const Address& address, SequencerRequest* request); // Private copy constructor and assignment operator @@ -161,6 +179,20 @@ //! Histogram for number of outstanding requests per cycle. Histogram m_outstandReqHist; + //! Histograms for profiling the miss latencies suffered by requests + Histogram m_allMissLatencyHist; + std::vector m_missLatencyHist; + std::vector m_machLatencyHist; + std::vector< std::vector > m_missMachLatencyHist; + + //! Histograms for recording the breakdown of miss latency + std::vector m_IssueToInitialDelayHist; + std::vector m_InitialToForwardDelayHist; + std::vector m_ForwardToFirstResponseDelayHist; + std::vector m_FirstResponseToCompletionDelayHist; + std::vector m_IncompleteTimes; + + class SequencerWakeupEvent : public Event { private: diff -r eb00b7a967bb -r bd183992b333 src/mem/ruby/system/Sequencer.cc --- a/src/mem/ruby/system/Sequencer.cc Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/ruby/system/Sequencer.cc Tue Jun 04 18:19:26 2013 -0500 @@ -136,6 +136,37 @@ void Sequencer::clearStats() { m_outstandReqHist.clear(); + m_allMissLatencyHist.clear(20); + + m_missLatencyHist.resize(RubyRequestType_NUM); + for (int i = 0; i < m_missLatencyHist.size(); i++) { + m_missLatencyHist[i].clear(20); + } + + m_machLatencyHist.resize(MachineType_NUM); + m_IssueToInitialDelayHist.resize(MachineType_NUM); + m_InitialToForwardDelayHist.resize(MachineType_NUM); + m_ForwardToFirstResponseDelayHist.resize(MachineType_NUM); + m_FirstResponseToCompletionDelayHist.resize(MachineType_NUM); + m_IncompleteTimes.resize(MachineType_NUM); + + for (int i = 0; i < m_machLatencyHist.size(); i++) { + m_machLatencyHist[i].clear(20); + + m_IssueToInitialDelayHist[i].clear(20); + m_InitialToForwardDelayHist[i].clear(20); + m_ForwardToFirstResponseDelayHist[i].clear(20); + m_FirstResponseToCompletionDelayHist[i].clear(20); + m_IncompleteTimes[i] = 0; + } + + m_missMachLatencyHist.resize(RubyRequestType_NUM); + for (int i = 0; i < m_missLatencyHist.size(); i++) { + m_missMachLatencyHist[i].resize(MachineType_NUM); + for (int j = 0; j < m_missMachLatencyHist[i].size(); j++) { + m_missMachLatencyHist[i][j].clear(20); + } + } } void @@ -370,26 +401,47 @@ } void -Sequencer::writeCallback(const Address& address, DataBlock& data) +Sequencer::recordMissLatency(const Cycles cycles, const RubyRequestType type, + const MachineType respondingMach, + bool isExternalHit, Cycles issuedTime, + Cycles initialRequestTime, + Cycles forwardRequestTime, + Cycles firstResponseTime, Cycles completionTime) { - writeCallback(address, GenericMachineType_NULL, data); + m_allMissLatencyHist.add(cycles); + m_missLatencyHist[type].add(cycles); + + if (respondingMach != MachineType_NUM) { + m_machLatencyHist[respondingMach].add(cycles); + m_missMachLatencyHist[type][respondingMach].add(cycles); + + if (isExternalHit) { + if ((issuedTime <= initialRequestTime) && + (initialRequestTime <= forwardRequestTime) && + (forwardRequestTime <= firstResponseTime) && + (firstResponseTime <= completionTime)) { + + m_IssueToInitialDelayHist[respondingMach].add( + initialRequestTime - issuedTime); + m_InitialToForwardDelayHist[respondingMach].add( + forwardRequestTime - initialRequestTime); + m_ForwardToFirstResponseDelayHist[respondingMach].add( + firstResponseTime - forwardRequestTime); + m_FirstResponseToCompletionDelayHist[respondingMach].add( + completionTime - firstResponseTime); + } else { + m_IncompleteTimes[respondingMach]++; + } + } + } } void -Sequencer::writeCallback(const Address& address, - GenericMachineType mach, - DataBlock& data) -{ - writeCallback(address, mach, data, Cycles(0), Cycles(0), Cycles(0)); -} - -void -Sequencer::writeCallback(const Address& address, - GenericMachineType mach, - DataBlock& data, - Cycles initialRequestTime, - Cycles forwardRequestTime, - Cycles firstResponseTime) +Sequencer::writeCallback(const Address& address, DataBlock& data, + const MachineType mach, const bool externalHit, + const Cycles initialRequestTime, + const Cycles forwardRequestTime, + const Cycles firstResponseTime) { assert(address == line_address(address)); assert(m_writeRequestTable.count(line_address(address))); @@ -427,28 +479,13 @@ m_controller->unblock(address); } - hitCallback(request, mach, data, success, + hitCallback(request, data, success, mach, externalHit, initialRequestTime, forwardRequestTime, firstResponseTime); } void -Sequencer::readCallback(const Address& address, DataBlock& data) -{ - readCallback(address, GenericMachineType_NULL, data); -} - -void -Sequencer::readCallback(const Address& address, - GenericMachineType mach, - DataBlock& data) -{ - readCallback(address, mach, data, Cycles(0), Cycles(0), Cycles(0)); -} - -void -Sequencer::readCallback(const Address& address, - GenericMachineType mach, - DataBlock& data, +Sequencer::readCallback(const Address& address, DataBlock& data, + const MachineType mach, bool externalHit, Cycles initialRequestTime, Cycles forwardRequestTime, Cycles firstResponseTime) @@ -466,18 +503,17 @@ assert((request->m_type == RubyRequestType_LD) || (request->m_type == RubyRequestType_IFETCH)); - hitCallback(request, mach, data, true, + hitCallback(request, data, true, mach, externalHit, initialRequestTime, forwardRequestTime, firstResponseTime); } void -Sequencer::hitCallback(SequencerRequest* srequest, - GenericMachineType mach, - DataBlock& data, - bool success, - Cycles initialRequestTime, - Cycles forwardRequestTime, - Cycles firstResponseTime) +Sequencer::hitCallback(SequencerRequest* srequest, DataBlock& data, + bool llscSuccess, + const MachineType mach, const bool externalHit, + const Cycles initialRequestTime, + const Cycles forwardRequestTime, + const Cycles firstResponseTime) { PacketPtr pkt = srequest->pkt; Address request_address(pkt->getAddr()); @@ -498,23 +534,13 @@ // Profile the miss latency for all non-zero demand misses if (miss_latency != 0) { - g_system_ptr->getProfiler()->missLatency(miss_latency, type, mach); - - if (mach == GenericMachineType_L1Cache_wCC) { - g_system_ptr->getProfiler()->missLatencyWcc(issued_time, - initialRequestTime, forwardRequestTime, - firstResponseTime, curCycle()); - } - - if (mach == GenericMachineType_Directory) { - g_system_ptr->getProfiler()->missLatencyDir(issued_time, - initialRequestTime, forwardRequestTime, - firstResponseTime, curCycle()); - } + recordMissLatency(miss_latency, type, mach, externalHit, + issued_time, initialRequestTime, + forwardRequestTime, firstResponseTime, curCycle()); DPRINTFR(ProtocolTrace, "%15s %3s %10s%20s %6s>%-6s %s %d cycles\n", curTick(), m_version, "Seq", - success ? "Done" : "SC_Failed", "", "", + llscSuccess ? "Done" : "SC_Failed", "", "", request_address, miss_latency); } diff -r eb00b7a967bb -r bd183992b333 src/mem/slicc/ast/MachineAST.py --- a/src/mem/slicc/ast/MachineAST.py Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/slicc/ast/MachineAST.py Tue Jun 04 18:19:26 2013 -0500 @@ -29,10 +29,11 @@ from slicc.symbols import StateMachine, Type class MachineAST(DeclAST): - def __init__(self, slicc, ident, pairs_ast, config_parameters, decls): + def __init__(self, slicc, idents, pairs_ast, config_parameters, decls): super(MachineAST, self).__init__(slicc, pairs_ast) - self.ident = ident + self.ident = idents[0] + self.machine_types = idents self.pairs_ast = pairs_ast self.config_parameters = config_parameters self.decls = decls @@ -71,10 +72,18 @@ def findMachines(self): # Add to MachineType enumeration - machine_type = self.symtab.find("MachineType", Type) - if not machine_type.addEnum(self.ident, self.pairs_ast.pairs): - self.error("Duplicate machine name: %s:%s" % (machine_type, - self.ident)) + for mtype in self.machine_types: + machine_type = self.symtab.find("MachineType", Type) + pairs = self.pairs_ast.pairs + + if mtype == self.ident: + pairs["Primary"] = True + else: + pairs["Primary"] = False + + if not machine_type.addEnum(mtype, pairs): + self.error("Duplicate machine name: %s:%s" % ( + machine_type, mtype)) # Generate code for all the internal decls self.decls.findMachines() diff -r eb00b7a967bb -r bd183992b333 src/mem/slicc/parser.py --- a/src/mem/slicc/parser.py Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/slicc/parser.py Tue Jun 04 18:19:26 2013 -0500 @@ -258,8 +258,12 @@ filename = os.path.join(self.base_dir, p[2]) p[0] = self.parse_file(filename) - def p_decl__machine(self, p): - "decl : MACHINE '(' ident pairs ')' ':' params '{' decls '}'" + def p_decl__machine0(self, p): + "decl : MACHINE '(' idents ')' ':' params '{' decls '}'" + p[0] = ast.MachineAST(self, p[3], [], p[7], p[9]) + + def p_decl__machine1(self, p): + "decl : MACHINE '(' idents pairs ')' ':' params '{' decls '}'" p[0] = ast.MachineAST(self, p[3], p[4], p[7], p[9]) def p_decl__action(self, p): diff -r eb00b7a967bb -r bd183992b333 src/mem/slicc/symbols/Type.py --- a/src/mem/slicc/symbols/Type.py Tue Jun 04 17:42:15 2013 -0500 +++ b/src/mem/slicc/symbols/Type.py Tue Jun 04 18:19:26 2013 -0500 @@ -477,7 +477,6 @@ if self.isMachineType: code('#include "base/misc.hh"') - code('#include "mem/protocol/GenericMachineType.hh"') code('#include "mem/ruby/common/Address.hh"') code('struct MachineID;') @@ -534,23 +533,6 @@ MachineID get${{enum.ident}}MachineID(NodeID RubyNode); ''') - code(''' -inline GenericMachineType -ConvertMachToGenericMach(MachineType machType) -{ -''') - for enum in self.enums.itervalues(): - genericType = self.enums[enum.ident].get('genericType', - enum.ident) - code(''' - if (machType == MachineType_${{enum.ident}}) - return GenericMachineType_${{genericType}}; -''') - code(''' - panic("cannot convert to a GenericMachineType"); -} -''') - if self.isStateDecl: code(''' @@ -610,7 +592,8 @@ if self.isMachineType: for enum in self.enums.itervalues(): - code('#include "mem/protocol/${{enum.ident}}_Controller.hh"') + if enum.get("Primary"): + code('#include "mem/protocol/${{enum.ident}}_Controller.hh"') code('#include "mem/ruby/system/MachineID.hh"') code(''' @@ -747,7 +730,11 @@ code.indent() code(' case ${{self.c_ident}}_NUM:') for enum in reversed(self.enums.values()): - code(' base += ${{enum.ident}}_Controller::getNumControllers();') + # Check if there is a defined machine with this type + if enum.get("Primary"): + code(' base += ${{enum.ident}}_Controller::getNumControllers();') + else: + code(' base += 0;') code(' case ${{self.c_ident}}_${{enum.ident}}:') code(' break;') code.dedent() @@ -771,10 +758,11 @@ # For each field for enum in self.enums.itervalues(): - code(''' - case ${{self.c_ident}}_${{enum.ident}}: - return ${{enum.ident}}_Controller::getNumControllers(); -''') + code('case ${{self.c_ident}}_${{enum.ident}}:') + if enum.get("Primary"): + code('return ${{enum.ident}}_Controller::getNumControllers();') + else: + code('return 0;') # total num code('''