WebAssembly.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <mutable/backend/Backend.hpp>
#include <mutable/storage/Index.hpp>
#include <mutable/IR/Operator.hpp>
#include <mutable/storage/DataLayoutFactory.hpp>
#include <mutable/util/macro.hpp>
#include <mutable/util/memory.hpp>
#include <unordered_map>
 
 
namespace m {
 
struct WasmEngine
{
    static constexpr std::size_t WASM_PAGE_SIZE = 1UL << 16;
    static constexpr std::size_t WASM_MAX_MEMORY = (1UL << 32) - (1UL << 16);
    static constexpr std::size_t WASM_ALIGNMENT = 8;
 
    struct WasmContext
    {
        enum config_t : uint64_t
        {
            TRAP_GUARD_PAGES = 0b1, 
        };
 
        private:
        config_t config_;
 
        public:
        unsigned id; 
        const MatchBase &plan; 
        std::unique_ptr<const storage::DataLayoutFactory> result_set_factory;
        memory::AddressSpace vm; 
        uint32_t heap = 0; 
        std::vector<std::reference_wrapper<const idx::IndexBase>> indexes; 
 
        WasmContext(uint32_t id, const MatchBase &plan, config_t configuration, std::size_t size);
 
        bool config(config_t cfg) const { return bool(cfg & config_); }
 
        uint32_t map_table(const Table &table);
 
        void install_guard_page();
 
        std::size_t add_index(const idx::IndexBase &index) {
            indexes.emplace_back(index);
            return indexes.size() - 1;
        }
    };
 
    private:
    static inline std::unordered_map<unsigned, std::unique_ptr<WasmContext>> contexts_;
 
    public:
    static WasmContext & Create_Wasm_Context_For_ID(unsigned id,
                                                    const MatchBase &plan,
                                                    WasmContext::config_t configuration = WasmContext::config_t(0x0),
                                                    std::size_t size = WASM_MAX_MEMORY)
    {
        auto wasm_context = std::make_unique<WasmContext>(id, plan, configuration, size);
        auto [it, inserted] = contexts_.emplace(id, std::move(wasm_context));
        M_insist(inserted, "WasmContext with that ID already exists");
        return *it->second;
    }
 
    static std::pair<std::reference_wrapper<WasmContext>, bool>
    Ensure_Wasm_Context_For_ID(unsigned id,
                               const MatchBase &plan,
                               WasmContext::config_t configuration = WasmContext::config_t(0x0),
                               std::size_t size = WASM_MAX_MEMORY)
    {
        auto [it, inserted] = contexts_.try_emplace(id, lazy_construct(
            [&](){ return std::make_unique<WasmContext>(id, plan, configuration, size); }
        ));
        return { std::ref(*it->second), inserted };
    }
 
    static void Dispose_Wasm_Context(unsigned id) {
        auto res = contexts_.erase(id);
        (void) res;
        M_insist(res == 1, "There is no context with the given ID to erase");
    }
 
    static void Dispose_Wasm_Context(const WasmContext &ctx) { Dispose_Wasm_Context(ctx.id); }
 
    static WasmContext & Get_Wasm_Context_By_ID(unsigned id) {
        auto it = contexts_.find(id);
        M_insist(it != contexts_.end(), "There is no context with the given ID");
        return *it->second;
    }
 
    static bool Has_Wasm_Context(unsigned id) { return contexts_.find(id) != contexts_.end(); }
 
    WasmEngine() = default;
    virtual ~WasmEngine() { }
    WasmEngine(const WasmEngine&) = delete;
    WasmEngine(WasmEngine&&) = default;
 
    virtual void compile(const MatchBase &plan) const = 0;
 
    virtual void execute(const MatchBase &plan) = 0;
};
 
struct WasmBackend : Backend
{
    private:
    std::unique_ptr<WasmEngine> engine_; 
 
    public:
    WasmBackend(std::unique_ptr<WasmEngine> engine) : engine_(std::move(engine)) { }
 
    const WasmEngine & engine() const { return *engine_; }
 
    void register_operators(PhysicalOptimizer &phys_opt) const override;
 
    void execute(const MatchBase &plan) const override;
};
 
}