simics_adapter.h

Go to the documentation of this file.

/*
  © 2015 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_SYSTEMC_IFACE_SIMICS_ADAPTER_H
#define SIMICS_SYSTEMC_IFACE_SIMICS_ADAPTER_H
 
#include <simics/iface/interface-info.h>
#include <simics/devs/io-memory.h>
#include <simics/systemc/description_interface.h>
#include <simics/systemc/iface/simics_adapter_interface.h>
#include <simics/systemc/registry.h>
#include <simics/systemc/simics_lock.h>
 
#include <string>
#include <vector>
 
namespace simics {
namespace systemc {
namespace iface {
 
template<typename TSimicsInterface>
class SimicsAdapter : public simics::iface::InterfaceInfo,
                      public Registrant<SimicsAdapterInterface> {
  public:
    SimicsAdapter(const char *name, TSimicsInterface iface)
        : name_(name),
          iface_(iface),
          conf_class_(NULL),
          map_adapter_(true) {
    }
 
    // simics::iface::InterfaceInfo
    std::string name() const override {
        return name_;
    }
    const interface_t *cstruct() const override {
        return &iface_;
    }
 
    void set_simics_class(conf_class_t *conf_class) override {
        if (!conf_class_)
            conf_class_ = conf_class;
    }
    conf_class_t *simics_class() const override {
        return conf_class_;
    }
    void set_map_adapter(bool map) override {
        map_adapter_ = map;
    }
    bool map_adapter() const override {
        return map_adapter_;
    }
 
  protected:
    template<typename TBase, typename TInterface>
    static TInterface *adapterWithoutLocking(conf_object_t *obj) {
        FATAL_ERROR_IF(!obj, "NULL object passed to Simics interface");
        TBase *so = simics::from_obj<TBase>(obj);
        TInterface *adapter = dynamic_cast<TInterface*>(so);
        FATAL_ERROR_IF(adapter == NULL, "Unable to locate GasketAdapter");
        return adapter;
    }
    // This version is mainly used by the tool_simics_adapter that the lock
    // is not implemented on obj but on the provider/connection object.
    template<typename TBase, typename TInterface>
    static SimicsLock<TInterface> adapter(conf_object_t *obj,
                                          conf_object_t *obj_lock) {
        // Cache the SimulationInterface* to avoid repeated dynamic_cast under
        // extreme call rates (highlighted by VTune at 100M+ consecutive calls).
        ConfObject *lock_base = simics::from_obj<ConfObject>(obj_lock);
        SimulationInterface *simulation = cached_simulation_;
        if (lock_base != cached_lock_base_) {
            simulation = dynamic_cast<SimulationInterface*>(lock_base);
            if (simulation == nullptr) {
                conf_object_t *parent = SIM_port_object_parent(obj_lock);
                if (parent) {
                    // Check port's parent
                    lock_base = simics::from_obj<ConfObject>(parent);
                    simulation = dynamic_cast<SimulationInterface*>(lock_base);
                }
            }
            FATAL_ERROR_IF(simulation == NULL, "Unable to locate Simulation");
            cached_lock_base_ = lock_base;
            cached_simulation_ = simulation;
        }
        return {simulation, adapterWithoutLocking<TBase, TInterface>(obj)};
    }
    template<typename TBase, typename TInterface>
    static SimicsLock<TInterface> adapter(conf_object_t *obj) {
        return adapter<TBase, TInterface>(obj, obj);
    }
    template<typename TBase, typename TInterface>
    std::vector<std::string> descriptionBase(conf_object_t *obj,
                                             DescriptionType type) {
        if (SIM_object_class(obj) != conf_class_ )
            return {};
 
        TInterface *iface = adapterWithoutLocking<TBase, TInterface>(obj);
        auto *adapter = dynamic_cast<DescriptionInterface<TInterface> *>(iface);
        if (!adapter)
            return {};
 
        std::vector<std::string> description = adapter->description(type);
        if (description.empty())
            return {};
 
        description.insert(description.begin(), name_);
        description.insert(description.begin(), SIM_object_name(obj));
        return description;
    }
 
  private:
    std::string name_;
    TSimicsInterface iface_;
    conf_class_t *conf_class_;
    bool map_adapter_;
    // Cache the ConfObject* and SimulationInterface* to avoid expensive
    // dynamic_cast operations during high-frequency interface calls.
    // dynamic_cast is O(n) in the inheritance hierarchy depth and can
    // dominate performance at extreme call rates (100M+ consecutive calls).
    // We use ConfObject* as the cache key because it identifies the
    // underlying C++ instance associated with the cached lock object for
    // these calls, allowing fast pointer-equality cache checks without
    // string allocation or comparison overhead.
    static ConfObject *cached_lock_base_;
    static SimulationInterface *cached_simulation_;
};
 
 
 
template<typename TSimicsInterface> ConfObject*
SimicsAdapter<TSimicsInterface>::cached_lock_base_ = nullptr;
template<typename TSimicsInterface> SimulationInterface*
SimicsAdapter<TSimicsInterface>::cached_simulation_ = nullptr;
 
 
template <typename InterfaceSimicsAdapter>
InterfaceSimicsAdapter& createAdapter() {
    static InterfaceSimicsAdapter adapter;
    return adapter;
}
 
inline void bindUnmappedSimicsAdapters(conf_class_t *conf_class) {
    struct Binder {
        bool operator()(SimicsAdapterInterface *adapter) {
            if (adapter->map_adapter()) {
                adapter->set_simics_class(conf_class_);
                adapter->set_map_adapter(false);
            }
            return false;
        }
        conf_class_t *conf_class_;
    };
    Binder binder{conf_class};
    Registry<SimicsAdapterInterface>::instance()->iterate(&binder);
}
 
 
}  // namespace iface
}  // namespace systemc
}  // namespace simics
 
#endif