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

added project

Browse Source
This commit is contained in:
ALEXks
2023-09-14 19:43:13 +03:00
parent d78c55e275
commit 59c56cc5c2
638 changed files with 352236 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
dvm/fdvm/trunk/include/acc_across_analyzer.h Normal file
View File

@@ -0,0 +1,156 @@
#pragma once
struct BasicBlock
{
int index;
SgStatement* head;
SgStatement* tail;
std::vector<int> in, out;// blocks this block takes control from / passes control to
std::set<SgStatement*> INrd, OUTrd, INae, OUTae;// reaching definitions and extended available expressions
std::map<SgExpression*, std::set<SgExpression*> > INss;// safe substitutes (expression propagation)
BasicBlock() : index(-1), head(NULL), tail(NULL) {}
};
class Access;
class Array;
class Loop;
class Access
{
private:
int blockIndex;
SgExpression* expr;
std::string str;
Array* array;
int* alignment;
public:
int getBlockIndex() const { return blockIndex; }
SgExpression* getSubscripts() { return expr; }
int* getAlignment() const { return alignment; }
Access(SgExpression* subscripts, std::string s, Array* array, int blockIndex) : expr(subscripts), str(s), array(array), blockIndex(blockIndex), alignment(NULL) {}
void analyze();
void getReferences(SgExpression* expr, std::set<SgExpression*>& references, std::map<SgExpression*, std::string>& unparsedRefs, std::map<std::string, SgExpression*>& refs) const;
~Access() { delete [] alignment; }
};
struct TfmInfo
{
std::vector<int> transformDims;
std::vector<std::pair<std::string, std::string> > exprs;
std::vector<SgSymbol*> coefficients;
std::vector<SgExpression*> first;
std::vector<SgExpression*> second;
std::vector<SgStatement*> zeroSt;
std::map<SgStatement*, std::vector<SgFunctionCallExp*> > ifCalls;
std::map<SgStatement*, std::vector<SgFunctionCallExp*> > elseCalls;
};
class Array
{
private:
SgSymbol* symbol;
int dimension;
Loop* loop;
std::map<std::string, Access*> accesses;
int* alignment;
std::vector<int> acrossDims;
int acrossType;
TfmInfo tfmInfo;
public:
SgSymbol* getSymbol() const { return symbol; }
Loop* getLoop() const { return loop; }
int getDimension() const { return dimension; }
int getAcrossType() const { return acrossType; }
void setAcrossType(const int acrossType) { this->acrossType = acrossType; }
std::vector<int>& getAcrossDims() { return acrossDims; }
int* getAlignment() const { return alignment; }
std::map<std::string, Access*>& getAccesses() { return accesses; }
TfmInfo& getTfmInfo() { return tfmInfo; }
Array(SgSymbol* symbol, int dimension, Loop* loop) : symbol(symbol), dimension(dimension), loop(loop), alignment(NULL), acrossDims(dimension, -1), acrossType(0) {}
void analyze();
void analyzeTransformDimensions();
SgSymbol* findAccess(SgExpression* subscripts, std::string& expr);
void addCoefficient(SgExpression* subscripts, std::string& expr, SgSymbol* symbol);
void generateAssigns(SgVarRefExp* offsetX, SgVarRefExp* offsetY, SgVarRefExp* Rx, SgVarRefExp* Ry, SgVarRefExp* slash);
~Array()
{
delete [] alignment;
for (std::map<std::string, Access*>::iterator it = accesses.begin(); it != accesses.end(); ++it)
delete it->second;
}
};
class Loop
{
private:
bool enable_opt;
bool irregular_acc_opt;
bool do_irreg_opt;
std::vector<BasicBlock> blocks;
std::map<SgStatement*, int> blockIn;
enum { ENTRY, EXIT };
SgStatement* loop_body;
int dimension;
std::map<SgSymbol*, Array*> arrays;
int* acrossDims;
int acrossType;
std::vector<SgSymbol*> symbols;
std::set<SgSymbol*> privateList;
bool IsTargetable(SgStatement* stmt) const;
void analyzeAcrossClause();
void analyzeAcrossType();
void analyzeAssignments(int blockIndex, SgStatement* stmt);
void buildCFG();
void setupSubstitutes();
void analyzeAssignments(SgExpression* ex, const int blockIndex);
void analyzeInderectAccess();
public:
const std::vector<BasicBlock>& getBlocks() const { return blocks; }
const std::map<SgStatement*, int>& getBlockIn() const { return blockIn; }
const std::vector<SgSymbol*>& getSymbols() const { return symbols; }
int getDimension() const { return dimension; }
int getAcrossType() const { return acrossType; }
std::map<SgSymbol*, Array*>& getArrays() { return arrays; }
std::set<SgSymbol*>& getPrivateList() { return privateList; }
Loop(SgStatement* loop_body, bool enable_opt, bool irreg_access = false);
// only for RD/AE analyses, which can be later performed only on statements in loop_body
// usage: Loop* loop = new Loop(loop_body_stmt); RDs = loop->RDsAt(stmtI); AEs = loop->AEsAt(stmtJ);
// note: only one loop object can exist at a time (lhs, rhs, unparsedLhs, unparsedRhs are global for all methods for simplicity,
// probably can be added to Loop class and transferred to Array/Access by pointer/reference, and this constraint will be solved)
Loop(SgStatement* loop_body);
// get defining statements which reach stmt
std::set<SgStatement*> RDsAt(SgStatement* stmt) const;
// get statements, rhss of which are available at stmt
std::set<SgStatement*> AEsAt(SgStatement* stmt) const;
void getRPN(SgExpression* expr, std::list<SgExpression*>& rpn) const;
void unrollRPN(std::list<SgExpression*>& rpn, std::map<SgExpression*, int>& arity) const;
void optimizeRPN(std::list<SgExpression*>& rpn, std::map<SgExpression*, int>& arity, bool unrolled) const;
SgExpression* simplify(SgExpression* expr) const;
void visualize(const char* scriptName) const;
bool irregularAnalysisIsOn() const;
~Loop()
{
delete [] acrossDims;
for (std::map<SgSymbol*, Array*>::iterator it = arrays.begin(); it != arrays.end(); ++it)
delete it->second;
}
};

1211
dvm/fdvm/trunk/include/acc_analyzer.h Normal file
View File

File diff suppressed because it is too large Load Diff

76
dvm/fdvm/trunk/include/acc_data.h Normal file
View File

@@ -0,0 +1,76 @@
#pragma once
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <cmath>
#include <cstring>
#include <climits>
#include <iostream>
#include <list>
#include <vector>
#include <stack>
#include <set>
#include <map>
#include <queue>
#include <deque>
#include <string>
#include <iterator>
#include <algorithm>
#include "dvm.h"
#include "acc_across_analyzer.h"
extern bool READ;
extern bool WRITE;
extern bool dontGenConvertXY;
extern bool oneCase;
extern int ACROSS_MOD_IN_KERNEL;
extern int DVM_DEBUG_LVL;
extern const int rtTypes[];
extern std::set<std::string> intrinsicF;
extern std::set<std::string> intrinsicDoubleT;
extern std::set<std::string> intrinsicFloatT;
extern std::set<std::string> intrinsicInt4T;
extern std::map<char, const char*> SpecialSymbols;
extern std::vector <SgFunctionCallExp* > RTC_FCall;
extern std::vector<SgExpression* > RTC_FArgs;
extern std::vector<SgFunctionCallExp* > RTC_FKernelArgs;
extern std::vector<SgSymbol*> newVars;
extern const char *funcDvmhConvXYname;
extern int number_of_loop_line;
extern std::stack<SgStatement*> CopyOfBody;
extern Loop *currentLoop;
extern unsigned countKernels;
extern SgType *indexType_int, *indexType_long, *indexType_llong;
extern SgSymbol *s_indexType_int, *s_indexType_long, *s_indexType_llong;
extern const char *declaration_cmnt;
extern int loc_el_num;
extern SgStatement *cur_in_mod, *cur_in_kernel;
extern SgStatement *dvm_parallel_dir, *loop_body;
extern SgStatement *kernel_st;
extern SgExpression *private_list, *uses_list, *kernel_index_var_list, *formal_red_grid_list;
extern struct local_part_list *lpart_list;
extern SgSymbol *kernel_symb, *s_overall_blocks;
extern SgType *t_dim3;
extern SgSymbol *s_threadidx, *s_blockidx, *s_blockdim, *s_griddim, *s_blocks_k;
//------ C ----------
extern SgStatement *block_C, *block_C_Cuda, *info_block;
extern SgSymbol *s_DvmhLoopRef, *s_cudaStream, *s_cmplx, *s_dcmplx;
enum ACROSS_ANALYZE { RIGHT, LEFT, RESTORE, ADD, ACROSS_TYPE, NON_ACROSS_TYPE };
enum rt_TYPES { rt_INT, rt_LONG, rt_LLONG };
enum { _NUL_, _READ_, _WRITE_, _READ_WRITE_ };
enum VAR_TYPES { EMPTY, INTENT_IN, INTENT_OUT, INTENT_INOUT, INTENT_LOCAL, INTENT_INLOCAL };
enum { ZERO_, HANDLER_TYPE_PARALLEL, HANDLER_TYPE_MASTER };
enum RED_TYPES { red_NULL, red_SUM, red_PROD, red_MAX, red_MIN, red_AND, red_OR,
red_NEQ, red_EQ, red_MAXL, red_MINL, red_SUM_N, red_PROD_N,
red_MAX_N, red_MIN_N, red_AND_N, red_OR_N, red_NEQ_N, red_EQ_N };

136
dvm/fdvm/trunk/include/aks_loopStructure.h Normal file
View File

@@ -0,0 +1,136 @@
#pragma once
#include <vector>
class Access;
class Array;
class Loop;
class AllLoops;
class Access
{
public:
Access(SgExpression *_exp, Array *_parent);
~Access() { }
void setExp(char* _exp);
void setExp(SgExpression *_exp);
char* getExpChar();
SgExpression* getExp();
void incOperW();
void incOperR();
Array* getParentArray();
void setParentArray(Array *_parent);
std::vector<int>* getAlignOnLoop();
void matchLoopIdxs(std::vector<SgSymbol*> &symbols);
private:
char *expAcc;
SgExpression *exp;
int operation[2];
Array *parentArray;
std::vector<int> alignOnLoop;
bool matchRecursion(SgExpression *_exp, SgSymbol *symb);
};
class Array
{
public:
Array(int _dim, char *_name, Loop *_parent);
Array(char *_name, Loop *_parent);
~Array() { }
void setDimNum(int _num);
int getDimNum();
std::vector<int>* getAcrDims();
std::vector<int>* getAlignOnLoop();
void addTfmDim(int _dim);
std::vector<int> *getTfmDims();
void addAccess(Access* _newAccess);
Access* getAccess(char* _expAcc);
std::vector<Access*>* getAccesses();
Loop* getParentLoop();
void setParentLoop(Loop *_loop);
void setArrayName(char* _name);
char* getArrayName();
int getAcrType();
void setAcrType(int _type);
std::vector<SgFunctionCallExp*>* getIfCals();
std::vector<SgFunctionCallExp*>* getElseCals();
std::vector<SgStatement*>* getZeroSt();
std::vector<SgSymbol* >* getCoefInAccess();
void analyzeAcrDims();
void analyzeAlignOnLoop();
void analyzeTrDims();
// diagTransform
SgSymbol* findAccess(SgExpression *_exp, char *&_charEx);
void addNewCoef(SgExpression *_exp, char *_charEx, SgSymbol *_symb);
void generateAssigns(SgVarRefExp *offsetX, SgVarRefExp *offsetY, SgVarRefExp *Rx, SgVarRefExp *Ry, SgVarRefExp *slash);
private:
int dimNum;
int acrossType;
std::vector<int> acrossDims;
std::vector<int> alignOnLoop;
std::vector<int> transformDims;
std::vector<Access*> accesses;
char *name;
Loop *parentLoop;
// diagTransform
std::vector<SgSymbol* > coefInAccess;
std::vector<SgExpression*> firstEx;
std::vector<SgExpression*> secondEx;
std::vector<char*> charEx;
std::vector<SgStatement*> zeroSt;
std::vector<SgFunctionCallExp*> ifCalls;
std::vector<SgFunctionCallExp*> elseCalls;
};
class Loop
{
public:
Loop(int _line, SgStatement *_body, bool withAnalyze);
Loop(int _acrType, int _line, SgStatement *_body);
Loop(int _line, SgStatement *_body);
Loop(int _line);
~Loop() {};
void setLine(int _line);
int getLine();
void setAcrType(int _type);
int getAcrType();
std::vector<Array*>* getArrays();
void addArray(Array *_array);
Array* getArray(char *name, int *_idx);
Array* getArray(char *name);
std::vector<SgSymbol*>* getSymbols();
int getLoopDim();
void analyzeLoopBody();
void analyzeAcrossType();
bool isArrayInPrivate(char *name);
void unroll(int level); // TODO
private:
int loopDim;
std::vector<SgSymbol*> symbols;
int line;
int acrossType;
std::vector<Array*> arrays;
SgStatement* loopBody;
std::vector<char*> privateList;
std::vector<int> acrDims;
void analyzeAssignOp(SgExpression *_exp, int oper);
};
// ---------------------------------------------------------------------- // AllLoops
class AllLoops
{
public:
AllLoops() {}
~AllLoops() {}
void addLoop(Loop *_loop) { loops.push_back(_loop); }
std::vector<Loop*>* getLoops() { return &loops; }
private:
std::vector<Loop*> loops;
};

223
dvm/fdvm/trunk/include/aks_structs.h Normal file
View File

@@ -0,0 +1,223 @@
#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;
};
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;
};
struct SageAcrossInfo
{
SageStOp *Op;
SageArrayIdxs *idx;
SageAcrossInfo *next;
};
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;
};
/*struct GetXYInfo
{
std::vector<SgExpression*> AllExp;
SgSymbol *varName;
char *arrayName;
long type;
int placeF;
int placeS;
};*/
/*struct TransformInfo
{
std::vector<char *> arrayNames;
std::vector<int> firstIdxs;
std::vector<int> secondIdxs;
bool exist(char *name);
bool find_in_exprs(SgSymbol*, SgSymbol*, char*, SgExpression*);
bool find_add(SgSymbol*, SgSymbol*, char*);
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;
};
struct Bound
{
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;
};
struct Pattern
{
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;
};
// <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;
};
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;
};
// 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
};
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
};
struct ArrayGroup
{
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;
};
struct ArrayIntents
{
std::vector<SgSymbol*> arrayList;
std::vector<int> intent;
};
struct AnalyzeReturnGpuO1
{
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*);
int GetIdxPlaceInParDir(SageSymbols*, SgSymbol*);

70
dvm/fdvm/trunk/include/calls.h Normal file
View File

@@ -0,0 +1,70 @@
#pragma once
#ifdef __SPF
extern "C" void addToCollection(const int line, const char *file, void *pointer, int type);
extern "C" void removeFromCollection(void *pointer);
#endif
struct graph_node {
int id; //a number of node
graph_node *next;
graph_node *next_header_node; //???
graph_node *Inext;
graph_node *same_name_next;
SgFile *file;
int file_id;
int header_id;
SgStatement *st_header;
SgStatement *st_last;
SgStatement *st_copy;
SgStatement *st_interface;
SgSymbol *symb; //??? st_header->symbol()
char *name;
struct edge *to_called; //outcoming
struct edge *from_calling; //incoming
int type; //flag - type of procedure: 1-external,2-internal,3-module
int split; //flag
int tmplt; //flag
int visited; //flag for partition algorithm
int clone; //flag is clone node
int count; //counter of inline expansions or calls
int is_routine;// has ROUTINE attribute - 1, else - 0
int samenamed; // flag - there is samenamed symbol
#if __SPF
graph_node() { addToCollection(__LINE__, __FILE__, this, 1); }
~graph_node() { removeFromCollection(this); }
#endif
};
struct graph_node_list {
graph_node_list *next;
graph_node *node;
#if __SPF
graph_node_list() { addToCollection(__LINE__, __FILE__, this, 1); }
~graph_node_list() { removeFromCollection(this); }
#endif
};
struct edge {
edge *next;
graph_node *from;
graph_node *to;
int inlined; //1 - inlined, 0 - not inlined
#if __SPF
edge() { addToCollection(__LINE__, __FILE__, this, 1); }
~edge() { removeFromCollection(this); }
#endif
};
struct edge_list {
edge_list *next;
edge *edg;
#if __SPF
edge_list() { addToCollection(__LINE__, __FILE__, this, 1); }
~edge_list() { removeFromCollection(this); }
#endif
};

2319
dvm/fdvm/trunk/include/dvm.h Normal file
View File

File diff suppressed because it is too large Load Diff

154
dvm/fdvm/trunk/include/dvm_tag.h Normal file
View File

@@ -0,0 +1,154 @@
#define HPF_TEMPLATE_STAT 296
#define HPF_ALIGN_STAT 297
#define HPF_PROCESSORS_STAT 298
#define DVM_DISTRIBUTE_DIR 277
#define DVM_REDISTRIBUTE_DIR 299
#define DVM_PARALLEL_ON_DIR 211
#define DVM_SHADOW_START_DIR 212
#define DVM_SHADOW_GROUP_DIR 213
#define DVM_SHADOW_WAIT_DIR 214
#define DVM_REDUCTION_START_DIR 215
#define DVM_REDUCTION_GROUP_DIR 216
#define DVM_REDUCTION_WAIT_DIR 217
#define DVM_DYNAMIC_DIR 218
#define DVM_ALIGN_DIR 219
#define DVM_REALIGN_DIR 220
#define DVM_REALIGN_NEW_DIR 221
#define DVM_REMOTE_ACCESS_DIR 222
#define HPF_INDEPENDENT_DIR 223
#define DVM_SHADOW_DIR 224
#define DVM_NEW_VALUE_DIR 247
#define DVM_VAR_DECL 248
#define DVM_POINTER_DIR 249
#define DVM_DEBUG_DIR 146
#define DVM_ENDDEBUG_DIR 147
#define DVM_TRACEON_DIR 148
#define DVM_TRACEOFF_DIR 149
#define DVM_INTERVAL_DIR 128
#define DVM_ENDINTERVAL_DIR 129
#define DVM_TASK_REGION_DIR 605
#define DVM_END_TASK_REGION_DIR 606
#define DVM_ON_DIR 607
#define DVM_END_ON_DIR 608
#define DVM_TASK_DIR 609
#define DVM_MAP_DIR 610
#define DVM_PARALLEL_TASK_DIR 611
#define DVM_INHERIT_DIR 612
#define DVM_INDIRECT_GROUP_DIR 613
#define DVM_INDIRECT_ACCESS_DIR 614
#define DVM_REMOTE_GROUP_DIR 615
#define DVM_RESET_DIR 616
#define DVM_PREFETCH_DIR 617
#define DVM_OWN_DIR 618
#define DVM_HEAP_DIR 619
#define DVM_ASYNCID_DIR 620
#define DVM_ASYNCHRONOUS_DIR 621
#define DVM_ENDASYNCHRONOUS_DIR 622
#define DVM_ASYNCWAIT_DIR 623
#define DVM_F90_DIR 624
#define DVM_BARRIER_DIR 625
#define FORALL_STAT 626
#define DVM_CONSISTENT_GROUP_DIR 627
#define DVM_CONSISTENT_START_DIR 628
#define DVM_CONSISTENT_WAIT_DIR 629
#define DVM_CONSISTENT_DIR 630
#define DVM_CHECK_DIR 631
#define DVM_IO_MODE_DIR 632
#define DVM_LOCALIZE_DIR 633
#define DVM_SHADOW_ADD_DIR 634
#define DVM_CP_CREATE_DIR 635
#define DVM_CP_LOAD_DIR 636
#define DVM_CP_SAVE_DIR 637
#define DVM_CP_WAIT_DIR 638
#define DVM_EXIT_INTERVAL_DIR 639
#define DVM_TEMPLATE_CREATE_DIR 640
#define DVM_TEMPLATE_DELETE_DIR 641
#define BLOCK_OP 705
#define NEW_SPEC_OP 706
#define REDUCTION_OP 707
#define SHADOW_RENEW_OP 708
#define SHADOW_START_OP 709
#define SHADOW_WAIT_OP 710
#define DIAG_OP 711
#define REMOTE_ACCESS_OP 712
#define TEMPLATE_OP 713
#define PROCESSORS_OP 714
#define DYNAMIC_OP 715
#define ALIGN_OP 716
#define DISTRIBUTE_OP 717
#define SHADOW_OP 718
#define INDIRECT_ACCESS_OP 719
#define ACROSS_OP 720
#define NEW_VALUE_OP 721
#define SHADOW_COMP_OP 722
#define STAGE_OP 723
#define FORALL_OP 724
#define CONSISTENT_OP 725
#define PARALLEL_OP 737
#define INDIRECT_OP 738
#define DERIVED_OP 739
#define DUMMY_REF 740
#define COMMON_OP 741
#define SHADOW_NAMES_OP 742
#define SHADOW_GROUP_NAME 523
#define REDUCTION_GROUP_NAME 524
#define REF_GROUP_NAME 525
#define ASYNC_ID 526
#define CONSISTENT_GROUP_NAME 527
#define ACC_REGION_DIR 900 /* ACC Fortran */
#define ACC_END_REGION_DIR 901 /* ACC Fortran */
#define ACC_CALL_STMT 907 /* ACC Fortran */
#define ACC_KERNEL_HEDR 908 /* ACC Fortran */
#define ACC_GET_ACTUAL_DIR 909 /* ACC Fortran */
#define ACC_ACTUAL_DIR 910 /* ACC Fortran */
#define ACC_CHECKSECTION_DIR 911 /* ACC Fortran */
#define ACC_END_CHECKSECTION_DIR 912 /* ACC Fortran */
#define ACC_ROUTINE_DIR 913 /* ACC Fortran */
#define ACC_TIE_OP 930 /* ACC Fortran */
#define ACC_INLOCAL_OP 931 /* ACC Fortran */
#define ACC_INOUT_OP 932 /* ACC Fortran */
#define ACC_IN_OP 933 /* ACC Fortran */
#define ACC_OUT_OP 934 /* ACC Fortran */
#define ACC_LOCAL_OP 935 /* ACC Fortran */
#define ACC_PRIVATE_OP 936 /* ACC Fortran */
#define ACC_DEVICE_OP 937 /* ACC Fortran */
#define ACC_CUDA_OP 938 /* ACC Fortran */
#define ACC_HOST_OP 939 /* ACC Fortran */
#define ACC_GLOBAL_OP 940 /* ACC Fortran */
#define ACC_ATTRIBUTES_OP 941 /* ACC Fortran */
#define ACC_VALUE_OP 942 /* ACC Fortran */
#define ACC_SHARED_OP 943 /* ACC Fortran */
#define ACC_CONSTANT_OP 944 /* ACC Fortran */
#define ACC_USES_OP 945 /* ACC Fortran */
#define ACC_CALL_OP 946 /* ACC Fortran */
#define ACC_CUDA_BLOCK_OP 947 /* ACC Fortran */
#define ACC_TARGETS_OP 948 /* ACC Fortran */
#define ACC_ASYNC_OP 949 /* ACC Fortran */
#define SPF_ANALYSIS_DIR 950 /* SAPFOR */
#define SPF_PARALLEL_DIR 951 /* SAPFOR */
#define SPF_TRANSFORM_DIR 952 /* SAPFOR */
#define SPF_NOINLINE_OP 953 /* SAPFOR */
#define SPF_PARALLEL_REG_DIR 954 /* SAPFOR */
#define SPF_END_PARALLEL_REG_DIR 955 /* SAPFOR */
#define SPF_REGION_NAME 956 /* SAPFOR */
#define SPF_EXPAND_OP 957 /* SAPFOR */
#define SPF_FISSION_OP 958 /* SAPFOR */
#define SPF_SHRINK_OP 959 /* SAPFOR */
#define SPF_CHECPOINT_DIR 960 /* SAPFOR */
#define SPF_TYPE_OP 961 /* SAPFOR */
#define SPF_VARLIST_OP 962 /* SAPFOR */
#define SPF_EXCEPT_OP 963 /* SAPFOR */
#define SPF_FILES_COUNT_OP 964 /* SAPFOR */
#define SPF_INTERVAL_OP 965 /* SAPFOR */
#define SPF_TIME_OP 966 /* SAPFOR */
#define SPF_ITER_OP 967 /* SAPFOR */
#define SPF_FLEXIBLE_OP 968 /* SAPFOR */
#define SPF_PARAMETER_OP 969 /* SAPFOR */
#define SPF_CODE_COVERAGE_OP 970 /* SAPFOR */
#define SPF_UNROLL_OP 971 /* SAPFOR */

58
dvm/fdvm/trunk/include/extern.h Normal file
View File

@@ -0,0 +1,58 @@
/*********************************************************************/
/* pC++/Sage++ Copyright (C) 1993 */
/* Indiana University University of Oregon University of Rennes */
/*********************************************************************/
#include "db.h"
extern char *infname;
extern char yytext[];
extern int yyleng;
extern int errline;
extern int needkwd;
extern int implkwd;
extern int optkwd;
extern int opt_kwd_;
extern int opt_in_out;
extern int as_op_kwd_;
extern int opt_kwd_hedr;
extern int opt_kwd_r;
extern int optcorner;
extern int optcall;
extern int opt_l_s;
extern int colon_flag;
extern int inioctl;
extern int shiftcase;
extern int nowarnflag;
extern int nwarn;
extern int errcnt;
extern int yylineno;
extern int mod_offset;
extern int num_files;
extern int parstate;
extern int procclass;
extern long procleng;
extern int nentry;
extern int blklevel;
extern int undeftype;
extern int dorange;
extern char intonly;
extern PTR_TYPE global_unknown;
extern PTR_FNAME head_file, cur_thread_file;
extern PTR_FILE fi;
char *copyn(), *copys();
#define INLOOP(x) ((LOOP_NODE <= x) && (x <= WHILE_NODE))
#define NEW_SCOPE(x) ((x->variant == FORALL_NODE)|| \
(x->variant == CDOALL_NODE)|| \
(x->variant == SDOALL_NODE)|| \
(x->variant == DOACROSS_NODE)|| \
(x->variant == CDOACROSS_NODE)|| \
(x->variant == FOR_NODE))
extern int is_openmp_stmt; /*OMP*/
extern int operator_slash; /*OMP*/
#define BIT_OPENMP 1024*128*128 /* OpenMP Fortran */

74
dvm/fdvm/trunk/include/fdvm.h Normal file
View File

@@ -0,0 +1,74 @@
/*********************************************************************/
/* pC++/Sage++ Copyright (C) 1993 */
/* Indiana University University of Oregon University of Rennes */
/*********************************************************************/
/* The following 16 different options are used to
declare variables are as follows:
( stored in symptr->attr ) */
#define ALLOCATABLE_BIT 1
#define DIMENSION_BIT 2
#define INHERIT_BIT 4
#define EXTERNAL_BIT 8
#define IN_BIT 16
#define INOUT_BIT 32
#define INTRINSIC_BIT 64
#define OPTIONAL_BIT 128
#define OUT_BIT 256
#define PARAMETER_BIT 512
#define POINTER_BIT 1024
#define PRIVATE_BIT 2048
#define PUBLIC_BIT 4096
#define SAVE_BIT 8192
#define SEQUENCE_BIT 16384
#define RECURSIVE_BIT 32768
#define TARGET_BIT 65536
#define PROCESSORS_BIT 131072
#define TEMPLATE_BIT 262144
#define DISTRIBUTE_BIT 524288
#define ALIGN_BIT 1048576
#define HEAP_BIT 2097152
#define DYNAMIC_BIT 4194304
#define SHADOW_BIT 8388608
#define DVM_POINTER_BIT 16777216
#define COMMON_BIT 33554432
#define INDIRECT_BIT 67108864
#define POSTPONE_BIT 134217728
#define DO_VAR_BIT 268435456
#define DATA_BIT 536870912
#define TASK_BIT 1073741824
#define EQUIVALENCE_BIT 16384
#define ALIGN_BASE_BIT 67108864
#define CONSISTENT_BIT 268435456
#define ELEMENTAL_BIT 2097152
#define PURE_BIT 33554432
/* This constant is used in HPF unparser */
#define DVM_POINTER_ARRAY_BIT 268435456
/*2147483648 */
#define ALREADY_DISTRIBUTE_BIT 524288
#define ALREADY_ALIGN_BIT 1048576
#define ALREADY_TEMPLATE_BIT 262144
#define ALREADY_DYNAMIC_BIT 4194304
#define ALREADY_PROCESSORS_BIT 131072
#define ALREADY_SHADOW_BIT 8388608
#define ALREADY_TASK_BIT 1073741824
#define ALREADY_INHERIT_BIT 67108864
#define ALREADY_DVM_POINTER_BIT 16777216
#define ALREADY_TASK_BIT 1073741824
/*ACC*/
#define USE_IN_BIT 8
#define USE_OUT_BIT 32768
#define USER_PROCEDURE_BIT 512
/* This constant is used in analyzer */
#define ASSOCIATION_BIT 2097152

1
dvm/fdvm/trunk/include/fdvm_version.h Normal file
View File

@@ -0,0 +1 @@
#define COMPILER_VERSION "6.0 (11.05.2018)"

11
dvm/fdvm/trunk/include/inc.h Normal file
View File

@@ -0,0 +1,11 @@
/*********************************************************************/
/* pC++/Sage++ Copyright (C) 1993 */
/* Indiana University University of Oregon University of Rennes */
/*********************************************************************/
#include <stdio.h>
#include "defs.h"
#include "bif.h"
#include "ll.h"
#include "symb.h"
#include "sets.h"

18
dvm/fdvm/trunk/include/leak_detector.h Normal file
View File

@@ -0,0 +1,18 @@
#pragma once
#ifdef _WIN32
#ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#ifdef _DEBUG
#ifndef DBG_NEW
#define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
#define new DBG_NEW
#endif
#endif
#endif
#endif

2000
dvm/fdvm/trunk/include/libSageOMP.h Normal file
View File

File diff suppressed because it is too large Load Diff

334
dvm/fdvm/trunk/include/libdvm.h Normal file
View File

@@ -0,0 +1,334 @@
name_dvm[CLFDVM] = "clfdvm"; //fortran subroutine closing all opened files
name_dvm[RTLINI] = "linit";
name_dvm[RTLEXI] = "lexit";
name_dvm[GETAM] = "getam";
name_dvm[GETVM] = "getps";
name_dvm[BEGBL] = "begbl";
name_dvm[ENDBL] = "endbl";
name_dvm[CRTAMV] = "crtamv";
name_dvm[DISAM] = "distr";
name_dvm[CRTDA] = "crtda";
name_dvm[ALGNDA] = "align";
name_dvm[REDVAR] = "crtred";
name_dvm[REDVARF] = "crtrdf";
name_dvm[CRTRG] = "crtrg";
name_dvm[INSRV] = "insred";
name_dvm[SAVERV] = "saverv";
name_dvm[STARTR] = "strtrd";
name_dvm[WAITR] = "waitrd";
name_dvm[DELRG] = "delrg";
name_dvm[CRTSHG] = "crtshg";
name_dvm[DATOSHG] = "inssh";
name_dvm[STARTSH] = "strtsh";
name_dvm[WAITSH] = "waitsh";
name_dvm[DELSHG] = "delshg";
name_dvm[CRTPLP] = "crtpl";
name_dvm[BEGPLP] = "mappl";
name_dvm[ENDPLP] = "endpl";
name_dvm[BFIRST] = "exfrst";
name_dvm[BLAST] = "imlast";
name_dvm[DOLOOP] = "dopl";
name_dvm[GETADR] = "getadr";
name_dvm[GETAI] = "getai";
name_dvm[GETAL] = "getal";
name_dvm[GETAF] = "getaf";
name_dvm[GETAD] = "getad";
name_dvm[GETAC] = "getac";
name_dvm[GETACH] = "getach";
name_dvm[TSTIOP] = "tstio";
name_dvm[GETRNK] = "getrnk";
name_dvm[GETSIZ] = "getsiz";
name_dvm[ARRCPY] = "arrcpy";
name_dvm[SRMEM] = "srmem";
name_dvm[RDISAM] = "redis";
name_dvm[REALGN] = "realn";
name_dvm[RWELM] = "rwelm";
name_dvm[RWELMF] = "rwelmf";
name_dvm[DELOBJ] = "delobj";
name_dvm[TSTELM] = "tstelm";
name_dvm[DLOADV] = "dldv";
name_dvm[DSTORV] = "dstv";
name_dvm[DPRSTV] = "dprstv";
name_dvm[DINOUT] = "dinout";
name_dvm[DRMBUF] = "drmbuf";
name_dvm[DITER] = "diter";
name_dvm[DBEGPL] = "dbegpl";
name_dvm[DBEGSL] = "dbegsl";
name_dvm[DENDL] = "dendl";
name_dvm[DSKPBL] = "dskpbl";
name_dvm[BINTER] = "binter";
name_dvm[EINTER] = "einter";
name_dvm[BSLOOP] = "bsloop";
name_dvm[BPLOOP] = "bploop";
name_dvm[ENLOOP] = "enloop";
name_dvm[BIOF] = "biof";
name_dvm[EIOF] = "eiof";
name_dvm[FNAME] = "fname";
name_dvm[LNUMB] = "lnumb";
name_dvm[ADDHDR] = "addhdr";
name_dvm[PSVIEW] = "psview";
name_dvm[CRTPS] = "crtps";
name_dvm[GETAMV] = "getamv";
name_dvm[GETAMR] = "getamr";
name_dvm[MAPAM] = "mapam";
name_dvm[RUNAM] = "runam";
name_dvm[STOPAM] = "stopam";
name_dvm[CRTBG] = "crtbg";
name_dvm[LOADBG] = "loadbg";
name_dvm[WAITBG] = "waitbg";
name_dvm[CRTRB] = "crtrbl";
name_dvm[CRTRBP] = "crtrbp";
name_dvm[LOADRB] = "loadrb";
name_dvm[WAITRB] = "waitrb";
name_dvm[INSRB] = "insrb";
name_dvm[CRTIG] = "crtig";
name_dvm[LOADIG] = "loadig";
name_dvm[WAITIG] = "waitig";
name_dvm[CRTIB] = "crtib";
name_dvm[LOADIB] = "loadib";
name_dvm[WAITIB] = "waitib";
name_dvm[INSIB] = "insib";
name_dvm[INSSHD] = "insshd";
name_dvm[SENDSH] = "sendsh";
name_dvm[RECVSH] = "recvsh";
name_dvm[TRON] = "tron";
name_dvm[TROFF] = "troff";
name_dvm[DBEGTR] = "dbegtr";
name_dvm[GENBLI] = "genbli";
name_dvm[TPCNTR] = "tpcntr";
name_dvm[RMKIND] = "rmkind";
name_dvm[SETELW] = "setelw";
name_dvm[DLOAD2] = "dldv2";
name_dvm[DREADA] = "dreada";
name_dvm[DREAD] = "dread";
name_dvm[LINDTP] = "lindtp";
name_dvm[DVMRM] = "acrecv";
name_dvm[DVMSM] = "acsend";
name_dvm[AARRCP] = "aarrcp";
name_dvm[WAITCP] = "waitcp";
name_dvm[ACROSS] = "across";
name_dvm[DVMLF] = "dvmlf";
name_dvm[ADDBND] = "addbnd";
name_dvm[INCSH] = "incsh";
name_dvm[INCSHD] = "incshd";
name_dvm[DRARR] = "drarr";
name_dvm[BARRIER] = "bsynch";
name_dvm[DINSRD] = "dinsrf";
name_dvm[DCRRG] = "dcrtrg";
name_dvm[DSAVRG] = "dsavrg";
name_dvm[DCLCRG] = "dclcrg";
name_dvm[DDLRG] = "ddelrg";
name_dvm[ADDSHD] = "addshd";
name_dvm[CRTRDA] = "crtraf";
name_dvm[STRTAC] = "strtac";
name_dvm[WAITAC] = "waitac";
name_dvm[CRTCG] = "crtcg";
name_dvm[INSCG] = "inscg";
name_dvm[STRTCG] = "strtcg";
name_dvm[WAITCG] = "waitcg";
name_dvm[DELCG] = "delcg";
name_dvm[CONSDA] = "consda";
name_dvm[INCLCG] = "inclcg";
name_dvm[RSTRDA] = "rstrda";
name_dvm[RSTCG] = "rstcg";
name_dvm[CRTRA9] = "crtra9";
name_dvm[CRTDA9] = "crtda9";
name_dvm[FTCNTR] = "ftcntr";
name_dvm[DACSUM] = "dacsum";
name_dvm[ARCSF] = "arcsf";
name_dvm[BLKDIV] = "blkdiv";
name_dvm[DOPLMB] = "doplmb";
name_dvm[DOSL] = "dosl";
name_dvm[DVTR] = "dvtr";
name_dvm[DOPLSEQ] = "doplmbseq";
name_dvm[INIMPI] = "linit";
name_dvm[DVMH_INIT] = "dvmh_init2";
name_dvm[DVMH_FINISH] = "dvmh_finish";
name_dvm[DVMH_EXIT] = "dvmh_exit";
name_dvm[INIT_CUDA] = "init_cuda";
name_dvm[REG_CREATE] = "region_create";
name_dvm[REG_CREATE_2] = "dvmh_region_create";
name_dvm[REG_END] = "region_end";
name_dvm[REG_END_2] = "dvmh_region_end";
name_dvm[REG_DEVICES] = "region_execute_on_targets";
name_dvm[REG_DEVICES_2] = "dvmh_region_execute_on_targets";
name_dvm[REG_START] = "region_inner_start";
name_dvm[RGSTR_ARRAY_2] = "dvmh_region_register_array";
name_dvm[RGSTR_SUBARRAY_2] = "dvmh_region_register_subarray";
name_dvm[RGSTR_SCALAR_2] = "dvmh_region_register_scalar";
name_dvm[RGSTR_ARRAY] = "region_register_array";
name_dvm[RGSTR_SUBARRAY] = "region_register_subarray";
name_dvm[RGSTR_SCALAR] = "region_register_scalar";
name_dvm[SET_NAME_ARRAY] = "region_set_name_array";
name_dvm[SET_NAME_VAR] = "region_set_name_variable";
name_dvm[BEFORE_LOADRB] = "dvmh_remote_access";
name_dvm[REG_WAITRB] = "region_after_waitrb";
name_dvm[REG_DESTROY_RB] = "region_destroy_rb";
name_dvm[GET_ACTUAL_EDGES] = "dvmh_get_actual_edges";
name_dvm[SHADOW_RENEW] = "dvmh_shadow_renew";
name_dvm[SHADOW_RENEW_2] = "dvmh_shadow_renew2";
name_dvm[INDIRECT_SH_RENEW]= "dvmh_indirect_shadow_renew";
name_dvm[LOOP_CREATE] = "loop_create";
name_dvm[LOOP_CREATE_2] = "dvmh_loop_create";
name_dvm[REG_HANDLER] = "loop_register_handler";
name_dvm[REG_HANDLER_2] = "dvmh_loop_register_handler";
name_dvm[HANDLER_FUNC] = "dvmh_handler_func";
name_dvm[LOOP_START] = "loop_start";
name_dvm[LOOP_END] = "loop_end";
name_dvm[LOOP_PERFORM] = "loop_perform";
name_dvm[LOOP_PERFORM_2] = "dvmh_loop_perform";
name_dvm[CUDA_BLOCK] = "loop_set_cuda_block";
name_dvm[CUDA_BLOCK_2] = "dvmh_loop_set_cuda_block";
name_dvm[LOOP_INSRED] = "loop_insred";
name_dvm[LOOP_RED] = "dvmh_loop_reduction";
name_dvm[SHADOW_COMPUTE] = "loop_shadow_compute";
name_dvm[SHADOW_COMPUTE_AR]= "dvmh_loop_shadow_compute_array";
name_dvm[SHADOW_COMPUTE_2] = "dvmh_loop_shadow_compute";
name_dvm[CORRESPONDENCE] = "dvmh_loop_array_correspondence";
name_dvm[GET_ACTUAL_ALL] = "dvmh_get_actual_all";
name_dvm[GET_ACTUAL_ALL_2] = "dvmh_get_actual_all2";
name_dvm[GET_ACTUAL_ARRAY] = "dvmh_get_actual_array";
name_dvm[GET_ACTUAL_ARR_2] = "dvmh_get_actual_array2";
name_dvm[GET_ACTUAL_SUBARRAY]= "dvmh_get_actual_subarray";
name_dvm[GET_ACTUAL_SUBARR_2]= "dvmh_get_actual_subarray2";
name_dvm[GET_ACTUAL_SCALAR] = "dvmh_get_actual_variable";
name_dvm[GET_ACTUAL_SCALAR_2]= "dvmh_get_actual_variable2";
name_dvm[GET_ACTUAL_SUBVAR] = "dvmh_get_actual_subvariable";
name_dvm[GET_ACTUAL_SUBVAR_2]= "dvmh_get_actual_subvariable2";
name_dvm[ACTUAL_ARRAY] = "dvmh_actual_array";
name_dvm[ACTUAL_ARRAY_2] = "dvmh_actual_array2";
name_dvm[ACTUAL_SUBARRAY] = "dvmh_actual_subarray";
name_dvm[ACTUAL_SUBARRAY_2]= "dvmh_actual_subarray2";
name_dvm[ACTUAL_SCALAR] = "dvmh_actual_variable";
name_dvm[ACTUAL_SCALAR_2] = "dvmh_actual_variable2";
name_dvm[ACTUAL_SUBVAR] = "dvmh_actual_subvariable";
name_dvm[ACTUAL_SUBVAR_2] = "dvmh_actual_subvariable2";
name_dvm[ACTUAL_ALL] = "dvmh_actual_all";
name_dvm[ACTUAL_ALL_2] = "dvmh_actual_all2";
name_dvm[DVMH_REDISTRIBUTE]= "dvmh_redistribute";
name_dvm[DVMH_REALIGN] = "dvmh_realign";
name_dvm[DESTROY_ARRAY] = "dvmh_destroy_array";
name_dvm[DESTROY_SCALAR] = "dvmh_destroy_variable";
name_dvm[HANDLE_CONSIST] = "region_handle_consistent";
name_dvm[LOOP_ACROSS] = "loop_across";
name_dvm[LOOP_ACROSS_2] = "dvmh_loop_across";
name_dvm[DVMH_SET_STAGE] = "dvmh_loop_set_stage";
name_dvm[GET_STAGE] = "dvmh_get_next_stage";
name_dvm[MAP_TASKS] = "map_tasks";
name_dvm[DATA_ENTER] = "dvmh_data_enter";
name_dvm[DATA_EXIT] = "dvmh_data_exit";
name_dvm[DELETE_OBJECT] = "dvmh_delete_object";
name_dvm[FORGET_HEADER] = "dvmh_forget_header";
name_dvm[SCOPE_START] = "dvmh_scope_start";
name_dvm[SCOPE_END] = "dvmh_scope_end";
name_dvm[SCOPE_INSERT] = "dvmh_scope_insert";
name_dvm[LOOP_MAP] = "dvmh_loop_map";
name_dvm[ALIGN_LINEAR] = "dvmh_alignment_linear";
name_dvm[REGISTER_ARR] = "dvmh_register_array";
name_dvm[GET_ADDR] = "dvmh_get_addr";
name_dvm[STRING] = "dvmh_string";
name_dvm[STRING_VAR] = "dvmh_string_var";
name_dvm[VAR_GEN_HDR] = "dvmh_variable_gen_header";
name_dvm[VAR_FILL_HDR] = "dvmh_variable_fill_header";
name_dvm[CP_CHECK_FILENAME]= "dvmh_cp_check_filename";
name_dvm[CP_NEXT_FILENAME] = "dvmh_cp_next_filename";
name_dvm[CP_SAVE_FILENAMES]= "dvmh_cp_save_filenames";
name_dvm[CP_WAIT] = "dvmh_cp_wait";
name_dvm[CP_SAVE_ASYNC_UNIT]="dvmh_cp_save_async_unit";
name_dvm[DVMH_LINE] = "dvmh_line";
name_dvm[CREATE_ARRAY] = "dvmh_array_create";
name_dvm[CREATE_TEMPLATE] = "dvmh_template_create";
name_dvm[DVMH_REPLICATED] = "dvmh_distribution_replicated";
name_dvm[DVMH_BLOCK] = "dvmh_distribution_block";
name_dvm[DVMH_WGTBLOCK] = "dvmh_distribution_wgtblock";
name_dvm[DVMH_GENBLOCK] = "dvmh_distribution_genblock";
name_dvm[DVMH_MULTBLOCK] = "dvmh_distribution_multblock";
name_dvm[DVMH_INDIRECT] = "dvmh_distribution_indirect";
name_dvm[DVMH_DERIVED] = "dvmh_distribution_derived";
name_dvm[DVMH_DISTRIBUTE] = "dvmh_distribute";
name_dvm[DVMH_REDISTR_2] = "dvmh_redistribute2";
name_dvm[DVMH_ALIGN] = "dvmh_align";
name_dvm[DVMH_REALIGN_2] = "dvmh_realign2";
name_dvm[DVMH_HAS_ELEMENT] = "dvmh_has_element";
name_dvm[CALC_LINEAR] = "dvmh_calc_linear";
name_dvm[LOCALIZE] = "dvmh_indirect_localize";
name_dvm[SHADOW_ADD] = "dvmh_indirect_shadow_add";
name_dvm[EXPR_IGNORE] = "dvmh_derived_rhs_expr_ignore";
name_dvm[EXPR_CONSTANT] = "dvmh_derived_rhs_expr_constant";
name_dvm[EXPR_SCAN] = "dvmh_derived_rhs_expr_scan";
name_dvm[DERIVED_RHS] = "dvmh_derived_rhs";
name_dvm[ARRAY_SLICE] = "dvmh_array_slice";
name_dvm[COPY_WHOLE] = "dvmh_array_copy_whole";
name_dvm[COPY_ARRAY] = "dvmh_array_copy";
name_dvm[SET_VALUE] = "dvmh_array_set_value";
name_dvm[LOOP_CONSISTENT] = "dvmh_loop_consistent";
name_dvm[DVMH_REMOTE2] = "dvmh_remote_access2";
name_dvm[LOOP_REMOTE] = "dvmh_loop_remote_access";
name_dvm[FTN_OPEN] = "dvmh_ftn_open"; /* IO */
name_dvm[FTN_CLOSE] = "dvmh_ftn_close"; /* IO */
name_dvm[FTN_READ] = "dvmh_ftn_read_unf"; /* IO */
name_dvm[FTN_WRITE] = "dvmh_ftn_write_unf"; /* IO */
name_dvm[FTN_ENDFILE] = "dvmh_ftn_endfile"; /* IO */
name_dvm[FTN_FLUSH] = "dvmh_ftn_flush"; /* IO */
name_dvm[FTN_REWIND] = "dvmh_ftn_rewind"; /* IO */
name_dvm[FTN_CONNECTED] = "dvmh_ftn_connected"; /* IO */
//--------------------- called from host-handler ------------
name_dvm[FILL_BOUNDS] = "loop_fill_bounds";
name_dvm[RED_INIT] = "loop_red_init";
name_dvm[RED_POST] = "loop_red_post";
name_dvm[SLOT_COUNT] = "loop_get_slot_count";
name_dvm[HAS_ELEMENT] = "loop_has_element";
name_dvm[HAS_ELEMENT_2] = "dvmh_loop_has_element";
name_dvm[FILL_LOCAL_PART] = "loop_fill_local_part";
name_dvm[OMP_STAT_BP] = "dvmh_perf_before_parallel";
name_dvm[OMP_STAT_AP] = "dvmh_perf_after_parallel";
name_dvm[OMP_STAT_BL] = "dvmh_perf_before_loop";
name_dvm[OMP_STAT_AL] = "dvmh_perf_after_loop";
name_dvm[OMP_STAT_BS] = "dvmh_perf_before_synchro";
name_dvm[OMP_STAT_AS] = "dvmh_perf_after_synchro";
//--------------------- called from cuda-handler ------------
name_dvm[GET_BASE] = "dvmh_get_natural_base";
name_dvm[GET_BASE_C] = "dvmh_get_natural_base_C";
name_dvm[FILL_HEADER] = "dvmh_fill_header_";
name_dvm[FILL_HEADER_2] = "dvmh_fill_header2_";
name_dvm[FILL_HEADER_EX] = "dvmh_fill_header_ex_";
name_dvm[FILL_HEADER_EX_2] = "dvmh_fill_header_ex2_";
name_dvm[DO_CUDA] = "loop_cuda_do";
name_dvm[RED_CUDA] = "loop_cuda_register_red";
name_dvm[RED_CUDA_C] = "dvmh_loop_cuda_register_red_C";
name_dvm[REGISTER_RED] = "loop_cuda_register_red_";
name_dvm[RED_INIT_C] = "loop_red_init_";
name_dvm[RED_INIT_2] = "dvmh_loop_red_init_";
name_dvm[CUDA_RED_INIT] = "loop_cuda_red_init";
name_dvm[CUDA_RED_INIT_2] = "dvmh_loop_cuda_red_init_C";
name_dvm[RED_PREPARE] = "loop_cuda_red_prepare";
name_dvm[RED_PREPARE_C] = "dvmh_loop_cuda_red_prepare_C";
name_dvm[RED_FINISH] = "loop_red_finish";
name_dvm[RED_FINISH_C] = "dvmh_loop_cuda_red_finish_C";
name_dvm[SHARED_NEEDED] = "loop_cuda_shared_needed_";
name_dvm[GET_DEVICE_ADDR] = "dvmh_get_device_addr";
name_dvm[GET_DEVICE_ADDR_C]= "dvmh_get_device_addr_C";
name_dvm[GET_LOCAL_PART] = "loop_cuda_get_local_part";
name_dvm[GET_LOCAL_PART_C] = "dvmh_loop_cuda_get_local_part_C";
name_dvm[GET_DEVICE_NUM] = "loop_get_device_num_";
name_dvm[GET_DEVICE_NUM_2] = "dvmh_loop_get_device_num_";
name_dvm[GET_OVERALL_STEP] = "loop_cuda_get_red_step";
name_dvm[FILL_BOUNDS_C] = "loop_fill_bounds_";
name_dvm[FILL_BOUNDS_2] = "dvmh_loop_fill_bounds_";
name_dvm[RED_POST_C] = "loop_red_post_";
name_dvm[RED_POST_2] = "dvmh_loop_red_post_";
name_dvm[CUDA_REPLICATE] = "dvmh_cuda_replicate";
name_dvm[GET_DEP_MASK] = "loop_get_dependency_mask_";
name_dvm[GET_DEP_MASK_2] = "dvmh_loop_get_dependency_mask_";
name_dvm[GET_DEP_MASK_F] = "loop_get_dependency_mask";
name_dvm[CUDA_TRANSFORM] = "loop_cuda_transform_";
name_dvm[CUDA_AUTOTRANSFORM]="loop_cuda_autotransform";
name_dvm[LOOP_AUTOTRANSFORM]="dvmh_loop_autotransform_";
name_dvm[APPLY_OFFSET] = "dvmh_apply_offset";
name_dvm[GET_CONFIG] = "loop_cuda_get_config";
name_dvm[GET_CONFIG_C] = "dvmh_loop_cuda_get_config_C";
name_dvm[CHANGE_BOUNDS] = "dvmh_change_filled_bounds";
name_dvm[GUESS_INDEX_TYPE] = "loop_guess_index_type_";
name_dvm[GUESS_INDEX_TYPE_2]= "dvmh_loop_guess_index_type_";
name_dvm[RTC_SET_LANG] = "loop_cuda_rtc_set_lang";

334
dvm/fdvm/trunk/include/libnum.h Normal file
View File

@@ -0,0 +1,334 @@
enum {
CLFDVM,
RTLINI,
RTLEXI,
GETAM,
GETVM,
BEGBL,
ENDBL,
CRTAMV,
DISAM,
CRTDA,
ALGNDA,
REDVAR,
REDVARF,
CRTRG,
INSRV,
SAVERV,
STARTR,
WAITR,
DELRG,
CRTSHG,
DATOSHG,
STARTSH,
WAITSH,
DELSHG,
CRTPLP,
BEGPLP,
ENDPLP,
BFIRST,
BLAST,
DOLOOP,
GETADR,
GETAI,
GETAL,
GETAF,
GETAD,
GETAC,
GETACH,
TSTIOP,
GETRNK,
GETSIZ,
ARRCPY,
SRMEM,
RDISAM,
REALGN,
RWELM,
RWELMF,
DELOBJ,
TSTELM,
DLOADV,
DSTORV,
DPRSTV,
DINOUT,
DRMBUF,
DITER,
DBEGPL,
DBEGSL,
DENDL,
DSKPBL,
BINTER,
EINTER,
BSLOOP,
BPLOOP,
ENLOOP,
BIOF,
EIOF,
FNAME,
LNUMB,
ADDHDR,
PSVIEW,
CRTPS,
GETAMV,
GETAMR,
MAPAM,
RUNAM,
STOPAM,
CRTBG,
LOADBG,
WAITBG,
CRTRB,
CRTRBP,
LOADRB,
WAITRB,
INSRB,
CRTIG,
LOADIG,
WAITIG,
CRTIB,
LOADIB,
WAITIB,
INSIB,
INSSHD,
SENDSH,
RECVSH,
TRON,
TROFF,
DBEGTR,
GENBLI,
TPCNTR,
RMKIND,
SETELW,
DLOAD2,
DREADA,
DREAD,
LINDTP,
DVMRM,
DVMSM,
AARRCP,
WAITCP,
ACROSS,
DVMLF,
ADDBND,
INCSH,
INCSHD,
DRARR,
BARRIER,
DINSRD,
DCRRG,
DSAVRG,
DCLCRG,
DDLRG,
ADDSHD,
CRTRDA,
STRTAC,
WAITAC,
CRTCG,
INSCG,
STRTCG,
WAITCG,
DELCG,
CONSDA,
INCLCG,
RSTRDA,
RSTCG,
CRTRA9,
CRTDA9,
FTCNTR,
DACSUM,
ARCSF,
BLKDIV,
DOPLMB,
DOSL,
DVTR,
DOPLSEQ,
INIMPI,
DVMH_INIT,
DVMH_FINISH,
DVMH_EXIT,
INIT_CUDA,
REG_CREATE,
REG_CREATE_2,
REG_END,
REG_END_2,
REG_DEVICES,
REG_DEVICES_2,
REG_START,
RGSTR_ARRAY_2,
RGSTR_SUBARRAY_2,
RGSTR_SCALAR_2,
RGSTR_ARRAY,
RGSTR_SUBARRAY,
RGSTR_SCALAR,
SET_NAME_ARRAY,
SET_NAME_VAR,
BEFORE_LOADRB,
REG_WAITRB,
REG_DESTROY_RB,
GET_ACTUAL_EDGES,
SHADOW_RENEW,
SHADOW_RENEW_2,
INDIRECT_SH_RENEW,
LOOP_CREATE,
LOOP_CREATE_2,
REG_HANDLER,
REG_HANDLER_2,
HANDLER_FUNC,
LOOP_START,
LOOP_END,
LOOP_PERFORM,
LOOP_PERFORM_2,
CUDA_BLOCK,
CUDA_BLOCK_2,
LOOP_INSRED,
LOOP_RED,
SHADOW_COMPUTE,
SHADOW_COMPUTE_AR,
SHADOW_COMPUTE_2,
CORRESPONDENCE,
GET_ACTUAL_ALL,
GET_ACTUAL_ALL_2,
GET_ACTUAL_ARRAY,
GET_ACTUAL_ARR_2,
GET_ACTUAL_SUBARRAY,
GET_ACTUAL_SUBARR_2,
GET_ACTUAL_SCALAR,
GET_ACTUAL_SCALAR_2,
GET_ACTUAL_SUBVAR,
GET_ACTUAL_SUBVAR_2,
ACTUAL_ARRAY,
ACTUAL_ARRAY_2,
ACTUAL_SUBARRAY,
ACTUAL_SUBARRAY_2,
ACTUAL_SCALAR,
ACTUAL_SCALAR_2,
ACTUAL_SUBVAR,
ACTUAL_SUBVAR_2,
ACTUAL_ALL,
ACTUAL_ALL_2,
DVMH_REDISTRIBUTE,
DVMH_REALIGN,
DESTROY_ARRAY,
DESTROY_SCALAR,
HANDLE_CONSIST,
LOOP_ACROSS,
LOOP_ACROSS_2,
DVMH_SET_STAGE,
GET_STAGE,
MAP_TASKS,
DATA_ENTER,
DATA_EXIT,
DELETE_OBJECT,
FORGET_HEADER,
SCOPE_START,
SCOPE_END,
SCOPE_INSERT,
LOOP_MAP,
ALIGN_LINEAR,
REGISTER_ARR,
GET_ADDR,
STRING,
STRING_VAR,
VAR_GEN_HDR,
VAR_FILL_HDR,
CP_NEXT_FILENAME,
CP_CHECK_FILENAME,
CP_SAVE_FILENAMES,
CP_WAIT,
CP_SAVE_ASYNC_UNIT,
DVMH_LINE,
CREATE_ARRAY,
CREATE_TEMPLATE,
DVMH_REPLICATED,
DVMH_BLOCK,
DVMH_WGTBLOCK,
DVMH_GENBLOCK,
DVMH_MULTBLOCK,
DVMH_INDIRECT,
DVMH_DERIVED,
DVMH_DISTRIBUTE,
DVMH_REDISTR_2,
DVMH_ALIGN,
DVMH_REALIGN_2,
DVMH_HAS_ELEMENT,
CALC_LINEAR,
LOCALIZE,
SHADOW_ADD,
EXPR_IGNORE,
EXPR_CONSTANT,
EXPR_SCAN,
DERIVED_RHS,
ARRAY_SLICE,
COPY_WHOLE,
COPY_ARRAY,
SET_VALUE,
LOOP_CONSISTENT,
DVMH_REMOTE2,
LOOP_REMOTE,
FTN_OPEN,
FTN_CLOSE,
FTN_READ,
FTN_WRITE,
FTN_ENDFILE,
FTN_FLUSH,
FTN_REWIND,
FTN_CONNECTED,
FILL_BOUNDS,
RED_INIT,
RED_POST,
SLOT_COUNT,
HAS_ELEMENT,
HAS_ELEMENT_2,
FILL_LOCAL_PART,
OMP_STAT_BP,
OMP_STAT_AP,
OMP_STAT_BL,
OMP_STAT_AL,
OMP_STAT_BS,
OMP_STAT_AS,
GET_BASE,
GET_BASE_C,
FILL_HEADER,
FILL_HEADER_2,
FILL_HEADER_EX,
FILL_HEADER_EX_2,
DO_CUDA,
RED_CUDA,
RED_CUDA_C,
REGISTER_RED,
RED_INIT_C,
RED_INIT_2,
CUDA_RED_INIT,
CUDA_RED_INIT_2,
RED_PREPARE,
RED_PREPARE_C,
RED_FINISH,
RED_FINISH_C,
SHARED_NEEDED,
GET_DEVICE_ADDR,
GET_DEVICE_ADDR_C,
GET_LOCAL_PART,
GET_LOCAL_PART_C,
GET_DEVICE_NUM,
GET_DEVICE_NUM_2,
GET_OVERALL_STEP,
FILL_BOUNDS_C,
FILL_BOUNDS_2,
RED_POST_C,
RED_POST_2,
CUDA_REPLICATE,
GET_DEP_MASK,
GET_DEP_MASK_2,
GET_DEP_MASK_F,
CUDA_TRANSFORM,
CUDA_AUTOTRANSFORM,
LOOP_AUTOTRANSFORM,
APPLY_OFFSET,
GET_CONFIG,
GET_CONFIG_C,
CHANGE_BOUNDS,
GUESS_INDEX_TYPE,
GUESS_INDEX_TYPE_2,
RTC_SET_LANG,
MAX_LIBFUN_NUM
};

1127
dvm/fdvm/trunk/include/unparse.hpf Normal file
View File

File diff suppressed because it is too large Load Diff

1097
dvm/fdvm/trunk/include/unparse1.hpf Normal file
View File

File diff suppressed because it is too large Load Diff

47
dvm/fdvm/trunk/include/user.h Normal file
View File

@@ -0,0 +1,47 @@
/*********************************************************************/
/* pC++/Sage++ Copyright (C) 1993 */
/* Indiana University University of Oregon University of Rennes */
/*********************************************************************/
#ifndef SAGEXXUSER_H
#define SAGEXXUSER_H 1
#define CPLUS_
#include "macro.h"
#undef CPLUS_
// For C/C++ parser internals
#include "vpc.h"
// For the fortran parser internals
#include "fdvm.h"
// All the "C" functions from the Rennes toolbox
#include "extcxx_low.h"
class SgProject;
class SgFile;
class SgStatement;
class SgExpression;
class SgLabel;
class SgSymbol;
class SgType;
class SgUnaryExp;
class SgClassSymb;
class SgVarDeclStmt;
class SgVarRefExp; /* ajm: I think they should all be here! @$!@ */
// All the externs (from libSage++.C) used in libSage++.h
#include "sage++extern.h"
#define SORRY Message("Sorry, not implemented yet",0)
// Prototype definitions for all the functions in libSage++.C
#include "sage++proto.h"
// dont delete needed in libSage++.h
#define USER
#include "libSage++.h"
#endif /* ndef SAGEXXUSER_H */