Mapper.h

Go to the documentation of this file.

/*******************************************************************************
 * The software programs comprising "CGRA-ME" and the documentation provided
 * with them are copyright by its authors and the University of Toronto. Only
 * non-commercial, not-for-profit use of this software is permitted without ex-
 * plicit permission. This software is provided "as is" with no warranties or
 * guarantees of support. See the LICENCE for more details. You should have re-
 * ceived a copy of the full licence along with this software. If not, see
 * <http://cgra-me.ece.utoronto.ca/license/>.
 ******************************************************************************/
 
#ifndef ___MAPPER_H__
#define ___MAPPER_H__
 
#include <CGRA/CGRA.h>
#include <CGRA/ConfigStore.h>
#include <CGRA/Mapping.h>
#include <CGRA/OpGraph.h>
#include <CGRA/TupleHash.h>
 
#include <iosfwd>
#include <map>
#include <regex>
#include <vector>
 
class Mapper
{
    public:
        virtual Mapping mapOpGraph(std::shared_ptr<OpGraph> opgraph, int II, const MRRG& mrrg, std::unordered_map<std::string, std::string> fix_port) = 0;
 
        virtual ~Mapper();
    protected:
        Mapper(std::shared_ptr<CGRA> cgra, int timelimit);
 
        std::shared_ptr<CGRA> cgra; //< Architecture Object
        int timelimit;  //< The mapper timeout in seconds
};
 
using MapperMaker = std::function<std::unique_ptr<Mapper>(std::shared_ptr<CGRA>, int, const ConfigStore&)>;
 
class MapperRegistry {
public:
    MapperRegistry(std::vector<ImplicitTuple<std::string, ImplicitlyToString, std::string>> common_defaults);
 
    MapperRegistry(const MapperRegistry&) = default;
    MapperRegistry(MapperRegistry&&) = default;
    MapperRegistry& operator=(const MapperRegistry&) = default;
    MapperRegistry& operator=(MapperRegistry&&) = default;
 
    std::unique_ptr<Mapper> createMapper(const std::string& mapper_id, std::shared_ptr<CGRA> cgra, int timelimit, const ConfigStore& args) const;
 
    void registerMapper(
        std::string mapper_id, MapperMaker maker, bool is_composite, std::string mapper_description,
        std::vector<ImplicitTuple<std::string, ImplicitlyToString, std::string>> required_arg_names_defaults_and_descriptions,
        std::vector<std::pair<std::string, std::string>> optional_arg_regexes_and_descriptions
    );
 
    ConfigStore getAllRegisteredArgDefaults() const;
 
    ConfigStore getMapperArgs(const std::string& mapper_id, const ConfigStore& args) const;
 
    void printMapperList(std::ostream& os) const;
 
    void printDefaultsAsINI(std::ostream& os) const;
 
    void printHelpForMapper(const std::string& mapper_id, const ConfigStore& args, std::ostream& os) const;
private:
    const std::string makeKeyPrefix(const std::string& mapper_id) const {
        return m_mapper_makers.at(mapper_id).is_composite ? mapper_id + '.' : ""; // composite mappers expect all keys to be prefixed
    }
 
    struct MakerAndDescription {
        MapperMaker maker;
        bool is_composite;
 
        std::string description;
        std::map<std::string, std::pair<std::regex, std::string>> allowed_arg_regexes_and_documentation;
        ConfigStore registered_defaults;
 
        auto findMatchingArg(const std::string& arg) const {
            const auto matches_key = [&](const auto& name_and_regex_and_doc) { return regex_match(arg, name_and_regex_and_doc.second.first); };
            return std::find_if(allowed_arg_regexes_and_documentation.begin(), allowed_arg_regexes_and_documentation.end(), matches_key);
        }
 
        bool hasMatchingArg(const std::string& arg) const {
            return
                registered_defaults.hasKey(arg)
                or findMatchingArg(arg) != allowed_arg_regexes_and_documentation.end();
        }
    };
 
    std::map<std::string, MakerAndDescription> m_mapper_makers;
};
 
class AutoRegisterMapper {
public:
    AutoRegisterMapper(
        std::string mapper_id, MapperMaker maker, bool is_composite, std::string mapper_description,
        std::vector<ImplicitTuple<std::string, ImplicitlyToString, std::string>> required_arg_names_defaults_and_descriptions,
        std::vector<std::pair<std::string, std::string>> optional_arg_regexes_and_descriptions
    );
 
    static const MapperRegistry& getDefaultRegistry() { return getDefaultMutableRegisty(); }
private:
    static MapperRegistry& getDefaultMutableRegisty();
};
 
#endif