spike_amp_transport.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
// Commercial license available
// © Concepts 1996–2026 Miroslav Šotek. All rights reserved.
// © Code 2020–2026 Miroslav Šotek. All rights reserved.
// ORCID: 0009-0009-3560-0851
// Contact: www.anulum.li | protoscience@anulum.li
// Loop Timing Witness — actual architectural RAM and production AXI transport for AMP logging

 
#ifndef WITNESS_SPIKE_AMP_TRANSPORT_H
#define WITNESS_SPIKE_AMP_TRANSPORT_H
#include "sim.h"
#include "../refusal.h"
#include "../rtl/simulation.h"
extern "C" {
#include "../bare_metal/amp_contract.h"
}
#include <array>
#include <cstddef>
#include <stdexcept>
 
namespace witness {
class SpikeAmpTransport {
    Simulation &fabric;
    abstract_mem_t *ram = nullptr;
    std::uint64_t ram_base = 0, shared;

    std::uint64_t offset(std::uint64_t address) const {
        if (address < shared || address - shared > sizeof(witness_amp_mailbox) - 4 || address % 4)
            throw witness::ArgumentRefused("AMP memory access outside the reserved mailbox");
        return address - ram_base;
    }
 
  public:
    SpikeAmpTransport(const sim_t &simulator, Simulation &model, std::uint64_t mailbox_address)
        : fabric(model), shared(mailbox_address) {
        if (!shared || shared % 8 || shared > UINT64_MAX - sizeof(witness_amp_mailbox))
            throw witness::ArgumentRefused("AMP shared memory address outside bounds");
        for (const auto &entry : simulator.get_bus().get_devices()) {
            auto *candidate = dynamic_cast<abstract_mem_t *>(entry.second);
            if (!candidate || shared < entry.first)
                continue;
            const auto displacement = shared - entry.first;
            if (displacement > candidate->size() ||
                sizeof(witness_amp_mailbox) > candidate->size() - displacement)
                continue;
            ram = candidate;
            ram_base = entry.first;
            break;
        }
        if (!ram)
            throw witness::ArgumentRefused("AMP mailbox does not fit actual simulator RAM");
    }

    std::uint32_t read_memory32(std::uint64_t address) {
        std::array<std::uint8_t, 4> bytes{};
        if (!ram->load(offset(address), bytes.size(), bytes.data()))
            throw witness::RuntimeRefused("actual AMP RAM load refused");
        std::uint32_t result = 0;
        for (unsigned index = 0; index < 4; ++index)
            result |= static_cast<std::uint32_t>(bytes[index]) << (index * 8);
        return result;
    }

    void write_memory32(std::uint64_t address, std::uint32_t value) {
        const auto displacement = address >= shared ? address - shared : UINT64_MAX;
        if (displacement != offsetof(witness_amp_mailbox, consumer) &&
            displacement != offsetof(witness_amp_mailbox, logger_status))
            throw witness::ArgumentRefused("AMP logger cannot write firmware-owned memory");
        std::array<std::uint8_t, 4> bytes{};
        for (unsigned index = 0; index < 4; ++index)
            bytes[index] = static_cast<std::uint8_t>(value >> (index * 8));
        if (!ram->store(offset(address), bytes.size(), bytes.data()))
            throw witness::RuntimeRefused("actual AMP RAM store refused");
    }

    Edge read(std::uint8_t address) { return fabric.read(address); }
    Edge write(std::uint8_t address, std::uint32_t value, std::uint8_t strobes) {
        return fabric.write(address, value, strobes);
    }

    std::uint64_t time() const { return fabric.time(); }
};
} // namespace witness
#endif