1/*
|
2 * Copyright (c) 2012-2013, 2015, 2018 ARM Limited
|
2 * Copyright (c) 2012-2013, 2015, 2018-2019 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)
|
58 stats(this, 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
|
110CommMonitor::MonitorStats::MonitorStats(Stats::Group *parent, 111 const CommMonitorParams *params) 112 : Stats::Group(parent), 113 114 disableBurstLengthHists(params->disable_burst_length_hists), 115 ADD_STAT(readBurstLengthHist, 116 "Histogram of burst lengths of transmitted packets"), 117 ADD_STAT(writeBurstLengthHist, 118 "Histogram of burst lengths of transmitted packets"), 119 120 disableBandwidthHists(params->disable_bandwidth_hists), 121 readBytes(0), 122 ADD_STAT(readBandwidthHist, 123 "Histogram of read bandwidth per sample period (bytes/s)"), 124 ADD_STAT(totalReadBytes, "Number of bytes read"), 125 ADD_STAT(averageReadBandwidth, "Average read bandwidth (bytes/s)", 126 totalReadBytes / simSeconds), 127 128 writtenBytes(0), 129 ADD_STAT(writeBandwidthHist, "Histogram of write bandwidth (bytes/s)"), 130 ADD_STAT(totalWrittenBytes, "Number of bytes written"), 131 ADD_STAT(averageWriteBandwidth, "Average write bandwidth (bytes/s)", 132 totalWrittenBytes / simSeconds), 133 134 disableLatencyHists(params->disable_latency_hists), 135 ADD_STAT(readLatencyHist, "Read request-response latency"), 136 ADD_STAT(writeLatencyHist, "Write request-response latency"), 137 138 disableITTDists(params->disable_itt_dists), 139 ADD_STAT(ittReadRead, "Read-to-read inter transaction time"), 140 ADD_STAT(ittWriteWrite , "Write-to-write inter transaction time"), 141 ADD_STAT(ittReqReq, "Request-to-request inter transaction time"), 142 timeOfLastRead(0), timeOfLastWrite(0), timeOfLastReq(0), 143 144 disableOutstandingHists(params->disable_outstanding_hists), 145 ADD_STAT(outstandingReadsHist, "Outstanding read transactions"), 146 outstandingReadReqs(0), 147 ADD_STAT(outstandingWritesHist, "Outstanding write transactions"), 148 outstandingWriteReqs(0), 149 150 disableTransactionHists(params->disable_transaction_hists), 151 ADD_STAT(readTransHist, 152 "Histogram of read transactions per sample period"), 153 readTrans(0), 154 ADD_STAT(writeTransHist, 155 "Histogram of write transactions per sample period"), 156 writeTrans(0), 157 158 disableAddrDists(params->disable_addr_dists), 159 readAddrMask(params->read_addr_mask), 160 writeAddrMask(params->write_addr_mask), 161 ADD_STAT(readAddrDist, "Read address distribution"), 162 ADD_STAT(writeAddrDist, "Write address distribution") 163{ 164 using namespace Stats; 165 166 readBurstLengthHist 167 .init(params->burst_length_bins) 168 .flags(disableBurstLengthHists ? nozero : pdf); 169 170 writeBurstLengthHist 171 .init(params->burst_length_bins) 172 .flags(disableBurstLengthHists ? nozero : pdf); 173 174 // Stats based on received responses 175 readBandwidthHist 176 .init(params->bandwidth_bins) 177 .flags(disableBandwidthHists ? nozero : pdf); 178 179 averageReadBandwidth 180 .flags(disableBandwidthHists ? nozero : pdf); 181 182 totalReadBytes 183 .flags(disableBandwidthHists ? nozero : pdf); 184 185 // Stats based on successfully sent requests 186 writeBandwidthHist 187 .init(params->bandwidth_bins) 188 .flags(disableBandwidthHists ? (pdf | nozero) : pdf); 189 190 averageWriteBandwidth 191 .flags(disableBandwidthHists ? nozero : pdf); 192 193 totalWrittenBytes 194 .flags(disableBandwidthHists ? nozero : pdf); 195 196 197 readLatencyHist 198 .init(params->latency_bins) 199 .flags(disableLatencyHists ? nozero : pdf); 200 201 writeLatencyHist 202 .init(params->latency_bins) 203 .flags(disableLatencyHists ? nozero : pdf); 204 205 ittReadRead 206 .init(1, params->itt_max_bin, params->itt_max_bin / 207 params->itt_bins) 208 .flags(disableITTDists ? nozero : pdf); 209 210 ittWriteWrite 211 .init(1, params->itt_max_bin, params->itt_max_bin / 212 params->itt_bins) 213 .flags(disableITTDists ? nozero : pdf); 214 215 ittReqReq 216 .init(1, params->itt_max_bin, params->itt_max_bin / 217 params->itt_bins) 218 .flags(disableITTDists ? nozero : pdf); 219 220 outstandingReadsHist 221 .init(params->outstanding_bins) 222 .flags(disableOutstandingHists ? nozero : pdf); 223 224 outstandingWritesHist 225 .init(params->outstanding_bins) 226 .flags(disableOutstandingHists ? nozero : pdf); 227 228 readTransHist 229 .init(params->transaction_bins) 230 .flags(disableTransactionHists ? nozero : pdf); 231 232 writeTransHist 233 .init(params->transaction_bins) 234 .flags(disableTransactionHists ? nozero : pdf); 235 236 readAddrDist 237 .init(0) 238 .flags(disableAddrDists ? nozero : pdf); 239 240 writeAddrDist 241 .init(0) 242 .flags(disableAddrDists ? nozero : pdf); 243} 244 |
245void 246CommMonitor::MonitorStats::updateReqStats( 247 const ProbePoints::PacketInfo& pkt_info, bool is_atomic, 248 bool expects_response) 249{ 250 if (pkt_info.cmd.isRead()) { 251 // Increment number of observed read transactions 252 if (!disableTransactionHists) 253 ++readTrans; 254 255 // Get sample of burst length 256 if (!disableBurstLengthHists) 257 readBurstLengthHist.sample(pkt_info.size); 258 259 // Sample the masked address 260 if (!disableAddrDists) 261 readAddrDist.sample(pkt_info.addr & readAddrMask); 262 263 if (!disableITTDists) { 264 // Sample value of read-read inter transaction time 265 if (timeOfLastRead != 0) 266 ittReadRead.sample(curTick() - timeOfLastRead); 267 timeOfLastRead = curTick(); 268 269 // Sample value of req-req inter transaction time 270 if (timeOfLastReq != 0) 271 ittReqReq.sample(curTick() - timeOfLastReq); 272 timeOfLastReq = curTick(); 273 } 274 if (!is_atomic && !disableOutstandingHists && expects_response) 275 ++outstandingReadReqs; 276 277 } else if (pkt_info.cmd.isWrite()) { 278 // Same as for reads 279 if (!disableTransactionHists) 280 ++writeTrans; 281 282 if (!disableBurstLengthHists) 283 writeBurstLengthHist.sample(pkt_info.size); 284 285 // Update the bandwidth stats on the request 286 if (!disableBandwidthHists) { 287 writtenBytes += pkt_info.size; 288 totalWrittenBytes += pkt_info.size; 289 } 290 291 // Sample the masked write address 292 if (!disableAddrDists) 293 writeAddrDist.sample(pkt_info.addr & writeAddrMask); 294 295 if (!disableITTDists) { 296 // Sample value of write-to-write inter transaction time 297 if (timeOfLastWrite != 0) 298 ittWriteWrite.sample(curTick() - timeOfLastWrite); 299 timeOfLastWrite = curTick(); 300 301 // Sample value of req-to-req inter transaction time 302 if (timeOfLastReq != 0) 303 ittReqReq.sample(curTick() - timeOfLastReq); 304 timeOfLastReq = curTick(); 305 } 306 307 if (!is_atomic && !disableOutstandingHists && expects_response) 308 ++outstandingWriteReqs; 309 } 310} 311 312void 313CommMonitor::MonitorStats::updateRespStats( 314 const ProbePoints::PacketInfo& pkt_info, Tick latency, bool is_atomic) 315{ 316 if (pkt_info.cmd.isRead()) { 317 // Decrement number of outstanding read requests 318 if (!is_atomic && !disableOutstandingHists) { 319 assert(outstandingReadReqs != 0); 320 --outstandingReadReqs; 321 } 322 323 if (!disableLatencyHists) 324 readLatencyHist.sample(latency); 325 326 // Update the bandwidth stats based on responses for reads 327 if (!disableBandwidthHists) { 328 readBytes += pkt_info.size; 329 totalReadBytes += pkt_info.size; 330 } 331 332 } else if (pkt_info.cmd.isWrite()) { 333 // Decrement number of outstanding write requests 334 if (!is_atomic && !disableOutstandingHists) { 335 assert(outstandingWriteReqs != 0); 336 --outstandingWriteReqs; 337 } 338 339 if (!disableLatencyHists) 340 writeLatencyHist.sample(latency); 341 } 342} 343 344Tick 345CommMonitor::recvAtomic(PacketPtr pkt) 346{ 347 const bool expects_response(pkt->needsResponse() && 348 !pkt->cacheResponding()); 349 ProbePoints::PacketInfo req_pkt_info(pkt); 350 ppPktReq->notify(req_pkt_info); 351 352 const Tick delay(masterPort.sendAtomic(pkt)); 353 354 stats.updateReqStats(req_pkt_info, true, expects_response); 355 if (expects_response) 356 stats.updateRespStats(req_pkt_info, delay, true); 357 358 // Some packets, such as WritebackDirty, don't need response. 359 assert(pkt->isResponse() || !expects_response); 360 ProbePoints::PacketInfo resp_pkt_info(pkt); 361 ppPktResp->notify(resp_pkt_info); 362 return delay; 363} 364 365Tick 366CommMonitor::recvAtomicSnoop(PacketPtr pkt) 367{ 368 return slavePort.sendAtomicSnoop(pkt); 369} 370 371bool 372CommMonitor::recvTimingReq(PacketPtr pkt) 373{ 374 // should always see a request 375 assert(pkt->isRequest()); 376 377 // Store relevant fields of packet, because packet may be modified 378 // or even deleted when sendTiming() is called. 379 const ProbePoints::PacketInfo pkt_info(pkt); 380 381 const bool expects_response(pkt->needsResponse() && 382 !pkt->cacheResponding()); 383 384 // If a cache miss is served by a cache, a monitor near the memory 385 // would see a request which needs a response, but this response 386 // would not come back from the memory. Therefore we additionally 387 // have to check the cacheResponding flag 388 if (expects_response && !stats.disableLatencyHists) { 389 pkt->pushSenderState(new CommMonitorSenderState(curTick())); 390 } 391 392 // Attempt to send the packet 393 bool successful = masterPort.sendTimingReq(pkt); 394 395 // If not successful, restore the sender state 396 if (!successful && expects_response && !stats.disableLatencyHists) { 397 delete pkt->popSenderState(); 398 } 399 400 if (successful) { 401 ppPktReq->notify(pkt_info); 402 } 403 404 if (successful) { 405 DPRINTF(CommMonitor, "Forwarded %s request\n", pkt->isRead() ? "read" : 406 pkt->isWrite() ? "write" : "non read/write"); 407 stats.updateReqStats(pkt_info, false, expects_response); 408 } 409 return successful; 410} 411 412bool 413CommMonitor::recvTimingResp(PacketPtr pkt) 414{ 415 // should always see responses 416 assert(pkt->isResponse()); 417 418 // Store relevant fields of packet, because packet may be modified 419 // or even deleted when sendTiming() is called. 420 const ProbePoints::PacketInfo pkt_info(pkt); 421 422 Tick latency = 0; 423 CommMonitorSenderState* received_state = 424 dynamic_cast<CommMonitorSenderState*>(pkt->senderState); 425 426 if (!stats.disableLatencyHists) { 427 // Restore initial sender state 428 if (received_state == NULL) 429 panic("Monitor got a response without monitor sender state\n"); 430 431 // Restore the sate 432 pkt->senderState = received_state->predecessor; 433 } 434 435 // Attempt to send the packet 436 bool successful = slavePort.sendTimingResp(pkt); 437 438 if (!stats.disableLatencyHists) { 439 // If packet successfully send, sample value of latency, 440 // afterwards delete sender state, otherwise restore state 441 if (successful) { 442 latency = curTick() - received_state->transmitTime; 443 DPRINTF(CommMonitor, "Latency: %d\n", latency); 444 delete received_state; 445 } else { 446 // Don't delete anything and let the packet look like we 447 // did not touch it 448 pkt->senderState = received_state; 449 } 450 } 451 452 if (successful) { 453 ppPktResp->notify(pkt_info); 454 DPRINTF(CommMonitor, "Received %s response\n", pkt->isRead() ? "read" : 455 pkt->isWrite() ? "write" : "non read/write"); 456 stats.updateRespStats(pkt_info, latency, false); 457 } 458 return successful; 459} 460 461void 462CommMonitor::recvTimingSnoopReq(PacketPtr pkt) 463{ 464 slavePort.sendTimingSnoopReq(pkt); 465} 466 467bool 468CommMonitor::recvTimingSnoopResp(PacketPtr pkt) 469{ 470 return masterPort.sendTimingSnoopResp(pkt); 471} 472 473void 474CommMonitor::recvRetrySnoopResp() 475{ 476 slavePort.sendRetrySnoopResp(); 477} 478 479bool 480CommMonitor::isSnooping() const 481{ 482 // check if the connected master port is snooping 483 return slavePort.isSnooping(); 484} 485 486AddrRangeList 487CommMonitor::getAddrRanges() const 488{ 489 // get the address ranges of the connected slave port 490 return masterPort.getAddrRanges(); 491} 492 493void 494CommMonitor::recvReqRetry() 495{ 496 slavePort.sendRetryReq(); 497} 498 499void 500CommMonitor::recvRespRetry() 501{ 502 masterPort.sendRetryResp(); 503} 504 505bool 506CommMonitor::tryTiming(PacketPtr pkt) 507{ 508 return masterPort.tryTiming(pkt); 509} 510 511void 512CommMonitor::recvRangeChange() 513{ 514 slavePort.sendRangeChange(); 515} 516 517void
|
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
|
518CommMonitor::samplePeriodic() 519{ 520 // the periodic stats update runs on the granularity of sample 521 // periods, but in combination with this there may also be a 522 // external resets and dumps of the stats (through schedStatEvent) 523 // causing the stats themselves to capture less than a sample 524 // period 525 526 // only capture if we have not reset the stats during the last 527 // sample period 528 if (simTicks.value() >= samplePeriodTicks) { 529 if (!stats.disableTransactionHists) { 530 stats.readTransHist.sample(stats.readTrans); 531 stats.writeTransHist.sample(stats.writeTrans); 532 } 533 534 if (!stats.disableBandwidthHists) { 535 stats.readBandwidthHist.sample(stats.readBytes / samplePeriod); 536 stats.writeBandwidthHist.sample(stats.writtenBytes / samplePeriod); 537 } 538 539 if (!stats.disableOutstandingHists) { 540 stats.outstandingReadsHist.sample(stats.outstandingReadReqs); 541 stats.outstandingWritesHist.sample(stats.outstandingWriteReqs); 542 } 543 } 544 545 // reset the sampled values 546 stats.readTrans = 0; 547 stats.writeTrans = 0; 548 549 stats.readBytes = 0; 550 stats.writtenBytes = 0; 551 552 schedule(samplePeriodicEvent, curTick() + samplePeriodTicks); 553} 554 555void 556CommMonitor::startup() 557{ 558 schedule(samplePeriodicEvent, curTick() + samplePeriodTicks); 559}
|