testbench_in.h

Go to the documentation of this file.

#ifndef TESTBENCH_IN_H
#define TESTBENCH_IN_H

// Needed for the simple_target_socket
#define SC_INCLUDE_DYNAMIC_PROCESSES

#include <systemc.h>
#include "tlm.h"
#include "tlm_utils/simple_initiator_socket.h"
#include "tlm_utils/simple_target_socket.h"
#include "tlm_utils/multi_passthrough_initiator_socket.h"
#include "tlm_utils/multi_passthrough_target_socket.h"
#include "tlm_utils/peq_with_cb_and_phase.h"
#include "utils.h"
#include "memory_manager.h"
#include "trace.h"
#include "simulation_controller.h"
#include "user_parameters.h"
#include "testbench_in_interface.h"
#include "testbench_algorithms.h"
#include <map>
#include <set>

using namespace sc_core;
using namespace sc_dt;
using namespace std;
using namespace tlm;
using namespace tlm_utils;

#define FOUT if(generate_logfile()) (*fout)

DECLARE_EXTENDED_PHASE(internal_ph_tb);

template<int Ni>
class TestbenchIn : public sc_module, public Testbench_in_interface<Ni> {

public:

        // I/O sockets
        multi_passthrough_target_socket<TestbenchIn> input_target_socket;
        
private:

        // Payload event queues
        peq_with_cb_and_phase<TestbenchIn> m_peq_targ;

        // Maps to retrieve socket ID from a transaction in PEQ callbacks
        map<tlm_generic_payload*, unsigned int> m_id_targ_map;
        
        // Events
        sc_event response_received_event[Ni];
        sc_event transaction_received;
        
        // Transactions
        tlm_generic_payload* incoming_transaction[Ni];
        tlm_generic_payload* incoming_transaction_pending[Ni];

        // Memory manager
        Memory_manager m_mm;

        // Data
        int *data_in[Ni];
        uint64 address_in[Ni];
        int nb_data_received[Ni];

        // Packet sizes
        int input_packet_size[Ni];

        // Timing parameters
        sc_time end_req_time[Ni];
        sc_time begin_resp_time[Ni];
        sc_time computation_time;

        // Trace methods events
        sc_event set_target_phase_end_req_event[Ni];
        sc_event set_target_phase_begin_resp_event[Ni];

        // Log file stream
        ofstream* fout;

        // Trace file
        sc_trace_file *tf;
        trace_packet_testbench_t<Ni, 0> trace_packet;

        // Misc
        int nb_responses_received;              /*< Number of responses received so far */
        int current_transaction_id;             /*< Transaction currently processed */

        vector<string> preceding_modules_connection_name;


        // Priority channels / Communications
        set<int> priority_channels_in;
        int nb_non_priority_channels_requests_in;
        sc_event decrement_nb_non_priority_channels_requests_in_event;  
        sc_event shared_channel_in_ready_event;                                                 
        sc_event send_end_req_event[Ni];                                                                
        string applicationName;

        void (*testbench_thread_ptr)(Testbench_in_interface<Ni> &);

        vector<int> sockets_with_new_transactions;

public:

        // Constructor
        SC_HAS_PROCESS(TestbenchIn);
        TestbenchIn(sc_module_name instname, void (*tb_thread)(Testbench_in_interface<Ni> &), ofstream& logfile, sc_trace_file *mtf) :
                        input_target_socket("input_socket"),
                        m_peq_targ(this, &TestbenchIn::peq_targ_callback),
                        fout(&logfile),
                        testbench_thread_ptr(tb_thread),
                        tf(mtf) {

                for(int i = 0; i < Ni; i++) {
                        incoming_transaction[i]= 0;
                        incoming_transaction_pending[i]= 0;
                        nb_data_received[i] = 0;
                }

                nb_responses_received = 0;
                current_transaction_id = 0;
                nb_non_priority_channels_requests_in = 0;
                
                // Data in initialization
                for(int i = 0; i < Ni; i++) {
                        input_packet_size[i] = 16;
                        data_in[i] = new int[input_packet_size[i]];
                        for(int j = 0; j < input_packet_size[i]; j++) data_in[i][j] = 0;
                }
        
                // Init timing parameters
                for(int i = 0; i < Ni; i++) end_req_time[Ni] = sc_time(50, SC_US);
                for(int i = 0; i < Ni; i++) begin_resp_time[Ni] = sc_time(50, SC_US);
                computation_time = sc_time(500, SC_US);

                // Register transport methods
                input_target_socket.register_nb_transport_fw(this, &TestbenchIn::nb_transport_fw);
                
                // Spawn testbench thread as a function outside the class
                sc_spawn(sc_bind(testbench_thread_ptr, sc_ref(*this)), "testbench_in_thread");

                SC_METHOD(decrement_nb_non_priority_channels_requests_in_method);
                sensitive << decrement_nb_non_priority_channels_requests_in_event;
                dont_initialize();

                // Dynamic threads initialization for tracing purpose: set_target_phase_end_req
                for(int i = 0; i < Ni; i++) {
                        sc_spawn_options method_options;
                        method_options.spawn_method();
                        method_options.dont_initialize();
                        method_options.set_sensitivity(&set_target_phase_end_req_event[i]);
                        string process_name("set_target_phase_end_req_process_");
                        ostringstream out;
                        out << i;
                        process_name.append(out.str());

                        sc_spawn(sc_bind(&TestbenchIn<Ni>::set_target_phase_end_req, this, i), process_name.c_str(), &method_options);
                }

                // Dynamic threads initialization for tracing purpose: set_target_phase_begin_resp
                for(int i = 0; i < Ni; i++) {
                        sc_spawn_options method_options;
                        method_options.spawn_method();
                        method_options.dont_initialize();
                        method_options.set_sensitivity(&set_target_phase_begin_resp_event[i]);
                        string process_name("set_target_phase_begin_resp_process_");
                        ostringstream out;
                        out << i;
                        process_name.append(out.str());

                        sc_spawn(sc_bind(&TestbenchIn<Ni>::set_target_phase_begin_resp, this, i), process_name.c_str(), &method_options);
                }

                // Send end req process
                for(int i = 0; i < Ni; i++) {
                        sc_spawn_options method_options;
                        method_options.spawn_method();
                        method_options.dont_initialize();
                        method_options.set_sensitivity(&send_end_req_event[i]);
                        string process_name("set_end_req_process_process_");
                        ostringstream out;
                        out << i;
                        process_name.append(out.str());

                        sc_spawn(sc_bind(&TestbenchIn<Ni>::send_end_req_method, this, i), process_name.c_str(), &method_options);
                }

                // Add signals to trace
                init_packet();
                sc_trace(tf, trace_packet, (string) name());
        }

        ~TestbenchIn() {
                for(int i = 0; i < Ni; i++) {
                        delete[] data_in[i];
                }
        }

        // Payload event queue callback function
        void peq_targ_callback(tlm_generic_payload& trans, const tlm_phase& phase);
        
        // Transport methods
        virtual tlm_sync_enum nb_transport_fw(int id, tlm_generic_payload& trans, tlm_phase& phase, sc_time& delay);

        // Helper functions
        void send_response(int id, tlm_generic_payload& trans);
        tlm_sync_enum send_end_req(int socketID, tlm_generic_payload& trans);

        void decrement_nb_non_priority_channels_requests_in_method(void);

        // Simulation controller interface
        void notify_simulation_controller(bool);

        // Testbench interface methods
        string getName(void) const;

        // User interface
        void verify_bindings(void);
        void set_packet_size(string connection_name, int val);

        void add_preceding_module_connection_name(string name);
        void add_timing_info(tlm_phase_enum phase, string connection_name, sc_time time);
        void set_end_req_time(string connection_name, sc_time t);
        void set_begin_resp_time(string connection_name, sc_time t);

        void info(void);

        // Trace packet
        void init_packet(void);
        void update_target_packet(int id, tlm_phase phase);
        void update_target_packet(int id);
        void set_target_phase_end_req(int id);
        void set_target_phase_begin_resp(int id);

        // Priority channels
        void add_priority_channel(string connection_name);
        bool is_priority_channel_in(int id);
        void send_end_req_method(int id);

        void set_application_name(string n);

        int get_input_socket_id(string connection_name) const;


        // TB In Interface
        const char * TB_IF_name(void) const;
        string TB_IF_get_instance_name(void) const;
        const sc_event& TB_IF_transaction_received_event(void) const;
        const int TB_IF_get_nb_transactions_received_per_socket(int socketID) const;
        const int TB_IF_get_nb_transactions_received_per_socket(string channelName) const;
        const int TB_IF_get_nb_transactions_received(void) const;
        int* TB_IF_get_data_in_ptr(int) const;
        int* TB_IF_get_data_in_ptr(string) const;
        void TB_IF_notify_simulation_controller(bool);
        int TB_IF_get_packet_size(int ID) const;
        int TB_IF_get_packet_size(string name) const;
        int TB_IF_get_input_socket_id(string name) const;
        string TB_IF_get_connection_name(int id) const;
        vector<int> TB_IF_get_sockets_with_new_transactions(void);
};


/***********************************
 ******      Target part      ******
 ***********************************/

// Forward path for the target socket
template<int Ni>
tlm_sync_enum TestbenchIn<Ni>::nb_transport_fw(int id, tlm_generic_payload& trans, tlm_phase& phase, sc_time& delay) {

        sc_dt::uint64    adr = trans.get_address();
    unsigned int     len = trans.get_data_length();
    unsigned char*   byt = trans.get_byte_enable_ptr();
    unsigned int     wid = trans.get_streaming_width();

    // Obliged to check the transaction attributes for unsupported features
    // and to generate the appropriate error response
        if (byt != 0) {
                trans.set_response_status(TLM_BYTE_ENABLE_ERROR_RESPONSE);
                return TLM_COMPLETED;
        }
        if (len > (4 * (unsigned int) input_packet_size[id]) || wid < len) {
                trans.set_response_status(TLM_BURST_ERROR_RESPONSE);
                return TLM_COMPLETED;
        }

        // Now queue the transaction until the annotated time has elapsed
        m_id_targ_map[&trans] = id;
        m_peq_targ.notify(trans, phase, delay);

        return TLM_ACCEPTED;
}

// Payload event queue callback (Target side)
template<int Ni>
void TestbenchIn<Ni>::peq_targ_callback(tlm_generic_payload& trans, const tlm_phase& phase) {
        
        int socketID = m_id_targ_map[&trans];

        int nb_total_data_received = 0;

        #ifdef DEBUG
                if(phase == BEGIN_REQ)
                        FOUT << sc_time_stamp() << ": " << name() << " (T" << socketID << ") received BEGIN_REQ at address " << hex << trans.get_address() << endl;
                else if(phase == END_RESP)
                        FOUT << sc_time_stamp() << ": " << name() << " (T" << socketID << ") received END_RESP at address " << hex << trans.get_address() << endl;
                else if(phase == internal_ph_tb)
                        FOUT << sc_time_stamp() << ": " << name() << " (T" << socketID << ") received int_phase at address " << hex << trans.get_address() << endl;
        #endif

        switch (phase) {
        case BEGIN_REQ:

                // Increment the transaction reference count
                trans.acquire();
                
                send_end_req_event[socketID].notify();

                incoming_transaction[socketID] = &trans;

                //nb_data_received[socketID]++;
                //status = send_end_req(socketID, trans);

                update_target_packet(socketID, phase);

                break;

        case END_RESP:

                //cout << "TB received response for transaction " << trans.get_address() << endl;

                incoming_transaction[socketID] = 0;

                sockets_with_new_transactions.push_back(socketID);
                transaction_received.notify();

                update_target_packet(socketID, phase);

                trans.release();

                break;

        case END_REQ:
        case BEGIN_RESP:
                SC_REPORT_FATAL("TLM-2", "Illegal transaction phase received by target");
                break;

        default:

                if (phase == internal_ph_tb) {

                        // Set response status (mandatory)
                        trans.set_response_status(TLM_OK_RESPONSE);
                        send_response(socketID, trans);
                        update_target_packet(socketID);
                        
                        break;
                }
        }

        
}

template<int Ni>
void TestbenchIn<Ni>::decrement_nb_non_priority_channels_requests_in_method(void) {
        nb_non_priority_channels_requests_in--;
        if(nb_non_priority_channels_requests_in == 0) shared_channel_in_ready_event.notify();
}

template<int Ni>
void TestbenchIn<Ni>::send_end_req_method(int id) {

        if(!is_priority_channel_in(id)) {
                if(nb_non_priority_channels_requests_in != 0) {
                        FOUT << sc_time_stamp() << ": " << name() << ": (I) request already in progress in shared channel, waiting for shared_channel_in_ready_event" << endl;
                        next_trigger(shared_channel_in_ready_event);
                        return;
                }

                nb_non_priority_channels_requests_in++;
        }

        // Store transaction address and data into local memory
        address_in[id] = incoming_transaction[id]->get_address();
        memcpy(data_in[id], reinterpret_cast<int *>(incoming_transaction[id]->get_data_ptr()), incoming_transaction[id]->get_data_length());

        //cout << name() << " socket " << socketID << " nb_data_received: " << nb_data_received[socketID] << endl;
#ifdef DEBUG
        FOUT << sc_time_stamp() << ": " << name() << " (T" << id << ") Updating address and data. New address: " << address_in[id] << " (Transaction " << dec << nb_data_received[id] << ")" << endl;

        FOUT << "Data: " << hex;
        for(int i = 0; i < 16; i++) FOUT << data_in[id][i] << " ";

        FOUT << endl << endl;

#endif

        send_end_req(id, *incoming_transaction[id]);

        next_trigger();
}

template<int Ni>
tlm_sync_enum TestbenchIn<Ni>::send_end_req(int socketID, tlm_generic_payload& trans) {

        tlm_sync_enum status;
        tlm_phase bw_phase;
        tlm_phase int_phase = internal_ph_tb;
    sc_time delay;

        // Queue the acceptance and the response with the appropriate latency
        bw_phase = END_REQ;
        delay = end_req_time[socketID];
        status = input_target_socket[socketID]->nb_transport_bw(trans, bw_phase, delay);
        if (status == TLM_COMPLETED) {
                // Transaction aborted by the initiator
                // (TLM_UPDATED cannot occur at this point in the base protocol, so need not be checked)
                trans.release();
                return status;
        }

        set_target_phase_end_req_event[socketID].notify(delay);

        // Queue internal event to mark beginning of response
        delay = delay + computation_time; // Latency
        m_id_targ_map[&trans] = socketID;
        m_peq_targ.notify(trans, int_phase, delay);

        if(!is_priority_channel_in(socketID)) decrement_nb_non_priority_channels_requests_in_event.notify(delay);

        nb_data_received[socketID]++;

        return status;
}

template<int Ni>
void TestbenchIn<Ni>::send_response(int id, tlm_generic_payload& trans) {

        tlm_sync_enum status;
        tlm_phase bw_phase;
        sc_time delay;

        bw_phase = BEGIN_RESP;
        delay = begin_resp_time[id];

        status = input_target_socket[id]->nb_transport_bw(trans, bw_phase, delay);

        set_target_phase_begin_resp_event[id].notify(delay);

        if (status == TLM_UPDATED) {
                // The timing annotation must be honored
                m_id_targ_map[&trans] = id;
                m_peq_targ.notify(trans, bw_phase, delay);
        } else if (status == TLM_COMPLETED) {
                // The initiator has terminated the transaction
                trans.release();
        }
}


template<int Ni>
void TestbenchIn<Ni>::notify_simulation_controller(bool success) {
        Reconfiguration_manager::endApplication(applicationName, success);
}

template<int Ni>
string TestbenchIn<Ni>::getName(void) const {
        return name();
}

/******************************
 ****    User interface    ****
 ******************************/
template<int Ni>
void TestbenchIn<Ni>::set_packet_size(string connection_name, int val) {

        int socketID = -1;
        for(int i = 0; i < (int) preceding_modules_connection_name.size(); i++) {
                if(preceding_modules_connection_name.at(i).compare(connection_name) == 0) {
                        socketID = i;
                        break;
                }
        }

#ifdef CONSOLE_DEBUG
        cout << "Preceding module" << endl;
        cout << "Socket ID: " << socketID << endl;
#endif

        assert(socketID < Ni);
        input_packet_size[socketID] = val;

        try {
                delete[] data_in[socketID];
                data_in[socketID] = new int[input_packet_size[socketID]];
                for(int i = 0; i < input_packet_size[socketID]; i++) data_in[socketID][i] = 0;
        } catch (bad_alloc& ba) {
                cerr << "ERROR: " << name() << " bad_alloc caught: " << ba.what() << endl;
                //exit(-1);
                Simulation_controller::endSimulation();
        }
}

template<int Ni>
void TestbenchIn<Ni>::verify_bindings(void) {
        if(input_target_socket.size() != Ni) {
                cerr << "ERROR: Incorrect bindings for module " << name() << "! Exiting..." << endl;
                exit(-1);
        }
}

template<int Ni>
void TestbenchIn<Ni>::set_end_req_time(string connection_name, sc_time t) {
        add_timing_info(END_REQ, connection_name, t);
}

template<int Ni>
void TestbenchIn<Ni>::set_begin_resp_time(string connection_name, sc_time t) {
        add_timing_info(BEGIN_RESP, connection_name, t);
}

template<int Ni>
void TestbenchIn<Ni>::add_preceding_module_connection_name(string name) {
        preceding_modules_connection_name.push_back(name);
}

template<int Ni>
void TestbenchIn<Ni>::add_timing_info(tlm_phase_enum phase, string connection_name, sc_time time) {
        
        int socketID = -1;
        for(int i = 0; i < (int) preceding_modules_connection_name.size(); i++) {
                if(preceding_modules_connection_name.at(i).compare(connection_name) == 0) {
                        socketID = i;
                        break;
                }
        }
        
        switch(phase) {
                case END_REQ: end_req_time[socketID] = time; break;
                case BEGIN_RESP: begin_resp_time[socketID] = time; break;
                default: cerr << "ERROR: Phase not recognized!" << endl;
        }
}

template<int Ni>
void TestbenchIn<Ni>::info(void) {

        FOUT << endl << "Testbench " << name() << ":" << endl;

        for(int i = 0; i < Ni; i++) {
                FOUT << "Input socket " << i << " (Connection " << preceding_modules_connection_name.at(i) << "):" << endl;
                if(priority_channels_in.find(i) != priority_channels_in.end()) FOUT << "  Priority channel" << endl;
                FOUT << "  Packet size: " << input_packet_size[i] << endl;
                FOUT << "  END_REQ time: " << end_req_time[i] << endl;
                FOUT << "  BEGIN_RESP time: " << begin_resp_time[i] << endl;
        }
}

// Priority channels
template<int Ni>
void TestbenchIn<Ni>::add_priority_channel(string connection_name) {
        int id = -1;
        for(int i = 0; i < (int) preceding_modules_connection_name.size(); i++) {
                if(preceding_modules_connection_name.at(i).compare(connection_name) == 0) {
                        id = i;
                        break;
                }
        }

        if(id == -1) cerr << "ERROR: Module " << name() << " cannot find connection name through preceding or following modules vector!" << endl;

        assert(id < Ni);
        priority_channels_in.insert(id);
}

template<int Ni>
bool TestbenchIn<Ni>::is_priority_channel_in(int id) {
        return (priority_channels_in.find(id) != priority_channels_in.end());
}

template<int Ni>
void TestbenchIn<Ni>::set_application_name(string n) {
        applicationName = n;
}



template<int Ni>
int TestbenchIn<Ni>::get_input_socket_id(string connection_name) const {
        int socketID = -1;
        for(int i = 0; i < (int) preceding_modules_connection_name.size(); i++) {
                if(preceding_modules_connection_name.at(i).compare(connection_name) == 0) {
                        socketID = i;
                        break;
                }
        }

        if(socketID == -1) {
                cerr << "Error: Testbench unable to retrieve input socket ID via connection name" << endl;
                exit(RECOSIM_INTERNAL_ERROR_ERRCODE);
        }

        return socketID;
}


/**********************************
 *     Testbench In Interface     *
 **********************************/
template<int Ni>
const char * TestbenchIn<Ni>::TB_IF_name(void) const {
        return name();
}

template<int Ni>
string TestbenchIn<Ni>::TB_IF_get_instance_name(void) const {
        string fullname(name());
        if(fullname.find("/") != string::npos) {
                return (fullname.substr(fullname.find("/") + 1)).c_str();
        } else return name();
}

template<int Ni>
const sc_event& TestbenchIn<Ni>::TB_IF_transaction_received_event(void) const {
        return transaction_received;
}

template<int Ni>
const int TestbenchIn<Ni>::TB_IF_get_nb_transactions_received_per_socket(int socketID) const {
        return nb_data_received[socketID];
}

template<int Ni>
const int TestbenchIn<Ni>::TB_IF_get_nb_transactions_received_per_socket(string channelName) const {
        return TB_IF_get_nb_transactions_received_per_socket(get_input_socket_id(channelName));
}

template<int Ni>
const int TestbenchIn<Ni>::TB_IF_get_nb_transactions_received(void) const {
        int nb_total_data_received = 0;
        for(int i = 0; i < Ni; i++) nb_total_data_received += nb_data_received[i];
        return nb_total_data_received;
}

template<int Ni>
int* TestbenchIn<Ni>::TB_IF_get_data_in_ptr(int socketID) const {
        return data_in[socketID];
}

template<int Ni>
int* TestbenchIn<Ni>::TB_IF_get_data_in_ptr(string connectionName) const {
        return data_in[get_input_socket_id(connectionName)];
}

template<int Ni>
void TestbenchIn<Ni>::TB_IF_notify_simulation_controller(bool val) {
        notify_simulation_controller(val);
}

template<int Ni>
int TestbenchIn<Ni>::TB_IF_get_packet_size(int ID) const {
        return input_packet_size[ID];
}

template<int Ni>
int TestbenchIn<Ni>::TB_IF_get_packet_size(string connectionName) const {
        return TB_IF_get_packet_size(get_input_socket_id(connectionName));
}

template<int Ni>
int TestbenchIn<Ni>::TB_IF_get_input_socket_id(string connectionName) const {
        return get_input_socket_id(connectionName);
}

template<int Ni>
string TestbenchIn<Ni>::TB_IF_get_connection_name(int id) const {
        return preceding_modules_connection_name.at(id);
}

template<int Ni>
vector<int> TestbenchIn<Ni>::TB_IF_get_sockets_with_new_transactions(void) {
        vector<int> vectorCopy(sockets_with_new_transactions);
        sockets_with_new_transactions.clear();
        return vectorCopy;
}


/**********************************
 *      Packet trace methods      *
 **********************************/


template<int Ni>
void TestbenchIn<Ni>::init_packet(void) {
        //update_initiator_packet(0);
        //update_target_packet(0);
}


template<int Ni>
void TestbenchIn<Ni>::update_target_packet(int id, tlm_phase phase) {
        assert(id < Ni);
        update_target_packet(id);
        trace_packet.target_packet[id].phase = tlm_phase_to_ascii(phase);
}

template<int Ni>
void TestbenchIn<Ni>::update_target_packet(int id) {
        assert(id < Ni);
        trace_packet.target_packet[id].transaction.update_transaction(incoming_transaction[id]);
        trace_packet.target_packet[id].transaction_pending.update_transaction(incoming_transaction_pending[id]);
}

template<int Ni>
void TestbenchIn<Ni>::set_target_phase_end_req(int id) {
        assert(id < Ni);
        trace_packet.target_packet[id].phase = END_REQ_ASCII;
}

template<int Ni>
void TestbenchIn<Ni>::set_target_phase_begin_resp(int id) {
        assert(id < Ni);
        trace_packet.target_packet[id].phase = BEGIN_RESP_ASCII;
}

#endif