DFGPass.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/DFGPass.hpp
*    Project:       CGRAOmp
*    Author:        Takuya Kojima in The University of Tokyo (tkojima@hal.ipc.i.u-tokyo.ac.jp)
*    Created Date:  15-12-2021 09:59:52
*    Last Modified: 12-07-2022 18:22:30
*/
#ifndef DFGPASS_H
#define DFGPASS_H
 
#include "llvm/IR/PassManager.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Instruction.h"
#include "llvm/Passes/PassBuilder.h"
#include "llvm/Passes/PassPlugin.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/iterator_range.h"
 
#include "CGRAModel.hpp"
#include "CGRADataFlowGraph.hpp"
 
using namespace llvm;
 
 
namespace CGRAOmp {
 
    struct DFGPassConcept {
        virtual ~DFGPassConcept() = default;
 
        virtual StringRef name() const = 0;
 
        virtual bool run(CGRADFG &G, Loop &L, FunctionAnalysisManager &FAM,
                                    LoopAnalysisManager &LAM,
                                    LoopStandardAnalysisResults &AR) = 0;
 
    };
 
    template <typename PassT>
    struct DFGPassModel : public DFGPassConcept {
        explicit DFGPassModel(PassT Pass) : Pass(std::move(Pass)) {}
        DFGPassModel(const DFGPassModel &Arg) : Pass(Arg.Pass) {}
        DFGPassModel(DFGPassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
 
        bool run(CGRADFG &G, Loop &L, FunctionAnalysisManager &FAM,
                                    LoopAnalysisManager &LAM,
                                    LoopStandardAnalysisResults &AR) override {
            return Pass.run(G, L, FAM, LAM, AR);
        };
 
        StringRef name() const override { return PassT::name(); }
 
        private:
            PassT Pass;
    };
 
    class DFGPassManager {
        public:
            template <typename PassT>
            void addPass(PassT Pass) {
                pipeline.emplace_back(new DFGPassModel(std::move(Pass)));
            }
 
            bool run(CGRADFG &G, Loop &L, FunctionAnalysisManager &FAM,
                                    LoopAnalysisManager &LAM,
                                    LoopStandardAnalysisResults &AR);
        private:
            SmallVector<DFGPassConcept*> pipeline;
    };
 
    class DFGPassBuilder {
        public:
            using CallBackT = std::function<bool(StringRef, DFGPassManager &)>;
            DFGPassBuilder();
            void registerPipelineParsingCallback(const CallBackT &C);
 
            Error parsePassPipeline(DFGPassManager &DPM, ArrayRef<std::string> PipelineText);
 
        private:
            SmallVector<CallBackT> callback_list;
 
            Error search_callback();
    };
 
    struct DFGPassPluginLibraryInfo {
        const char *PluginName;
        void (*RegisterPassBuilderCallbacks)(DFGPassBuilder &);
    };
 
    class DFGPassHandler : public PassInfoMixin<DFGPassHandler> {
        public:
            using GraphList = SmallVector<CGRADFG*>;
            using graph_iterator = GraphList::iterator;
 
            DFGPassHandler();
            ~DFGPassHandler() {
                delete DPB;
                delete DPM;
            }
            DFGPassHandler(DFGPassHandler &&P) : PassInfoMixin<DFGPassHandler>(std::move(P)),
                DPB(P.DPB), DPM(P.DPM) {
                P.DPB = nullptr;
                P.DPM = nullptr;
            };
 
            PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
            
            void addGraph(CGRADFG *G) {
                graph_list.emplace_back(G);
            }
 
            graph_iterator removeGraph(CGRADFG *G) {
                graph_iterator it;
                //find graph
                for (it = graph_begin(); it != graph_end(); it++) {
                    if (*it == G) {
                        break;
                    }
                }
                if (it != graph_end()) {
                    return graph_list.erase(it);
                }
                return it;
            }
 
            graph_iterator graph_begin() {
                return graph_list.begin();
            }
 
            graph_iterator graph_end() {
                return graph_list.end();
            }
 
 
            iterator_range<graph_iterator> graphs() {
                return make_range(graph_begin(), graph_end());
            }
 
        private:
            template<typename VerifyPassT>
            void createDataFlowGraphsForAllKernels(Function &F, FunctionAnalysisManager &AM);
 
            template<typename VerifyPassT>
            void createDataFlowGraph(Function &F, Loop &L, FunctionAnalysisManager &FAM,
                                        LoopAnalysisManager &LAM, 
                                        LoopStandardAnalysisResults &AR);
 
            inline bool isMemAccess(Instruction &I) {
                return isa<LoadInst>(I) || isa<StoreInst>(I);
            }
 
            inline DFGNode* make_mem_node(Instruction &I) {
                if (auto load = dyn_cast<LoadInst>(&I)) {
                    return new MemAccessNode(load);
                } else if (auto store = dyn_cast<StoreInst>(&I)) {
                    return new MemAccessNode(store);
                } else {
                    assert(false && "Non-memory access instruction");
                }
            }
            inline DFGNode* make_comp_node(Instruction *inst, std::string opcode) {
                return new ComputeNode(inst, opcode);
            }
 
            inline DFGNode* make_const_node(Value *V) {
                return new ConstantNode(V);
            }
 
            inline DFGNode* make_const_node(Value *V, SmallVector<Value*>* seq) {
                return new ConstantNode(V, seq);
            }
 
            inline DFGNode* make_global_node(Value *V) {
                return new GlobalDataNode(V);
            }
 
            inline DFGNode* make_global_node(Value *V, SmallVector<Value*>* seq) {
                return new GlobalDataNode(V, seq);
            }
 
            DFGPassBuilder *DPB;
            DFGPassManager *DPM;
            SmallVector<CGRADFG*> graph_list;
 
 
    };
 
}
 
#endif //DFGPASS_H