tl_tlm.cpp

/*******************************************************************************
 * Copyright 2019-2024 MINRES Technologies GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
 
#include <array>
#include <fmt/format.h>
#include <tilelink/tl_tlm.h>
#include <tlm/scc/scv/tlm_extension_recording_registry.h>
#include <util/ities.h>
 
namespace tilelink {
namespace {
const std::array<std::string, 3> cmd_str{"R", "W", "I"};
}
 
template <> const char* to_char<opcode_e>(opcode_e v) {
    switch(v) {
    case opcode_e::Get:
        return "Get";
    case opcode_e::AccessAckData:
        return "AccessAckData";
    case opcode_e::PutFullData:
        return "PutFullData";
    case opcode_e::PutPartialData:
        return "PutPartialData";
    case opcode_e::AccessAck:
        return "AccessAck";
    case opcode_e::ArithmeticData:
        return "ArithmeticData";
    case opcode_e::LogicalData:
        return "LogicalData";
    case opcode_e::Intent:
        return "Intent";
    case opcode_e::HintAck:
        return "HintAck";
    case opcode_e::AcquireBlock:
        return "AcquireBlock";
    case opcode_e::AcquirePerm:
        return "AcquirePerm";
    case opcode_e::Grant:
        return "Grant";
    case opcode_e::GrantData:
        return "GrantData";
    case opcode_e::GrantAck:
        return "GrantAck";
    case opcode_e::ProbeBlock:
        return "ProbeBlock";
    case opcode_e::ProbePerm:
        return "ProbePerm";
    case opcode_e::ProbeAck:
        return "ProbeAck";
    case opcode_e::ProbeAckData:
        return "ProbeAckData";
    case opcode_e::Release:
        return "Release";
    case opcode_e::ReleaseData:
        return "ReleaseData";
    case opcode_e::ReleaseAck:
        return "ReleaseAck";
    default:
        return "UNKNOWN";
    }
}
 
template <> const char* to_char<param_e>(param_e v) {
    switch(v) {
    case param_e::CAP_2T:
        return "Cap:2T (0)";
    case param_e::CAP_2B:
        return "Cap:2B (1)";
    case param_e::CAP_2N:
        return "Cap:2N (2)";
    case param_e::GROW_N2B:
        return "Grow:N2B (0)";
    case param_e::GROW_N2T:
        return "Grow:N2T (1)";
    case param_e::GROW_B2T:
        return "Grow:B2T (2)";
    case param_e::PRUNE_T2B:
        return "Prune:T2B (0)";
    case param_e::PRUNE_T2N:
        return "Prune:T2N (1)";
    case param_e::PRUNE_B2N:
        return "Prune:B2N (2)";
    case param_e::REP_T2T:
        return "Report:T2T (0)";
    case param_e::REP_B2B:
        return "Report:B2B (1)";
    case param_e::REP_N2N:
        return "Report:N2N (2)";
    default:
        return "UNKNOWN";
    }
}
 
std::ostream& operator<<(std::ostream& os, const tlm::tlm_generic_payload& t) {
    os << "CMD:" << cmd_str[t.get_command()] << ", "
       << "ADDR:0x" << std::hex << t.get_address() << ", TXLEN:0x" << t.get_data_length();
    if(auto e = t.get_extension<tilelink::tilelink_extension>()) {
        os << ", "
           << "OPC:0x" << std::hex << static_cast<unsigned>(e->get_opcode()) << "PARAM:" << e->get_param();
    }
    os << " [ptr:" << &t << "]";
    return os;
}
 
using namespace tlm::scc::scv;
 
struct tlc_ext_record : public tlm_extension_record_if {
 
    tlc_ext_record() { recordBegin = &tlc_ext_record::recordBeginTx; }
 
    static void recordBeginTx(SCVNS scv_tr_handle& handle, tlm::tlm_extension_base* e, std::string const& prefix) {
        if(auto ext = dynamic_cast<tilelink_extension*>(e)) {
            handle.record_attribute(fmt::format("{}opcode", prefix).c_str(), std::string(to_char(ext->get_opcode())));
            handle.record_attribute(fmt::format("{}param", prefix).c_str(), std::string(to_char(ext->get_param())));
            handle.record_attribute(fmt::format("{}source", prefix).c_str(), ext->get_source());
            handle.record_attribute(fmt::format("{}sink", prefix).c_str(), ext->get_sink());
            handle.record_attribute(fmt::format("{}corrupt", prefix).c_str(), ext->is_corrupt());
            handle.record_attribute(fmt::format("{}denied", prefix).c_str(), ext->is_denied());
        }
    }
};
 
struct tlc_ext_recording : public tlm_extensions_recording_if<tl_protocol_types> {
 
    tlc_ext_recording() { recordBegin = &tlc_ext_recording::recordBeginTx; }
 
    static void recordBeginTx(SCVNS scv_tr_handle& handle, tl_protocol_types::tlm_payload_type& trans) {
        tlm_extension_record_registry::get().recordBeginTx(tilelink_extension::ID, handle, trans.get_extension<tilelink_extension>(),
                                                           "trans.tl.");
    }
};
 
namespace scv {
using namespace tlm::scc::scv;
#if defined(__GNUG__)
__attribute__((constructor))
#endif
bool register_extensions() {
    tilelink::tilelink_extension ext; // NOLINT
    tlm_extension_recording_registry<tilelink::tl_protocol_types>::get().register_ext_rec(ext.ID,
                                                                                          util::make_unique<tlc_ext_recording>()); // NOLINT
    tlm_extension_record_registry::get().register_ext_rec(ext.ID, util::make_unique<tlc_ext_record>());                            // NOLINT
    return true;                                                                                                                   // NOLINT
}
bool registered = register_extensions();
} // namespace scv
} // namespace tilelink