[PhysOpt][Backend] Decouple physical optimization from specific backend.

Prior to this commit, the `PhysicalOptimizer` was only used in the
WasmV8 backend. Now, the physical optimization takes place independently
before calling a backend to execute the query. The interpreter
currently does not support physical operators and thus ignores the
given empty `PhysicalOptimizer` instance.

Author: lucagretscher

include/mutable/IR/PhysicalOptimizer.hpp

@@ -172,8 +172,15 @@ struct MatchBase
     public:
     virtual ~MatchBase() { }
 
+    /** Executes this physical operator match.  Recursively calls children operators to execute.  The three callbacks
+     * are specified by the parent operator and are used as follows: \p setup for some initializations, \p pipeline
+     * for the actual computation, and \p teardown for post-processing. */
     virtual void execute(setup_t setup, pipeline_t pipeline, teardown_t teardown) const = 0;
 
+    /** Returns the matched logical operator for physical operators with singleton patterns.  Must not be called for
+     * physical operators with a pattern tree. */
+    virtual const Operator & get_matched_singleton() const = 0;
+
     double cost() const { return cost_; }
     private:
     void cost(double new_cost) { cost_ = new_cost; }
@@ -228,9 +235,8 @@ struct PhysicalOptimizer
 
     /** Returns true iff a physical operator covering is found. */
     virtual bool has_plan() const = 0;
-
-    /** Executes the found physical operator covering. */
-    virtual void execute() const = 0;
+    /** Returns the found physical operator covering. */
+    virtual const MatchBase & get_plan() const = 0;
 
     virtual void accept(PhysOptVisitor &v) = 0;
     virtual void accept(ConstPhysOptVisitor &v) const = 0;
@@ -272,8 +278,9 @@ struct PhysicalOptimizerImpl : PhysicalOptimizer, ConstPostOrderOperatorVisitor
     }
 
     bool has_plan() const override { return not table().back().empty(); }
+    private:
     /** Returns the entry for the found physical operator covering. */
-    const entry_type & get_plan() const {
+    const entry_type & get_plan_entry() const {
         M_insist(has_plan(), "no physical operator covering found");
         typename PhysicalPlanTable::condition2entry_map_type::const_iterator it_best;
         double min_cost = std::numeric_limits<double>::infinity();
@@ -285,8 +292,8 @@ struct PhysicalOptimizerImpl : PhysicalOptimizer, ConstPostOrderOperatorVisitor
         }
         return it_best->entry;
     }
-
-    void execute() const override;
+    public:
+    const MatchBase & get_plan() const override { return get_plan_entry().match(); }
 
     private:
     /** Handles the found match \p match with children entries \p children for the logical plan rooted in \p op. */

include/mutable/backend/Backend.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <mutable/IR/PhysicalOptimizer.hpp>
 #include <mutable/mutable-config.hpp>
 #include <memory>
 #include <string>
@@ -16,8 +17,11 @@ struct M_EXPORT Backend
 {
     virtual ~Backend() { }
 
-    /** Executes the given `plan` using this `Backend`. */
-    virtual void execute(const Operator &plan) const = 0;
+    /** Registers all physical operators of this `Backend` in \p phys_opt. */
+    virtual void register_operators(PhysicalOptimizer &phys_opt) const = 0;
+
+    /** Executes the already computed physical covering represented by \p plan using this `Backend`. */
+    virtual void execute(const MatchBase &plan) const = 0;
 };
 
 }

include/mutable/backend/WebAssembly.hpp

@@ -34,13 +34,13 @@ struct WasmEngine
 
         public:
         unsigned id; ///< a unique ID
-        const Operator &plan; ///< current plan
+        const MatchBase &plan; ///< current plan
         ///> factory used to create the result set data layout
         std::unique_ptr<const storage::DataLayoutFactory> result_set_factory;
         memory::AddressSpace vm; ///<  WebAssembly module instance's virtual address space aka.\ *linear memory*
         uint32_t heap = 0; ///< beginning of the heap, encoded as offset from the beginning of the virtual address space
 
-        WasmContext(uint32_t id, config_t configuration, const Operator &plan, std::size_t size);
+        WasmContext(uint32_t id, const MatchBase &plan, config_t configuration, std::size_t size);
 
         bool config(config_t cfg) const { return bool(cfg & config_); }
 
@@ -61,11 +61,11 @@ struct WasmEngine
     public:
     /** Creates a new `WasmContext` for ID `id` with `size` bytes of virtual address space. */
     static WasmContext & Create_Wasm_Context_For_ID(unsigned id,
+                                                    const MatchBase &plan,
                                                     WasmContext::config_t configuration = WasmContext::config_t(0x0),
-                                                    const Operator &plan = NoOpOperator(std::cout),
                                                     std::size_t size = WASM_MAX_MEMORY)
     {
-        auto wasm_context = std::make_unique<WasmContext>(id, configuration, plan, size);
+        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;
@@ -74,12 +74,12 @@ struct WasmEngine
     /** If none exists, creates a new `WasmContext` for ID `id` with `size` bytes of virtual address space. */
     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),
-                               const Operator &plan = NoOpOperator(std::cout),
                                std::size_t size = WASM_MAX_MEMORY)
     {
         auto [it, inserted] = contexts_.try_emplace(id, lazy_construct(
-            [&](){ return std::make_unique<WasmContext>(id, configuration, plan, size); }
+            [&](){ return std::make_unique<WasmContext>(id, plan, configuration, size); }
         ));
         return { std::ref(*it->second), inserted };
     }
@@ -109,11 +109,11 @@ struct WasmEngine
     WasmEngine(const WasmEngine&) = delete;
     WasmEngine(WasmEngine&&) = default;
 
-    /** Compiles the given `plan` for this `WasmEngine`. */
-    virtual void compile(const Operator &plan) const = 0;
+    /** Compiles the already computed physical covering represented by \p plan using this `WasmEngine`. */
+    virtual void compile(const MatchBase &plan) const = 0;
 
-    /** Executes the given `plan` on this `WasmEngine`. */
-    virtual void execute(const Operator &plan) = 0;
+    /** Executes the already computed physical covering represented by \p plan using this `WasmEngine`. */
+    virtual void execute(const MatchBase &plan) = 0;
 };
 
 /** A `Backend` to execute a plan on a specific `WasmEngine`. */
@@ -128,8 +128,9 @@ struct WasmBackend : Backend
     /** Returns this backend's `WasmEngine`. */
     const WasmEngine & engine() const { return *engine_; }
 
-    /** Executes the given `plan` with this backend. */
-    void execute(const Operator &plan) const override;
+    void register_operators(PhysicalOptimizer &phys_opt) const override;
+
+    void execute(const MatchBase &plan) const override;
 };
 
 }

src/IR/PhysicalOptimizer.cpp

@@ -1,12 +1,7 @@
 #include <mutable/IR/PhysicalOptimizer.hpp>
 
-#include "backend/WasmDSL.hpp"
-#include "backend/WasmMacro.hpp"
-#include "backend/WasmUtil.hpp"
-
 
 using namespace m;
-using namespace m::wasm;
 
 
 /*======================================================================================================================
@@ -23,20 +18,6 @@ M_LCOV_EXCL_STOP
  * PhysicalOptimizerImpl
  *====================================================================================================================*/
 
-template<typename PhysicalPlanTable>
-void PhysicalOptimizerImpl<PhysicalPlanTable>::execute() const
-{
-    /* Emit code for run function which computes the last pipeline and calls other pipeline functions. */
-    FUNCTION(run, void(void))
-    {
-        auto S = CodeGenContext::Get().scoped_environment(); // create scoped environment for this function
-        get_plan().match().execute(setup_t::Make_Without_Parent(), pipeline_t(), teardown_t::Make_Without_Parent());
-    }
-
-    /* Call run function. */
-    run();
-}
-
 template<typename PhysicalPlanTable>
 void PhysicalOptimizerImpl<PhysicalPlanTable>::accept(PhysOptVisitor &v) { v(*this); }
 template<typename PhysicalPlanTable>
@@ -68,14 +49,14 @@ void PhysicalOptimizerImpl<PhysicalPlanTable>::dot_plan(std::ostream &out) const
         << "    graph [fontname = \"DejaVu Sans\"];\n"
         << "    node [fontname = \"DejaVu Sans\"];\n"
         << "    edge [fontname = \"DejaVu Sans\"];\n";
-    dot_plan_helper(get_plan(), out);
+    dot_plan_helper(get_plan_entry(), out);
     out << "}\n";
 };
 
 template<typename PhysicalPlanTable>
 void PhysicalOptimizerImpl<PhysicalPlanTable>::dump_plan(std::ostream &out) const
 {
-    out << get_plan().match() << std::endl;
+    out << get_plan() << std::endl;
 }
 template<typename PhysicalPlanTable>
 void PhysicalOptimizerImpl<PhysicalPlanTable>::dump_plan() const { dump_plan(std::cerr); }

src/backend/Interpreter.hpp

@@ -216,7 +216,9 @@ struct Interpreter : Backend, ConstOperatorVisitor
     public:
     Interpreter() = default;
 
-    void execute(const Operator &plan) const override { (*const_cast<Interpreter*>(this))(plan); }
+    void register_operators(PhysicalOptimizer &phys_opt) const override { /* nothing to be done */ }
+
+    void execute(const MatchBase &plan) const override { M_unreachable("currently not supported"); }
 
     using ConstOperatorVisitor::operator();
 #define DECLARE(CLASS) void operator()(Const<CLASS> &op) override;

src/backend/V8Engine.cpp

@@ -72,7 +72,6 @@ struct V8Engine : m::WasmEngine
     static inline v8::Platform *PLATFORM_ = nullptr;
     v8::ArrayBuffer::Allocator *allocator_ = nullptr;
     v8::Isolate *isolate_ = nullptr;
-    std::unique_ptr<PhysicalOptimizer> phys_opt_ = std::make_unique<PhysicalOptimizerImpl<ConcretePhysicalPlanTable>>();
 
     /*----- Objects for remote debugging via CDT. --------------------------------------------------------------------*/
     std::unique_ptr<V8InspectorClientImpl> inspector_;
@@ -90,8 +89,8 @@ struct V8Engine : m::WasmEngine
     }
 
     void initialize();
-    void compile(const m::Operator &plan) const override;
-    void execute(const m::Operator &plan) override;
+    void compile(const MatchBase &plan) const override;
+    void execute(const MatchBase &plan) override;
 };
 
 
@@ -294,7 +293,8 @@ void m::wasm::detail::read_result_set(const v8::FunctionCallbackInfo<v8::Value>
 {
     auto &context = WasmEngine::Get_Wasm_Context_By_ID(Module::ID());
 
-    auto &schema = context.plan.schema();
+    auto &root_op = context.plan.get_matched_singleton();
+    auto &schema = root_op.schema();
     auto deduplicated_schema = schema.deduplicate();
     auto deduplicated_schema_without_constants = deduplicated_schema.drop_constants();
 
@@ -332,7 +332,7 @@ void m::wasm::detail::read_result_set(const v8::FunctionCallbackInfo<v8::Value>
         };
         return find_projection_impl(op, find_projection_impl);
     };
-    auto &projections = find_projection(context.plan).projections();
+    auto &projections = find_projection(root_op).projections();
 
     ///> helper function to print given `ast::Constant` \p c of `Type` \p type to \p out
     auto print_constant = [](std::ostringstream &out, const ast::Constant &c, const Type *type){
@@ -389,7 +389,7 @@ void m::wasm::detail::read_result_set(const v8::FunctionCallbackInfo<v8::Value>
 
     if (deduplicated_schema_without_constants.num_entries() == 0) {
         /* Schema contains only constants. Create simple loop to generate `num_tuples` constant result tuples. */
-        if (auto callback_op = cast<const CallbackOperator>(&context.plan)) {
+        if (auto callback_op = cast<const CallbackOperator>(&root_op)) {
             Tuple tup(schema); // tuple entries which are not set are implicitly NULL
             for (std::size_t i = 0; i < schema.num_entries(); ++i) {
                 auto &e = schema[i];
@@ -399,7 +399,7 @@ void m::wasm::detail::read_result_set(const v8::FunctionCallbackInfo<v8::Value>
             }
             for (std::size_t i = 0; i < num_tuples; ++i)
                 callback_op->callback()(schema, tup);
-        } else if (auto print_op = cast<const PrintOperator>(&context.plan)) {
+        } else if (auto print_op = cast<const PrintOperator>(&root_op)) {
             std::ostringstream tup;
             for (std::size_t i = 0; i < schema.num_entries(); ++i) {
                 auto &e = schema[i];
@@ -419,7 +419,7 @@ void m::wasm::detail::read_result_set(const v8::FunctionCallbackInfo<v8::Value>
     auto layout = context.result_set_factory->make(deduplicated_schema_without_constants);
 
     /* Extract results. */
-    if (auto callback_op = cast<const CallbackOperator>(&context.plan)) {
+    if (auto callback_op = cast<const CallbackOperator>(&root_op)) {
         auto loader = Interpreter::compile_load(deduplicated_schema_without_constants, result_set, layout,
                                                 deduplicated_schema_without_constants);
         if (schema.num_entries() == deduplicated_schema.num_entries()) {
@@ -468,7 +468,7 @@ void m::wasm::detail::read_result_set(const v8::FunctionCallbackInfo<v8::Value>
                 callback_op->callback()(schema, tup_dupl);
             }
         }
-    } else if (auto print_op = cast<const PrintOperator>(&context.plan)) {
+    } else if (auto print_op = cast<const PrintOperator>(&root_op)) {
         /* Compute a `Tuple` with duplicates and constants. */
         Tuple tup(deduplicated_schema_without_constants);
         Tuple *args[] = { &tup };
@@ -599,12 +599,7 @@ struct CollectStringLiterals : ConstOperatorVisitor, ast::ConstASTExprVisitor
  * V8Engine implementation
  *====================================================================================================================*/
 
-V8Engine::V8Engine()
-{
-    register_wasm_operators(*phys_opt_);
-
-    initialize();
-}
+V8Engine::V8Engine() { initialize(); }
 
 V8Engine::~V8Engine()
 {
@@ -661,24 +656,27 @@ void V8Engine::initialize()
     isolate_ = v8::Isolate::New(create_params);
 }
 
-void V8Engine::compile(const Operator &plan) const
+void V8Engine::compile(const MatchBase &plan) const
 {
 #if 1
     /*----- Add print function. --------------------------------------------------------------------------------------*/
     Module::Get().emit_function_import<void(uint32_t)>("print");
 #endif
 
+    /*----- Emit code for run function which computes the last pipeline and calls other pipeline functions. ----------*/
+    FUNCTION(run, void(void))
+    {
+        auto S = CodeGenContext::Get().scoped_environment(); // create scoped environment for this function
+        plan.execute(setup_t::Make_Without_Parent(), pipeline_t(), teardown_t::Make_Without_Parent()); // emit code
+    }
+
     /*----- Create function `main` which executes the given query. ---------------------------------------------------*/
     m::wasm::Function<uint32_t(uint32_t)> main("main");
     BLOCK_OPEN(main.body())
     {
         auto S = CodeGenContext::Get().scoped_environment(); // create scoped environment for this function
-
-        /*----- Compile plan. ----------------------------------------------------------------------------------------*/
-        phys_opt_->execute(); // emit code
-
-        /*----- Return size of result set. ---------------------------------------------------------------------------*/
-        main.emit_return(CodeGenContext::Get().num_tuples());
+        run(); // call run function
+        main.emit_return(CodeGenContext::Get().num_tuples()); // return size of result set
     }
 
     /*----- Export main. ---------------------------------------------------------------------------------------------*/
@@ -719,21 +717,12 @@ void V8Engine::compile(const Operator &plan) const
 #endif
 }
 
-void V8Engine::execute(const Operator &plan)
+void V8Engine::execute(const MatchBase &plan)
 {
-    Module::Init();
-    CodeGenContext::Init(); // fresh context
-
     Catalog &C = Catalog::Get();
 
-    M_TIME_EXPR(phys_opt_->cover(plan), "Compute optimal physical operator covering", C.timer());
-    if (Options::Get().physplan) phys_opt_->dump_plan();
-    if (Options::Get().physplandot) {
-        Diagnostic diag(Options::Get().has_color, std::cout, std::cerr);
-        DotTool dot(diag);
-        phys_opt_->dot_plan(dot.stream());
-        dot.show("physical_plan", true);
-    }
+    Module::Init();
+    CodeGenContext::Init(); // fresh context
 
     M_insist(bool(isolate_), "must have an isolate");
     v8::Locker locker(isolate_);
@@ -755,7 +744,7 @@ void V8Engine::execute(const Operator &plan)
         WasmContext::config_t wasm_config{0};
         if (options::cdt_port < 1024)
             wasm_config |= WasmContext::TRAP_GUARD_PAGES;
-        auto &wasm_context = Create_Wasm_Context_For_ID(Module::ID(), wasm_config, plan);
+        auto &wasm_context = Create_Wasm_Context_For_ID(Module::ID(), plan, wasm_config);
 
         auto imports = v8::Object::New(isolate_);
         auto env = create_env(*isolate_, plan);
@@ -795,10 +784,11 @@ void V8Engine::execute(const Operator &plan)
                         "Execute machine code", C.timer());
 
         /* Print total number of result tuples. */
-        if (auto print_op = cast<const PrintOperator>(&plan)) {
+        auto &root_op = plan.get_matched_singleton();
+        if (auto print_op = cast<const PrintOperator>(&root_op)) {
             if (not Options::Get().quiet)
                 print_op->out << num_rows << " rows\n";
-        } else if (auto noop_op = cast<const NoOpOperator>(&plan)) {
+        } else if (auto noop_op = cast<const NoOpOperator>(&root_op)) {
             if (not Options::Get().quiet)
                 noop_op->out << num_rows << " rows\n";
         }
@@ -905,7 +895,7 @@ v8::Local<v8::WasmModuleObject> m::wasm::detail::instantiate(v8::Isolate &isolat
                ->CallAsConstructor(Ctx, 2, instance_args).ToLocalChecked().As<v8::WasmModuleObject>();
 }
 
-v8::Local<v8::Object> m::wasm::detail::create_env(v8::Isolate &isolate, const Operator &plan)
+v8::Local<v8::Object> m::wasm::detail::create_env(v8::Isolate &isolate, const MatchBase &plan)
 {
     auto &context = WasmEngine::Get_Wasm_Context_By_ID(Module::ID());
     auto Ctx = isolate.GetCurrentContext();
@@ -931,7 +921,7 @@ v8::Local<v8::Object> m::wasm::detail::create_env(v8::Isolate &isolate, const Op
 
     /* Map all string literals into the Wasm module. */
     M_insist(Is_Page_Aligned(context.heap));
-    auto literals = CollectStringLiterals::Collect(plan);
+    auto literals = CollectStringLiterals::Collect(plan.get_matched_singleton());
     std::size_t bytes = 0;
     for (auto literal : literals)
         bytes += strlen(literal) + 1;