event.h

Go to the documentation of this file.

// -*- mode: C++; c-file-style: "virtutech-c++" -*-
 
/*
  © 2023 Intel Corporation
 
  This software and the related documents are Intel copyrighted materials, and
  your use of them is governed by the express license under which they were
  provided to you ("License"). Unless the License provides otherwise, you may
  not use, modify, copy, publish, distribute, disclose or transmit this software
  or the related documents without Intel's prior written permission.
 
  This software and the related documents are provided as is, with no express or
  implied warranties, other than those that are expressly stated in the License.
*/
 
#ifndef SIMICS_EVENT_H
#define SIMICS_EVENT_H
 
#include <simics/base/event.h>  // event_class_flag_t
#include <simics/base/time.h>  // SIM_object_clock
#include <simics/base/sim-exception.h>  // SIM_clear_exception
#include <string>
#include <stdexcept>
#include <type_traits>  // add_pointer_t
 
#include "conf-object.h"
#include "log.h"
#include "iface/event-interface.h"
#include "detail/event-helper.h"
 
namespace simics {
 
using ev_callback = std::add_pointer_t<void(conf_object_t *, void *)>;
using ev_destroy = ev_callback;
using ev_value_getter = std::add_pointer_t<attr_value_t(conf_object_t *obj,
                                                        void *data)>;
using ev_value_setter = std::add_pointer_t<void *(conf_object_t *obj,
                                                       attr_value_t value)>;
using ev_describe = std::add_pointer_t<char *(conf_object_t *obj,
                                              void *data)>;
 
/*
 * Class provides information for event registration
 * @see ConfClass *add(EventInfo &&event)
 */
struct EventInfo {
    EventInfo(const std::string &name, event_class_flag_t flags,
              event_class_t **ev, ev_callback callback, ev_destroy destroy,
              ev_value_getter get_value, ev_value_setter set_value,
              ev_describe describe)
        : name_(name), flags_(flags), ev_(ev), callback_(callback),
          destroy_(destroy), get_value_(get_value), set_value_(set_value),
          describe_(describe) {
        if (name.empty()) {
            throw std::invalid_argument {
                "Event name cannot be empty"
            };
        }
        if (ev == nullptr) {
            throw std::invalid_argument {
                "Pointer of event class pointer for event " + name + \
                " is missing"
            };
        }
        if (callback == nullptr) {
            throw std::invalid_argument {
                "Callback function for event " + name + " is missing"
            };
        }
    }
 
    EventInfo(const std::string &name, event_class_t **ev,
              ev_callback callback)
        : EventInfo(name, Sim_EC_No_Flags, ev, callback,
                    nullptr, nullptr, nullptr, nullptr) {
    }
 
    std::string name_;
    event_class_flag_t flags_ {Sim_EC_No_Flags};
    event_class_t **ev_ {nullptr};
    ev_callback callback_ {nullptr};
    ev_destroy destroy_ {nullptr};
    ev_value_getter get_value_ {nullptr};
    ev_value_setter set_value_ {nullptr};
    ev_describe describe_ {nullptr};
};
 
/*
 * Base class for all events that can be posted on a processor time
 * queue. Use TimeEvent/CycleEvent/StepEvent based on the event type.
 *
 * @see event_class_t
 */
class Event : public iface::EventInterface {
  public:
    Event(ConfObject *obj, event_class_t *ev) : obj_(obj), ev_(ev) {
        if (obj == nullptr) {
            throw std::invalid_argument {
                "Device object can't be NULL"
            };
        }
 
        if (ev == nullptr) {
            throw std::invalid_argument {
                "Event is not registered yet. Call add() from the"
                " device class"
            };
        }
    }
 
    // EventInterface
    void destroy(void *data) override {}
    attr_value_t get_value(void *data) override {
        return SIM_make_attr_nil();
    }
    void *set_value(attr_value_t value) override {
        return nullptr;
    }
    char *describe(void *data) const override {
        return nullptr;
    }
 
    operator event_class_t *() const { return ev_; }
 
  protected:
    static int pointer_eq(void *data, void *match_data) {
        return data == match_data;
    }
 
    template <typename T>
    T *device_ptr() const {
        static_assert(std::is_base_of<ConfObject, T>::value,
                      "T must be a descendant of ConfObject");
        return static_cast<T *>(obj_);
    }
 
    const char *name() const {
        return ev_->name;
    }
 
    ConfObject *obj_ {nullptr};
    event_class_t *ev_ {nullptr};
    conf_object_t *clock_ {nullptr};
};
 
template <typename T = ConfObject>
class TimeEvent : public Event,
                  public iface::TimeEventInterface {
  public:
    using Event::Event;
 
    // TimeEventInterface
    bool posted(void *match_data = nullptr) const override {
        return next(match_data) >= 0.0;
    }
 
    void remove(void *match_data = nullptr) const override {
        if (clock_) {
            SIM_event_cancel_time(clock_, ev_, obj_->obj(),
                                  Event::pointer_eq, match_data);
        }
    }
 
    void post(double seconds, void *data = nullptr) override {
        if (clock_ == nullptr) {
            clock_ = SIM_object_clock(obj_->obj());
            if (clock_ == nullptr) {
                SIM_LOG_ERROR(obj_->obj(), 0,
                              "Queue not set, unable to post events");
                return;
            }
        }
        SIM_event_post_time(clock_, ev_, obj_->obj(), seconds, data);
        if (SIM_clear_exception() != SimExc_No_Exception) {
            SIM_LOG_ERROR(obj_->obj(), 0, "%s", SIM_last_error());
        }
    }
 
    double next(void *match_data = nullptr) const override {
        if (clock_ == nullptr) {
            return -1.0;
        }
        return SIM_event_find_next_time(clock_, ev_, obj_->obj(),
                                        Event::pointer_eq, match_data);
    }
 
  protected:
    T *dev_ {device_ptr<T>()};
};
 
template <typename T = ConfObject>
class CycleEvent : public Event,
                   public iface::CycleEventInterface {
  public:
    using Event::Event;
 
    // CycleEventInterface
    bool posted(void *match_data = nullptr) const override {
        return next(match_data) >= 0;
    }
 
    void remove(void *match_data = nullptr) const override {
        if (clock_) {
            // There is no SIM_event_cancel_cycle
            SIM_event_cancel_time(clock_, ev_, obj_->obj(),
                                  Event::pointer_eq, match_data);
        }
    }
 
    void post(cycles_t cycles, void *data = nullptr) override {
        if (clock_ == nullptr) {
            clock_ = SIM_object_clock(obj_->obj());
        }
        SIM_event_post_cycle(clock_, ev_, obj_->obj(), cycles, data);
        if (SIM_clear_exception() != SimExc_No_Exception) {
            SIM_LOG_ERROR(obj_->obj(), 0, "%s", SIM_last_error());
        }
    }
 
    cycles_t next(void *match_data = nullptr) const override {
        if (clock_ == nullptr) {
            return -1;
        }
        return SIM_event_find_next_cycle(clock_, ev_, obj_->obj(),
                                         Event::pointer_eq, match_data);
    }
 
  protected:
    T *dev_ {device_ptr<T>()};
};
 
template <typename T = ConfObject>
class StepEvent : public Event,
                  public iface::StepEventInterface {
  public:
    using Event::Event;
 
    // StepEventInterface
    bool posted(void *match_data = nullptr) const override {
        return next(match_data) >= 0;
    }
 
    void remove(void *match_data = nullptr) const override {
        if (clock_) {
            SIM_event_cancel_step(clock_, ev_, obj_->obj(),
                                  Event::pointer_eq, match_data);
        }
    }
 
    void post(pc_step_t steps, void *data = nullptr) override {
        if (clock_ == nullptr) {
            clock_ = SIM_object_clock(obj_->obj());
        }
        SIM_event_post_step(clock_, ev_, obj_->obj(), steps, data);
        if (SIM_clear_exception() != SimExc_No_Exception) {
            SIM_LOG_ERROR(obj_->obj(), 0, "%s", SIM_last_error());
        }
    }
 
    pc_step_t next(void *match_data = nullptr) const override {
        if (clock_ == nullptr) {
            return -1;
        }
        return SIM_event_find_next_step(clock_, ev_, obj_->obj(),
                                        Event::pointer_eq, match_data);
    }
 
  protected:
    T *dev_ {device_ptr<T>()};
};
 
}  // namespace simics
 
#endif