blob: 8807a737254fb70760bcb430fdcf12a655bd6d77 [file] [log] [blame]
/*
* Copyright (c) 2012-2013, 2015, 2018-2019 ARM Limited
* Copyright (c) 2016 Google Inc.
* Copyright (c) 2017, Centre National de la Recherche Scientifique
* All rights reserved.
*
* The license below extends only to copyright in the software and shall
* not be construed as granting a license to any other intellectual
* property including but not limited to intellectual property relating
* to a hardware implementation of the functionality of the software
* licensed hereunder. You may use the software subject to the license
* terms below provided that you ensure that this notice is replicated
* unmodified and in its entirety in all distributions of the software,
* modified or unmodified, in source code or in binary form.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "mem/comm_monitor.hh"
#include "base/trace.hh"
#include "debug/CommMonitor.hh"
#include "sim/stats.hh"
CommMonitor::CommMonitor(const Params &params)
: SimObject(params),
memSidePort(name() + "-mem_side_port", *this),
cpuSidePort(name() + "-cpu_side_port", *this),
samplePeriodicEvent([this]{ samplePeriodic(); }, name()),
samplePeriodTicks(params.sample_period),
samplePeriod(params.sample_period / SimClock::Float::s),
stats(this, params)
{
DPRINTF(CommMonitor,
"Created monitor %s with sample period %d ticks (%f ms)\n",
name(), samplePeriodTicks, samplePeriod * 1E3);
}
void
CommMonitor::init()
{
// make sure both sides of the monitor are connected
if (!cpuSidePort.isConnected() || !memSidePort.isConnected())
fatal("Communication monitor is not connected on both sides.\n");
}
void
CommMonitor::regProbePoints()
{
ppPktReq.reset(new ProbePoints::Packet(getProbeManager(), "PktRequest"));
ppPktResp.reset(new ProbePoints::Packet(getProbeManager(), "PktResponse"));
}
Port &
CommMonitor::getPort(const std::string &if_name, PortID idx)
{
if (if_name == "mem_side_port") {
return memSidePort;
} else if (if_name == "cpu_side_port") {
return cpuSidePort;
} else {
return SimObject::getPort(if_name, idx);
}
}
void
CommMonitor::recvFunctional(PacketPtr pkt)
{
memSidePort.sendFunctional(pkt);
}
void
CommMonitor::recvFunctionalSnoop(PacketPtr pkt)
{
cpuSidePort.sendFunctionalSnoop(pkt);
}
CommMonitor::MonitorStats::MonitorStats(Stats::Group *parent,
const CommMonitorParams &params)
: Stats::Group(parent),
disableBurstLengthHists(params.disable_burst_length_hists),
ADD_STAT(readBurstLengthHist, UNIT_BYTE,
"Histogram of burst lengths of transmitted packets"),
ADD_STAT(writeBurstLengthHist, UNIT_BYTE,
"Histogram of burst lengths of transmitted packets"),
disableBandwidthHists(params.disable_bandwidth_hists),
readBytes(0),
ADD_STAT(readBandwidthHist,
UNIT_RATE(Stats::Units::Byte, Stats::Units::Second),
"Histogram of read bandwidth per sample period"),
ADD_STAT(totalReadBytes, UNIT_BYTE, "Number of bytes read"),
ADD_STAT(averageReadBandwidth,
UNIT_RATE(Stats::Units::Byte, Stats::Units::Second),
"Average read bandwidth",
totalReadBytes / simSeconds),
writtenBytes(0),
ADD_STAT(writeBandwidthHist,
UNIT_RATE(Stats::Units::Byte, Stats::Units::Second),
"Histogram of write bandwidth"),
ADD_STAT(totalWrittenBytes,
UNIT_RATE(Stats::Units::Byte, Stats::Units::Second),
"Number of bytes written"),
ADD_STAT(averageWriteBandwidth,
UNIT_RATE(Stats::Units::Byte, Stats::Units::Second),
"Average write bandwidth",
totalWrittenBytes / simSeconds),
disableLatencyHists(params.disable_latency_hists),
ADD_STAT(readLatencyHist, UNIT_TICK, "Read request-response latency"),
ADD_STAT(writeLatencyHist, UNIT_TICK, "Write request-response latency"),
disableITTDists(params.disable_itt_dists),
ADD_STAT(ittReadRead, UNIT_TICK, "Read-to-read inter transaction time"),
ADD_STAT(ittWriteWrite, UNIT_TICK,
"Write-to-write inter transaction time"),
ADD_STAT(ittReqReq, UNIT_TICK,
"Request-to-request inter transaction time"),
timeOfLastRead(0), timeOfLastWrite(0), timeOfLastReq(0),
disableOutstandingHists(params.disable_outstanding_hists),
ADD_STAT(outstandingReadsHist, UNIT_COUNT,
"Outstanding read transactions"),
outstandingReadReqs(0),
ADD_STAT(outstandingWritesHist, UNIT_COUNT,
"Outstanding write transactions"),
outstandingWriteReqs(0),
disableTransactionHists(params.disable_transaction_hists),
ADD_STAT(readTransHist, UNIT_COUNT,
"Histogram of read transactions per sample period"),
readTrans(0),
ADD_STAT(writeTransHist, UNIT_COUNT,
"Histogram of write transactions per sample period"),
writeTrans(0),
disableAddrDists(params.disable_addr_dists),
readAddrMask(params.read_addr_mask),
writeAddrMask(params.write_addr_mask),
ADD_STAT(readAddrDist, UNIT_COUNT, "Read address distribution"),
ADD_STAT(writeAddrDist, UNIT_COUNT, "Write address distribution")
{
using namespace Stats;
readBurstLengthHist
.init(params.burst_length_bins)
.flags(disableBurstLengthHists ? nozero : pdf);
writeBurstLengthHist
.init(params.burst_length_bins)
.flags(disableBurstLengthHists ? nozero : pdf);
// Stats based on received responses
readBandwidthHist
.init(params.bandwidth_bins)
.flags(disableBandwidthHists ? nozero : pdf);
averageReadBandwidth
.flags(disableBandwidthHists ? nozero : pdf);
totalReadBytes
.flags(disableBandwidthHists ? nozero : pdf);
// Stats based on successfully sent requests
writeBandwidthHist
.init(params.bandwidth_bins)
.flags(disableBandwidthHists ? (pdf | nozero) : pdf);
averageWriteBandwidth
.flags(disableBandwidthHists ? nozero : pdf);
totalWrittenBytes
.flags(disableBandwidthHists ? nozero : pdf);
readLatencyHist
.init(params.latency_bins)
.flags(disableLatencyHists ? nozero : pdf);
writeLatencyHist
.init(params.latency_bins)
.flags(disableLatencyHists ? nozero : pdf);
ittReadRead
.init(1, params.itt_max_bin, params.itt_max_bin /
params.itt_bins)
.flags(disableITTDists ? nozero : pdf);
ittWriteWrite
.init(1, params.itt_max_bin, params.itt_max_bin /
params.itt_bins)
.flags(disableITTDists ? nozero : pdf);
ittReqReq
.init(1, params.itt_max_bin, params.itt_max_bin /
params.itt_bins)
.flags(disableITTDists ? nozero : pdf);
outstandingReadsHist
.init(params.outstanding_bins)
.flags(disableOutstandingHists ? nozero : pdf);
outstandingWritesHist
.init(params.outstanding_bins)
.flags(disableOutstandingHists ? nozero : pdf);
readTransHist
.init(params.transaction_bins)
.flags(disableTransactionHists ? nozero : pdf);
writeTransHist
.init(params.transaction_bins)
.flags(disableTransactionHists ? nozero : pdf);
readAddrDist
.init(0)
.flags(disableAddrDists ? nozero : pdf);
writeAddrDist
.init(0)
.flags(disableAddrDists ? nozero : pdf);
}
void
CommMonitor::MonitorStats::updateReqStats(
const ProbePoints::PacketInfo& pkt_info, bool is_atomic,
bool expects_response)
{
if (pkt_info.cmd.isRead()) {
// Increment number of observed read transactions
if (!disableTransactionHists)
++readTrans;
// Get sample of burst length
if (!disableBurstLengthHists)
readBurstLengthHist.sample(pkt_info.size);
// Sample the masked address
if (!disableAddrDists)
readAddrDist.sample(pkt_info.addr & readAddrMask);
if (!disableITTDists) {
// Sample value of read-read inter transaction time
if (timeOfLastRead != 0)
ittReadRead.sample(curTick() - timeOfLastRead);
timeOfLastRead = curTick();
// Sample value of req-req inter transaction time
if (timeOfLastReq != 0)
ittReqReq.sample(curTick() - timeOfLastReq);
timeOfLastReq = curTick();
}
if (!is_atomic && !disableOutstandingHists && expects_response)
++outstandingReadReqs;
} else if (pkt_info.cmd.isWrite()) {
// Same as for reads
if (!disableTransactionHists)
++writeTrans;
if (!disableBurstLengthHists)
writeBurstLengthHist.sample(pkt_info.size);
// Update the bandwidth stats on the request
if (!disableBandwidthHists) {
writtenBytes += pkt_info.size;
totalWrittenBytes += pkt_info.size;
}
// Sample the masked write address
if (!disableAddrDists)
writeAddrDist.sample(pkt_info.addr & writeAddrMask);
if (!disableITTDists) {
// Sample value of write-to-write inter transaction time
if (timeOfLastWrite != 0)
ittWriteWrite.sample(curTick() - timeOfLastWrite);
timeOfLastWrite = curTick();
// Sample value of req-to-req inter transaction time
if (timeOfLastReq != 0)
ittReqReq.sample(curTick() - timeOfLastReq);
timeOfLastReq = curTick();
}
if (!is_atomic && !disableOutstandingHists && expects_response)
++outstandingWriteReqs;
}
}
void
CommMonitor::MonitorStats::updateRespStats(
const ProbePoints::PacketInfo& pkt_info, Tick latency, bool is_atomic)
{
if (pkt_info.cmd.isRead()) {
// Decrement number of outstanding read requests
if (!is_atomic && !disableOutstandingHists) {
assert(outstandingReadReqs != 0);
--outstandingReadReqs;
}
if (!disableLatencyHists)
readLatencyHist.sample(latency);
// Update the bandwidth stats based on responses for reads
if (!disableBandwidthHists) {
readBytes += pkt_info.size;
totalReadBytes += pkt_info.size;
}
} else if (pkt_info.cmd.isWrite()) {
// Decrement number of outstanding write requests
if (!is_atomic && !disableOutstandingHists) {
assert(outstandingWriteReqs != 0);
--outstandingWriteReqs;
}
if (!disableLatencyHists)
writeLatencyHist.sample(latency);
}
}
Tick
CommMonitor::recvAtomic(PacketPtr pkt)
{
const bool expects_response(pkt->needsResponse() &&
!pkt->cacheResponding());
ProbePoints::PacketInfo req_pkt_info(pkt);
ppPktReq->notify(req_pkt_info);
const Tick delay(memSidePort.sendAtomic(pkt));
stats.updateReqStats(req_pkt_info, true, expects_response);
if (expects_response)
stats.updateRespStats(req_pkt_info, delay, true);
// Some packets, such as WritebackDirty, don't need response.
assert(pkt->isResponse() || !expects_response);
ProbePoints::PacketInfo resp_pkt_info(pkt);
ppPktResp->notify(resp_pkt_info);
return delay;
}
Tick
CommMonitor::recvAtomicSnoop(PacketPtr pkt)
{
return cpuSidePort.sendAtomicSnoop(pkt);
}
bool
CommMonitor::recvTimingReq(PacketPtr pkt)
{
// should always see a request
assert(pkt->isRequest());
// Store relevant fields of packet, because packet may be modified
// or even deleted when sendTiming() is called.
const ProbePoints::PacketInfo pkt_info(pkt);
const bool expects_response(pkt->needsResponse() &&
!pkt->cacheResponding());
// If a cache miss is served by a cache, a monitor near the memory
// would see a request which needs a response, but this response
// would not come back from the memory. Therefore we additionally
// have to check the cacheResponding flag
if (expects_response && !stats.disableLatencyHists) {
pkt->pushSenderState(new CommMonitorSenderState(curTick()));
}
// Attempt to send the packet
bool successful = memSidePort.sendTimingReq(pkt);
// If not successful, restore the sender state
if (!successful && expects_response && !stats.disableLatencyHists) {
delete pkt->popSenderState();
}
if (successful) {
ppPktReq->notify(pkt_info);
}
if (successful) {
DPRINTF(CommMonitor, "Forwarded %s request\n", pkt->isRead() ? "read" :
pkt->isWrite() ? "write" : "non read/write");
stats.updateReqStats(pkt_info, false, expects_response);
}
return successful;
}
bool
CommMonitor::recvTimingResp(PacketPtr pkt)
{
// should always see responses
assert(pkt->isResponse());
// Store relevant fields of packet, because packet may be modified
// or even deleted when sendTiming() is called.
const ProbePoints::PacketInfo pkt_info(pkt);
Tick latency = 0;
CommMonitorSenderState* received_state =
dynamic_cast<CommMonitorSenderState*>(pkt->senderState);
if (!stats.disableLatencyHists) {
// Restore initial sender state
if (received_state == NULL)
panic("Monitor got a response without monitor sender state\n");
// Restore the sate
pkt->senderState = received_state->predecessor;
}
// Attempt to send the packet
bool successful = cpuSidePort.sendTimingResp(pkt);
if (!stats.disableLatencyHists) {
// If packet successfully send, sample value of latency,
// afterwards delete sender state, otherwise restore state
if (successful) {
latency = curTick() - received_state->transmitTime;
DPRINTF(CommMonitor, "Latency: %d\n", latency);
delete received_state;
} else {
// Don't delete anything and let the packet look like we
// did not touch it
pkt->senderState = received_state;
}
}
if (successful) {
ppPktResp->notify(pkt_info);
DPRINTF(CommMonitor, "Received %s response\n", pkt->isRead() ? "read" :
pkt->isWrite() ? "write" : "non read/write");
stats.updateRespStats(pkt_info, latency, false);
}
return successful;
}
void
CommMonitor::recvTimingSnoopReq(PacketPtr pkt)
{
cpuSidePort.sendTimingSnoopReq(pkt);
}
bool
CommMonitor::recvTimingSnoopResp(PacketPtr pkt)
{
return memSidePort.sendTimingSnoopResp(pkt);
}
void
CommMonitor::recvRetrySnoopResp()
{
cpuSidePort.sendRetrySnoopResp();
}
bool
CommMonitor::isSnooping() const
{
// check if the connected request port is snooping
return cpuSidePort.isSnooping();
}
AddrRangeList
CommMonitor::getAddrRanges() const
{
// get the address ranges of the connected CPU-side port
return memSidePort.getAddrRanges();
}
void
CommMonitor::recvReqRetry()
{
cpuSidePort.sendRetryReq();
}
void
CommMonitor::recvRespRetry()
{
memSidePort.sendRetryResp();
}
bool
CommMonitor::tryTiming(PacketPtr pkt)
{
return memSidePort.tryTiming(pkt);
}
void
CommMonitor::recvRangeChange()
{
cpuSidePort.sendRangeChange();
}
void
CommMonitor::samplePeriodic()
{
// the periodic stats update runs on the granularity of sample
// periods, but in combination with this there may also be a
// external resets and dumps of the stats (through schedStatEvent)
// causing the stats themselves to capture less than a sample
// period
// only capture if we have not reset the stats during the last
// sample period
if (simTicks.value() >= samplePeriodTicks) {
if (!stats.disableTransactionHists) {
stats.readTransHist.sample(stats.readTrans);
stats.writeTransHist.sample(stats.writeTrans);
}
if (!stats.disableBandwidthHists) {
stats.readBandwidthHist.sample(stats.readBytes / samplePeriod);
stats.writeBandwidthHist.sample(stats.writtenBytes / samplePeriod);
}
if (!stats.disableOutstandingHists) {
stats.outstandingReadsHist.sample(stats.outstandingReadReqs);
stats.outstandingWritesHist.sample(stats.outstandingWriteReqs);
}
}
// reset the sampled values
stats.readTrans = 0;
stats.writeTrans = 0;
stats.readBytes = 0;
stats.writtenBytes = 0;
schedule(samplePeriodicEvent, curTick() + samplePeriodTicks);
}
void
CommMonitor::startup()
{
schedule(samplePeriodicEvent, curTick() + samplePeriodTicks);
}