diff --git a/DRAMSys/library/library.pro b/DRAMSys/library/library.pro index ad74744a..58c031bb 100644 --- a/DRAMSys/library/library.pro +++ b/DRAMSys/library/library.pro @@ -190,7 +190,9 @@ HEADERS += \ src/error/eccbaseclass.h \ src/error/ecchamming.h \ src/controller/scheduler/Fr_Fcfs_read_priority.h \ - src/controller/scheduler/Fr_Fcfs_grouper.h + src/controller/scheduler/Fr_Fcfs_grouper.h \ + src/simulation/IArbiter.h \ + src/simulation/SimpleArbiter.h thermalsim = $$(THERMALSIM) isEmpty(thermalsim) { diff --git a/DRAMSys/library/src/simulation/IArbiter.h b/DRAMSys/library/src/simulation/IArbiter.h new file mode 100644 index 00000000..7cf75bff --- /dev/null +++ b/DRAMSys/library/src/simulation/IArbiter.h @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2015, University of Kaiserslautern + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. 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. + * + * 3. Neither the name of the copyright holder 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 HOLDER + * 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: + * Matthias Jung + * Felipe S. Prado + */ + +#ifndef IARBITER_H_ +#define IARBITER_H_ + +#include +#include +#include +#include +#include +#include +#include +#include "../controller/core/configuration/ConfigurationLoader.h" + +using namespace std; +using namespace tlm; + +struct IArbiter: public sc_module { +public: + tlm_utils::multi_passthrough_initiator_socket iSocket; + tlm_utils::multi_passthrough_target_socket tSocket; + + SC_CTOR(IArbiter) { + // The arbiter communicates with one or more memory unity through one or more sockets (one or more memory channels). + // Each of the arbiter's initiator sockets is bound to a memory controller's target socket. + // Anytime an transaction comes from a memory unity to the arbiter the "bw" callback is called. + iSocket.register_nb_transport_bw(this, &IArbiter::nb_transport_bw); + + // One or more devices can accesss all the memory units through the arbiter. + // Devices' initiator sockets are bound to arbiter's target sockets. + // As soon the arbiter receives a request in any of its target sockets it should treat and forward it to the proper memory channel. + tSocket.register_nb_transport_fw(this, &IArbiter::nb_transport_fw); + + tSocket.register_transport_dbg(this, &IArbiter::transport_dbg); + } + + virtual void setTlmRecorder(TlmRecorder* recorder) = 0; + virtual bool isOutputBufferFull(unsigned int initiatorSocket) = 0; + virtual void incrementNumberOfOutputBufferTransactions(unsigned int initiatorSocket) = 0; + +protected: + // Initiated by dram side + // This function is called when an arbiter's initiator socket receives a transaction from a memory controller + virtual tlm_sync_enum nb_transport_bw(int channelId, tlm_generic_payload &payload, tlm_phase &phase, sc_time &bwDelay) = 0; + + // Initiated by initiator side + // This function is called when an arbiter's target socket receives a transaction from a device + virtual tlm_sync_enum nb_transport_fw(int id, tlm_generic_payload& payload, tlm_phase& phase, sc_time& fwDelay) = 0; + + virtual unsigned int transport_dbg(int /*id*/, tlm::tlm_generic_payload &trans) = 0; +}; + +#endif /* IARBITER_H_ */ diff --git a/DRAMSys/library/src/simulation/SimpleArbiter.h b/DRAMSys/library/src/simulation/SimpleArbiter.h new file mode 100644 index 00000000..4ae4c89d --- /dev/null +++ b/DRAMSys/library/src/simulation/SimpleArbiter.h @@ -0,0 +1,171 @@ +#ifndef SIMPLEARBITER_H +#define SIMPLEARBITER_H + +#include "IArbiter.h" +#include "../common/xmlAddressdecoder.h" +#include "../common/dramExtension.h" +#include "../controller/core/TimingCalculation.h" + +using namespace std; +using namespace tlm; + +struct SimpleArbiter: public IArbiter{ +public: + SimpleArbiter(sc_module_name name) : IArbiter(name) { + } + + void setTlmRecorder(TlmRecorder* recorder) + { + tlmRecorder = recorder; + } + + virtual bool isOutputBufferFull(unsigned int /*initiatorSocket*/) + { + return false; + } + + virtual void incrementNumberOfOutputBufferTransactions(unsigned int /*initiatorSocket*/) + { + } + +protected: + TlmRecorder* tlmRecorder; + + // Initiated by dram side + // This function is called when an arbiter's initiator socket receives a transaction from a memory controller + virtual tlm_sync_enum nb_transport_bw(int /*channelId*/, tlm_generic_payload &payload, tlm_phase &phase, sc_time &bwDelay) + { + tlmRecorder->recordPhase(payload, phase, bwDelay + sc_time_stamp()); + + sendToInitiator(getPayloadThread(payload)-1, payload, phase, bwDelay); + + if(phase == BEGIN_RESP) + { + // Early Completion [3.1] + tlmRecorder->recordPhase(payload, END_RESP, bwDelay + sc_time_stamp()); + tlmRecorder->recordArbiterPhase(payload, BEGIN_RESP, sc_time_stamp()+bwDelay); + return TLM_COMPLETED; + } + // 4-Phase Handshake [1.3] + return TLM_ACCEPTED; + } + + // Initiated by initiator side + // This function is called when an arbiter's target socket receives a transaction from a device + virtual tlm_sync_enum nb_transport_fw(int id, tlm_generic_payload& payload, tlm_phase& phase, sc_time& fwDelay) + { + if (phase == BEGIN_REQ) + { + payload.acquire(); + // adjust address offset, e.g. for gem5 simulation + payload.set_address(payload.get_address() - Configuration::getInstance().AddressOffset); + + // In the begin request phase the socket ID is appended to the payload. + // It will extracted from the payload and used later. + appendDramExtension(id, payload); + + tlmRecorder->recordArbiterPhase(payload, phase, sc_time_stamp()+fwDelay); + tlmRecorder->recordArbiterPhase(payload, END_REQ,sc_time_stamp()+fwDelay); + tlmRecorder->recordPhase(payload, phase, sc_time_stamp()+fwDelay); + + // Forward Path [1.0] + sendToChannel(getPayloadChannel(payload), payload, phase, fwDelay); + } + else if(phase == END_RESP) + { + payload.release(); + tlmRecorder->recordArbiterPhase(payload, phase, sc_time_stamp()+fwDelay); + } + else + { + SC_REPORT_FATAL("Arbiter", "Illegal phase received by initiator"); + } + + // 4-Phase Handshake [1.1] + // 4-Phase Handshake [1.7] + return TLM_ACCEPTED; + } + + virtual unsigned int transport_dbg(int /*id*/, tlm::tlm_generic_payload &trans) + { + // adjust address offset: + trans.set_address(trans.get_address() - Configuration::getInstance().AddressOffset); + + DecodedAddress decodedAddress = xmlAddressDecoder::getInstance().decodeAddress(trans.get_address()); + size_t index = decodedAddress.channel*Configuration::getInstance().memSpec.NumberOfBanks + DramExtension::getBank(trans).ID(); + return iSocket[index]->transport_dbg(trans); + } + + virtual tlm_sync_enum sendToChannel(unsigned int /*channelId*/, tlm_generic_payload& payload, const tlm_phase& phase, const sc_time& delay) + { + tlm_phase TPhase = phase; + sc_time TDelay = delay; + return iSocket[getISocketIndex(payload)]->nb_transport_fw(payload, TPhase, TDelay); + } + + virtual unsigned int getISocketIndex(tlm_generic_payload& payload) + { + return DramExtension::getBank(payload).ID(); + } + + virtual tlm_sync_enum sendToInitiator(unsigned int id, tlm_generic_payload& payload, const tlm_phase& phase, const sc_time& delay) + { + tlm_phase TPhase = phase; + sc_time TDelay = delay; + return tSocket[id]->nb_transport_bw(payload, TPhase, TDelay); + } + + void printDebugMessage(std::string message) + { + DebugManager::getInstance().printDebugMessage(this->name(), message); + } + + void appendDramExtension(int socketId, tlm_generic_payload& payload) + { + // Append Generation Extension + GenerationExtension* genExtension = new GenerationExtension(clkAlign(sc_time_stamp(),Configuration::getInstance().ControllerClk)); + payload.set_auto_extension(genExtension); + + unsigned int burstlength = payload.get_streaming_width(); + DecodedAddress decodedAddress = xmlAddressDecoder::getInstance().decodeAddress(payload.get_address()); + // Check the valid range of decodedAddress + if (addressIsValid(decodedAddress)) { + DramExtension* extension = new DramExtension(Thread(socketId+1), Channel(decodedAddress.channel), Bank(decodedAddress.bank), BankGroup(decodedAddress.bankgroup), Row(decodedAddress.row), Column(decodedAddress.column),burstlength); + payload.set_auto_extension(extension); + } else { + SC_REPORT_FATAL("Arbiter", "Decoded Address are not inside the valid range"); + } + } + + bool addressIsValid(DecodedAddress& decodedAddress) + { + if (decodedAddress.channel >= xmlAddressDecoder::getInstance().amount["channel"]) { + return false; + } + if (decodedAddress.bank >= xmlAddressDecoder::getInstance().amount["bank"]) { + return false; + } + if (decodedAddress.bankgroup > xmlAddressDecoder::getInstance().amount["bankgroup"]) { + return false; + } + if (decodedAddress.column >= xmlAddressDecoder::getInstance().amount["column"]) { + return false; + } + if (decodedAddress.row >= xmlAddressDecoder::getInstance().amount["row"]) { + return false; + } + return true; + } + + unsigned int getPayloadChannel(tlm_generic_payload& payload) + { + return DramExtension::getExtension(payload).getChannel().ID(); + } + + unsigned int getPayloadThread(tlm_generic_payload& payload) + { + return DramExtension::getExtension(payload).getThread().ID(); + } +}; + +#endif // SIMPLEARBITER_H