simulation_engine.h

Go to the documentation of this file.

// MIT License
// 
// Copyright (c) 2019 Ruhr University Bochum, Chair for Embedded Security. All Rights reserved.
// Copyright (c) 2019 Marc Fyrbiak, Sebastian Wallat, Max Hoffmann ("ORIGINAL AUTHORS"). All rights reserved.
// Copyright (c) 2021 Max Planck Institute for Security and Privacy. All Rights reserved.
// Copyright (c) 2021 Jörn Langheinrich, Julian Speith, Nils Albartus, René Walendy, Simon Klix ("ORIGINAL AUTHORS"). All Rights reserved.
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#pragma once
#include "hal_core/defines.h"
#include "hal_core/netlist/boolean_function.h"
#include "netlist_simulator_controller/simulation_input.h"
#include "netlist_simulator_controller/wave_event.h"
 
#include <string>
#include <unordered_map>
#include <vector>
#include <filesystem>
 
namespace hal
{
    class NetlistSimulatorController;
    class SimulationLogReceiver;
 
    class SimulationEngine
    {
        std::string mName;
 
    public:
        enum State
        {
            Failed    = -1,
            Done      = 0,
            Running   = 1,
            Preparing = 2
        };
 
    protected:
        bool mRequireClockEvents;
        bool mCanShareMemory;
        std::string mResultFilename;
        State mState;
        std::unordered_map<std::string, std::string> mProperties;
        SimulationInput* mSimulationInput;
        std::string mWorkDir;
 
    public:
        SimulationEngine(const std::string& nam);
        virtual ~SimulationEngine() {;}
 
        std::string name() const
        {
            return mName;
        }
 
        State state() const
        {
            return mState;
        }
 
        int get_state() const
        {
            return mState;
        }
 
        std::string get_working_directory() const;
 
        void set_working_directory(const std::string& workDir);
 
        bool clock_events_required() const
        {
            return mRequireClockEvents;
        }
 
        bool can_share_memory() const
        {
            return mCanShareMemory;
        }
 
        bool install_saleae_parser(std::string dirname) const;
 
        virtual bool setSimulationInput(SimulationInput* simInput) = 0;
 
        virtual void setResultFilename(const std::string filename)
        {
            mResultFilename = filename;
        };
 
        std::string get_result_filename() const
        {
            return mResultFilename;
        }
 
        virtual bool run(NetlistSimulatorController* controller, SimulationLogReceiver* logReceiver=nullptr) = 0;
 
        virtual bool finalize();
 
        virtual void failed();
 
        virtual void set_engine_property(const std::string& key, const std::string& value);
        
        
        virtual std::string get_engine_property(const std::string& key);
 
        virtual const std::unordered_map<std::string,std::string>& get_engine_properties() const { return mProperties; }
 
        virtual SimulationInput* get_simulation_input() const { return mSimulationInput; }
    };
 
    class SimulationEngineEventDriven : public SimulationEngine
    {
        bool run(NetlistSimulatorController* controller, SimulationLogReceiver* logReceiver=nullptr) override;
        bool setSimulationInput(SimulationInput* simInput) override;
 
    public:
        SimulationEngineEventDriven(const std::string& nam);
 
        virtual bool inputEvent(const SimulationInputNetEvent& netEv) = 0;
 
        virtual std::vector<WaveEvent> get_simulation_events(u32 netId) const;
    };
 
    class SimulationEngineScripted : public SimulationEngine
    {
        virtual bool run(NetlistSimulatorController* controller, SimulationLogReceiver *logReceiver=nullptr) override;
 
    public:
        SimulationEngineScripted(const std::string& nam) : SimulationEngine(nam)
        {
            ;
        }
 
        virtual int numberCommandLines() const = 0;
 
        virtual std::vector<std::string> commandLine(int lineIndex) const = 0;
    };
 
    class SimulationEngineFactory
    {
    protected:
        std::string mName;
 
    public:
        SimulationEngineFactory(const std::string& nam);
        virtual ~SimulationEngineFactory()
        {
            ;
        }
        virtual SimulationEngine* createEngine() const = 0;
        std::string name() const
        {
            return mName;
        }
    };
 
    class SimulationEngineFactories : public std::vector<SimulationEngineFactory*>
    {
        SimulationEngineFactories()
        {
            ;
        }
        static SimulationEngineFactories* inst;
 
    public:
        static SimulationEngineFactories* instance();
 
        std::vector<std::string> factoryNames() const;
        SimulationEngineFactory* factoryByName(const std::string nam) const;
        void deleteFactory(const std::string nam);
    };
}    // namespace hal