Orca.cpp File Reference

#include <signal.h>
#include <iostream>
#include <iomanip>
#include <chrono>
#include <cmath>
#include "Event.hpp"
#include "Simulator.hpp"
#include "UMemory.hpp"
#include "THFRiscV.hpp"
#include "ProcessingTile.hpp"

Go to the source code of this file.

Functions
static void	sig_handler (int _)
void	check_params ()
int	main (int __attribute__((unused)) argc, char **argv)

Variables
ProcessingTile *	tile
static volatile sig_atomic_t	interruption = 0
int	_status = 0

Function Documentation

check_params()

void check_params

(

)

Definition at line 75 of file Orca.cpp.

                    {
    #ifndef ORCA_EPOCH_LENGTH
    std::runtime_error(
        "ORCA_EPOCH_LENGTH must be defined in Configuration.mk\n");
    #else
    std::cout << "ORCA_EPOCH_LENGTH set to " << ORCA_EPOCH_LENGTH << std::endl;
    #endif

    #ifndef ORCA_EPOCHS_TO_SIM
    std::cout << "ORCA_EPOCHS_TO_SIM set to INFINITE" << std::endl;
    #else
    std::cout << "ORCA_EPOCHS_TO_SIM set to "
        << ORCA_EPOCHS_TO_SIM << std::endl;
    #endif

    // ursa params
    #ifndef URSA_ZERO_TIME_CHECKING
    std::cout << "URSA_ZERO_TIME_CHECKING disabled" << std::endl;
    #else
    std::cout << "URSA_ZERO_TIME_CHECKING set to "
        << URSA_ZERO_TIME_CHECKING << std::endl;
    #endif

    #ifndef URSA_QUEUE_SIZE_CHECKING
    std::cout << "URSA_QUEUE_SIZE_CHECKING disabled" << std::endl;
    #else
    std::cout << "URSA_QUEUE_SIZE_CHECKING set to "
        << URSA_QUEUE_SIZE_CHECKING << std::endl;
    #endif

    // memory
    #ifndef MEMORY_WRITE_ADDRESS_CHECKING
    std::cout << "MEMORY_WRITE_ADDRESS_CHECKING disabled" << std::endl;
    #else
    std::cout << "MEMORY_WRITE_ADDRESS_CHECKING enabled" << std::endl;
    #endif

    #ifndef MEMORY_READ_ADDRESS_CHECKING
    std::cout << "MEMORY_READ_ADDRESS_CHECKING disabled" << std::endl;
    #else
    std::cout << "MEMORY_READ_ADDRESS_CHECKING enabled" << std::endl;
    #endif

    #ifndef MEMORY_WIPE_ADDRESS_CHECKING
    std::cout << "MEMORY_WIPE_ADDRESS_CHECKING disabled" << std::endl;
    #else
    std::cout << "MEMORY_WIPE_ADDRESS_CHECKING enabled" << std::endl;
    #endif

    #ifndef MEMORY_ENABLE_COUNTERS
    std::cout << "MEMORY_ENABLE_COUNTERS disabled" << std::endl;
    #else
    std::cout << "MEMORY_ENABLE_COUNTERS enabled" << std::endl;
    #endif

    // hfriscv
    #ifndef HFRISCV_WRITE_ADDRESS_CHECKING
    std::cout << "HFRISCV_WRITE_ADDRESS_CHECKING disabled" << std::endl;
    #else
    std::cout << "HFRISCV_WRITE_ADDRESS_CHECKING enabled" << std::endl;
    #endif

    #ifndef HFRISCV_READ_ADDRESS_CHECKING
    std::cout << "HFRISCV_READ_ADDRESS_CHECKING disabled" << std::endl;
    #else
    std::cout << "HFRISCV_READ_ADDRESS_CHECKING enabled" << std::endl;
    #endif

    #ifndef HFRISCV_ENABLE_COUNTERS
    std::cout << "HFRISCV_ENABLE_COUNTERS disabled" << std::endl;
    #else
    std::cout << "HFRISCV_ENABLE_COUNTERS enabled" << std::endl;
    #endif
}

main()

int main	(	int __attribute__((unused))	argc,
		char **	argv
	)

Definition at line 150 of file Orca.cpp.

                                                        {
    // argc = argc; //workaround to use -Wextra

    // register interruption handler
    signal(SIGINT, sig_handler);

    std::cout << "URSA/ORCA Platform " << std::endl;

    std::cout << "==============[ PARAMETERS ]" << std::endl;
    try {
        check_params();
    } catch (std::runtime_error& e) {
        std::cout << e.what() << std::endl;
        return 1;
    }

    std::cout << "==============[ TILE COMPOSITION ]" << std::endl;

    // create new tile (single)
    tile = new ProcessingTile();

    // load bin into memory
    tile->GetMem0()->LoadBin(std::string(argv[1]), MEM0_BASE, MEM0_SIZE);

    std::cout << "==============[ SIMULATION ]" << std::endl;

    // instantiate simulation
    Simulator* s = new Simulator();

    std::cout << "Scheduling..." << std::endl;

    // schedule pcore
    s->Schedule(Event(3, tile->GetCpu()));

    // schedule dma
    s->Schedule(Event(2, tile->GetDma()));

    std::cout << "Epoch set to " << ORCA_EPOCH_LENGTH
        << " cycles." << std::endl;
    std::cout << "Please wait..." << std::endl;

    try {
        std::chrono::high_resolution_clock::time_point t1, t2;
        while (!interruption) {
            t1 = std::chrono::high_resolution_clock::now();
            s->Run(ORCA_EPOCH_LENGTH);
            t2 = std::chrono::high_resolution_clock::now();

            auto duration =
                std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1)
                    .count();
            s->NextEpoch();

            // converts mili to seconds before calculating the frequency
            double hertz = static_cast<double>(ORCA_EPOCH_LENGTH) /
                (static_cast<double>(duration) / 1000.0);

            // divide frequency by 1k (Hz -> KHz)
            std::cout << "notice: epoch #" << s->GetEpochs() << " took ~"
                << duration << "ms (running @ " << (hertz / 1000000.0)
                << " MHz)" << std::endl;

            #ifdef ORCA_EPOCHS_TO_SIM
            // simulate until reach the limit of pulses
            if (s->GetEpochs() >= ORCA_EPOCHS_TO_SIM)
                break;
            #endif
        }
    } catch(std::runtime_error& e) {
        std::cout << e.what() << std::endl;
        _status = 1;
    }

    // CPU statuses
    std::cout
        << tile->GetName()
        << ": INTR=" << static_cast<int>((tile->GetSignalIntr()->Read()))
        << ", STALL=" << static_cast<int>((tile->GetSignalStall()->Read()))
        << std::endl;

    delete(s);
    delete(tile);

    if (_status)
        std::cout << "Simulation failed!" << std::endl;
    else
        std::cout << "Simulation ended without errors." << std::endl;

    return _status;
}

sig_handler()

static void sig_handler ( int  _ )

static

Definition at line 56 of file Orca.cpp.

                               {
    (void)_;

    switch (interruption) {
    case 0:
        interruption = 1;
        std::cout << std::endl <<
            "Simulation interrupted. Wait for the current epoch to finish " <<
            "or press CTRL+C again to force quit." << std::endl;
        break;
    case 1:
        exit(0);
        break;
    case 2:
        std::cout << std::endl << "Hold your horses!" << std::endl;
        break;
    }
}

Variable Documentation

_status

int _status = 0

Definition at line 54 of file Orca.cpp.

interruption

volatile sig_atomic_t interruption = 0

static

Definition at line 52 of file Orca.cpp.

tile

ProcessingTile* tile

Definition at line 49 of file Orca.cpp.