Subversion Repositories s80186

// Copyright Jamie Iles, 2017

//

// This file is part of s80x86.

//

// s80x86 is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// s80x86 is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with s80x86.  If not, see <http://www.gnu.org/licenses/>.

#pragma once

#include <verilated.h>

#include <verilated_vcd_c.h>

#include <verilated_cov.h>

#include <boost/algorithm/string/replace.hpp>

#include <boost/format.hpp>

#include <boost/type_index.hpp>

#include <functional>

#include <map>

#include <vector>

#include <errno.h>

#include <sys/stat.h>

enum PeriodicEventType {

    // Run at the end of the cycle once the DUT has been clocked and

    // evaluated.  Signals should be stable and ready for capturing by the

    // test driver.

    ClockCapture,

    // Run immediately before the positive clock edge, any changed signals

    // will be delivered on the clock edge and not evaluated before.  Use this

    // when sending data into the DUT that would normally be registered in the

    // real system.

    ClockSetup,

};

const int evals_per_cycle = 10;

extern double sc_time_stamp();

extern double cur_time_stamp;

static_assert(evals_per_cycle % 2 == 0,

              "evals_per_cycle must be divisible by 2");

#ifdef DEBUG

const bool verilator_debug_enabled = true;

#else

const bool verilator_debug_enabled = false;

#endif

#ifdef VM_COVERAGE

const bool verilator_coverage_enabled = true;

#else

const bool verilator_coverage_enabled = false;

#endif

template <typename T, bool debug_enabled = verilator_debug_enabled>

class VerilogDriver

{

public:

    VerilogDriver();

    explicit VerilogDriver(const std::string &instance_name);

    VerilogDriver(const VerilogDriver &rhs) = delete;

    virtual ~VerilogDriver();

    void reset(int count = 2);

    void after_n_cycles(vluint64_t delta, const std::function<void()> &cb)

    {

        at_cycle(cycle_num + delta, cb);

    }

    void periodic(PeriodicEventType edge_type, std::function<void()> fn)

    {

        periodic_events[edge_type].push_back(fn);

    }

    virtual void cycle(int count = 1);

    vluint64_t cur_cycle() const

    {

        return cycle_num;

    }

protected:

    T dut;

private:

    void at_cycle(vluint64_t cycle_num, std::function<void()> cb);

    void run_deferred_events();

    void run_periodic_events(PeriodicEventType edge_type);

    void setup_trace();

    void teardown_trace();

    VerilatedVcdC tracer;

    vluint64_t cur_time;

    vluint64_t cycle_num;

    std::map<vluint64_t, std::vector<std::function<void()>>> deferred_events;

    std::map<PeriodicEventType, vector<std::function<void()>>> periodic_events;

    std::string instance_name;

};

template <typename T, bool debug_enabled>

VerilogDriver<T, debug_enabled>::VerilogDriver()

    : VerilogDriver<T, debug_enabled>(

          boost::typeindex::type_id<T>().pretty_name())

{

}

template <typename T, bool debug_enabled>

VerilogDriver<T, debug_enabled>::VerilogDriver(const std::string &instance_name)

    : cycle_num(0), instance_name(instance_name)

{

    dut.reset = 0;

    dut.clk = 0;

    cur_time = 0;

    cur_time_stamp = 0;

    if (debug_enabled)

        setup_trace();

}

template <typename T, bool debug_enabled>

struct tracer_impl {

};

template <typename T>

struct tracer_impl<T, true> {

    static void trace_dut(T *dut, VerilatedVcdC *tracer)

    {

        dut->trace(tracer, 99);

    }

};

template <typename T>

struct tracer_impl<T, false> {

    static void trace_dut(T *, VerilatedVcdC *)

    {

    }

};

template <typename T, bool debug_enabled>

void VerilogDriver<T, debug_enabled>::setup_trace()

{

    if (debug_enabled) {

        Verilated::traceEverOn(true);

        tracer_impl<T, debug_enabled>::trace_dut(&dut, &tracer);

        auto filename = (boost::format("%s.vcd") % instance_name).str();

        boost::replace_all(filename, "/", "_");

        tracer.open(filename.c_str());

    }

}

template <typename T, bool debug_enabled>

void VerilogDriver<T, debug_enabled>::teardown_trace()

{

    if (debug_enabled)

        tracer.close();

}

template <typename T, bool debug_enabled>

VerilogDriver<T, debug_enabled>::~VerilogDriver()

{

    if (debug_enabled)

        teardown_trace();

    dut.final();

    if (verilator_coverage_enabled) {

        auto filename = (boost::format("%s.dat") % instance_name).str();

        if (mkdir("coverage", 0755) && errno != EEXIST)

            throw std::runtime_error("Failed to create coverage dir");

        boost::replace_all(filename, "/", "_");

        VerilatedCov::write(("coverage/" + filename).c_str());

        VerilatedCov::clear();

    }

}

template <typename T, bool debug_enabled>

void VerilogDriver<T, debug_enabled>::reset(int count)

{

    this->dut.reset = 1;

    after_n_cycles(count, [&] { this->dut.reset = 0; });

    do {

        cycle();

    } while (dut.reset);

}

template <typename T, bool debug_enabled>

void VerilogDriver<T, debug_enabled>::cycle(int count)

{

    for (int i = 0; i < count; ++i) {

        for (auto j = 0; j < evals_per_cycle; ++j) {

            if (debug_enabled)

                tracer.dump(cur_time);

            if (j == 0) {

                run_periodic_events(ClockSetup);

                dut.clk = !dut.clk;

                dut.eval();

                run_deferred_events();

                dut.eval();

                run_periodic_events(ClockCapture);

            } else if (j == evals_per_cycle / 2) {

                dut.clk = !dut.clk;

                dut.eval();

            } else {

                dut.eval();

            }

            ++cur_time;

        }

        ++cycle_num;

        ++cur_time_stamp;

    }

}

template <typename T, bool debug_enabled>

void VerilogDriver<T, debug_enabled>::run_periodic_events(

    PeriodicEventType edge_type)

{

    for (auto &e : periodic_events[edge_type])

        e();

}

template <typename T, bool debug_enabled>

void VerilogDriver<T, debug_enabled>::run_deferred_events()

{

    auto events = deferred_events[cycle_num];

    deferred_events.erase(cycle_num);

    for (auto &e : events)

        e();

}

template <typename T, bool debug_enabled>

void VerilogDriver<T, debug_enabled>::at_cycle(vluint64_t target_cycle_num,

                                               std::function<void()> cb)

{

    assert(target_cycle_num >= cycle_num);

    deferred_events[target_cycle_num].push_back(cb);

}