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')
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')
--- /dev/null
+/*
+ * 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);
+}
--- /dev/null
+/*
+ * 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__
--- /dev/null
+/*
+ * 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);
+}
--- /dev/null
+/*
+ * 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__
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)
{
}
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();
-}
#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;
*/
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;
-
};
/**
*/
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 */
* 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();
*/
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
*/
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
*
* @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
*/
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() { }
};
/**
* 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
*
* @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
*
* @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
*
* @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
*
* @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.
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__
--- /dev/null
+/*
+ * 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();
+}
--- /dev/null
+/*
+ * 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__
projects / gem5.git / commitdiff