Alexander_KS/SAPFOR
4
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

improved and fixed FDVM, added ISNERT_INCLUDES pass

Browse Source
This commit is contained in:
ALEXks
2023-12-16 17:42:11 +03:00
parent 110970caa6
commit 1f3d9944b8
10 changed files with 613 additions and 775 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
dvm/fdvm/trunk/fdvm/acc.cpp
View File

@@ -2532,7 +2532,10 @@ void ACC_ParallelLoopEnd(SgStatement *pardo)
}
if (options.isOn(LOOP_ANALYSIS))
{
delete currentLoop;
currentLoop = NULL;
}
}
if (options.isOn(RTC))

982
dvm/fdvm/trunk/fdvm/acc_across.cpp
View File

File diff suppressed because it is too large Load Diff

134
dvm/fdvm/trunk/fdvm/aks_structs.cpp
View File

@@ -1,5 +1,12 @@
#include "dvm.h"
#include "aks_structs.h"
#include <vector>
#include <map>
#include <string>
using std::vector;
using std::string;
using std::map;
#define DEBUG_LV1 true
#if 1
@@ -16,22 +23,20 @@ SgExpression* findDirect(SgExpression *inExpr, int DIR)
if (inExpr)
{
if (inExpr->variant() == DIR)
{
return inExpr;
}
else
{
if (inExpr->lhs())
temp = findDirect(inExpr->lhs(), DIR);
if (inExpr->lhs())
temp = findDirect(inExpr->lhs(), DIR);
if(temp == NULL && inExpr->rhs())
if(temp == NULL && inExpr->rhs())
temp = findDirect(inExpr->rhs(), DIR);
}
}
return temp;
}
static SgSymbol** fillDataOfArray(SgExpression* on, int& dimInPar)
static vector<SgSymbol*> fillDataOfArray(SgExpression* on, int& dimInPar)
{
dimInPar = 0;
SgExpression* temp = on;
@@ -40,7 +45,8 @@ static SgSymbol** fillDataOfArray(SgExpression* on, int& dimInPar)
dimInPar++;
temp = temp->rhs();
}
SgSymbol** symbInPar = new SgSymbol * [dimInPar];
vector<SgSymbol*> symbInPar(dimInPar);
temp = on;
for (int i = 0; i < dimInPar; ++i)
{
@@ -50,20 +56,20 @@ static SgSymbol** fillDataOfArray(SgExpression* on, int& dimInPar)
return symbInPar;
}
SageArrayIdxs* GetIdxInParDir(const std::map<std::string, SgExpression*>& on, SgExpression *across, bool tie = false)
static void printError()
{
SageArrayIdxs *ret = new SageArrayIdxs();
SageArrayIdxs *act = ret;
int allDim = 0;
int dimInPar = 0;
SgSymbol** symbInPar = NULL;
ret->next = NULL;
ret->array_expr = NULL;
ret->read_write = -1;
ret->dim = 0;
ret->symb = NULL;
err("internal error in across", 424, first_do_par);
exit(-1);
}
static vector<SageArrayIdxs> GetIdxInParDir(const map<string, SgExpression*>& on, SgExpression *across, bool tie = false)
{
vector<SageArrayIdxs> ret;
int dimInPar = 0;
vector<SgSymbol*> symbInPar;
vector<SgExpression*> toAnalyze;
std::vector<SgExpression*> toAnalyze;
if (across->lhs()->variant() == EXPR_LIST)
toAnalyze.push_back(across->lhs());
else
@@ -80,15 +86,12 @@ SageArrayIdxs* GetIdxInParDir(const std::map<std::string, SgExpression*>& on, Sg
across = toAnalyze[i];
while (across)
{
if (symbInPar == NULL)
if (symbInPar.size() == 0)
{
if (on.size() == 0)
{
fprintf(stderr, "internal error in across convertion for GPU\n");
exit(-1);
}
printError();
else if (on.size() == 1)
symbInPar = fillDataOfArray(on.begin()->second, dimInPar);
symbInPar = fillDataOfArray(on.begin()->second, dimInPar);
}
SgExpression *t = across->lhs();
@@ -99,20 +102,14 @@ SageArrayIdxs* GetIdxInParDir(const std::map<std::string, SgExpression*>& on, Sg
if (t->variant() == ARRAY_REF)
{
if (on.find(t->symbol()->identifier()) == on.end())
{
fprintf(stderr, "internal error in across convertion for GPU\n");
exit(-1);
}
printError();
else
symbInPar = fillDataOfArray(on.find(t->symbol()->identifier())->second, dimInPar);
}
else if (t->variant() == ARRAY_OP)
{
if (on.find(t->lhs()->symbol()->identifier()) == on.end())
{
fprintf(stderr, "internal error in across convertion for GPU\n");
exit(-1);
}
printError();
else
symbInPar = fillDataOfArray(on.find(t->lhs()->symbol()->identifier())->second, dimInPar);
}
@@ -134,53 +131,50 @@ SageArrayIdxs* GetIdxInParDir(const std::map<std::string, SgExpression*>& on, Sg
dim++;
tmp = tmp->rhs();
}
act->next = new SageArrayIdxs();
act = act->next;
act->next = NULL;
act->symb = new SageSymbols*[dim];
act->dim = dim;
SageArrayIdxs act;
act.symb.resize(dim);
act.dim = dim;
for (int i = 0; i < dim; ++i)
{
act->symb[i] = new SageSymbols();
act->symb[i]->across_left = t->lhs()->lhs()->valueInteger();
act->symb[i]->across_right = t->lhs()->rhs()->valueInteger();
if (act->symb[i]->across_left != 0 || act->symb[i]->across_right != 0)
act->symb[i]->symb = symbInPar[i];
act.symb[i].across_left = t->lhs()->lhs()->valueInteger();
act.symb[i].across_right = t->lhs()->rhs()->valueInteger();
if (act.symb[i].across_left != 0 || act.symb[i].across_right != 0)
act.symb[i].symb = symbInPar[i];
else if (i < dimInPar)
act->symb[i]->symb = symbInPar[i];
act.symb[i].symb = symbInPar[i];
else
act->symb[i]->symb = NULL;
act->symb[i]->next = NULL;
act.symb[i].symb = NULL;
t = t->rhs();
}
allDim++;
ret.push_back(act);
across = across->rhs();
}
}
ret->dim = allDim;
return ret;
}
SageAcrossInfo* GetLoopsWithParAndAcrDir()
SageAcrossInfo GetLoopsWithParAndAcrDir()
{
SageAcrossInfo *q = NULL;
SageAcrossInfo retVal;
SgStatement *temp = dvm_parallel_dir;
if (temp->variant() == DVM_PARALLEL_ON_DIR)
{
SgExpression *t = findDirect(temp->expr(1), ACROSS_OP);
SgExpression *tie = findDirect(temp->expr(1), ACC_TIE_OP);
std::map<std::string, SgExpression*> arrays;
map<string, SgExpression*> arrays;
if (t != NULL)
{
q = new SageAcrossInfo();
if (temp->expr(0) && temp->expr(0)->lhs())
{
arrays[temp->expr(0)->symbol()->identifier()] = temp->expr(0)->lhs();
q->idx = GetIdxInParDir(arrays, t);
}
retVal.idxs = GetIdxInParDir(arrays, t);
}
else if (tie)
{
SgExpression* list = tie->lhs();
@@ -189,34 +183,24 @@ SageAcrossInfo* GetLoopsWithParAndAcrDir()
arrays[list->lhs()->symbol()->identifier()] = list->lhs()->lhs();
list = list->rhs();
}
q->idx = GetIdxInParDir(arrays, t, true);
retVal.idxs = GetIdxInParDir(arrays, t, true);
}
else
{
fprintf(stderr, "internal error in across convertion for GPU\n");
exit(-1);
}
q->next = NULL;
printError();
}
}
return q;
}
return retVal;
}
SageSymbols *GetSymbInParalell(int *n, SgExpression *first)
vector<SageSymbols> GetSymbInParalell(SgExpression *first)
{
SageSymbols *retval;
SageSymbols *p_t = new SageSymbols();
retval = p_t;
vector<SageSymbols> retval;
while(first)
{
SageSymbols *q = new SageSymbols();
q->len = -1;
q->next = NULL;
q->symb = first->lhs()->symbol();
p_t->next = q;
p_t = q;
n[0]++;
SageSymbols q(first->lhs()->symbol(), -1, 0, 0);
retval.push_back(q);
first = first->rhs();
}
return retval->next;
return retval;
}

6
dvm/fdvm/trunk/fdvm/dvm.cpp
View File

@@ -4757,7 +4757,7 @@ void RedistributeArray(SgSymbol *das, int idisars, SgExpression *distr_rule_list
if_st = doIfThenConstrForRedis(headref_flag,stdis,iamv); /*08.05.17*/
where = end_if = if_st->lexNext()->lexNext(); // reffer to ENDIF statement
i1 = ndvm;
if(ACC_program) /*ACC*/
if(ACC_program || parloop_by_handler) /*ACC*/
where->insertStmtBefore(*Redistribute_H(headref,sign),*where->controlParent());
amvref = (ia & TEMPLATE_BIT) ? headref : GetAMView( headref);
//inserting after ELSE
@@ -4838,7 +4838,7 @@ void RedistributeArray(SgSymbol *das, int idisars, SgExpression *distr_rule_list
else {
SgExpression *amvref;
if(ACC_program) /*ACC*/
if(ACC_program || parloop_by_handler) /*ACC*/
where->insertStmtBefore(*Redistribute_H(headref,sign),*where->controlParent());
amvref = (ia & TEMPLATE_BIT) ? headref : GetAMView( headref);
@@ -5108,7 +5108,7 @@ void RealignArray(SgSymbol *als, SgSymbol *tgs, int iaxis, int nr, SgExpression
return;
}
iamv = ndvm;
if(ACC_program ) /*ACC*/
if(ACC_program || parloop_by_handler) /*ACC*/
{ if( !(ia & POSTPONE_BIT) )
doCallAfter(Realign_H(HeaderRef(als),new_sign));
else {

2
dvm/fdvm/trunk/fdvm/funcall.cpp
View File

@@ -2668,7 +2668,7 @@ SgStatement *RTL_GPU_Init()
SgCallStmt *call = new SgCallStmt(*fdvm[DVMH_INIT]);
fmask[DVMH_INIT] = 2;
call -> addArg(*DVM000(ndvm));
if(!only_debug && ACC_program)
if(!only_debug && (ACC_program || parloop_by_handler))
call -> addComment(OpenMpComment_InitFlags(ndvm));
int flag = 1;

4
dvm/fdvm/trunk/fdvm/parloop.cpp
View File

@@ -282,7 +282,7 @@ void EndOfParallelLoopNest(SgStatement *stmt, SgStatement *end_stmt, SgStatement
ConsistentArraysStart(cons_list);
if(iconsg) {//there is synchronous CONSISTENT clause in PARALLEL
if(IN_COMPUTE_REGION || parloop_by_handler) /*ACC*/
if(IN_COMPUTE_REGION) /*ACC*/
// generating call statement:
// call dvmh_handle_consistent(ConsistGroupRef)
doCallAfter(HandleConsistent(consgref));
@@ -2227,6 +2227,8 @@ SgExpression *MappingList(SgStatement *stmt, SgExpression *aref)
(el = new SgExprListExp(*e))->setRhs(arglist);
arglist = el;
}
(el = new SgExprListExp(*ConstRef(nt)))->setRhs(arglist); // add rank to axis list
arglist = el;
return arglist;
}

240
dvm/fdvm/trunk/include/aks_structs.h
View File

@@ -1,80 +1,65 @@
#pragma once
#include "acc_data.h"
struct SageStOp
{
SgForStmt *loop_op;
SgStatement *comment_op;
SageStOp *inner_loops;
SageStOp *next;
int count_inner_loops;
int line_code;
int numChList1;
int numChList2;
int depth;
int LoopNest;
};
struct SageSymbols
{
SgSymbol *symb;
int len;
SageSymbols *next;
int across_left;
int across_right;
SageSymbols()
{
across_left = across_right = 0;
len = -1;
symb = NULL;
}
SageSymbols(SgSymbol* symb, int len, int across_left, int across_right) :
symb(symb), len(len), across_left(across_left), across_right(across_right)
{ }
SgSymbol *symb;
int len;
int across_left;
int across_right;
};
struct SageArrayIdxs
{
SageSymbols **symb;
int dim;
int read_write;
SgExpression *array_expr;
SageArrayIdxs *next;
};
struct Templates
{
SageSymbols *first;
int count;
int read_write;
int count_write_read;
Templates *next;
std::vector<SageSymbols> symb;
int dim;
int read_write;
SgExpression *array_expr;
};
struct SageAcrossInfo
{
SageStOp *Op;
SageArrayIdxs *idx;
SageAcrossInfo *next;
std::vector<SageArrayIdxs> idxs;
};
struct ArgsForKernel
{
SgStatement *st_header;
std::list<SageSymbols*> symb;
std::list<SageSymbols*> nSymb;
std::list<SgSymbol*> sizeVars;
std::list<SgSymbol*> acrossS;
std::list<SgSymbol*> notAcrS;
std::list<SgSymbol*> idxAcross;
std::list<SgSymbol*> idxNotAcross;
std::vector<SgSymbol*> otherVars;
std::vector<char*> arrayNames;
std::vector<SgSymbol*> otherVarsForOneTh;
std::vector<SgSymbol*> baseIdxsInKer;
SgSymbol *cond_;
std::vector<SgSymbol*> steps;
SgStatement *st_header;
std::vector<SageSymbols> symb;
std::vector<SageSymbols> nSymb;
std::vector<SgSymbol*> sizeVars;
std::vector<SgSymbol*> acrossS;
std::vector<SgSymbol*> notAcrossS;
std::vector<SgSymbol*> idxAcross;
std::vector<SgSymbol*> idxNotAcross;
std::vector<SgSymbol*> otherVars;
std::vector<char*> arrayNames;
std::vector<SgSymbol*> otherVarsForOneTh;
std::vector<SgSymbol*> baseIdxsInKer;
SgSymbol *cond_;
std::vector<SgSymbol*> steps;
};
/*struct GetXYInfo
{
std::vector<SgExpression*> AllExp;
SgSymbol *varName;
char *arrayName;
long type;
int placeF;
int placeS;
std::vector<SgExpression*> AllExp;
SgSymbol *varName;
char *arrayName;
long type;
int placeF;
int placeS;
};*/
@@ -91,133 +76,132 @@ void getIdxs(char*, int&, int&);
struct ParamsForAllVariants
{
SgSymbol *s_adapter;
SgSymbol *s_kernel_symb;
int loopV;
int acrossV;
int allDims;
SageSymbols **loopSymb;
SageSymbols **loopAcrossSymb;
char *nameOfNewSAdapter;
char *nameOfNewKernelSymb;
int type;
SgSymbol *s_adapter;
SgSymbol *s_kernel_symb;
int loopV;
int acrossV;
int allDims;
std::vector<SageSymbols> loopSymb;
std::vector<SageSymbols> loopAcrossSymb;
char *nameOfNewSAdapter;
char *nameOfNewKernelSymb;
int type;
};
struct Bound
{
int L;
int R;
bool exL;
bool exR;
bool ifDdot;
SgExpression *additionalExpr;
int L;
int R;
bool exL;
bool exR;
bool ifDdot;
SgExpression *additionalExpr;
};
struct BestPattern
{
std::vector<int> what;
std::vector<Bound> bounds;
SgExpression *bestPatt;
int count_of_pattern;
std::vector<int> what;
std::vector<Bound> bounds;
SgExpression *bestPatt;
int count_of_pattern;
};
struct Pattern
{
int count_read_op;
int count_write_op;
SgExpression *symbs;
int count_read_op;
int count_write_op;
SgExpression *symbs;
};
struct AnalyzeStat
{
SgSymbol *replaceSymbol;
int ifHasDim;
SgSymbol *name_of_array;
SgExpression *ex_name_of_array;
std::vector<Pattern> patterns;
SgSymbol *replaceSymbol;
int ifHasDim;
SgSymbol *name_of_array;
SgExpression *ex_name_of_array;
std::vector<Pattern> patterns;
};
// <for oprimization>
struct acrossInfo
{
char *nameOfArray;
SgSymbol *symbol;
int allDim;
int acrossPos;
int widthL;
int widthR;
int acrossNum;
std::vector<int> dims;
std::vector<SgSymbol*> symbs;
char *nameOfArray;
SgSymbol *symbol;
int allDim;
int acrossPos;
int widthL;
int widthR;
int acrossNum;
std::vector<int> dims;
std::vector<SgSymbol*> symbs;
};
struct newInfo
{
SgSymbol *newArray;
std::vector<int> dimSize;
std::vector<SgStatement*> loadsBeforePlus;
std::vector<SgStatement*> loadsInForPlus;
std::vector<SgStatement*> loadsBeforeMinus;
std::vector<SgStatement*> loadsInForMinus;
std::vector<SgStatement*> stores;
std::vector<SgStatement*> swapsDown;
std::vector<SgStatement*> swapsUp;
SgSymbol *newArray;
std::vector<int> dimSize;
std::vector<SgStatement*> loadsBeforePlus;
std::vector<SgStatement*> loadsInForPlus;
std::vector<SgStatement*> loadsBeforeMinus;
std::vector<SgStatement*> loadsInForMinus;
std::vector<SgStatement*> stores;
std::vector<SgStatement*> swapsDown;
std::vector<SgStatement*> swapsUp;
};
// end <for oprimization>
// block <gpuO1 lvl 2>
struct Group
{
char *strOfmain; //
SgExpression *mainPattern;
std::vector<SgExpression*> inGroup;
std::vector<int> len;
std::vector<int> sortLen;
newInfo replaceInfo; // replace info with all needed loads and swaps for optimization
char *strOfmain; //
SgExpression *mainPattern;
std::vector<SgExpression*> inGroup;
std::vector<int> len;
std::vector<int> sortLen;
newInfo replaceInfo; // replace info with all needed loads and swaps for optimization
};
struct PositionGroup
{
std::map<std::string, SgExpression*> tableReplace; // table of mapping new private variables to distributed arrays for replacing in loop body
std::map<std::string, SgSymbol*> tableNewVars; // table of new private variables that is needed to add in cuda kernel
int position; // position of fixed variable in distributed loop, index 0 corresponds to the first variable.
SgExpression *idxInPos; //
std::vector<Group> allPosGr; // all groups of array access patterns with fixed loop variables, which is distributed
std::map<std::string, SgExpression*> tableReplace; // table of mapping new private variables to distributed arrays for replacing in loop body
std::map<std::string, SgSymbol*> tableNewVars; // table of new private variables that is needed to add in cuda kernel
int position; // position of fixed variable in distributed loop, index 0 corresponds to the first variable.
SgExpression *idxInPos; //
std::vector<Group> allPosGr; // all groups of array access patterns with fixed loop variables, which is distributed
};
struct ArrayGroup
{
SgSymbol *arrayName; // name of distribute array
std::vector<PositionGroup> allGroups; // all groups, where one loop variable is fixed
SgSymbol *arrayName; // name of distribute array
std::vector<PositionGroup> allGroups; // all groups, where one loop variable is fixed
};
// end of block <gpuO1 lvl 2>
struct LoopInfo
{
std::vector<SgSymbol*> loopSymbols;
std::vector<SgExpression*> lowBounds;
std::vector<SgExpression*> highBounds;
std::vector<SgExpression*> steps;
int lineNumber;
std::vector<SgSymbol*> loopSymbols;
std::vector<SgExpression*> lowBounds;
std::vector<SgExpression*> highBounds;
std::vector<SgExpression*> steps;
int lineNumber;
};
struct ArrayIntents
{
std::vector<SgSymbol*> arrayList;
std::vector<int> intent;
std::vector<SgSymbol*> arrayList;
std::vector<int> intent;
};
struct AnalyzeReturnGpuO1
{
std::vector<AnalyzeStat> allStat;
std::vector<BestPattern> bestPatterns;
std::vector<ArrayGroup> allArrayGroup;
std::vector<AnalyzeStat> allStat;
std::vector<BestPattern> bestPatterns;
std::vector<ArrayGroup> allArrayGroup;
};
// functions
SgExpression* findDirect(SgExpression*, int);
//SageArrayIdxs* GetIdxInParDir(SgExpression*, SgExpression*);
SageAcrossInfo* GetLoopsWithParAndAcrDir();
SageSymbols *GetSymbInParalell(int*, SgExpression*);
SageAcrossInfo GetLoopsWithParAndAcrDir();
std::vector<SageSymbols> GetSymbInParalell(SgExpression*);
int GetIdxPlaceInParDir(SageSymbols*, SgSymbol*);

12
sapfor/experts/Sapfor_2017/_src/Sapfor.cpp
View File

@@ -321,7 +321,8 @@ static string unparseProjectIfNeed(SgFile* file, const int curr_regime, const bo
//TODO: add freeForm for each file
if (curr_regime == INSERT_INCLUDES && filesToInclude.find(file_name) != filesToInclude.end())
{
unparseToBuf = removeIncludeStatsAndUnparse(file, file_name, fout_name.c_str(), allIncludeFiles, out_free_form == 1, moduleUsesByFile, moduleDecls, getObjectForFileFromMap(file_name, exctactedModuleStats), toString, true); //,
unparseToBuf = removeIncludeStatsAndUnparse(file, file_name, fout_name.c_str(), allIncludeFiles, out_free_form == 1, moduleUsesByFile,
moduleDecls, getObjectForFileFromMap(file_name, exctactedModuleStats), toString, true);
auto itI = filesToInclude.find(file_name);
for (auto& incl : itI->second)
if (allIncludeFiles.find(incl) != allIncludeFiles.end())
@@ -329,7 +330,8 @@ static string unparseProjectIfNeed(SgFile* file, const int curr_regime, const bo
}
else
{
unparseToBuf = removeIncludeStatsAndUnparse(file, file_name, fout_name.c_str(), allIncludeFiles, out_free_form == 1, moduleUsesByFile, moduleDecls, getObjectForFileFromMap(file_name, exctactedModuleStats), toString);
unparseToBuf = removeIncludeStatsAndUnparse(file, file_name, fout_name.c_str(), allIncludeFiles, out_free_form == 1, moduleUsesByFile,
moduleDecls, getObjectForFileFromMap(file_name, exctactedModuleStats), toString);
// copy includes that have not changed
if (folderName != NULL)
@@ -995,6 +997,10 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
fileIt->second.insert(first->fileName());
}
}
if (inlcudeAllFiles)
if (fileIt->second.size())
filesToInclude[file_name] = fileIt->second;
}
else if (curr_regime == REMOVE_AND_CALC_SHADOW)
{
@@ -2825,6 +2831,8 @@ int main(int argc, char **argv)
debSh = 1;
else if (string(curr_arg) == "-noLogo")
noLogo = true;
else if (string(curr_arg) == "-includeAll")
inlcudeAllFiles = true;
break;
default:
break;

3
sapfor/experts/Sapfor_2017/_src/SapforData.h
View File

@@ -46,6 +46,7 @@ bool ignoreArrayDistributeState = false;
bool fullDepGraph = false;
bool noLogo = false;
bool withTemplateInfo = false;
bool inlcudeAllFiles = false; // for pass INSERT_INLCUDES
uint64_t currentAvailMemory = 0;
int QUALITY; // quality of conflicts search in graph
@@ -82,7 +83,7 @@ std::map<std::string, std::map<int, std::set<std::string>>> commentsToInclude;
//
//for INSERT_INCLUDES
std::map<std::string, std::set<std::string>> filesToInclude;
std::map<std::string, std::set<std::string>> filesToInclude; // file -> includes
//
//for PASSES DEPENDENSIES

2
sapfor/experts/Sapfor_2017/_src/Utils/version.h
View File

@@ -1,3 +1,3 @@
#pragma once
#define VERSION_SPF "2256"
#define VERSION_SPF "2257"