//// Dis VM// File: vm.cpp// Author: arr// #include <cassert>#include <memory>#include <algorithm>#include <disvm.h>#include <debug.h>#include <runtime.h>#include <exceptions.h>#include <builtin_module.h>#include <vm_version.h>#include "scheduler.h"#include "garbage_collector.h"#include "tool_dispatch.h" using namespace disvm;using namespace disvm::runtime; vm_t::vm_t(    create_vm_interface_callback_t<runtime::vm_scheduler_t> create_scheduler,    create_vm_interface_callback_t<runtime::vm_garbage_collector_t> create_gc){    // Initialize built-in modules.    builtin::initialize_builtin_modules();     if (create_gc == nullptr)        _gc = std::make_unique<default_garbage_collector_t>(*this);    else        _gc = create_gc(*this);     if (create_scheduler == nullptr)    {        _scheduler = std::make_unique<default_scheduler_t>(*this, default_system_thread_count, default_thread_quanta);    }    else    {        _scheduler = create_scheduler(*this);    }} vm_t::vm_t(uint32_t system_thread_count, uint32_t thread_quanta){    // Initialize built-in modules.    builtin::initialize_builtin_modules();     _gc = std::make_unique<default_garbage_collector_t>(*this);    _scheduler = std::make_unique<default_scheduler_t>(*this, system_thread_count, thread_quanta);} vm_t::~vm_t(){    // Release the scheduler first since it could be using the gc instance.    _scheduler.reset();    _gc.reset();     std::lock_guard<std::mutex> lock{ _modules_lock };    for (auto &m : _modules)    {        if (m.origin != nullptr)            m.origin->release();    }} vm_version_t vm_t::get_version() const{    return{ DISVM_VERSION_MAJOR, DISVM_VERSION_MINOR, DISVM_VERSION_PATCH, DISVM_VERSION_LABEL };} namespace{    std::unique_ptr<runtime::vm_thread_t> _create_thread_safe(std::unique_ptr<runtime::vm_module_ref_t> &entry_module_ref)    {        auto thread = std::make_unique<vm_thread_t>(*entry_module_ref, vm_t::root_vm_thread_id);         // Now that the thread has been created and has inherited ownership of the pointer, relinquish the smart pointer's ownership.        entry_module_ref->release(); // decrement the vm alloc ref count        entry_module_ref.release(); // release the smart pointer         return thread;    }} const runtime::vm_thread_t& vm_t::exec(const char *path){    assert(path != nullptr);    auto entry_module = load_module(path);     auto entry_module_ref = std::make_unique<vm_module_ref_t>(entry_module);    auto thread = _create_thread_safe(entry_module_ref);    return schedule_thread(std::move(thread));} const runtime::vm_thread_t& vm_t::exec(std::unique_ptr<runtime::vm_module_t> entry_module){    assert(entry_module != nullptr);     auto entry_module_ref = std::make_unique<vm_module_ref_t>(std::move(entry_module));    auto thread = _create_thread_safe(entry_module_ref);    return schedule_thread(std::move(thread));} const runtime::vm_thread_t& vm_t::fork(    const uint32_t parent_tid,    runtime::vm_module_ref_t &module_ref,    const runtime::vm_frame_t &initial_frame,    runtime::vm_pc_t initial_pc){    if (initial_pc < 0 || static_cast<vm_pc_t>(module_ref.code_section.size()) <= initial_pc)        throw vm_system_exception{ "Invalid entry program counter" };     auto thread = std::make_unique<vm_thread_t>(module_ref, parent_tid, initial_frame, initial_pc);    return schedule_thread(std::move(thread));} std::shared_ptr<runtime::vm_module_t> vm_t::load_module(const char *path){    if (path == nullptr)        throw vm_user_exception{ "Invalid module path" };     auto new_module_iter = loaded_modules_t::const_iterator{};    auto new_module = std::shared_ptr<vm_module_t>{};    {        std::lock_guard<std::mutex> lock{ _modules_lock };         // Check if the module is already loaded.        auto iter = std::begin(_modules);        while (iter != std::end(_modules))        {            if (0 == ::strcmp(iter->origin->str(), path))            {                auto module = iter->module.lock();                 // If an entry exists but is null, the module was loaded before. Read the module again and return.                if (module == nullptr)                {                    module = std::shared_ptr<vm_module_t>{ std::move(read_module(path)) };                    iter->module = module;                     debug::log_msg(debug::component_trace_t::module, debug::log_level_t::debug, "reload: vm module: >>%s<<\n", path);                }                 return module;            }             ++iter;        }         if (path[0] == BUILTIN_MODULE_PREFIX_CHAR)        {            new_module = std::move(builtin::get_builtin_module(path));        }        else        {            // Read in the module            new_module = std::move(read_module(path));        }         auto path_local = std::make_unique<vm_string_t>(std::strlen(path), reinterpret_cast<const uint8_t *>(path));         auto load_id_next = std::size_t{ 0 };        if (!_modules.empty())            load_id_next = (_modules.front().load_id + 1);         _modules.push_front(std::move(loaded_vm_module_t{ load_id_next, std::move(path_local), new_module }));        new_module_iter = _modules.begin();    }     if (_tool_dispatch != nullptr)    {        std::lock_guard<std::mutex> lock{ _tool_dispatch_lock };        if (_tool_dispatch != nullptr)            _tool_dispatch->on_module_vm_load(new_module, *new_module_iter->origin);    }     if (debug::is_component_tracing_enabled<debug::component_trace_t::module>())        debug::log_msg(debug::component_trace_t::module, debug::log_level_t::debug, "load: vm module: >>%s<<\n", path);     return new_module;} void vm_t::enum_loaded_modules(loaded_vm_module_callback_t callback) const{    if (callback == nullptr)        throw vm_system_exception{ "Callback should not be null" };     std::lock_guard<std::mutex> lock{ _modules_lock };    for (auto &m : _modules)    {        if (!callback(m))            return;    }} runtime::vm_scheduler_control_t &vm_t::get_scheduler_control() const{    return _scheduler->get_controller();} runtime::vm_garbage_collector_t &vm_t::get_garbage_collector() const{    return *_gc;} void vm_t::spin_sleep_till_idle(std::chrono::milliseconds sleep_interval) const{    do        std::this_thread::sleep_for(sleep_interval);    while (!_scheduler->is_idle());} std::size_t vm_t::load_tool(std::shared_ptr<runtime::vm_tool_t> tool){    std::lock_guard<std::mutex> lock{ _tool_dispatch_lock };     if (_tool_dispatch == nullptr)    {        _tool_dispatch = std::make_unique<vm_tool_dispatch_t>(*this);         // Attach to all threads        _scheduler->set_tool_dispatch_on_all_threads(_tool_dispatch.get());    }     return _tool_dispatch->load_tool(std::move(tool));} void vm_t::unload_tool(std::size_t tool_id){    std::lock_guard<std::mutex> lock{ _tool_dispatch_lock };     if (_tool_dispatch == nullptr)        return;     const auto tool_count = _tool_dispatch->unload_tool(tool_id);    if (tool_count == 0)    {        // Detach from all threads        _scheduler->set_tool_dispatch_on_all_threads(nullptr);        _tool_dispatch.reset();    }} const runtime::vm_thread_t &vm_t::schedule_thread(std::unique_ptr<runtime::vm_thread_t> thread){    assert(thread != nullptr);     if (_tool_dispatch != nullptr)    {        std::lock_guard<std::mutex> lock{ _tool_dispatch_lock };        if (_tool_dispatch != nullptr)        {            _tool_dispatch->on_thread_begin(*thread);            thread->set_tool_dispatch(_tool_dispatch.get());        }    }     return _scheduler->schedule_thread(std::move(thread));}