1/*
2 * Copyright (c) 1999-2013 Mark D. Hill and David A. Wood
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;

--- 28 unchanged lines hidden (view full) ---

37
38 ----------------------------------------------------------------------
39
40 File modification date: 2008-02-23
41
42 ----------------------------------------------------------------------
43*/
44
45#include <sys/types.h>
46#include <unistd.h>
47
48#include <algorithm>
49#include <fstream>
50
51#include "base/stl_helpers.hh"
52#include "base/str.hh"
53#include "mem/protocol/MachineType.hh"
54#include "mem/protocol/RubyRequest.hh"
55#include "mem/ruby/network/Network.hh"
56#include "mem/ruby/profiler/AddressProfiler.hh"
57#include "mem/ruby/profiler/Profiler.hh"
58#include "mem/ruby/system/Sequencer.hh"
59
60using namespace std;
61using m5::stl_helpers::operator<<;
62
63Profiler::Profiler(const RubySystemParams *p, RubySystem *rs)
64 : m_ruby_system(rs), m_hot_lines(p->hot_lines),
65 m_all_instructions(p->all_instructions),

--- 35 unchanged lines hidden (view full) ---

101 delayVCHistogram.push_back(new Stats::Histogram());
102 delayVCHistogram[i]
103 ->init(10)
104 .name(pName + csprintf(".delayVCHist.vnet_%i", i))
105 .desc(csprintf("delay histogram for vnet_%i", i))
106 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
107 }
108
109 m_outstandReqHist
110 .init(10)
111 .name(pName + ".outstanding_req_hist")
112 .desc("")
113 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
114
115 m_latencyHist
116 .init(10)
117 .name(pName + ".latency_hist")
118 .desc("")
119 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
120
121 m_hitLatencyHist
122 .init(10)
123 .name(pName + ".hit_latency_hist")
124 .desc("")
125 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
126
127 m_missLatencyHist
128 .init(10)
129 .name(pName + ".miss_latency_hist")
130 .desc("")
131 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
132
133 for (int i = 0; i < RubyRequestType_NUM; i++) {
134 m_typeLatencyHist.push_back(new Stats::Histogram());
135 m_typeLatencyHist[i]
136 ->init(10)
137 .name(pName + csprintf(".%s.latency_hist",
138 RubyRequestType(i)))
139 .desc("")
140 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
141
142 m_hitTypeLatencyHist.push_back(new Stats::Histogram());
143 m_hitTypeLatencyHist[i]
144 ->init(10)
145 .name(pName + csprintf(".%s.hit_latency_hist",
146 RubyRequestType(i)))
147 .desc("")
148 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
149
150 m_missTypeLatencyHist.push_back(new Stats::Histogram());
151 m_missTypeLatencyHist[i]
152 ->init(10)
153 .name(pName + csprintf(".%s.miss_latency_hist",
154 RubyRequestType(i)))
155 .desc("")
156 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
157 }
158
159 for (int i = 0; i < MachineType_NUM; i++) {
160 m_hitMachLatencyHist.push_back(new Stats::Histogram());
161 m_hitMachLatencyHist[i]
162 ->init(10)
163 .name(pName + csprintf(".%s.hit_mach_latency_hist",
164 MachineType(i)))
165 .desc("")
166 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
167
168 m_missMachLatencyHist.push_back(new Stats::Histogram());
169 m_missMachLatencyHist[i]
170 ->init(10)
171 .name(pName + csprintf(".%s.miss_mach_latency_hist",
172 MachineType(i)))
173 .desc("")
174 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
175
176 m_IssueToInitialDelayHist.push_back(new Stats::Histogram());
177 m_IssueToInitialDelayHist[i]
178 ->init(10)
179 .name(pName + csprintf(
180 ".%s.miss_latency_hist.issue_to_initial_request",
181 MachineType(i)))
182 .desc("")
183 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
184
185 m_InitialToForwardDelayHist.push_back(new Stats::Histogram());
186 m_InitialToForwardDelayHist[i]
187 ->init(10)
188 .name(pName + csprintf(".%s.miss_latency_hist.initial_to_forward",
189 MachineType(i)))
190 .desc("")
191 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
192
193 m_ForwardToFirstResponseDelayHist.push_back(new Stats::Histogram());
194 m_ForwardToFirstResponseDelayHist[i]
195 ->init(10)
196 .name(pName + csprintf(
197 ".%s.miss_latency_hist.forward_to_first_response",
198 MachineType(i)))
199 .desc("")
200 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
201
202 m_FirstResponseToCompletionDelayHist.push_back(new Stats::Histogram());
203 m_FirstResponseToCompletionDelayHist[i]
204 ->init(10)
205 .name(pName + csprintf(
206 ".%s.miss_latency_hist.first_response_to_completion",
207 MachineType(i)))
208 .desc("")
209 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
210
211 m_IncompleteTimes[i]
212 .name(pName + csprintf(".%s.incomplete_times", MachineType(i)))
213 .desc("")
214 .flags(Stats::nozero);
215 }
216
217 for (int i = 0; i < RubyRequestType_NUM; i++) {
218 m_hitTypeMachLatencyHist.push_back(std::vector());
219 m_missTypeMachLatencyHist.push_back(std::vector());
220
221 for (int j = 0; j < MachineType_NUM; j++) {
222 m_hitTypeMachLatencyHist[i].push_back(new Stats::Histogram());
223 m_hitTypeMachLatencyHist[i][j]
224 ->init(10)
225 .name(pName + csprintf(".%s.%s.hit_type_mach_latency_hist",
226 RubyRequestType(i), MachineType(j)))
227 .desc("")
228 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
229
230 m_missTypeMachLatencyHist[i].push_back(new Stats::Histogram());
231 m_missTypeMachLatencyHist[i][j]
232 ->init(10)
233 .name(pName + csprintf(".%s.%s.miss_type_mach_latency_hist",
234 RubyRequestType(i), MachineType(j)))
235 .desc("")
236 .flags(Stats::nozero | Stats::pdf | Stats::oneline);
237 }
238 }
239}
240
241void
242Profiler::collateStats()
243{
244 if (!m_all_instructions) {

--- 21 unchanged lines hidden (view full) ---

266 for (uint32_t i = 0; i < MachineType_NUM; i++) {
267 for (map<uint32_t, AbstractController*>::iterator it =
268 m_ruby_system->m_abstract_controls[i].begin();
269 it != m_ruby_system->m_abstract_controls[i].end(); ++it) {
270
271 AbstractController *ctr = (*it).second;
272 Sequencer *seq = ctr->getCPUSequencer();
273 if (seq != NULL) {
274 m_outstandReqHist.add(seq->getOutstandReqHist());
275 }
276 }
277 }
278
279 for (uint32_t i = 0; i < MachineType_NUM; i++) {
280 for (map<uint32_t, AbstractController*>::iterator it =
281 m_ruby_system->m_abstract_controls[i].begin();
282 it != m_ruby_system->m_abstract_controls[i].end(); ++it) {
283
284 AbstractController *ctr = (*it).second;
285 Sequencer *seq = ctr->getCPUSequencer();
286 if (seq != NULL) {
287 // add all the latencies
288 m_latencyHist.add(seq->getLatencyHist());
289 m_hitLatencyHist.add(seq->getHitLatencyHist());
290 m_missLatencyHist.add(seq->getMissLatencyHist());
291
292 // add the per request type latencies
293 for (uint32_t j = 0; j < RubyRequestType_NUM; ++j) {
294 m_typeLatencyHist[j]
295 ->add(seq->getTypeLatencyHist(j));
296 m_hitTypeLatencyHist[j]
297 ->add(seq->getHitTypeLatencyHist(j));
298 m_missTypeLatencyHist[j]
299 ->add(seq->getMissTypeLatencyHist(j));
300 }
301
302 // add the per machine type miss latencies
303 for (uint32_t j = 0; j < MachineType_NUM; ++j) {
304 m_hitMachLatencyHist[j]
305 ->add(seq->getHitMachLatencyHist(j));
306 m_missMachLatencyHist[j]
307 ->add(seq->getMissMachLatencyHist(j));
308
309 m_IssueToInitialDelayHist[j]->add(
310 seq->getIssueToInitialDelayHist(MachineType(j)));
311
312 m_InitialToForwardDelayHist[j]->add(
313 seq->getInitialToForwardDelayHist(MachineType(j)));
314 m_ForwardToFirstResponseDelayHist[j]->add(seq->
315 getForwardRequestToFirstResponseHist(MachineType(j)));
316
317 m_FirstResponseToCompletionDelayHist[j]->add(seq->
318 getFirstResponseToCompletionDelayHist(
319 MachineType(j)));
320 m_IncompleteTimes[j] +=
321 seq->getIncompleteTimes(MachineType(j));
322 }
323
324 // add the per (request, machine) type miss latencies
325 for (uint32_t j = 0; j < RubyRequestType_NUM; j++) {
326 for (uint32_t k = 0; k < MachineType_NUM; k++) {
327 m_hitTypeMachLatencyHist[j][k]->add(
328 seq->getHitTypeMachLatencyHist(j,k));
329 m_missTypeMachLatencyHist[j][k]->add(
330 seq->getMissTypeMachLatencyHist(j,k));
331 }
332 }
333 }
334 }
335 }
336}
337
338void
339Profiler::addAddressTraceSample(const RubyRequest& msg, NodeID id)
340{
341 if (msg.getType() != RubyRequestType_IFETCH) {
342 // Note: The following line should be commented out if you
343 // want to use the special profiling that is part of the GS320
344 // protocol
345
346 // NOTE: Unless PROFILE_HOT_LINES is enabled, nothing will be
347 // profiled by the AddressProfiler
348 m_address_profiler_ptr->
349 addTraceSample(msg.getLineAddress(), msg.getProgramCounter(),
350 msg.getType(), msg.getAccessMode(), id, false);
351 }
352}