| /* | |
| * Copyright 2022 Fraunhofer IESE | |
| * | |
| * 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. | |
| * | |
| */ | |
| #include <tlm_utils/simple_initiator_socket.h> | |
| #include <tlm_utils/simple_target_socket.h> | |
| #include <iomanip> | |
| #include <iostream> | |
| #include <map> | |
| #include <queue> | |
| #include <vector> | |
| #include "base/trace.hh" | |
| #include "systemc/ext/systemc" | |
| #include "systemc/ext/tlm" | |
| #define N 1024 | |
| using namespace std; | |
| using namespace sc_core; | |
| using namespace gem5; | |
| SC_MODULE(Initiator) | |
| { | |
| public: | |
| tlm_utils::simple_initiator_socket<Initiator> iSocket; | |
| protected: | |
| int data[16]; | |
| public: | |
| SC_CTOR(Initiator): iSocket("iSocket") | |
| { | |
| SC_THREAD(process); | |
| for (int i=0; i<16; i++) { | |
| data[i] = 0; | |
| } | |
| } | |
| protected: | |
| void process() | |
| { | |
| sc_time delay; | |
| for (int i = 0; i < N; i++) | |
| { | |
| tlm::tlm_generic_payload trans; | |
| data[i % 16] = i; | |
| trans.set_address(rand()%N); | |
| trans.set_data_length(4); | |
| trans.set_streaming_width(4); | |
| trans.set_command(tlm::TLM_WRITE_COMMAND); | |
| trans.set_data_ptr(reinterpret_cast<unsigned char*>(&data[i%16])); | |
| trans.set_response_status( tlm::TLM_INCOMPLETE_RESPONSE ); | |
| sc_time delay = sc_time(10, SC_NS); | |
| iSocket->b_transport(trans, delay); | |
| if (trans.is_response_error()) | |
| { | |
| SC_REPORT_FATAL(name(), "Response error"); | |
| } | |
| wait(delay); | |
| cout << "\033[1;31m(" | |
| << name() | |
| << ")@" << setfill(' ') << setw(12) << sc_time_stamp() | |
| << ": " << setw(12) << "Write to " | |
| << "Addr = " << setfill('0') << setw(8) | |
| << dec << trans.get_address() | |
| << " Data = " << "0x" << setfill('0') << setw(8) | |
| << hex << data[i%16] << "(b_transport) \033[0m" << endl; | |
| } | |
| } | |
| }; | |
| SC_MODULE(Target) | |
| { | |
| public: | |
| tlm_utils::simple_target_socket<Target> tSocket; | |
| private: | |
| unsigned char mem[512]; | |
| public: | |
| SC_HAS_PROCESS(Target); | |
| Target(sc_module_name name, unsigned int bufferSize = 8) : | |
| sc_module(name), | |
| tSocket("tSocket") | |
| { | |
| tSocket.register_b_transport(this, &Target::b_transport); | |
| } | |
| virtual void b_transport(tlm::tlm_generic_payload& trans, | |
| sc_time& delay) | |
| { | |
| executeTransaction(trans); | |
| } | |
| // Common to b_transport and nb_transport | |
| void executeTransaction(tlm::tlm_generic_payload& trans) | |
| { | |
| tlm::tlm_command cmd = trans.get_command(); | |
| sc_dt::uint64 adr = trans.get_address(); | |
| unsigned char* ptr = trans.get_data_ptr(); | |
| unsigned int len = trans.get_data_length(); | |
| unsigned char* byt = trans.get_byte_enable_ptr(); | |
| unsigned int wid = trans.get_streaming_width(); | |
| if (trans.get_address() >= 512) { | |
| trans.set_response_status( tlm::TLM_ADDRESS_ERROR_RESPONSE ); | |
| return; | |
| } | |
| if (byt != 0) { | |
| trans.set_response_status( tlm::TLM_BYTE_ENABLE_ERROR_RESPONSE ); | |
| return; | |
| } | |
| if (len > 4 || wid < len) { | |
| trans.set_response_status( tlm::TLM_BURST_ERROR_RESPONSE ); | |
| return; | |
| } | |
| if (cmd == tlm::TLM_READ_COMMAND) | |
| { | |
| memcpy(&mem[trans.get_address()], // destination | |
| trans.get_data_ptr(), // source | |
| trans.get_data_length()); // size | |
| } | |
| else if (cmd == tlm::TLM_WRITE_COMMAND) | |
| { | |
| memcpy(trans.get_data_ptr(), // destination | |
| &mem[trans.get_address()], // source | |
| trans.get_data_length()); // size | |
| } | |
| cout << "\033[1;32m(" | |
| << name() | |
| << ")@" << setfill(' ') << setw(12) << sc_time_stamp() | |
| << ": " << setw(12) << (cmd ? "Exec. Write " : "Exec. Read ") | |
| << "Addr = " << setfill('0') << setw(8) << dec << adr | |
| << " Data = " << "0x" << setfill('0') << setw(8) << hex | |
| << *reinterpret_cast<int*>(ptr) | |
| << "\033[0m" << endl; | |
| trans.set_response_status( tlm::TLM_OK_RESPONSE ); | |
| } | |
| }; | |
| template<unsigned int I, unsigned int T> | |
| SC_MODULE(Interconnect) | |
| { | |
| public: | |
| tlm_utils::simple_target_socket_tagged<Interconnect> tSocket[T]; | |
| tlm_utils::simple_initiator_socket_tagged<Interconnect> iSocket[I]; | |
| SC_CTOR(Interconnect) | |
| { | |
| for (unsigned int i = 0; i < T; i++) { | |
| tSocket[i].register_b_transport(this, | |
| &Interconnect::b_transport, | |
| i); | |
| } | |
| } | |
| private: | |
| int routeFW(int inPort, tlm::tlm_generic_payload &trans) | |
| { | |
| int outPort = 0; | |
| // Memory map implementation: | |
| if (trans.get_address() < 512) { | |
| outPort = 0; | |
| } else if (trans.get_address() >= 512 && trans.get_address() < 1024) { | |
| // Correct Address: | |
| trans.set_address(trans.get_address() - 512); | |
| outPort = 1; | |
| } else { | |
| trans.set_response_status( tlm::TLM_ADDRESS_ERROR_RESPONSE ); | |
| } | |
| return outPort; | |
| } | |
| virtual void b_transport( int id, | |
| tlm::tlm_generic_payload& trans, | |
| sc_time& delay ) | |
| { | |
| sc_assert(id < T); | |
| int outPort = routeFW(id, trans); | |
| iSocket[outPort]->b_transport(trans, delay); | |
| } | |
| }; | |
| int | |
| sc_main (int __attribute__((unused)) sc_argc, | |
| char __attribute__((unused)) *sc_argv[]) | |
| { | |
| Initiator * cpu1 = new Initiator("C1"); | |
| Initiator * cpu2 = new Initiator("C2"); | |
| Target * memory1 = new Target("M1"); | |
| Target * memory2 = new Target("M2"); | |
| Interconnect<2,2> * bus = new Interconnect<2,2>("B1"); | |
| cpu1->iSocket.bind(bus->tSocket[0]); | |
| cpu2->iSocket.bind(bus->tSocket[1]); | |
| bus->iSocket[0].bind(memory1->tSocket); | |
| bus->iSocket[1].bind(memory2->tSocket); | |
| sc_core::sc_start(); | |
| return 0; | |
| } |