plugin system

src/thorin/CMakeLists.txt

@@ -47,6 +47,10 @@ set(THORIN_SOURCES
     transform/codegen_prepare.cpp
     transform/dead_load_opt.cpp
     transform/dead_load_opt.h
+    transform/hls_channels.cpp
+    transform/hls_channels.h
+    transform/hls_kernel_launch.h
+    transform/hls_kernel_launch.cpp
     transform/hoist_enters.cpp
     transform/hoist_enters.h
     transform/flatten_tuples.cpp
@@ -59,18 +63,16 @@ set(THORIN_SOURCES
     transform/lift_builtins.h
     transform/mangle.cpp
     transform/mangle.h
-    transform/resolve_loads.cpp
-    transform/resolve_loads.h
     transform/partial_evaluation.cpp
     transform/partial_evaluation.h
     transform/rewrite.cpp
     transform/rewrite.h
+    transform/plugin_execute.cpp
+    transform/plugin_execute.h
+    transform/resolve_loads.cpp
+    transform/resolve_loads.h
     transform/split_slots.cpp
     transform/split_slots.h
-    transform/hls_channels.cpp
-    transform/hls_channels.h
-    transform/hls_kernel_launch.h
-    transform/hls_kernel_launch.cpp
     util/array.h
     util/cast.h
     util/hash.h
@@ -150,3 +152,5 @@ endif()
 if(THORIN_ENABLE_JSON)
     target_link_libraries(thorin PRIVATE nlohmann_json::nlohmann_json)
 endif()
+
+target_link_libraries(thorin PRIVATE ${CMAKE_DL_LIBS})

src/thorin/be/emitter.h

@@ -41,7 +41,7 @@ class Emitter {
         }
 
         //auto place = def->no_dep() ? entry_ : scheduler_.smart(def);
-        auto place = !scheduler_.scope().contains(def) ? entry_ : scheduler_.smart(def);
+        auto place = !(&scheduler_.scope()) ? nullptr : (!scheduler_.scope().contains(def) ? entry_ : scheduler_.smart(def));
 
         if (place) {
             auto& bb = cont2bb_[place];

src/thorin/be/json/json.cpp

@@ -227,6 +227,45 @@ class DefTable {
                     result["intrinsic"] = "match";
                     result["variant_type"] = variant_type;
                     result["num_patterns"] = num_patterns;
+                } else if (cont->intrinsic() == Intrinsic::Plugin) {
+                    auto intrinsic_name = cont->name();
+                    auto intrinsic_type = type_table_.translate_type(cont->type());
+                    auto name = "_plugin_" + std::to_string(decl_table.size());
+                    known_defs[def] = name;
+
+                    json forward_decl;
+                    forward_decl["name"] = name;
+                    forward_decl["type"] = "continuation";
+                    forward_decl["intrinsic"] = intrinsic_name;
+                    forward_decl["fn_type"] = intrinsic_type;
+                    forward_decl["plugin"] = true;
+
+                    bool emit_node = false;
+                    if (cont->attributes().depends) {
+                        result["depends"] = translate_def(cont->attributes().depends);
+
+                        emit_node = true;
+                    }
+                    if (cont->filter() && !cont->filter()->empty()) {
+                        //The filter will most certainly rely on these parameters.
+                        json arg_names = json::array();
+                        for (auto arg : cont->params()) {
+                            arg_names.push_back(translate_def(arg));
+                        }
+                        forward_decl["arg_names"] = arg_names;
+
+                        emit_node = true;
+                    }
+
+                    decl_table.push_back(forward_decl);
+
+                    if (emit_node) {
+                        result["name"] = name;
+                        result["type"] = "continuation";
+                        result["plugin"] = true;
+                    } else {
+                        return name;
+                    }
                 } else {
                     auto intrinsic_name = cont->name();
                     auto intrinsic_type = type_table_.translate_type(cont->type());
@@ -283,9 +322,12 @@ class DefTable {
                     };
                 } else {
                     //Early return. We do not have a body, so there is no point in writing something to the def table.
-                    if (cont->filter() && !cont->filter()->empty())
-                        assert(false && "These filters cannot be generated RN");
-                    return name;
+                    if (cont->filter() && !cont->filter()->empty()) {
+                        result["name"] = name;
+                        result["type"] = "continuation";
+                        result["filter"] = translate_def(cont->filter());
+                    } else
+                        return name;
                 }
             }
         } else if (auto lit = def->isa<PrimLit>()) {
@@ -295,11 +337,19 @@ class DefTable {
             result["name"] = name;
             result["type"] = "const";
             result["const_type"] = type;
-            //result["value"] = lit->value().get_s32(); //TODO: this looks wrong. What I get should depend on the lit type.
+
             switch (lit->primtype_tag()) {
 #define THORIN_I_TYPE(T, M) case PrimType_##T: { result["value"] = lit->value().get_##M(); break; }
 #define THORIN_BOOL_TYPE(T, M) case PrimType_##T: { result["value"] = lit->value().get_##M(); break; }
-#define THORIN_F_TYPE(T, M) case PrimType_##T: { result["value"] = (double)lit->value().get_##M(); break; }
+#define THORIN_F_TYPE(T, M) case PrimType_##T: { \
+    double value = (double)lit->value().get_##M(); \
+    result["value"] = value; \
+    if (value == INFINITY) { result["special"] = "inf"; } \
+    if (value == - INFINITY) { result["special"] = "-inf"; } \
+    if (value == NAN) { result["special"] = "nan"; } \
+    if (value == - NAN) { result["special"] = "- nan"; } \
+    break; \
+}
 #include <thorin/tables/primtypetable.h>
             default:
                 assert(false && "not implemented");

src/thorin/be/llvm/amdgpu.h

@@ -22,6 +22,7 @@ class AMDGPUCodeGen : public CodeGen {
     llvm::Value* emit_mathop(llvm::IRBuilder<>&, const MathOp*) override;
     llvm::Value* emit_reserve(llvm::IRBuilder<>&, const Continuation*) override;
     std::string get_alloc_name() const override { return "malloc"; }
+    std::string get_release_name() const override { return "free"; }
 
     const Cont2Config& kernel_config_;
 };

src/thorin/be/llvm/cpu.h

@@ -13,6 +13,7 @@ class CPUCodeGen : public CodeGen {
 
 protected:
     std::string get_alloc_name() const override { return "anydsl_alloc"; }
+    std::string get_release_name() const override { return "anydsl_release"; }
 };
 
 }

src/thorin/be/llvm/llvm.cpp

@@ -1013,6 +1013,9 @@ llvm::Value* CodeGen::emit_builder(llvm::IRBuilder<>& irbuilder, const Def* def)
     } else if (auto alloc = def->isa<Alloc>()) {
         emit_unsafe(alloc->mem());
         return emit_alloc(irbuilder, alloc->alloced_type(), alloc->extra());
+    } else if (auto release = def->isa<Release>()) {
+        emit_unsafe(release->mem());
+        return emit_release(irbuilder, release->alloc());
     } else if (auto slot = def->isa<Slot>()) {
         return emit_alloca(irbuilder, convert(slot->type()->as<PtrType>()->pointee()), slot->unique_name());
     } else if (auto vector = def->isa<Vector>()) {
@@ -1058,6 +1061,15 @@ llvm::Value* CodeGen::emit_alloc(llvm::IRBuilder<>& irbuilder, const Type* type,
     return irbuilder.CreatePointerCast(void_ptr, llvm::PointerType::get(context(), 0));
 }
 
+llvm::Value* CodeGen::emit_release(llvm::IRBuilder<>& irbuilder, const Def* alloc) {
+    auto llvm_release = runtime_->get(*this, get_release_name().c_str());
+    llvm::Value* llvm_alloc = emit(alloc);
+    llvm::Value* cast_alloc = irbuilder.CreatePointerCast(llvm_alloc, irbuilder.getInt8PtrTy());
+    llvm::Value* release_args[] = { irbuilder.getInt32(0), cast_alloc };
+    irbuilder.CreateCall(llvm_release, release_args);
+    return nullptr;
+}
+
 llvm::AllocaInst* CodeGen::emit_alloca(llvm::IRBuilder<>& irbuilder, llvm::Type* type, const std::string& name) {
     // Emit the alloca in the entry block
     auto entry = &irbuilder.GetInsertBlock()->getParent()->getEntryBlock();

src/thorin/be/llvm/llvm.h

@@ -74,6 +74,7 @@ class CodeGen : public thorin::CodeGen, public thorin::Emitter<llvm::Value*, llv
 
     llvm::AllocaInst* emit_alloca(llvm::IRBuilder<>&, llvm::Type*, const std::string&);
     llvm::Value*      emit_alloc (llvm::IRBuilder<>&, const Type*, const Def*);
+    llvm::Value*      emit_release (llvm::IRBuilder<>&, const Def*);
     virtual void emit_fun_decl_hook(Continuation*, llvm::Function*) {}
     virtual llvm::Value* map_param(llvm::Function*, llvm::Argument* a, const Param*) { return a; }
 
@@ -87,6 +88,7 @@ class CodeGen : public thorin::CodeGen, public thorin::Emitter<llvm::Value*, llv
     llvm::Value* emit_reserve_shared(llvm::IRBuilder<>&, const Continuation*, bool=false);
 
     virtual std::string get_alloc_name() const = 0;
+    virtual std::string get_release_name() const = 0;
     llvm::BasicBlock* cont2bb(Continuation* cont) { return cont2bb_[cont].first; }
 
     virtual llvm::Value* emit_global(const Global*);

src/thorin/be/llvm/nvvm.cpp

@@ -19,8 +19,8 @@
 
 namespace thorin::llvm {
 
-NVVMCodeGen::NVVMCodeGen(Thorin& thorin, const Cont2Config& kernel_config, int opt, bool debug)
-    : CodeGen(thorin, llvm::CallingConv::C, llvm::CallingConv::PTX_Device, llvm::CallingConv::PTX_Kernel, 0, debug)
+NVVMCodeGen::NVVMCodeGen(Thorin& thorin, const Cont2Config& kernel_config, int /* opt */, bool /* debug */)
+    : CodeGen(thorin, llvm::CallingConv::C, llvm::CallingConv::PTX_Device, llvm::CallingConv::PTX_Kernel, 0, false)
     , kernel_config_(kernel_config)
 {
     auto triple = llvm::Triple(llvm::sys::getDefaultTargetTriple());

src/thorin/be/llvm/nvvm.h

@@ -33,6 +33,7 @@ class NVVMCodeGen : public CodeGen {
     llvm::Value* emit_global(const Global*) override;
 
     std::string get_alloc_name() const override { return "malloc"; }
+    std::string get_release_name() const override { return "free"; }
 
 private:
     llvm::Function* get_texture_handle_fun(llvm::IRBuilder<>&);

src/thorin/continuation.cpp

@@ -59,6 +59,18 @@ bool App::verify() const {
     return true;
 }
 
+void App::jump(const Def* callee, Defs args, Debug dbg) {
+    unset_ops();
+    resize(args.size() + 1);
+
+    set_op(0, callee);
+    for (int i = 0, e = args.size(); i < e; i++) {
+        set_op(i + 1, args[i]);
+    }
+
+    verify();
+}
+
 //------------------------------------------------------------------------------
 
 Filter::Filter(World& world, const Defs defs, Debug dbg) : Def(world, Node_Filter, world.bottom_type(), defs, dbg) {}
@@ -300,9 +312,7 @@ void Continuation::match(const Def* mem, const Def* val, Continuation* otherwise
 
 bool Continuation::verify() const {
     bool ok = true;
-    if (!has_body())
-        assertf(filter()->is_empty(), "continuations with no body should have an empty (no) filter");
-    else {
+    if (has_body()) {
         ok &= body()->verify();
         assert(!dead_); // destroy() should remove the body
         assert(intrinsic() == Intrinsic::None);

src/thorin/continuation.h

@@ -118,6 +118,7 @@ enum class Intrinsic : uint8_t {
     Branch,                     ///< branch(mem, cond, T, F).
     Match,                      ///< match(mem, val, otherwise, (case1, cont1), (case2, cont2), ...)
     PeInfo,                     ///< Partial evaluation debug info.
+    Plugin,                     ///< Some plugin derived intrinsic. Indentified by its name.
     EndScope                    ///< Dummy function which marks the end of a @p Scope.
 };
 
@@ -131,12 +132,13 @@ class Continuation : public Def {
     struct Attributes {
         Intrinsic intrinsic = Intrinsic::None;
         CC cc = CC::Thorin;
+        const Continuation* depends = nullptr;
 
         Attributes(Intrinsic intrinsic) : intrinsic(intrinsic) {}
         Attributes(CC cc = CC::Thorin) : cc(cc) {}
     };
 
-private:
+protected:
     Continuation(World&, const FnType* pi, const Attributes& attributes, Debug dbg);
     virtual ~Continuation() { for (auto param : params()) delete param; }
 

src/thorin/primop.cpp

@@ -112,6 +112,12 @@ Alloc::Alloc(World& world, const Type* type, const Def* mem, const Def* extra, D
     set_type(world.tuple_type({world.mem_type(), world.ptr_type(type)}));
 }
 
+Release::Release(World& world, const Def* mem, const Def* alloc, Debug dbg)
+    : MemOp(world, Node_Release, nullptr, {mem, alloc}, dbg)
+{
+    set_type(world.mem_type());
+}
+
 Load::Load(World& world, const Def* mem, const Def* ptr, Debug dbg)
     : Access(world, Node_Load, nullptr, {mem, ptr}, dbg)
 {
@@ -223,6 +229,10 @@ const Def* Alloc::rebuild(World& w, const Type* t, Defs o) const {
     return w.alloc(t->as<TupleType>()->op(1)->as<PtrType>()->pointee(), o[0], o[1], debug());
 }
 
+const Def* Release::rebuild(World& w, const Type* t, Defs o) const {
+    return w.release(o[0], o[1], debug());
+}
+
 const Def* Assembly::rebuild(World& w, const Type* t, Defs o) const {
     return w.assembly(t, o, asm_template(), output_constraints(), input_constraints(), clobbers(), flags(), debug());
 }

src/thorin/primop.h

@@ -585,6 +585,20 @@ class Alloc : public MemOp {
     friend class World;
 };
 
+class Release : public MemOp {
+private:
+    Release(World& world, const Def* mem, const Def* alloc, Debug dbg);
+
+public:
+    const Def* alloc() const { return op(1); }
+
+private:
+    const Def* rebuild(World&, const Type*, Defs) const override;
+
+    friend class World;
+};
+
+
 /// Base class for @p Load and @p Store.
 class Access : public MemOp {
 protected:

src/thorin/rec_stream.cpp

@@ -63,6 +63,12 @@ void RecStreamer::run() {
             s.fmt("// free frontier: {, }\n", scope.free_frontier());
         }
 
+        if (cont->is_intrinsic() && cont->intrinsic() == Intrinsic::Plugin) {
+            s.fmt("plugin ");
+            if (cont->attributes().depends)
+                s.fmt("[depends {}] ", cont->attributes().depends->unique_name());
+        }
+
         if (cont->has_body()) {
             std::vector<std::string> param_names;
             for (auto param : cont->params()) param_names.push_back(param->unique_name());

src/thorin/tables/nodetable.h

@@ -12,6 +12,7 @@
             THORIN_NODE(BlobPtr, mem_blob)
         // MemOp
             THORIN_NODE(Alloc, alloc)
+            THORIN_NODE(Release, release)
             // Access
                 THORIN_NODE(Load, load)
                 THORIN_NODE(Store, store)

src/thorin/transform/cleanup_world.cpp

@@ -30,6 +30,7 @@ class Cleaner {
     void clean_pe_info(std::queue<Continuation*>, Continuation*);
     Thorin& thorin_;
     bool todo_ = true;
+friend class Thorin;
 };
 
 void Cleaner::eliminate_tail_rec() {
@@ -244,7 +245,7 @@ void Cleaner::cleanup_fix_point() {
         todo_ |= resolve_loads(world());
         rebuild();
         //if (!world().is_pe_done())
-            todo_ |= partial_evaluation(world());
+            todo_ |= partial_evaluation(thorin_);
         //else
         //    clean_pe_infos();
     }
@@ -258,7 +259,8 @@ void Cleaner::cleanup() {
         world().mark_pe_done();
         for (auto def : world().defs()) {
             if (auto cont = def->isa_nom<Continuation>())
-                cont->destroy_filter();
+                if (cont->cc() != CC::Thorin)
+                    cont->destroy_filter();
         }
 
         todo_ = true;
@@ -273,5 +275,6 @@ void Cleaner::cleanup() {
 }
 
 void Thorin::cleanup() { Cleaner(*this).cleanup(); }
+void Thorin::cleanup_fix_point() { Cleaner(*this).cleanup_fix_point(); }
 
 }

src/thorin/transform/closure_conversion.cpp

@@ -74,7 +74,7 @@ class ClosureConversion {
         }
 
         // prevent conversion of calls to vectorize() or cuda(), but allow graph intrinsics
-        if (!callee || !callee->is_intrinsic()) {
+        if (!callee || !callee->is_intrinsic() || callee->intrinsic() == Intrinsic::Plugin) {
             Array<const Def*> new_args(body->num_args());
             for (size_t i = 0, e = body->num_args(); i != e; ++i)
                 new_args[i] = convert_def(body->arg(i));

src/thorin/transform/codegen_prepare.cpp

@@ -43,8 +43,11 @@ void codegen_prepare(Thorin& thorin) {
     auto destination = std::make_unique<World>(src);
     CodegenPrepare pass(src, *destination.get());
 
-    for (auto& external : src.externals())
+    for (auto& external : src.externals()) {
+        if (auto cont = external.second->isa<Continuation>(); cont && cont->cc() == CC::Thorin)
+            continue;
         pass.instantiate(external.second);
+    }
 
     thorin.world_container().swap(destination);
     thorin.world().VLOG("end codegen_prepare");