Injector.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
//
// This file is part of ETISS. It is licensed under the BSD 3-Clause License; you may not use this file except in
// compliance with the License. You should have received a copy of the license along with this project. If not, see the
// LICENSE file.
#ifndef ETISS_INJECTOR_H_
#define ETISS_INJECTOR_H_
 
#ifndef NO_ETISS
#include "etiss/Misc.h"
#include "etiss/fault/Defs.h"
#include "etiss/fault/Misc.h"
#include "etiss/fault/Trigger.h"
#else
#include "fault/Defs.h"
#include "fault/Misc.h"
#include "fault/Trigger.h"
#endif
 
#if CXX0X_UP_SUPPORTED
#include <functional>
#include <memory>
#include <mutex>
#endif
 
#include <fstream>
 
namespace etiss
{
 
namespace fault
{
 
class Stressor;
class Fault;
class Trigger;
class Action;
 
class Injector
{
  public:
#if CXX0X_UP_SUPPORTED
    typedef std::shared_ptr<Injector> ptr;
#else
    typedef Injector *ptr;
#endif
 
  public: // override in inheriting classes
    Injector();
    virtual ~Injector() {};
    virtual std::list<std::string> listFields() = 0;
    virtual std::list<std::string> listSubInjectors() = 0;
 
    virtual ptr getSubInjector(const std::string &name) = 0;
    virtual ptr getParentInjector() = 0;
 
  public: // callbacks
    virtual bool needsCallbacks();
    virtual bool cycleAccurateCallback(uint64_t time_ps);       // returns if trigger fired
    virtual bool instructionAccurateCallback(uint64_t time_ps); // returns if trigger fired
 
  public: // currently public functions but might become protected later on
    virtual void *fastFieldAccessPtr(const std::string &name, std::string &errormsg) = 0;
    virtual void freeFastFieldAccessPtr(void *);
    virtual bool readField(void *fastfieldaccessptr, uint64_t &val, std::string &errormsg) = 0;
    virtual bool applyAction(const etiss::fault::Fault &fault, const etiss::fault::Action &action,
                             std::string &errormsg) = 0;
 
    virtual bool acceleratedTrigger(const etiss::fault::Trigger &, int32_t fault_id);
 
    virtual bool update_field_access_rights(const etiss::fault::Action &action, std::string &errormsg) = 0;
 
  public: // static
    static ptr get(const std::string &injectorPath);
 
    virtual std::string getInjectorPath();
 
  private:
#if CXX0X_UP_SUPPORTED
    std::mutex sync;
#endif
    bool has_pending_triggers{ false };
    bool has_remove_triggers{ false };
    std::list<std::pair<Trigger, int32_t>> pending_triggers; 
    std::list<std::pair<Trigger, int32_t>> unknown_triggers; 
    std::list<std::pair<Trigger, int32_t>>
        remove_triggers; 
 
  public: // interface for Stressor
    void addTrigger(const Trigger &t, int32_t fault_id);
    void removeTrigger(const Trigger &t, int32_t fault_id);
};
 
} // namespace fault
 
} // namespace etiss
 
#endif