CGRAModel.hpp

Go to the documentation of this file.

/*
*    MIT License
*    
*    Copyright (c) 2021 Amano laboratory, Keio University & Processor Research Team, RIKEN Center for Computational Science
*    
*    Permission is hereby granted, free of charge, to any person obtaining a copy of
*    this software and associated documentation files (the "Software"), to deal in
*    the Software without restriction, including without limitation the rights to
*    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
*    of the Software, and to permit persons to whom the Software is furnished to do
*    so, subject to the following conditions:
*    
*    The above copyright notice and this permission notice shall be included in all
*    copies or substantial portions of the Software.
*    
*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
*    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
*    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
*    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
*    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*    SOFTWARE.
*    
*    File:          /include/CGRAModel.hpp
*    Project:       CGRAOmp
*    Author:        Takuya Kojima in The University of Tokyo (tkojima@hal.ipc.i.u-tokyo.ac.jp)
*    Created Date:  27-08-2021 15:00:30
*    Last Modified: 19-02-2022 06:45:05
*/
#ifndef CGRAModel_H
#define CGRAModel_H
 
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/JSON.h"
 
#include "CGRAInstMap.hpp"
 
#include <string>
#include <climits>
 
// Key setting to parse the JSON object
#define CATEGORY_KEY    "category"
#define AG_CONF_KEY     "address_generator"
#define AG_STYLE_KEY    "control"
#define AG_MAX_NEST_KEY "max_nested_level"
#define COND_STYLE_KEY  "conditional"
#define IDP_STYLE_KEY   "inter-loop-dependency"
#define OPT_ENABLE_KEY  "allowed"
#define OPT_TYPE_KEY    "type"
#define CUSTOM_INST_KEY "custom_instructions"
#define GEN_INST_KEY    "generic_instructions"
#define INST_MAP_KEY    "instruction_map"
 
 
 
using namespace llvm;
 
namespace CGRAOmp
{
 
    class CGRAModel {
        public:
            enum class CGRACategory {
                TimeMultiplexed,
                Decoupled,
            };
 
            enum class ConditionalStyle {
                No,
                MuxInst,
                TriState
            };
 
            enum class InterLoopDep {
                No,
                Generic,
                BackwardInst,
            };
            static StringMap<CGRACategory> CategoryMap;
            static StringMap<ConditionalStyle> CondStyleMap;
            static StringMap<InterLoopDep> InterLoopDepMap;
 
            // constructors
            explicit CGRAModel(StringRef filename, CGRACategory category,
                                ConditionalStyle cond,
                                InterLoopDep inter_loop_dep) :
                                filename(filename), category(category),
                                cond(cond), inter_loop_dep(inter_loop_dep) {};
            CGRAModel() = delete;
            CGRAModel(const CGRAModel &) = default;
            CGRAModel(CGRAModel &&) = default;
 
            Error addSupportedInst(StringRef opcode);
 
 
            void addCustomInst(StringRef opcode, ModuleAnalysisManager &MAM);
 
            Error add_map_entry(StringRef opcode, MapCondition *map_cond);
 
            InstMapEntry* isSupported(Instruction *I);
 
            template <typename DerivedT>
            DerivedT* asDerived() {
                return dyn_cast<DerivedT>(this);
            }
 
            CGRACategory getKind() const {
                return category;
            }
 
            InterLoopDep getInterLoopDepType() const {
                return inter_loop_dep;
            }
 
        protected:
            StringRef filename;
            ConditionalStyle cond;
            InterLoopDep inter_loop_dep;
            CGRACategory category;
            InstMap inst_map;
 
    };
 
    class AddressGenerator {
        public:
            enum class Kind {
                Affine,
                FullState,
            };
 
            AddressGenerator() = delete;
            explicit AddressGenerator(Kind kind) : kind(kind) {};
            AddressGenerator(const AddressGenerator &AG) = default;
            AddressGenerator(AddressGenerator &&) = default;
 
 
            Kind getKind() const {
                return kind;
            }
 
            template <typename DerivedT>
            DerivedT* asDerived() {
                return dyn_cast<DerivedT>(this);
            }
 
        private:
            Kind kind;
    };
 
    class DecoupledCGRA : public CGRAModel {
        public:
            DecoupledCGRA(StringRef filename, AddressGenerator *AG,
                            ConditionalStyle cond, InterLoopDep inter_loop_dep) :
                CGRAModel(filename, CGRACategory::Decoupled,
                            cond, inter_loop_dep), AG(AG) {};
 
            DecoupledCGRA(const DecoupledCGRA&);
 
            ~DecoupledCGRA() {
                delete AG;
            }
 
            AddressGenerator* getAG() const {
                return AG;
            }
 
            static bool classof(const CGRAModel *M) {
                return M->getKind() == CGRACategory::Decoupled;
            }
        private:
            AddressGenerator *AG;
 
    };
 
    class AffineAG : public AddressGenerator {
        using AG = AddressGenerator;
        public:
            AffineAG() : AG(AG::Kind::Affine) {
                max_nests = INT_MAX;
            }
            explicit AffineAG(int max_nests) : AG(AG::Kind::Affine),
                max_nests(max_nests) {};
 
            AffineAG(const AffineAG&);
 
            int getMaxNests() const {
                return max_nests;
            }
 
            static bool classof(const AG *ag) {
                return ag->getKind() == Kind::Affine;
            }
 
        private:
            int max_nests;
    };
 
    class FullStateAG : public AddressGenerator {
        using AG = AddressGenerator;
        public:
            FullStateAG(const FullStateAG&);
            static bool classof(const AG *ag) {
                return ag->getKind() == Kind::FullState;
            }
    };
 
    class TMCGRA : public CGRAModel {
        public:
            explicit TMCGRA(StringRef filename) :
                CGRAModel(filename, CGRACategory::TimeMultiplexed,
                            ConditionalStyle::No,
                            InterLoopDep::No) {}
            TMCGRA(const TMCGRA &);
 
            static bool classof(const CGRAModel *M) {
                return M->getKind() == CGRAModel::CGRACategory::TimeMultiplexed;
            }
 
        private:
    };
 
    class ModelError : public ErrorInfo<ModelError> {
        public:
            ModelError(StringRef filename, StringRef missed_key) :
                filename(filename),
                errtype(ErrorType::MissingKey),
                error_key(missed_key) {}
 
            ModelError(StringRef filename, StringRef key,
                        StringRef exptected_type, 
                        json::Value *v = nullptr) :
                    filename(filename),
                    errtype(ErrorType::InvalidDataType),
                    error_key(key),
                    exptected_type(exptected_type) {
                        if (v != nullptr) {
                            raw_string_ostream OS(json_val);
                            OS << *v;
                        }
                    }
 
            ModelError(StringRef filename, std::pair<StringRef,StringRef> config) :
                filename(filename), errtype(ErrorType::NoImplemented),
                error_key(config.first), error_val(config.second.str()) {};
 
            ModelError(StringRef filename, StringRef key, 
                        StringRef val, ArrayRef<StringRef> list);
 
            void setRegion(StringRef region_str) {
                region = region_str;
            }
 
            static char ID;
            std::error_code convertToErrorCode() const override {
                // Unknown error
                return std::error_code(41, std::generic_category());
            }
            void log(raw_ostream &OS) const override;
 
 
            bool isMissingKey() {
                return errtype == ErrorType::MissingKey;
            }
 
        private:
            enum class ErrorType {
                MissingKey,
                InvalidDataType,
                InvalidValue,
                NoImplemented,
            };
 
            ErrorType errtype;
            std::string json_val = "";
            StringRef filename;
            StringRef error_key;
            std::string error_val;
            StringRef exptected_type;
            StringRef region = "";
            SmallVector<StringRef> valid_values;
 
    };
 
 
    /* ---------- Utility functions  ---------- */
    Expected<CGRAModel*> parseCGRASetting(StringRef filepath,
                                            ModuleAnalysisManager &MAM);
 
    template <typename SettingT>
    SmallVector<StringRef> get_setting_values(StringMap<SettingT> settingMap);
 
    template <typename SettingT>
    bool containsValidData(StringMap<SettingT> settingMap, StringRef val);
 
    Expected<CGRAModel::CGRACategory> getCategory(json::Object *json_obj,
                                                    StringRef filename);
 
    template <char const *key_str, typename SettingT>
    Expected<SettingT> getOption(json::Object *json_obj,
                                            StringRef filename,
                                            StringMap<SettingT> settingMap);
 
    Expected<AddressGenerator*> parseAGConfig(json::Object *json_obj,
                                                StringRef filename);
 
    Expected<AddressGenerator*>  createAffineAG(json::Object *json_obj,
                                                StringRef filename);
 
    using AGGen_t = std::function<Expected<AddressGenerator*>(json::Object*,StringRef)>;
 
} // namespace CGRAOmp
 
 
#endif //CGRAModel_H