comm_monitor.cc revision 14084:9e60f14d5f0d
1/* 2 * Copyright (c) 2012-2013, 2015, 2018 ARM Limited 3 * Copyright (c) 2016 Google Inc. 4 * Copyright (c) 2017, Centre National de la Recherche Scientifique 5 * All rights reserved. 6 * 7 * The license below extends only to copyright in the software and shall 8 * not be construed as granting a license to any other intellectual 9 * property including but not limited to intellectual property relating 10 * to a hardware implementation of the functionality of the software 11 * licensed hereunder. You may use the software subject to the license 12 * terms below provided that you ensure that this notice is replicated 13 * unmodified and in its entirety in all distributions of the software, 14 * modified or unmodified, in source code or in binary form. 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions are 18 * met: redistributions of source code must retain the above copyright 19 * notice, this list of conditions and the following disclaimer; 20 * redistributions in binary form must reproduce the above copyright 21 * notice, this list of conditions and the following disclaimer in the 22 * documentation and/or other materials provided with the distribution; 23 * neither the name of the copyright holders nor the names of its 24 * contributors may be used to endorse or promote products derived from 25 * this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 30 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 31 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 32 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 33 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 34 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 35 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 36 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 37 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 38 * 39 * Authors: Thomas Grass 40 * Andreas Hansson 41 * Rahul Thakur 42 * Pierre-Yves Peneau 43 */ 44 45#include "mem/comm_monitor.hh" 46 47#include "base/trace.hh" 48#include "debug/CommMonitor.hh" 49#include "sim/stats.hh" 50 51CommMonitor::CommMonitor(Params* params) 52 : SimObject(params), 53 masterPort(name() + "-master", *this), 54 slavePort(name() + "-slave", *this), 55 samplePeriodicEvent([this]{ samplePeriodic(); }, name()), 56 samplePeriodTicks(params->sample_period), 57 samplePeriod(params->sample_period / SimClock::Float::s), 58 stats(params) 59{ 60 DPRINTF(CommMonitor, 61 "Created monitor %s with sample period %d ticks (%f ms)\n", 62 name(), samplePeriodTicks, samplePeriod * 1E3); 63} 64 65CommMonitor* 66CommMonitorParams::create() 67{ 68 return new CommMonitor(this); 69} 70 71void 72CommMonitor::init() 73{ 74 // make sure both sides of the monitor are connected 75 if (!slavePort.isConnected() || !masterPort.isConnected()) 76 fatal("Communication monitor is not connected on both sides.\n"); 77} 78 79void 80CommMonitor::regProbePoints() 81{ 82 ppPktReq.reset(new ProbePoints::Packet(getProbeManager(), "PktRequest")); 83 ppPktResp.reset(new ProbePoints::Packet(getProbeManager(), "PktResponse")); 84} 85 86Port & 87CommMonitor::getPort(const std::string &if_name, PortID idx) 88{ 89 if (if_name == "master") { 90 return masterPort; 91 } else if (if_name == "slave") { 92 return slavePort; 93 } else { 94 return SimObject::getPort(if_name, idx); 95 } 96} 97 98void 99CommMonitor::recvFunctional(PacketPtr pkt) 100{ 101 masterPort.sendFunctional(pkt); 102} 103 104void 105CommMonitor::recvFunctionalSnoop(PacketPtr pkt) 106{ 107 slavePort.sendFunctionalSnoop(pkt); 108} 109 110void 111CommMonitor::MonitorStats::updateReqStats( 112 const ProbePoints::PacketInfo& pkt_info, bool is_atomic, 113 bool expects_response) 114{ 115 if (pkt_info.cmd.isRead()) { 116 // Increment number of observed read transactions 117 if (!disableTransactionHists) 118 ++readTrans; 119 120 // Get sample of burst length 121 if (!disableBurstLengthHists) 122 readBurstLengthHist.sample(pkt_info.size); 123 124 // Sample the masked address 125 if (!disableAddrDists) 126 readAddrDist.sample(pkt_info.addr & readAddrMask); 127 128 if (!disableITTDists) { 129 // Sample value of read-read inter transaction time 130 if (timeOfLastRead != 0) 131 ittReadRead.sample(curTick() - timeOfLastRead); 132 timeOfLastRead = curTick(); 133 134 // Sample value of req-req inter transaction time 135 if (timeOfLastReq != 0) 136 ittReqReq.sample(curTick() - timeOfLastReq); 137 timeOfLastReq = curTick(); 138 } 139 if (!is_atomic && !disableOutstandingHists && expects_response) 140 ++outstandingReadReqs; 141 142 } else if (pkt_info.cmd.isWrite()) { 143 // Same as for reads 144 if (!disableTransactionHists) 145 ++writeTrans; 146 147 if (!disableBurstLengthHists) 148 writeBurstLengthHist.sample(pkt_info.size); 149 150 // Update the bandwidth stats on the request 151 if (!disableBandwidthHists) { 152 writtenBytes += pkt_info.size; 153 totalWrittenBytes += pkt_info.size; 154 } 155 156 // Sample the masked write address 157 if (!disableAddrDists) 158 writeAddrDist.sample(pkt_info.addr & writeAddrMask); 159 160 if (!disableITTDists) { 161 // Sample value of write-to-write inter transaction time 162 if (timeOfLastWrite != 0) 163 ittWriteWrite.sample(curTick() - timeOfLastWrite); 164 timeOfLastWrite = curTick(); 165 166 // Sample value of req-to-req inter transaction time 167 if (timeOfLastReq != 0) 168 ittReqReq.sample(curTick() - timeOfLastReq); 169 timeOfLastReq = curTick(); 170 } 171 172 if (!is_atomic && !disableOutstandingHists && expects_response) 173 ++outstandingWriteReqs; 174 } 175} 176 177void 178CommMonitor::MonitorStats::updateRespStats( 179 const ProbePoints::PacketInfo& pkt_info, Tick latency, bool is_atomic) 180{ 181 if (pkt_info.cmd.isRead()) { 182 // Decrement number of outstanding read requests 183 if (!is_atomic && !disableOutstandingHists) { 184 assert(outstandingReadReqs != 0); 185 --outstandingReadReqs; 186 } 187 188 if (!disableLatencyHists) 189 readLatencyHist.sample(latency); 190 191 // Update the bandwidth stats based on responses for reads 192 if (!disableBandwidthHists) { 193 readBytes += pkt_info.size; 194 totalReadBytes += pkt_info.size; 195 } 196 197 } else if (pkt_info.cmd.isWrite()) { 198 // Decrement number of outstanding write requests 199 if (!is_atomic && !disableOutstandingHists) { 200 assert(outstandingWriteReqs != 0); 201 --outstandingWriteReqs; 202 } 203 204 if (!disableLatencyHists) 205 writeLatencyHist.sample(latency); 206 } 207} 208 209Tick 210CommMonitor::recvAtomic(PacketPtr pkt) 211{ 212 const bool expects_response(pkt->needsResponse() && 213 !pkt->cacheResponding()); 214 ProbePoints::PacketInfo req_pkt_info(pkt); 215 ppPktReq->notify(req_pkt_info); 216 217 const Tick delay(masterPort.sendAtomic(pkt)); 218 219 stats.updateReqStats(req_pkt_info, true, expects_response); 220 if (expects_response) 221 stats.updateRespStats(req_pkt_info, delay, true); 222 223 // Some packets, such as WritebackDirty, don't need response. 224 assert(pkt->isResponse() || !expects_response); 225 ProbePoints::PacketInfo resp_pkt_info(pkt); 226 ppPktResp->notify(resp_pkt_info); 227 return delay; 228} 229 230Tick 231CommMonitor::recvAtomicSnoop(PacketPtr pkt) 232{ 233 return slavePort.sendAtomicSnoop(pkt); 234} 235 236bool 237CommMonitor::recvTimingReq(PacketPtr pkt) 238{ 239 // should always see a request 240 assert(pkt->isRequest()); 241 242 // Store relevant fields of packet, because packet may be modified 243 // or even deleted when sendTiming() is called. 244 const ProbePoints::PacketInfo pkt_info(pkt); 245 246 const bool expects_response(pkt->needsResponse() && 247 !pkt->cacheResponding()); 248 249 // If a cache miss is served by a cache, a monitor near the memory 250 // would see a request which needs a response, but this response 251 // would not come back from the memory. Therefore we additionally 252 // have to check the cacheResponding flag 253 if (expects_response && !stats.disableLatencyHists) { 254 pkt->pushSenderState(new CommMonitorSenderState(curTick())); 255 } 256 257 // Attempt to send the packet 258 bool successful = masterPort.sendTimingReq(pkt); 259 260 // If not successful, restore the sender state 261 if (!successful && expects_response && !stats.disableLatencyHists) { 262 delete pkt->popSenderState(); 263 } 264 265 if (successful) { 266 ppPktReq->notify(pkt_info); 267 } 268 269 if (successful) { 270 DPRINTF(CommMonitor, "Forwarded %s request\n", pkt->isRead() ? "read" : 271 pkt->isWrite() ? "write" : "non read/write"); 272 stats.updateReqStats(pkt_info, false, expects_response); 273 } 274 return successful; 275} 276 277bool 278CommMonitor::recvTimingResp(PacketPtr pkt) 279{ 280 // should always see responses 281 assert(pkt->isResponse()); 282 283 // Store relevant fields of packet, because packet may be modified 284 // or even deleted when sendTiming() is called. 285 const ProbePoints::PacketInfo pkt_info(pkt); 286 287 Tick latency = 0; 288 CommMonitorSenderState* received_state = 289 dynamic_cast<CommMonitorSenderState*>(pkt->senderState); 290 291 if (!stats.disableLatencyHists) { 292 // Restore initial sender state 293 if (received_state == NULL) 294 panic("Monitor got a response without monitor sender state\n"); 295 296 // Restore the sate 297 pkt->senderState = received_state->predecessor; 298 } 299 300 // Attempt to send the packet 301 bool successful = slavePort.sendTimingResp(pkt); 302 303 if (!stats.disableLatencyHists) { 304 // If packet successfully send, sample value of latency, 305 // afterwards delete sender state, otherwise restore state 306 if (successful) { 307 latency = curTick() - received_state->transmitTime; 308 DPRINTF(CommMonitor, "Latency: %d\n", latency); 309 delete received_state; 310 } else { 311 // Don't delete anything and let the packet look like we 312 // did not touch it 313 pkt->senderState = received_state; 314 } 315 } 316 317 if (successful) { 318 ppPktResp->notify(pkt_info); 319 DPRINTF(CommMonitor, "Received %s response\n", pkt->isRead() ? "read" : 320 pkt->isWrite() ? "write" : "non read/write"); 321 stats.updateRespStats(pkt_info, latency, false); 322 } 323 return successful; 324} 325 326void 327CommMonitor::recvTimingSnoopReq(PacketPtr pkt) 328{ 329 slavePort.sendTimingSnoopReq(pkt); 330} 331 332bool 333CommMonitor::recvTimingSnoopResp(PacketPtr pkt) 334{ 335 return masterPort.sendTimingSnoopResp(pkt); 336} 337 338void 339CommMonitor::recvRetrySnoopResp() 340{ 341 slavePort.sendRetrySnoopResp(); 342} 343 344bool 345CommMonitor::isSnooping() const 346{ 347 // check if the connected master port is snooping 348 return slavePort.isSnooping(); 349} 350 351AddrRangeList 352CommMonitor::getAddrRanges() const 353{ 354 // get the address ranges of the connected slave port 355 return masterPort.getAddrRanges(); 356} 357 358void 359CommMonitor::recvReqRetry() 360{ 361 slavePort.sendRetryReq(); 362} 363 364void 365CommMonitor::recvRespRetry() 366{ 367 masterPort.sendRetryResp(); 368} 369 370bool 371CommMonitor::tryTiming(PacketPtr pkt) 372{ 373 return masterPort.tryTiming(pkt); 374} 375 376void 377CommMonitor::recvRangeChange() 378{ 379 slavePort.sendRangeChange(); 380} 381 382void 383CommMonitor::regStats() 384{ 385 SimObject::regStats(); 386 387 // Initialise all the monitor stats 388 using namespace Stats; 389 390 stats.readBurstLengthHist 391 .init(params()->burst_length_bins) 392 .name(name() + ".readBurstLengthHist") 393 .desc("Histogram of burst lengths of transmitted packets") 394 .flags(stats.disableBurstLengthHists ? nozero : pdf); 395 396 stats.writeBurstLengthHist 397 .init(params()->burst_length_bins) 398 .name(name() + ".writeBurstLengthHist") 399 .desc("Histogram of burst lengths of transmitted packets") 400 .flags(stats.disableBurstLengthHists ? nozero : pdf); 401 402 // Stats based on received responses 403 stats.readBandwidthHist 404 .init(params()->bandwidth_bins) 405 .name(name() + ".readBandwidthHist") 406 .desc("Histogram of read bandwidth per sample period (bytes/s)") 407 .flags(stats.disableBandwidthHists ? nozero : pdf); 408 409 stats.averageReadBW 410 .name(name() + ".averageReadBandwidth") 411 .desc("Average read bandwidth (bytes/s)") 412 .flags(stats.disableBandwidthHists ? nozero : pdf); 413 414 stats.totalReadBytes 415 .name(name() + ".totalReadBytes") 416 .desc("Number of bytes read") 417 .flags(stats.disableBandwidthHists ? nozero : pdf); 418 419 stats.averageReadBW = stats.totalReadBytes / simSeconds; 420 421 // Stats based on successfully sent requests 422 stats.writeBandwidthHist 423 .init(params()->bandwidth_bins) 424 .name(name() + ".writeBandwidthHist") 425 .desc("Histogram of write bandwidth (bytes/s)") 426 .flags(stats.disableBandwidthHists ? (pdf | nozero) : pdf); 427 428 stats.averageWriteBW 429 .name(name() + ".averageWriteBandwidth") 430 .desc("Average write bandwidth (bytes/s)") 431 .flags(stats.disableBandwidthHists ? nozero : pdf); 432 433 stats.totalWrittenBytes 434 .name(name() + ".totalWrittenBytes") 435 .desc("Number of bytes written") 436 .flags(stats.disableBandwidthHists ? nozero : pdf); 437 438 stats.averageWriteBW = stats.totalWrittenBytes / simSeconds; 439 440 stats.readLatencyHist 441 .init(params()->latency_bins) 442 .name(name() + ".readLatencyHist") 443 .desc("Read request-response latency") 444 .flags(stats.disableLatencyHists ? nozero : pdf); 445 446 stats.writeLatencyHist 447 .init(params()->latency_bins) 448 .name(name() + ".writeLatencyHist") 449 .desc("Write request-response latency") 450 .flags(stats.disableLatencyHists ? nozero : pdf); 451 452 stats.ittReadRead 453 .init(1, params()->itt_max_bin, params()->itt_max_bin / 454 params()->itt_bins) 455 .name(name() + ".ittReadRead") 456 .desc("Read-to-read inter transaction time") 457 .flags(stats.disableITTDists ? nozero : pdf); 458 459 stats.ittWriteWrite 460 .init(1, params()->itt_max_bin, params()->itt_max_bin / 461 params()->itt_bins) 462 .name(name() + ".ittWriteWrite") 463 .desc("Write-to-write inter transaction time") 464 .flags(stats.disableITTDists ? nozero : pdf); 465 466 stats.ittReqReq 467 .init(1, params()->itt_max_bin, params()->itt_max_bin / 468 params()->itt_bins) 469 .name(name() + ".ittReqReq") 470 .desc("Request-to-request inter transaction time") 471 .flags(stats.disableITTDists ? nozero : pdf); 472 473 stats.outstandingReadsHist 474 .init(params()->outstanding_bins) 475 .name(name() + ".outstandingReadsHist") 476 .desc("Outstanding read transactions") 477 .flags(stats.disableOutstandingHists ? nozero : pdf); 478 479 stats.outstandingWritesHist 480 .init(params()->outstanding_bins) 481 .name(name() + ".outstandingWritesHist") 482 .desc("Outstanding write transactions") 483 .flags(stats.disableOutstandingHists ? nozero : pdf); 484 485 stats.readTransHist 486 .init(params()->transaction_bins) 487 .name(name() + ".readTransHist") 488 .desc("Histogram of read transactions per sample period") 489 .flags(stats.disableTransactionHists ? nozero : pdf); 490 491 stats.writeTransHist 492 .init(params()->transaction_bins) 493 .name(name() + ".writeTransHist") 494 .desc("Histogram of write transactions per sample period") 495 .flags(stats.disableTransactionHists ? nozero : pdf); 496 497 stats.readAddrDist 498 .init(0) 499 .name(name() + ".readAddrDist") 500 .desc("Read address distribution") 501 .flags(stats.disableAddrDists ? nozero : pdf); 502 503 stats.writeAddrDist 504 .init(0) 505 .name(name() + ".writeAddrDist") 506 .desc("Write address distribution") 507 .flags(stats.disableAddrDists ? nozero : pdf); 508} 509 510void 511CommMonitor::samplePeriodic() 512{ 513 // the periodic stats update runs on the granularity of sample 514 // periods, but in combination with this there may also be a 515 // external resets and dumps of the stats (through schedStatEvent) 516 // causing the stats themselves to capture less than a sample 517 // period 518 519 // only capture if we have not reset the stats during the last 520 // sample period 521 if (simTicks.value() >= samplePeriodTicks) { 522 if (!stats.disableTransactionHists) { 523 stats.readTransHist.sample(stats.readTrans); 524 stats.writeTransHist.sample(stats.writeTrans); 525 } 526 527 if (!stats.disableBandwidthHists) { 528 stats.readBandwidthHist.sample(stats.readBytes / samplePeriod); 529 stats.writeBandwidthHist.sample(stats.writtenBytes / samplePeriod); 530 } 531 532 if (!stats.disableOutstandingHists) { 533 stats.outstandingReadsHist.sample(stats.outstandingReadReqs); 534 stats.outstandingWritesHist.sample(stats.outstandingWriteReqs); 535 } 536 } 537 538 // reset the sampled values 539 stats.readTrans = 0; 540 stats.writeTrans = 0; 541 542 stats.readBytes = 0; 543 stats.writtenBytes = 0; 544 545 schedule(samplePeriodicEvent, curTick() + samplePeriodTicks); 546} 547 548void 549CommMonitor::startup() 550{ 551 schedule(samplePeriodicEvent, curTick() + samplePeriodTicks); 552} 553