1/*
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(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
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}
560