plugins.h

Go to the documentation of this file.

#pragma once
 
#include <list>
#include <memory>
#include <string>
 
#include "sdfg/codegen/dispatchers/map_dispatcher.h"
#include "sdfg/codegen/dispatchers/node_dispatcher_registry.h"
#include "sdfg/codegen/dispatchers/reduce_dispatcher.h"
#include "sdfg/passes/scheduler/scheduler_registry.h"
#include "sdfg/plugins/targets.h"
#include "sdfg/serializer/json_serializer.h"
#include "sdfg/structured_sdfg.h"
#include "sdfg/tiles/tile_target_registry.h"
 
namespace sdfg {
namespace plugins {

struct Context {
    // Serialization
    serializer::LibraryNodeSerializerRegistry& library_node_serializer_registry;
 
    serializer::LibraryNodeSerializerRegistry& get_library_node_serializer_registry() {
        return library_node_serializer_registry;
    }
 
    // Dispatchers
    codegen::NodeDispatcherRegistry& get_node_dispatcher_registry() {
        return node_dispatcher_registry;
    }
    codegen::MapDispatcherRegistry& get_map_dispatcher_registry() {
        return map_dispatcher_registry;
    }
    codegen::ReduceDispatcherRegistry& get_reduce_dispatcher_registry() {
        return reduce_dispatcher_registry;
    }
    codegen::LibraryNodeDispatcherRegistry& get_library_node_dispatcher_registry() {
        return library_node_dispatcher_registry;
    }

    codegen::NodeDispatcherRegistry& node_dispatcher_registry;
    codegen::MapDispatcherRegistry& map_dispatcher_registry;
    codegen::ReduceDispatcherRegistry& reduce_dispatcher_registry;
    codegen::LibraryNodeDispatcherRegistry& library_node_dispatcher_registry;
 
    // Schedulers
    passes::scheduler::SchedulerRegistry& scheduler_registry;
    passes::scheduler::SchedulerRegistry& get_scheduler_registry() {
        return scheduler_registry;
    }
 
    // Tile targets
    tiles::TileTargetRegistry& get_tile_target_registry() {
        return tile_target_registry_;
    }
 
    OptionRegistry& option_registry() {
        return option_registry_;
    }
 
protected:
    std::unordered_map<std::string, docc::target::DoccTarget*> available_targets;
    OptionRegistry option_registry_;
    tiles::TileTargetRegistry& tile_target_registry_;
 
public:
    Context(
        serializer::LibraryNodeSerializerRegistry& library_node_serializer_registry,
        codegen::NodeDispatcherRegistry& node_dispatcher_registry,
        codegen::MapDispatcherRegistry& map_dispatcher_registry,
        codegen::ReduceDispatcherRegistry& reduce_dispatcher_registry,
        codegen::LibraryNodeDispatcherRegistry& library_node_dispatcher_registry,
        passes::scheduler::SchedulerRegistry& scheduler_registry,
        tiles::TileTargetRegistry& tile_target_registry
    )
        : library_node_serializer_registry(library_node_serializer_registry),
          node_dispatcher_registry(node_dispatcher_registry), map_dispatcher_registry(map_dispatcher_registry),
          reduce_dispatcher_registry(reduce_dispatcher_registry),
          library_node_dispatcher_registry(library_node_dispatcher_registry), scheduler_registry(scheduler_registry),
          tile_target_registry_(tile_target_registry) {
    }
 
    static Context global_context() {
        return Context{
            serializer::LibraryNodeSerializerRegistry::instance(),
            codegen::NodeDispatcherRegistry::instance(),
            codegen::MapDispatcherRegistry::instance(),
            codegen::ReduceDispatcherRegistry::instance(),
            codegen::LibraryNodeDispatcherRegistry::instance(),
            passes::scheduler::SchedulerRegistry::instance(),
            tiles::TileTargetRegistry::instance()
        };
    }
 
    bool add_target(docc::target::DoccTarget* target) {
        auto res = available_targets.insert_or_assign(target->short_name, target);
        return res.second;
    }
 
    docc::target::DoccTarget* get_target_handler(const std::string& target) const {
        auto it = available_targets.find(target);
        if (it != available_targets.end()) {
            return it->second;
        }
        return nullptr;
    }
};
 
struct Plugin {
    const char* name;
    const char* version;
    const char* description;
 
    // Register callback
    void (*register_plugin_callback)(Context& context);
 
    // SDFG lookup
    std::list<std::unique_ptr<sdfg::StructuredSDFG>> (*sdfg_lookup)(std::string name);
};
 
} // namespace plugins
} // namespace sdfg