reimplement plugin subsystem

Author: fogInSingularity

include/machine.hh

@@ -3,13 +3,14 @@
 
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "config.hh"
 #include "cpu_state.hh"
 #include "elf_loader.hh"
 #include "executors.hh"
+#include "machine_event.hh"
 #include "memory.hh"
-#include "plugin_manager.hh"
 
 namespace hsim {
 
@@ -34,15 +35,16 @@ class Machine final {
         }
     }
 
-    void loadPlugin(const std::string &pluginPath,
-                    const std::string &options = "") {
-        m_plugins.loadPlugin(pluginPath, options);
+    void addEventConsumer(IEventConsumerHandle consumer) {
+        m_eventManager.attach(std::move(consumer));
     }
 
+    void notify() { m_eventManager.notify(); }
+
   private:
     std::unique_ptr<CpuState> m_state;
     Memory m_mem{};
-    PluginManager m_plugins;
+    EventManager m_eventManager;
 };
 
 } // namespace hsim

include/machine_event.hh

@@ -0,0 +1,35 @@
+#ifndef HSIM_MACHINE_EVENT_INCLUDED
+#define HSIM_MACHINE_EVENT_INCLUDED
+
+#include <list>
+#include <memory>
+#include <utility>
+
+namespace hsim {
+
+class IEventConsumer {
+  public:
+    virtual ~IEventConsumer() = default;
+    virtual void update() = 0;
+};
+
+using IEventConsumerHandle = std::unique_ptr<IEventConsumer>;
+class EventManager final {
+  public:
+    void notify() {
+        for (auto &consumer : m_consumers) {
+            consumer->update();
+        }
+    }
+    void attach(IEventConsumerHandle consumer) {
+        m_consumers.push_back(std::move(consumer));
+    }
+    void detach(IEventConsumerHandle consumer) { m_consumers.remove(consumer); }
+
+  private:
+    std::list<IEventConsumerHandle> m_consumers; // unique?
+};
+
+} // namespace hsim
+
+#endif // HSIM_MACHINE_EVENT_INCLUDED

include/plugin.hh

@@ -1,60 +1,84 @@
 #ifndef HSIM_PLUGIN_INCLUDED
 #define HSIM_PLUGIN_INCLUDED
 
-#include <stdexcept>
+#include <filesystem>
+#include <memory>
 #include <string>
+#include <utility>
 
 #include <dlfcn.h>
 
-#include "plugin_api.hh"
+#include "machine_event.hh"
+#include "so_loader.hh"
 
 namespace hsim {
 
-class Plugin final {
+class IPlugin : public IEventConsumer {
   public:
-    Plugin(const std::string &pluginPath, const std::string &options = "")
-        : m_pluginName{pluginPath}, m_options{options} {
-        m_dlhandle = dlopen(pluginPath.c_str(), RTLD_NOW);
-        if (m_dlhandle == nullptr) {
-            std::string dlErrorMsg = dlerror();
-            std::string fullErrorMsg = "Unable to load plugin: " + pluginPath +
-                                       ". Error: " + dlErrorMsg;
-            throw std::runtime_error(fullErrorMsg);
-        }
-
-        auto loadFunc = reinterpret_cast<LoadFunc>(
-            dlsym(m_dlhandle, kLoadFuncName.c_str()));
-        if (loadFunc == nullptr) {
-            std::string dlErrorMsg = dlerror();
-            std::string fullErrorMsg =
-                "Unable to load : " + pluginPath + ". Error: " + dlErrorMsg;
-            throw std::runtime_error(fullErrorMsg);
-        }
-
-        LoadablePlugin plugin = loadFunc(options.c_str());
-        m_pluginMem = plugin.pluginMem;
-        m_notify = plugin.notify;
-        m_unload = plugin.unload;
-    }
-
-    ~Plugin() {
-        m_unload(m_pluginMem);
-
-        dlclose(m_dlhandle);
-    }
-
-    void notify() { m_notify(m_pluginMem); }
+    IPlugin(SharedLib so_lib) : m_sharedLib(std::move(so_lib)) {}
+    ~IPlugin() override = default;
+    SharedLib getSOLib() { return m_sharedLib; }
 
   private:
-    std::string m_pluginName;
-    std::string m_options;
-
-    void *m_dlhandle;
-    void *m_pluginMem;
-    NotifyFunc m_notify;
-    UnloadFunc m_unload;
+    SharedLib m_sharedLib;
 };
 
+using LoadPLuginFunc = hsim::IPlugin *(*)(const char *options,
+                                          SharedLib so_lib);
+
+// using IPluginHandler = std::unique_ptr<IPlugin, void (*)(IPlugin*)>;
+// auto loadPluginFromSO(const std::filesystem::path& path, const std::string&
+// options) {
+//     SharedLib sharedLib{path, kLazy};
+//     auto loadPluginFunc = sharedLib.get<LoadPLuginFunc>("loadPlugin");
+//
+//     // NOTE reason for custom deleter:
+//     //      when ~IPlugin is called it first calls ~SharedLib and then
+//     ~SimplePlugin(wich is already unloaded) auto pluginDeleter = [lib =
+//     SharedLib{sharedLib}](IPlugin* plugin) mutable { delete plugin; };
+
+//     IPlugin* plugin = loadPluginFunc(options.c_str(), sharedLib);
+//     return std::unique_ptr<IPlugin, decltype(pluginDeleter)>{plugin,
+//     pluginDeleter};
+// }
+
+// // NOTE reason for custom deleter:
+// //      when ~IPlugin is called it first calls ~SharedLib and then
+// ~SimplePlugin(wich is already unloaded) void ipluginDeleter(IPlugin* plugin)
+// {
+//     SharedLib soLib = plugin->getSOLib();
+//     soLib.~SharedLib();
+// }
+
+// using IPluginHandler = std::unique_ptr<IPlugin, void (*)(IPlugin*)>;
+// IPluginHandler loadPluginFromSO(const std::filesystem::path& path, const
+// std::string& options) {
+//     SharedLib sharedLib{path, kLazy};
+//     auto loadPluginFunc = sharedLib.get<LoadPLuginFunc>("loadPlugin");
+//
+//     IPlugin* plugin = loadPluginFunc(options.c_str(), sharedLib);
+//     return IPluginHandler{plugin, ipluginDeleter};
+// }
+
+// using IPluginHandler = std::unique_ptr<IPlugin>;
+// IPluginHandler loadPluginFromSO(const std::filesystem::path& path, const
+// std::string& options) {
+//     SharedLib sharedLib{path, kLazy};
+//     auto loadPluginFunc = sharedLib.get<LoadPLuginFunc>("loadPlugin");
+//
+//     IPlugin* plugin = loadPluginFunc(options.c_str(), sharedLib);
+//     return IPluginHandler{plugin};
+// }
+
+using IPluginHandler = std::unique_ptr<IPlugin>;
+IPluginHandler loadPluginFromSO(SharedLib sharedLib,
+                                const std::string &options) {
+    auto loadPluginFunc = sharedLib.get<LoadPLuginFunc>("loadPlugin");
+
+    IPlugin *plugin = loadPluginFunc(options.c_str(), sharedLib);
+    return IPluginHandler{plugin};
+}
+
 } // namespace hsim
 
 #endif // HSIM_PLUGIN_INCLUDED

include/plugin_api.hh

@@ -0,0 +1,48 @@
+#ifndef HSIM_SO_LOADER_INCLUDED
+#define HSIM_SO_LOADER_INCLUDED
+
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+#include <stdexcept>
+#include <string>
+
+#include <dlfcn.h>
+
+namespace hsim {
+
+enum SharedLibMode : std::uint16_t {
+    kLazy = RTLD_LAZY,
+    kNow = RTLD_NOW,
+    kGlobal = RTLD_GLOBAL,
+    kLocal = RTLD_LOCAL,
+};
+
+class SharedLib {
+  public:
+    SharedLib(const std::filesystem::path &libPath, SharedLibMode mode)
+        : m_handle{dlopen(libPath.c_str(), mode), [](void *handle) {
+                       if (handle != nullptr) {
+                           dlclose(handle);
+                       }
+                   }} {
+        if (m_handle == nullptr) {
+            throw std::runtime_error{dlerror()};
+        }
+    }
+    template <typename T> T get(const std::string &symbol) {
+        void *loadedSymbol = dlsym(m_handle.get(), symbol.c_str());
+        if (loadedSymbol == nullptr) {
+            throw std::runtime_error{dlerror()};
+        }
+
+        return reinterpret_cast<T>(loadedSymbol);
+    }
+
+  private:
+    std::shared_ptr<void> m_handle;
+};
+
+} // namespace hsim
+
+#endif // HSIM_SO_LOADER_INCLUDED

include/plugin_manager.hh

@@ -1,25 +1,30 @@
-#include "plugin_api.hh"
-
 #include <iostream>
+#include <string>
+#include <utility>
 
-void notify(void* pluginMem);
-void unload(void* pluginMem);
+#include "plugin.hh"
+#include "so_loader.hh"
 
-HSIM_PLUGIN_API_ATTR hsim::LoadablePlugin loadPlugin([[maybe_unused]] const char* options) {
-    hsim::LoadablePlugin plugin = {};
-    plugin.pluginMem = nullptr;
-    plugin.notify = notify;
-    plugin.unload = unload;
+class SimplePlugin : public hsim::IPlugin {
+  public:
+    SimplePlugin(std::string name, hsim::SharedLib so_lib)
+        : IPlugin{std::move(so_lib)}, m_name{std::move(name)} {
+        std::cout << "SimplePlugin: " << m_name << std::endl;
+    }
 
-    std::cout << "load plugin" << std::endl;
+    ~SimplePlugin() override {
+        std::cout << "~SimplePlugin: " << m_name << std::endl;
+    }
 
-    return plugin;
-}
+    void update() override {
+        std::cout << "SimplePlugin name is : " << m_name << std::endl;
+    }
 
-void notify([[maybe_unused]] void* pluginMem) {
-    std::cout << "notify plugin" << std::endl;   
-}
+  private:
+    std::string m_name;
+};
 
-void unload([[maybe_unused]] void* pluginMem) {
-    std::cout << "unload plugin" << std::endl;
-} 
+extern "C" hsim::IPlugin *loadPlugin(const char *options,
+                                     hsim::SharedLib so_lib) {
+    return new SimplePlugin{options, std::move(so_lib)};
+}

include/so_loader.hh

@@ -1,10 +1,13 @@
+#include <exception>
 #include <iostream>
-#include <stdexcept>
+#include <utility>
 //
 #include <CLI/CLI.hpp>
 
 #include "config.hh"
 #include "machine.hh"
+#include "plugin.hh"
+#include "so_loader.hh"
 
 int main(int argc, char **argv) try {
     CLI::App app("hSim: high Performance CPU Simulator");
@@ -30,10 +33,15 @@ int main(int argc, char **argv) try {
     //
     hsim::Machine machine{config};
 
-    // machine.loadPlugin("./build/plugins/libsimple_plugin.so");
-
     machine.run();
 
+    // hsim::SharedLib sharedLib{"./build/plugins/libsimple_plugin.so",
+    // hsim::kLazy};
+
+    // auto plugin = hsim::loadPluginFromSO(sharedLib, "vova");
+    // machine.addEventConsumer(std::move(plugin));
+    // machine.notify();
+
     return 0;
 } catch (const std::exception &e) {
     std::cout << e.what() << '\n';