diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/mem/SConscript | 3 | ||||
| -rw-r--r-- | src/mem/atomic_protocol.cc | 73 | ||||
| -rw-r--r-- | src/mem/atomic_protocol.hh | 120 | ||||
| -rw-r--r-- | src/mem/functional_protocol.cc | 65 | ||||
| -rw-r--r-- | src/mem/functional_protocol.hh | 92 | ||||
| -rw-r--r-- | src/mem/port.cc | 88 | ||||
| -rw-r--r-- | src/mem/port.hh | 343 | ||||
| -rw-r--r-- | src/mem/timing_protocol.cc | 105 | ||||
| -rw-r--r-- | src/mem/timing_protocol.hh | 190 |
9 files changed, 836 insertions, 243 deletions
diff --git a/src/mem/SConscript b/src/mem/SConscript index 95d8654b1..9ebb07436 100644 --- a/src/mem/SConscript +++ b/src/mem/SConscript @@ -60,12 +60,14 @@ SimObject('MemDelay.py') Source('abstract_mem.cc') Source('addr_mapper.cc') +Source('atomic_protocol.cc') Source('bridge.cc') Source('coherent_xbar.cc') Source('drampower.cc') Source('dram_ctrl.cc') Source('external_master.cc') Source('external_slave.cc') +Source('functional_protocol.cc') Source('mem_object.cc') Source('mport.cc') Source('noncoherent_xbar.cc') @@ -75,6 +77,7 @@ Source('packet_queue.cc') Source('port_proxy.cc') Source('physical.cc') Source('secure_port_proxy.cc') +Source('timing_protocol.cc') Source('simple_mem.cc') Source('snoop_filter.cc') Source('stack_dist_calc.cc') diff --git a/src/mem/atomic_protocol.cc b/src/mem/atomic_protocol.cc new file mode 100644 index 000000000..6aecc4058 --- /dev/null +++ b/src/mem/atomic_protocol.cc @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2012,2015,2017 ARM Limited + * 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. + * + * Copyright (c) 2002-2005 The Regents of The University of Michigan + * All rights reserved. + * + * 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. + * + * Authors: Steve Reinhardt + * Andreas Hansson + * William Wang + */ + +#include "mem/atomic_protocol.hh" + +#include "base/trace.hh" + +/* The request protocol. */ + +Tick +AtomicRequestProtocol::send(AtomicResponseProtocol *peer, PacketPtr pkt) +{ + assert(pkt->isRequest()); + return peer->recvAtomic(pkt); +} + +Tick +AtomicRequestProtocol::sendBackdoor(AtomicResponseProtocol *peer, + PacketPtr pkt, MemBackdoorPtr &backdoor) +{ + assert(pkt->isRequest()); + return peer->recvAtomicBackdoor(pkt, backdoor); +} + +/* The response protocol. */ + +Tick +AtomicResponseProtocol::sendSnoop(AtomicRequestProtocol *peer, PacketPtr pkt) +{ + assert(pkt->isRequest()); + return peer->recvAtomicSnoop(pkt); +} diff --git a/src/mem/atomic_protocol.hh b/src/mem/atomic_protocol.hh new file mode 100644 index 000000000..bb2de0a22 --- /dev/null +++ b/src/mem/atomic_protocol.hh @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2011-2012,2015,2017 ARM Limited + * 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. + * + * Copyright (c) 2002-2005 The Regents of The University of Michigan + * All rights reserved. + * + * 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. + * + * Authors: Ron Dreslinski + * Andreas Hansson + * William Wang + */ + +#ifndef __MEM_ATOMIC_PROTOCOL_HH__ +#define __MEM_ATOMIC_PROTOCOL_HH__ + +#include "mem/backdoor.hh" +#include "mem/packet.hh" + +class AtomicResponseProtocol; + +class AtomicRequestProtocol +{ + friend class AtomicResponseProtocol; + + protected: + /** + * Send an atomic request packet, where the data is moved and the + * state is updated in zero time, without interleaving with other + * memory accesses. + * + * @param peer Peer to send packet to. + * @param pkt Packet to send. + * + * @return Estimated latency of access. + */ + Tick send(AtomicResponseProtocol *peer, PacketPtr pkt); + + /** + * Send an atomic request packet like above, but also request a backdoor + * to the data being accessed. + * + * @param peer Peer to send packet to. + * @param pkt Packet to send. + * @param backdoor Can be set to a back door pointer by the target to let + * caller have direct access to the requested data. + * + * @return Estimated latency of access. + */ + Tick sendBackdoor(AtomicResponseProtocol *peer, PacketPtr pkt, + MemBackdoorPtr &backdoor); + + /** + * Receive an atomic snoop request packet from our peer. + */ + virtual Tick recvAtomicSnoop(PacketPtr pkt) = 0; +}; + +class AtomicResponseProtocol +{ + friend class AtomicRequestProtocol; + + protected: + /** + * Send an atomic snoop request packet, where the data is moved + * and the state is updated in zero time, without interleaving + * with other memory accesses. + * + * @param peer Peer to send packet to. + * @param pkt Snoop packet to send. + * + * @return Estimated latency of access. + */ + Tick sendSnoop(AtomicRequestProtocol *peer, PacketPtr pkt); + + /** + * Receive an atomic request packet from the peer. + */ + virtual Tick recvAtomic(PacketPtr pkt) = 0; + + /** + * Receive an atomic request packet from the peer, and optionally + * provide a backdoor to the data being accessed. + */ + virtual Tick recvAtomicBackdoor( + PacketPtr pkt, MemBackdoorPtr &backdoor) = 0; +}; + +#endif //__MEM_ATOMIC_PROTOCOL_HH__ diff --git a/src/mem/functional_protocol.cc b/src/mem/functional_protocol.cc new file mode 100644 index 000000000..be129539b --- /dev/null +++ b/src/mem/functional_protocol.cc @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2012,2015,2017 ARM Limited + * 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. + * + * Copyright (c) 2002-2005 The Regents of The University of Michigan + * All rights reserved. + * + * 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. + * + * Authors: Steve Reinhardt + * Andreas Hansson + * William Wang + */ + +#include "mem/functional_protocol.hh" + +/* The request protocol. */ + +void +FunctionalRequestProtocol::send( + FunctionalResponseProtocol *peer, PacketPtr pkt) const +{ + assert(pkt->isRequest()); + return peer->recvFunctional(pkt); +} + +/* The response protocol. */ + +void +FunctionalResponseProtocol::sendSnoop( + FunctionalRequestProtocol *peer, PacketPtr pkt) const +{ + assert(pkt->isRequest()); + return peer->recvFunctionalSnoop(pkt); +} diff --git a/src/mem/functional_protocol.hh b/src/mem/functional_protocol.hh new file mode 100644 index 000000000..443b98032 --- /dev/null +++ b/src/mem/functional_protocol.hh @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2011-2012,2015,2017 ARM Limited + * 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. + * + * Copyright (c) 2002-2005 The Regents of The University of Michigan + * All rights reserved. + * + * 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. + * + * Authors: Ron Dreslinski + * Andreas Hansson + * William Wang + */ + +#ifndef __MEM_FUNCTIONAL_PROTOCOL_HH__ +#define __MEM_FUNCTIONAL_PROTOCOL_HH__ + +#include "mem/packet.hh" + +class FunctionalResponseProtocol; + +class FunctionalRequestProtocol +{ + friend class FunctionalResponseProtocol; + + protected: + /** + * Send a functional request packet, where the data is instantly + * updated everywhere in the memory system, without affecting the + * current state of any block or moving the block. + * + * @param pkt Packet to send. + */ + void send(FunctionalResponseProtocol *peer, PacketPtr pkt) const; + + /** + * Receive a functional snoop request packet from the peer. + */ + virtual void recvFunctionalSnoop(PacketPtr pkt) = 0; +}; + +class FunctionalResponseProtocol +{ + friend class FunctionalRequestProtocol; + + protected: + /** + * Send a functional snoop request packet, where the data is + * instantly updated everywhere in the memory system, without + * affecting the current state of any block or moving the block. + * + * @param pkt Snoop packet to send. + */ + void sendSnoop(FunctionalRequestProtocol *peer, PacketPtr pkt) const; + + /** + * Receive a functional request packet from the peer. + */ + virtual void recvFunctional(PacketPtr pkt) = 0; +}; + +#endif //__MEM_FUNCTIONAL_PROTOCOL_HH__ diff --git a/src/mem/port.cc b/src/mem/port.cc index ee312eac7..40481b0bb 100644 --- a/src/mem/port.cc +++ b/src/mem/port.cc @@ -137,54 +137,6 @@ MasterPort::getAddrRanges() const return _slavePort->getAddrRanges(); } -Tick -MasterPort::sendAtomic(PacketPtr pkt) -{ - assert(pkt->isRequest()); - return _slavePort->recvAtomic(pkt); -} - -Tick -MasterPort::sendAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor) -{ - assert(pkt->isRequest()); - return _slavePort->recvAtomicBackdoor(pkt, backdoor); -} - -void -MasterPort::sendFunctional(PacketPtr pkt) -{ - assert(pkt->isRequest()); - return _slavePort->recvFunctional(pkt); -} - -bool -MasterPort::sendTimingReq(PacketPtr pkt) -{ - assert(pkt->isRequest()); - return _slavePort->recvTimingReq(pkt); -} - -bool -MasterPort::tryTiming(PacketPtr pkt) const -{ - assert(pkt->isRequest()); - return _slavePort->tryTiming(pkt); -} - -bool -MasterPort::sendTimingSnoopResp(PacketPtr pkt) -{ - assert(pkt->isResponse()); - return _slavePort->recvTimingSnoopResp(pkt); -} - -void -MasterPort::sendRetryResp() -{ - _slavePort->recvRespRetry(); -} - void MasterPort::printAddr(Addr a) { @@ -236,43 +188,3 @@ SlavePort::recvAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor) } return recvAtomic(pkt); } - -Tick -SlavePort::sendAtomicSnoop(PacketPtr pkt) -{ - assert(pkt->isRequest()); - return _masterPort->recvAtomicSnoop(pkt); -} - -void -SlavePort::sendFunctionalSnoop(PacketPtr pkt) -{ - assert(pkt->isRequest()); - return _masterPort->recvFunctionalSnoop(pkt); -} - -bool -SlavePort::sendTimingResp(PacketPtr pkt) -{ - assert(pkt->isResponse()); - return _masterPort->recvTimingResp(pkt); -} - -void -SlavePort::sendTimingSnoopReq(PacketPtr pkt) -{ - assert(pkt->isRequest()); - _masterPort->recvTimingSnoopReq(pkt); -} - -void -SlavePort::sendRetryReq() -{ - _masterPort->recvReqRetry(); -} - -void -SlavePort::sendRetrySnoopResp() -{ - _masterPort->recvRetrySnoopResp(); -} diff --git a/src/mem/port.hh b/src/mem/port.hh index 76ad3bd63..16257ed4f 100644 --- a/src/mem/port.hh +++ b/src/mem/port.hh @@ -51,8 +51,10 @@ #define __MEM_PORT_HH__ #include "base/addr_range.hh" -#include "mem/backdoor.hh" +#include "mem/atomic_protocol.hh" +#include "mem/functional_protocol.hh" #include "mem/packet.hh" +#include "mem/timing_protocol.hh" #include "sim/port.hh" class SimObject; @@ -68,18 +70,14 @@ class BaseSlavePort; */ class BaseMasterPort : public Port { - protected: + BaseSlavePort *_baseSlavePort; - BaseSlavePort* _baseSlavePort; - - BaseMasterPort(const std::string& name, PortID id=InvalidPortID); + BaseMasterPort(const std::string &name, PortID id=InvalidPortID); virtual ~BaseMasterPort(); public: - BaseSlavePort& getSlavePort() const; - }; /** @@ -88,18 +86,14 @@ class BaseMasterPort : public Port */ class BaseSlavePort : public Port { - protected: + BaseMasterPort *_baseMasterPort; - BaseMasterPort* _baseMasterPort; - - BaseSlavePort(const std::string& name, PortID id=InvalidPortID); + BaseSlavePort(const std::string &name, PortID id=InvalidPortID); virtual ~BaseSlavePort(); public: - BaseMasterPort& getMasterPort() const; - }; /** Forward declaration */ @@ -111,22 +105,22 @@ class SlavePort; * transport functions. In addition to the basic functionality of * sending packets, it also has functions to receive range changes or * determine if the port is snooping or not. + * + * The three protocols are atomic, timing, and functional, each with its own + * header file. */ -class MasterPort : public BaseMasterPort +class MasterPort : public BaseMasterPort, public AtomicRequestProtocol, + public TimingRequestProtocol, public FunctionalRequestProtocol { - friend class SlavePort; private: - - SlavePort* _slavePort; + SlavePort *_slavePort; protected: - - SimObject& owner; + SimObject &owner; public: - MasterPort(const std::string& name, SimObject* _owner, PortID id=InvalidPortID); virtual ~MasterPort(); @@ -143,6 +137,31 @@ class MasterPort : public BaseMasterPort void unbind() override; /** + * Determine if this master port is snooping or not. The default + * implementation returns false and thus tells the neighbour we + * are not snooping. Any master port that wants to receive snoop + * requests (e.g. a cache connected to a bus) has to override this + * function. + * + * @return true if the port should be considered a snooper + */ + virtual bool isSnooping() const { return false; } + + /** + * Get the address ranges of the connected slave port. + */ + AddrRangeList getAddrRanges() const; + + /** + * Inject a PrintReq for the given address to print the state of + * that address throughout the memory system. For debugging. + */ + void printAddr(Addr a); + + public: + /* The atomic protocol. */ + + /** * Send an atomic request packet, where the data is moved and the * state is updated in zero time, without interleaving with other * memory accesses. @@ -165,6 +184,9 @@ class MasterPort : public BaseMasterPort */ Tick sendAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor); + public: + /* The functional protocol. */ + /** * Send a functional request packet, where the data is instantly * updated everywhere in the memory system, without affecting the @@ -172,7 +194,10 @@ class MasterPort : public BaseMasterPort * * @param pkt Packet to send. */ - void sendFunctional(PacketPtr pkt); + void sendFunctional(PacketPtr pkt) const; + + public: + /* The timing protocol. */ /** * Attempt to send a timing request to the slave port by calling @@ -219,84 +244,43 @@ class MasterPort : public BaseMasterPort */ virtual void sendRetryResp(); + protected: /** - * Determine if this master port is snooping or not. The default - * implementation returns false and thus tells the neighbour we - * are not snooping. Any master port that wants to receive snoop - * requests (e.g. a cache connected to a bus) has to override this - * function. - * - * @return true if the port should be considered a snooper - */ - virtual bool isSnooping() const { return false; } - - /** - * Get the address ranges of the connected slave port. - */ - AddrRangeList getAddrRanges() const; - - /** Inject a PrintReq for the given address to print the state of - * that address throughout the memory system. For debugging. + * Called to receive an address range change from the peer slave + * port. The default implementation ignores the change and does + * nothing. Override this function in a derived class if the owner + * needs to be aware of the address ranges, e.g. in an + * interconnect component like a bus. */ - void printAddr(Addr a); - - protected: + virtual void recvRangeChange() { } /** - * Receive an atomic snoop request packet from the slave port. + * Default implementations. */ - virtual Tick recvAtomicSnoop(PacketPtr pkt) + Tick + recvAtomicSnoop(PacketPtr pkt) override { panic("%s was not expecting an atomic snoop request\n", name()); return 0; } - /** - * Receive a functional snoop request packet from the slave port. - */ - virtual void recvFunctionalSnoop(PacketPtr pkt) + void + recvFunctionalSnoop(PacketPtr pkt) override { panic("%s was not expecting a functional snoop request\n", name()); } - /** - * Receive a timing response from the slave port. - */ - virtual bool recvTimingResp(PacketPtr pkt) = 0; - - /** - * Receive a timing snoop request from the slave port. - */ - virtual void recvTimingSnoopReq(PacketPtr pkt) + void + recvTimingSnoopReq(PacketPtr pkt) override { - panic("%s was not expecting a timing snoop request\n", name()); + panic("%s was not expecting a timing snoop request.\n", name()); } - /** - * Called by the slave port if sendTimingReq was called on this - * master port (causing recvTimingReq to be called on the slave - * port) and was unsuccesful. - */ - virtual void recvReqRetry() = 0; - - /** - * Called by the slave port if sendTimingSnoopResp was called on this - * master port (causing recvTimingSnoopResp to be called on the slave - * port) and was unsuccesful. - */ - virtual void recvRetrySnoopResp() + void + recvRetrySnoopResp() override { - panic("%s was not expecting a snoop retry\n", name()); + panic("%s was not expecting a snoop retry.\n", name()); } - - /** - * Called to receive an address range change from the peer slave - * port. The default implementation ignores the change and does - * nothing. Override this function in a derived class if the owner - * needs to be aware of the address ranges, e.g. in an - * interconnect component like a bus. - */ - virtual void recvRangeChange() { } }; /** @@ -304,28 +288,64 @@ class MasterPort : public BaseMasterPort * basic functionality of sending packets to its master peer, it also * has functions specific to a slave, e.g. to send range changes * and get the address ranges that the port responds to. + * + * The three protocols are atomic, timing, and functional, each with its own + * header file. */ -class SlavePort : public BaseSlavePort +class SlavePort : public BaseSlavePort, public AtomicResponseProtocol, + public TimingResponseProtocol, public FunctionalResponseProtocol { - friend class MasterPort; private: - MasterPort* _masterPort; bool defaultBackdoorWarned; protected: - SimObject& owner; public: - SlavePort(const std::string& name, SimObject* _owner, PortID id=InvalidPortID); virtual ~SlavePort(); /** + * Find out if the peer master port is snooping or not. + * + * @return true if the peer master port is snooping + */ + bool isSnooping() const { return _masterPort->isSnooping(); } + + /** + * Called by the owner to send a range change + */ + void + sendRangeChange() const + { + fatal_if(!_masterPort, + "%s cannot sendRangeChange() without master port.", name()); + _masterPort->recvRangeChange(); + } + + /** + * Get a list of the non-overlapping address ranges the owner is + * responsible for. All slave ports must override this function + * and return a populated list with at least one item. + * + * @return a list of ranges responded to + */ + virtual AddrRangeList getAddrRanges() const = 0; + + /** + * We let the master port do the work, so these don't do anything. + */ + void unbind() override {} + void bind(Port &peer) override {} + + public: + /* The atomic protocol. */ + + /** * Send an atomic snoop request packet, where the data is moved * and the state is updated in zero time, without interleaving * with other memory accesses. @@ -334,7 +354,14 @@ class SlavePort : public BaseSlavePort * * @return Estimated latency of access. */ - Tick sendAtomicSnoop(PacketPtr pkt); + Tick + sendAtomicSnoop(PacketPtr pkt) + { + return AtomicResponseProtocol::sendSnoop(_masterPort, pkt); + } + + public: + /* The functional protocol. */ /** * Send a functional snoop request packet, where the data is @@ -343,7 +370,14 @@ class SlavePort : public BaseSlavePort * * @param pkt Snoop packet to send. */ - void sendFunctionalSnoop(PacketPtr pkt); + void + sendFunctionalSnoop(PacketPtr pkt) const + { + FunctionalResponseProtocol::sendSnoop(_masterPort, pkt); + } + + public: + /* The timing protocol. */ /** * Attempt to send a timing response to the master port by calling @@ -356,7 +390,11 @@ class SlavePort : public BaseSlavePort * * @return If the send was succesful or not. */ - bool sendTimingResp(PacketPtr pkt); + bool + sendTimingResp(PacketPtr pkt) + { + return TimingResponseProtocol::sendResp(_masterPort, pkt); + } /** * Attempt to send a timing snoop request packet to the master port @@ -365,53 +403,33 @@ class SlavePort : public BaseSlavePort * * @param pkt Packet to send. */ - void sendTimingSnoopReq(PacketPtr pkt); + void + sendTimingSnoopReq(PacketPtr pkt) + { + TimingResponseProtocol::sendSnoopReq(_masterPort, pkt); + } /** * Send a retry to the master port that previously attempted a * sendTimingReq to this slave port and failed. */ - void sendRetryReq(); + void + sendRetryReq() + { + TimingResponseProtocol::sendRetryReq(_masterPort); + } /** * Send a retry to the master port that previously attempted a * sendTimingSnoopResp to this slave port and failed. */ - void sendRetrySnoopResp(); - - /** - * Find out if the peer master port is snooping or not. - * - * @return true if the peer master port is snooping - */ - bool isSnooping() const { return _masterPort->isSnooping(); } - - /** - * Called by the owner to send a range change - */ - void sendRangeChange() const { - if (!_masterPort) - fatal("%s cannot sendRangeChange() without master port", name()); - _masterPort->recvRangeChange(); + void + sendRetrySnoopResp() + { + TimingResponseProtocol::sendRetrySnoopResp(_masterPort); } - /** - * Get a list of the non-overlapping address ranges the owner is - * responsible for. All slave ports must override this function - * and return a populated list with at least one item. - * - * @return a list of ranges responded to - */ - virtual AddrRangeList getAddrRanges() const = 0; - - /** - * We let the master port do the work, so these don't do anything. - */ - void unbind() override {} - void bind(Port &peer) override {} - protected: - /** * Called by the master port to unbind. Should never be called * directly. @@ -425,48 +443,63 @@ class SlavePort : public BaseSlavePort void slaveBind(MasterPort& master_port); /** - * Receive an atomic request packet from the master port. - */ - virtual Tick recvAtomic(PacketPtr pkt) = 0; - - /** - * Receive an atomic request packet from the master port, and optionally - * provide a backdoor to the data being accessed. - */ - virtual Tick recvAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor); - - /** - * Receive a functional request packet from the master port. + * Default implementations. */ - virtual void recvFunctional(PacketPtr pkt) = 0; + Tick recvAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor) override; - /** - * Receive a timing request from the master port. - */ - virtual bool recvTimingReq(PacketPtr pkt) = 0; - - /** - * Availability request from the master port. - */ - virtual bool tryTiming(PacketPtr pkt) { + bool + tryTiming(PacketPtr pkt) override + { panic("%s was not expecting a %s\n", name(), __func__); } - /** - * Receive a timing snoop response from the master port. - */ - virtual bool recvTimingSnoopResp(PacketPtr pkt) + bool + recvTimingSnoopResp(PacketPtr pkt) override { panic("%s was not expecting a timing snoop response\n", name()); } +}; - /** - * Called by the master port if sendTimingResp was called on this - * slave port (causing recvTimingResp to be called on the master - * port) and was unsuccesful. - */ - virtual void recvRespRetry() = 0; +inline Tick +MasterPort::sendAtomic(PacketPtr pkt) +{ + return AtomicRequestProtocol::send(_slavePort, pkt); +} -}; +inline Tick +MasterPort::sendAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor) +{ + return AtomicRequestProtocol::sendBackdoor(_slavePort, pkt, backdoor); +} + +inline void +MasterPort::sendFunctional(PacketPtr pkt) const +{ + return FunctionalRequestProtocol::send(_slavePort, pkt); +} + +inline bool +MasterPort::sendTimingReq(PacketPtr pkt) +{ + return TimingRequestProtocol::sendReq(_slavePort, pkt); +} + +inline bool +MasterPort::tryTiming(PacketPtr pkt) const +{ + return TimingRequestProtocol::trySend(_slavePort, pkt); +} + +inline bool +MasterPort::sendTimingSnoopResp(PacketPtr pkt) +{ + return TimingRequestProtocol::sendSnoopResp(_slavePort, pkt); +} + +inline void +MasterPort::sendRetryResp() +{ + TimingRequestProtocol::sendRetryResp(_slavePort); +} #endif //__MEM_PORT_HH__ diff --git a/src/mem/timing_protocol.cc b/src/mem/timing_protocol.cc new file mode 100644 index 000000000..bc56ce2e3 --- /dev/null +++ b/src/mem/timing_protocol.cc @@ -0,0 +1,105 @@ +/* + * Copyright (c) 2012,2015,2017 ARM Limited + * 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. + * + * Copyright (c) 2002-2005 The Regents of The University of Michigan + * All rights reserved. + * + * 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. + * + * Authors: Steve Reinhardt + * Andreas Hansson + * William Wang + */ + +#include "mem/timing_protocol.hh" + +/* The request protocol. */ + +bool +TimingRequestProtocol::sendReq(TimingResponseProtocol *peer, PacketPtr pkt) +{ + assert(pkt->isRequest()); + return peer->recvTimingReq(pkt); +} + +bool +TimingRequestProtocol::trySend( + TimingResponseProtocol *peer, PacketPtr pkt) const +{ + assert(pkt->isRequest()); + return peer->tryTiming(pkt); +} + +bool +TimingRequestProtocol::sendSnoopResp( + TimingResponseProtocol *peer, PacketPtr pkt) +{ + assert(pkt->isResponse()); + return peer->recvTimingSnoopResp(pkt); +} + +void +TimingRequestProtocol::sendRetryResp(TimingResponseProtocol *peer) +{ + peer->recvRespRetry(); +} + +/* The response protocol. */ + +bool +TimingResponseProtocol::sendResp(TimingRequestProtocol *peer, PacketPtr pkt) +{ + assert(pkt->isResponse()); + return peer->recvTimingResp(pkt); +} + +void +TimingResponseProtocol::sendSnoopReq( + TimingRequestProtocol *peer, PacketPtr pkt) +{ + assert(pkt->isRequest()); + peer->recvTimingSnoopReq(pkt); +} + +void +TimingResponseProtocol::sendRetryReq(TimingRequestProtocol *peer) +{ + peer->recvReqRetry(); +} + +void +TimingResponseProtocol::sendRetrySnoopResp(TimingRequestProtocol *peer) +{ + peer->recvRetrySnoopResp(); +} diff --git a/src/mem/timing_protocol.hh b/src/mem/timing_protocol.hh new file mode 100644 index 000000000..42235732c --- /dev/null +++ b/src/mem/timing_protocol.hh @@ -0,0 +1,190 @@ +/* + * Copyright (c) 2011-2012,2015,2017 ARM Limited + * 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. + * + * Copyright (c) 2002-2005 The Regents of The University of Michigan + * All rights reserved. + * + * 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. + * + * Authors: Ron Dreslinski + * Andreas Hansson + * William Wang + */ + +#ifndef __MEM_TIMING_PROTOCOL_HH__ +#define __MEM_TIMING_PROTOCOL_HH__ + +#include "mem/packet.hh" + +class TimingResponseProtocol; + +class TimingRequestProtocol +{ + friend class TimingResponseProtocol; + + protected: + /** + * Attempt to send a timing request to the peer by calling + * its corresponding receive function. If the send does not + * succeed, as indicated by the return value, then the sender must + * wait for a recvReqRetry at which point it can re-issue a + * sendTimingReq. + * + * @param peer Peer to send packet to. + * @param pkt Packet to send. + * + * @return If the send was succesful or not. + */ + bool sendReq(TimingResponseProtocol *peer, PacketPtr pkt); + + /** + * Check if the peer can handle a timing request. + * + * If the send cannot be handled at the moment, as indicated by + * the return value, then the sender will receive a recvReqRetry + * at which point it can re-issue a sendTimingReq. + * + * @param peer Peer to send packet to. + * @param pkt Packet to send. + * + * @return If the send was succesful or not. + */ + bool trySend(TimingResponseProtocol *peer, PacketPtr pkt) const; + + /** + * Attempt to send a timing snoop response packet to it's peer + * by calling its corresponding receive function. If the send + * does not succeed, as indicated by the return value, then the + * sender must wait for a recvRetrySnoop at which point it can + * re-issue a sendTimingSnoopResp. + * + * @param pkt Packet to send. + */ + bool sendSnoopResp(TimingResponseProtocol *peer, PacketPtr pkt); + + /** + * Send a retry to the peer that previously attempted a + * sendTimingResp to this protocol and failed. + */ + void sendRetryResp(TimingResponseProtocol *peer); + + /** + * Receive a timing response from the peer. + */ + virtual bool recvTimingResp(PacketPtr pkt) = 0; + + /** + * Receive a timing snoop request from the peer. + */ + virtual void recvTimingSnoopReq(PacketPtr pkt) = 0; + + /** + * Called by the peer if sendTimingReq was called on this peer (causing + * recvTimingReq to be called on the peer) and was unsuccessful. + */ + virtual void recvReqRetry() = 0; + + /** + * Called by the peer if sendTimingSnoopResp was called on this + * protocol (causing recvTimingSnoopResp to be called on the peer) + * and was unsuccessful. + */ + virtual void recvRetrySnoopResp() = 0; +}; + +class TimingResponseProtocol +{ + friend class TimingRequestProtocol; + + protected: + /** + * Attempt to send a timing response to the peer by calling + * its corresponding receive function. If the send does not + * succeed, as indicated by the return value, then the sender must + * wait for a recvRespRetry at which point it can re-issue a + * sendTimingResp. + * + * @param peer Peer to send the packet to. + * @param pkt Packet to send. + * + * @return If the send was succesful or not. + */ + bool sendResp(TimingRequestProtocol *peer, PacketPtr pkt); + + /** + * Attempt to send a timing snoop request packet to the peer + * by calling its corresponding receive function. Snoop requests + * always succeed and hence no return value is needed. + * + * @param peer Peer to send the packet to. + * @param pkt Packet to send. + */ + void sendSnoopReq(TimingRequestProtocol *peer, PacketPtr pkt); + + /** + * Send a retry to the peer that previously attempted a + * sendTimingReq to this protocol and failed. + */ + void sendRetryReq(TimingRequestProtocol *peer); + + /** + * Send a retry to the peer that previously attempted a + * sendTimingSnoopResp to this peer and failed. + */ + void sendRetrySnoopResp(TimingRequestProtocol *peer); + + /** + * Receive a timing request from the peer. + */ + virtual bool recvTimingReq(PacketPtr pkt) = 0; + + /** + * Availability request from the peer. + */ + virtual bool tryTiming(PacketPtr pkt) = 0; + + /** + * Receive a timing snoop response from the peer. + */ + virtual bool recvTimingSnoopResp(PacketPtr pkt) = 0; + + /** + * Called by the peer if sendTimingResp was called on this + * protocol (causing recvTimingResp to be called on the peer) + * and was unsuccessful. + */ + virtual void recvRespRetry() = 0; +}; + +#endif //__MEM_TIMING_PROTOCOL_HH__ |