SAPFOR/src/PrivateAnalyzer/private_arrays_search.h

#pragma once

#include "../GraphLoop/graph_loops.h"
#include "../CFGraph/CFGraph.h"

using std::vector;
using std::map;
using std::string;
using std::set;
using std::unordered_set;
using std::pair;

struct ArrayDimension 
{
    uint64_t start, step, tripCount;
};

class AccessingSet {
    private:
        vector<vector<ArrayDimension>> allElements;

    public:
        AccessingSet(vector<vector<ArrayDimension>> input) : allElements(input) {};
        AccessingSet() {};
        vector<vector<ArrayDimension>> GetElements() const;
        void Insert(const vector<ArrayDimension>& element);
        AccessingSet Union(const AccessingSet& source);
        AccessingSet Intersect(const AccessingSet& secondSet) const;
        AccessingSet Diff(const AccessingSet& secondSet) const;
        bool ContainsElement(const vector<ArrayDimension>& element) const;        
        void FindCoveredBy(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const;
        void FindUncovered(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const;
        friend bool operator==(const AccessingSet& lhs, const AccessingSet& rhs);
};

using ArrayAccessingIndexes = map<string, AccessingSet>;

class Region: public SAPFOR::BasicBlock {
    public:
        Region() 
        {
            header = nullptr; 
        }

        Region(SAPFOR::BasicBlock block) : SAPFOR::BasicBlock::BasicBlock(block)
        {
            header = nullptr;
        }

        Region(LoopGraph* loop, vector<SAPFOR::BasicBlock*>& Blocks);

        Region* getHeader()
        {
            return header;
        }

        unordered_set<Region*>& getBasickBlocks()
        {
            return basickBlocks;
        }

        void addBasickBlocks(Region* region)
        {
            basickBlocks.insert(region);
        }
        unordered_set<Region*> getPrevRegions()
        {
            return prevRegions;
        }

        unordered_set<Region*> getNextRegions()
        {
            return nextRegions;
        }

        void addPrevRegion(Region* region) 
        {
            prevRegions.insert(region);
        }

        void addNextRegion(Region* region) 
        {
            nextRegions.insert(region);
        }

        void replaceInPrevRegions(Region* source, Region* destination)
        {
            prevRegions.erase(destination);
            prevRegions.insert(source);
        }

        void replaceInNextRegions(Region* source, Region* destination)
        {
            nextRegions.erase(destination);
            nextRegions.insert(source);
        }

        unordered_set<Region*> getSubRegions()
        {
            return subRegions;
        }

        void addSubRegions(Region* region)
        {
            subRegions.insert(region);
        }

        ArrayAccessingIndexes array_def, array_use, array_out, array_in;
            
    private:
        unordered_set<Region*> subRegions, basickBlocks;
        /*next Region which is BB for current BB Region*/
        unordered_set<Region*> nextRegions;
        /*prev Regions which is BBs for current BB Region*/
        unordered_set<Region*> prevRegions;
        Region* header;      
};


void Collapse(Region* region);
void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR);
void GetDimensionInfo(LoopGraph* loop, map<DIST::Array*, vector<vector<ArrayDimension>>>& loopDimensionsInfo, int level);
pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(LoopGraph* loop, vector<SAPFOR::BasicBlock*> blocks);