diff --git a/src/Makefile b/src/Makefile index 5b78a253..3ab42ae4 100644 --- a/src/Makefile +++ b/src/Makefile @@ -1,10 +1,10 @@ EXPENDABLES_WINDOWS = bin/MainContextj.o bin/ASTHelper.o bin/SymbolTableBuilder.o bin/SymbolTableNew.o bin/y.tab.o bin/lex.yy.o parser/y.tab.c parser/lex.yy.c bin/deviceVarsAnalyser.o bin/analyserUtil.o bin/dv*.o bin/bv*.o -EXPENDABLES = bin/MainContext.o bin/ASTHelper.o bin/SymbolTableBuilder.o bin/SymbolTableNew.o bin/y.tab.o bin/lex.yy.o parser/y.tab.c parser/lex.yy.c bin/deviceVarsAnalyser.o bin/blockVarsAnalyser.o +EXPENDABLES = bin/MainContext.o bin/ASTHelper.o bin/SymbolTableBuilder.o bin/SymbolTableNew.o bin/y.tab.o bin/lex.yy.o parser/y.tab.c parser/lex.yy.c bin/deviceVarsAnalyser.o bin/blockVarsAnalyser.o bin/liveVarsAnalyser.o bin/liveVarsNode.o bin/getUsed.o ANALYSER = bin/dataRaceAnalyser.o PROGRAMS = bin/MainContext.o bin/ASTHelper.o bin/SymbolTableBuilder.o bin/SymbolTableNew.o bin/y.tab.o bin/lex.yy.o bin/cu_dsl_cpp_generator.o bin/ac_dsl_cpp_generator.o bin/om_dsl_cpp_generator.o bin/mpi_dsl_cpp_generator.o bin/om_dyn_dsl_cpp_generator.o bin/mpi_dsl_cpp_generator_helper.o bin/mpi_dsl_cpp_expression_generator.o bin/mpi_dsl_cpp_statement_generator.o bin/mpi_dsl_dyn_cpp_generator.o bin/sycl_dsl_cpp_generator.o bin/multigpu_dsl_cpp_generator.o bin/amd_dsl_cpp_generator.o bin/bAnalyzer.o #bin/ac_dsl_cpp_generator.o #bin/om_dsl_cpp_generator.o -A_PROGRAM = bin/attachPropAnalyser.o bin/dataRaceAnalyser.o bin/deviceVarsAnalyser.o bin/blockVarsAnalyser.o bin/analyserUtil.o bin/pushpullAnalyser.o +A_PROGRAM = bin/attachPropAnalyser.o bin/dataRaceAnalyser.o bin/deviceVarsAnalyser.o bin/blockVarsAnalyser.o bin/analyserUtil.o bin/pushpullAnalyser.o bin/liveVarsAnalyser.o bin/liveVarsNode.o bin/getUsed.o CFLAGS = -g CC = g++ -std=c++11 #-Wall # -Wno-unused-variable #-fsanitize=address @@ -23,6 +23,20 @@ all: starplat #~ starplat_cuda: bin/MainContext.o bin/ASTHelper.o bin/SymbolTableBuilder.o bin/SymbolTableNew.o bin/y.tab.o bin/lex.yy.o $(A_PROGRAM) #~ $(CC) bin/MainContext.o bin/ASTHelper.o bin/SymbolTableBuilder.o bin/SymbolTableNew.o bin/y.tab.o bin/lex.yy.o bin/dsl_cpp_generator.o $(A_PROGRAM) -o starplat +#hip +HIP_PROGRAMS = bin/hip_dsl_cpp_generator.o bin/hip_auxillary.o bin/hip_code_gen.o bin/hip_get_used.o + +bin/hip_dsl_cpp_generator.o: backends/backend_hip/dsl_cpp_generator.cpp backends/dslCodePad.h backends/backend_hip/auxillary_functions.cpp + $(CC) $(CFLAGS) -c backends/backend_hip/dsl_cpp_generator.cpp -o bin/hip_dsl_cpp_generator.o + +bin/hip_auxillary.o: backends/backend_hip/auxillary_functions.cpp backends/dslCodePad.h + $(CC) $(CFLAGS) -c backends/backend_hip/auxillary_functions.cpp -o bin/hip_auxillary.o + +bin/hip_code_gen.o: backends/backend_hip/hip_gen_functions.cpp backends/dslCodePad.h + $(CC) $(CFLAGS) -c backends/backend_hip/hip_gen_functions.cpp -o bin/hip_code_gen.o + +bin/hip_get_used.o: backends/backend_hip/get_used_data.cpp backends/dslCodePad.h + $(CC) $(CFLAGS) -c backends/backend_hip/get_used_data.cpp -o bin/hip_get_used.o #amd bin/amd_dsl_cpp_generator.o: backends/backend_amd/dsl_cpp_generator.cpp backends/dslCodePad.h @@ -66,6 +80,8 @@ bin/bAnalyzer.o : backends/backend_mpi/bAnalyzer/bAnalyzer.h backends/backend_mp $(CC) $(CFLAGS) -c backends/backend_mpi/bAnalyzer/bAnalyzer.cc -o bin/bAnalyzer.o #sycl + + bin/sycl_dsl_cpp_generator.o: backends/backend_sycl/dsl_cpp_generator.cpp backends/dslCodePad.h $(CC) $(CFLAGS) -c backends/backend_sycl/dsl_cpp_generator.cpp -o bin/sycl_dsl_cpp_generator.o @@ -147,9 +163,18 @@ bin/bv5.o: analyser/blockVars/setVarsInParallel.cpp analyser/blockVars/blockVars bin/bv6.o.o: analyser/blockVars/analyserUtil.cpp analyser/blockVars/analyserUtil.h $(CC) $(CFLAGS) -c analyser/blockVars/analyserUtil.cpp -o bin/bv6.o.o -bin/analyserUtil.o: analyser/analyserUtil.cpp +bin/analyserUtil.o: analyser/analyserUtil.cpp analyser/analyserUtil.h ast/ASTNodeTypes.hpp $(CC) $(CFLAGS) -c analyser/analyserUtil.cpp -o bin/analyserUtil.o +bin/liveVarsNode.o: analyser/liveVars/liveVarsNode.cpp analyser/liveVars/liveVarsNode.h + $(CC) $(CFLAGS) -c analyser/liveVars/liveVarsNode.cpp -o bin/liveVarsNode.o + +bin/liveVarsAnalyser.o: analyser/liveVars/liveVarsAnalyser.cpp analyser/liveVars/liveVarsAnalyser.h + $(CC) $(CFLAGS) -c analyser/liveVars/liveVarsAnalyser.cpp -o bin/liveVarsAnalyser.o + +bin/getUsed.o: analyser/liveVars/getUsed.cpp analyser/liveVars/liveVarsAnalyser.h + $(CC) $(CFLAGS) -c analyser/liveVars/getUsed.cpp -o bin/getUsed.o + #bin/dsl_cpp_generator.o: backends/backend_mpi/mpi_cpp_generator.cpp backends/dslCodePad.h # $(CC) -c backends/backend_mpi/mpi_cpp_generator.cpp -o bin/dsl_cpp_generator.o @@ -169,3 +194,31 @@ clean: #~ rm -f $(EXPENDABLES) rm bin/*.o StarPlat rmdir bin + +# HIP SPECIFIC TARGETS + +define generate_hip_code + @./StarPlat -s -f ../graphcode/staticDSLCodes/$(1) -b hip > /dev/null 2>&1 && echo "\033[0;32m$(2) success for $(1)\033[0m" || echo "\033[0;31m$(2) failed for $(1)\033[0m" +endef + +define compile_hip_code + @hipcc ../graphcode/generated_hip/$(1) -c > /dev/null 2>&1 && echo -e "\033[0;32mCompile success for $(1)\033[0m" || echo -e "\033[0;31mCompile failed for $(1)\033[0m" +endef + +define check_hipcc_installation + @which hipcc > /dev/null 2>&1 || (echo "\033[0;31mhipcc is not installed. Please install hipcc to proceed.\033[0m" && exit 1) +endef + + +compile-hip: generate-hip + $(call check_hipcc_installation) + $(call compile_hip_code,sssp_dslV3.cc) + $(call compile_hip_code,triangle_counting_dsl.cc) + $(call compile_hip_code,bc_dslV2.cc) + $(call compile_hip_code,PageRankDSLV3.cc) + +generate-hip: all + $(call generate_hip_code,PageRankDSLV3,CodeGeneration) + $(call generate_hip_code,bc_dslV2,CodeGeneration) + $(call generate_hip_code,sssp_dslV3,CodeGeneration) + $(call generate_hip_code,triangle_counting_dsl,CodeGeneration) diff --git a/src/analyser/Grammar b/src/analyser/Grammar index 4a1914d6..58e60cbb 100644 --- a/src/analyser/Grammar +++ b/src/analyser/Grammar @@ -23,6 +23,8 @@ statement: declaration ';' |control_flow |reduction ';' | bfs_abstraction + | bfs_reverse_abstraction + | bfs_abstraction2 | blockstatements | unary_expr ';' @@ -152,9 +154,15 @@ arg_list : bfs_abstraction : T_BFS '(' id T_IN id '.' proc_call T_FROM id ')' filterExpr blockstatements reverse_abstraction | T_BFS '(' id T_IN id '.' proc_call T_FROM id ')' filterExpr blockstatements +bfs_abstraction2 : T_BFS2 '(' id T_IN id '.' proc_call T_FROM id ')' filterExpr blockstatements reverse_abstraction + | T_BFS2 '(' id T_IN id '.' proc_call T_FROM id ')' filterExpr blockstatements + + reverse_abstraction : T_REVERSE blockstatements | T_REVERSE '(' boolean_expr ')' blockstatements +bfs_reverse_abstraction : T_BFSREVERSE '(' id T_IN id '.' proc_call T_FROM id ')' filterExpr blockstatements + oid : id '.' id tid : id '.' id '.' id diff --git a/src/analyser/analyserUtil.cpp b/src/analyser/analyserUtil.cpp index bab60805..27c8abec 100644 --- a/src/analyser/analyserUtil.cpp +++ b/src/analyser/analyserUtil.cpp @@ -1,437 +1,361 @@ -#ifndef ANALYSER_UTILITY -#define ANALYSER_UTILITY +#include "analyserUtil.h" -#include "../ast/ASTNodeTypes.hpp" -#include -//#include "../symbolutil/SymbolTable.h" - -#define propKey pair - -enum variable_type +void usedVariables::addVariable(Identifier *iden, int type) { - READ = 1, - WRITE, - READ_WRITE, - READ_ONLY, - WRITE_ONLY, - READ_AND_WRITE -}; + if (iden->getSymbolInfo() == NULL) // To not include the iterators in the list + return; + if (type & 1) + readVars.insert({iden->getSymbolInfo(), iden}); + if (type & 2) + writeVars.insert({iden->getSymbolInfo(), iden}); +} -/* -enum depeandancy +void usedVariables::addPropAccess(PropAccess *prop, int type) { - READ_READ, - READ_WRITE, - WRTIE_READ, - WRITE_WRTIE, - ALL_READ, - ALL_WRITE, - READ_ALL, - WRITE_ALL + Identifier *iden1 = prop->getIdentifier1(); + Identifier *iden2 = prop->getIdentifier2(); + propKey prop_key = make_pair(iden1->getSymbolInfo(), iden2->getSymbolInfo()); + + if (type & 1) + readProp.insert({prop_key, prop}); + if (type & 2) + writeProp.insert({prop_key, prop}); } -struct IdentifierWrap +void usedVariables::merge(usedVariables usedVars1) { - string id; - Identifier *iden; - - IdentifierWrap() {} - IdentifierWrap(Identifier *iden) - { - this->id = string(iden->getIdentifier()); - this->iden = iden; - } - bool operator==(const IdentifierWrap &iden) const{ - return (this->id == iden.id); - } - - struct HashFunction - { - size_t operator()(const IdentifierWrap &iden) const{ - return hash()(iden.id); - } - }; -};*/ + for (pair iden : usedVars1.readVars) + this->readVars.insert({iden.first, iden.second}); -class usedVariables -{ -private: - struct hash_pair - { - template - size_t operator()(const pair &p) const - { - auto hash1 = hash{}(p.first); - auto hash2 = hash{}(p.second); - return hash1 ^ hash2; - } - }; + for (pair iden : usedVars1.writeVars) + this->writeVars.insert({iden.first, iden.second}); - unordered_map readVars, writeVars; - unordered_map readProp, writeProp; + for (pair iden : usedVars1.readProp) + this->readProp.insert({iden.first, iden.second}); -public: - usedVariables() {} + for (pair iden : usedVars1.writeProp) + this->writeProp.insert({iden.first, iden.second}); +} - void addVariable(Identifier *iden, int type) +void usedVariables::removeVariable(Identifier *iden, int type) +{ + TableEntry *symbInfo = iden->getSymbolInfo(); + if (type & 1) { - if (iden->getSymbolInfo() == NULL) // To not include the iterators in the list - return; - if (type & 1) - readVars.insert({iden->getSymbolInfo(), iden}); - if (type & 2) - writeVars.insert({iden->getSymbolInfo(), iden}); + if (readVars.find(symbInfo) != readVars.end()) + readVars.erase(symbInfo); } - void addPropAccess(PropAccess *prop, int type) + if (type & 2) { - Identifier *iden1 = prop->getIdentifier1(); - Identifier *iden2 = prop->getIdentifier2(); - propKey prop_key = make_pair(iden1->getSymbolInfo(), iden2->getSymbolInfo()); - - if (type & 1) - readProp.insert({prop_key, prop}); - if (type & 2) - writeProp.insert({prop_key, prop}); + if (writeVars.find(symbInfo) != writeVars.end()) + writeVars.erase(symbInfo); } +} - void merge(usedVariables usedVars1) - { - for (pair iden : usedVars1.readVars) - this->readVars.insert({iden.first, iden.second}); - - for (pair iden : usedVars1.writeVars) - this->writeVars.insert({iden.first, iden.second}); - - for (pair iden : usedVars1.readProp) - this->readProp.insert({iden.first, iden.second}); +bool usedVariables::isUsedVar(Identifier *iden, int type) +{ + TableEntry *symbInfo = iden->getSymbolInfo(); + if (type == READ) + return (readVars.find(symbInfo) != readVars.end()); + else if (type == WRITE) + return (writeVars.find(symbInfo) != writeVars.end()); + else + return ((readVars.find(symbInfo) != readVars.end()) || (writeVars.find(symbInfo) != writeVars.end())); +} - for (pair iden : usedVars1.writeProp) - this->writeProp.insert({iden.first, iden.second}); - } +list usedVariables::getVariables(int type) +{ + list result; - void removeVariable(Identifier *iden, int type) + if (type == READ) { - TableEntry *symbInfo = iden->getSymbolInfo(); - if (type & 1) - { - if (readVars.find(symbInfo) != readVars.end()) - readVars.erase(symbInfo); - } - - if (type & 2) - { - if (writeVars.find(symbInfo) != writeVars.end()) - writeVars.erase(symbInfo); - } + for (pair iden : readVars) + result.push_back(iden.second); } - - bool isUsedVar(Identifier *iden, int type = READ_WRITE) + else if (type == WRITE) { - TableEntry *symbInfo = iden->getSymbolInfo(); - if (type == READ) - return (readVars.find(symbInfo) != readVars.end()); - else if (type == WRITE) - return (writeVars.find(symbInfo) != writeVars.end()); - else - return ((readVars.find(symbInfo) != readVars.end()) || (writeVars.find(symbInfo) != writeVars.end())); + for (pair iden : writeVars) + result.push_back(iden.second); } - - list getVariables(int type = READ_WRITE) + else if(type == READ_WRITE) { - list result; - - if (type == READ) + for (pair iden : readVars) + result.push_back(iden.second); + + for (pair iden : writeVars) { - for (pair iden : readVars) + if(readVars.find(iden.first) == readVars.end()) result.push_back(iden.second); } - else if (type == WRITE) + } + else if(type == READ_AND_WRITE) + { + for (pair iden: writeVars) { - for (pair iden : writeVars) + if(readVars.find(iden.first) != readVars.end()) result.push_back(iden.second); } - else if(type == READ_WRITE) + } + else if(type == READ_ONLY) + { + for (pair iden : readVars) { - for (pair iden : readVars) + if(writeVars.find(iden.first) == writeVars.end()) result.push_back(iden.second); - - for (pair iden : writeVars) - { - if(readVars.find(iden.first) == readVars.end()) - result.push_back(iden.second); - } - } - else if(type == READ_AND_WRITE) - { - for (pair iden: writeVars) - { - if(readVars.find(iden.first) != readVars.end()) - result.push_back(iden.second); - } - } - else if(type == READ_ONLY) - { - for (pair iden : readVars) - { - if(writeVars.find(iden.first) == writeVars.end()) - result.push_back(iden.second); - } } - else if(type == WRITE_ONLY) + } + else if(type == WRITE_ONLY) + { + for (pair iden: writeVars) { - for (pair iden: writeVars) - { - if(readVars.find(iden.first) == readVars.end()) - result.push_back(iden.second); - } + if(readVars.find(iden.first) == readVars.end()) + result.push_back(iden.second); } - return result; } + return result; +} + +bool usedVariables::hasVariables(int type) +{ + if (type == READ) + return (readVars.size() > 0); + else if (type == WRITE) + return (writeVars.size() > 0); + else + return ((writeVars.size() > 0) || (readVars.size() > 0)); +} + +bool usedVariables::isUsedPropAcess(PropAccess *propId, int type) +{ + Identifier *iden1 = propId->getIdentifier1(); + Identifier *iden2 = propId->getIdentifier2(); + propKey prop_key = make_pair(iden1->getSymbolInfo(), iden2->getSymbolInfo()); + + if (type == READ) + return (readProp.find(prop_key) != readProp.end()); + else if (type == WRITE) + return (writeProp.find(prop_key) != writeProp.end()); + else + return ((readProp.find(prop_key) != readProp.end()) || (writeProp.find(prop_key) != writeProp.end())); +} + +bool usedVariables::isUsedProp(PropAccess *propId, int type) +{ + Identifier *iden2 = propId->getIdentifier2(); + TableEntry *symbInfo = iden2->getSymbolInfo(); - bool hasVariables(int type = READ_WRITE) + if (type & 1) { - if (type == READ) - return (readVars.size() > 0); - else if (type == WRITE) - return (writeVars.size() > 0); - else - return ((writeVars.size() > 0) || (readVars.size() > 0)); + for (pair iden : readProp) + if (iden.first.second == symbInfo) + return true; } - - bool isUsedPropAcess(PropAccess *propId, int type = READ_WRITE) + if (type & 2) { - Identifier *iden1 = propId->getIdentifier1(); - Identifier *iden2 = propId->getIdentifier2(); - propKey prop_key = make_pair(iden1->getSymbolInfo(), iden2->getSymbolInfo()); - - if (type == READ) - return (readProp.find(prop_key) != readProp.end()); - else if (type == WRITE) - return (writeProp.find(prop_key) != writeProp.end()); - else - return ((readProp.find(prop_key) != readProp.end()) || (writeProp.find(prop_key) != writeProp.end())); + for (pair iden : writeProp) + if (iden.first.second == symbInfo) + return true; } + return false; +} - bool isUsedProp(PropAccess *propId, int type = READ_WRITE) +list usedVariables::getPropAcess(int type) +{ + list result; + if (type & 1) { - Identifier *iden2 = propId->getIdentifier2(); - TableEntry *symbInfo = iden2->getSymbolInfo(); - - if (type & 1) - { - for (pair iden : readProp) - if (iden.first.second == symbInfo) - return true; - } - if (type & 2) - { - for (pair iden : writeProp) - if (iden.first.second == symbInfo) - return true; - } - return false; + for (pair iden : readProp) + result.push_back(iden.second); } - - list getPropAcess(int type = READ_WRITE) + if (type & 2) { - list result; - if (type & 1) - { - for (pair iden : readProp) - result.push_back(iden.second); - } - if (type & 2) - { - for (pair iden : writeProp) - result.push_back(iden.second); - } - return result; + for (pair iden : writeProp) + result.push_back(iden.second); } + return result; +} - void clear() - { - readVars.clear(); - writeVars.clear(); +void usedVariables::clear() +{ + readVars.clear(); + writeVars.clear(); - readProp.clear(); - writeProp.clear(); - } -}; + readProp.clear(); + writeProp.clear(); +} -class analyserUtils +usedVariables analyserUtils::getVarsExpr(Expression *expr) { -public: - static usedVariables getVarsExpr(Expression *expr) - { - usedVariables result; + usedVariables result; - if (expr->isIdentifierExpr()) - { - Identifier *iden = expr->getId(); - result.addVariable(iden, READ); - } - else if (expr->isPropIdExpr()) - { - PropAccess *propExpr = expr->getPropId(); - result.addPropAccess(propExpr, READ); - } - else if (expr->isUnary()) - { - if (expr->getOperatorType() == OPERATOR_NOT) - result = getVarsExpr(expr->getUnaryExpr()); - else if ((expr->getOperatorType() == OPERATOR_INC) || (expr->getOperatorType() == OPERATOR_DEC)) - { - Expression *uExpr = expr->getUnaryExpr(); - if (uExpr->isIdentifierExpr()) - result.addVariable(uExpr->getId(), READ_WRITE); - else if (uExpr->isPropIdExpr()) - result.addPropAccess(uExpr->getPropId(), READ_WRITE); - } - } - else if (expr->isLogical() || expr->isArithmetic() || expr->isRelational()) + if (expr->isIdentifierExpr()) + { + Identifier *iden = expr->getId(); + result.addVariable(iden, READ); + } + else if (expr->isPropIdExpr()) + { + PropAccess *propExpr = expr->getPropId(); + result.addPropAccess(propExpr, READ); + } + else if (expr->isUnary()) + { + if (expr->getOperatorType() == OPERATOR_NOT) + result = getVarsExpr(expr->getUnaryExpr()); + else if ((expr->getOperatorType() == OPERATOR_INC) || (expr->getOperatorType() == OPERATOR_DEC)) { - result = getVarsExpr(expr->getLeft()); - result.merge(getVarsExpr(expr->getRight())); + Expression *uExpr = expr->getUnaryExpr(); + if (uExpr->isIdentifierExpr()) + result.addVariable(uExpr->getId(), READ_WRITE); + else if (uExpr->isPropIdExpr()) + result.addPropAccess(uExpr->getPropId(), READ_WRITE); } - return result; } -}; - -class printAST -{ - void printTabs() + else if (expr->isLogical() || expr->isArithmetic() || expr->isRelational()) { - int temp = tabSpace; - while (temp--) - cout << '\t'; + result = getVarsExpr(expr->getLeft()); + result.merge(getVarsExpr(expr->getRight())); } + return result; +} -public: - int tabSpace = 0; +void printAST::printTabs() +{ + int temp = tabSpace; + while (temp--) + cout << '\t'; +} - void printFunction(Function *func) - { - printTabs(); - cout << "Function " << string(func->getIdentifier()->getIdentifier()) << '\n'; - tabSpace++; - printBlock(func->getBlockStatement()); - tabSpace--; - } +void printAST::printFunction(Function *func) +{ + printTabs(); + cout << "Function " << string(func->getIdentifier()->getIdentifier()) << '\n'; + tabSpace++; + printBlock(func->getBlockStatement()); + tabSpace--; +} - void printBlock(blockStatement *stmt) - { - printTabs(); - cout << "{\n"; - tabSpace++; +void printAST::printBlock(blockStatement *stmt) +{ + printTabs(); + cout << "{\n"; + tabSpace++; - for (statement *body : stmt->returnStatements()) - printStatement(body); + for (statement *body : stmt->returnStatements()) + printStatement(body); - tabSpace--; - printTabs(); - cout << "}\n"; - } + tabSpace--; + printTabs(); + cout << "}\n"; +} + +void printAST::printStatement(statement *stmt) +{ + if (stmt == nullptr) + return; - void printStatement(statement *stmt) + switch (stmt->getTypeofNode()) { - if (stmt == nullptr) - return; + case NODE_DECL: + printTabs(); + cout << "Declaration\n"; + break; - switch (stmt->getTypeofNode()) - { - case NODE_DECL: - printTabs(); - cout << "Declaration\n"; - break; + case NODE_ASSIGN: + printTabs(); + cout << "Assignment\n"; + break; - case NODE_ASSIGN: - printTabs(); - cout << "Assignment\n"; - break; + case NODE_REDUCTIONCALLSTMT: + printTabs(); + cout << "Reduction\n"; + break; - case NODE_REDUCTIONCALLSTMT: - printTabs(); - cout << "Reduction\n"; - break; + case NODE_PROCCALLSTMT: + printTabs(); + cout << "Procedure Call\n"; + break; - case NODE_PROCCALLSTMT: - printTabs(); - cout << "Procedure Call\n"; - break; + case NODE_UNARYSTMT: + printTabs(); + cout << "Unary statment\n"; + break; - case NODE_UNARYSTMT: - printTabs(); - cout << "Unary statment\n"; - break; + case NODE_BLOCKSTMT: + printBlock((blockStatement *)stmt); + break; - case NODE_BLOCKSTMT: - printBlock((blockStatement *)stmt); - break; + case NODE_WHILESTMT: + printTabs(); + cout << "While\n"; + tabSpace++; + printStatement(((whileStmt *)stmt)->getBody()); + tabSpace--; + break; - case NODE_WHILESTMT: - printTabs(); - cout << "While\n"; - tabSpace++; - printStatement(((whileStmt *)stmt)->getBody()); - tabSpace--; - break; + case NODE_DOWHILESTMT: + printTabs(); + cout << "Do While\n"; + tabSpace++; + printStatement(((dowhileStmt *)stmt)->getBody()); + tabSpace--; + break; - case NODE_DOWHILESTMT: - printTabs(); - cout << "Do While\n"; - tabSpace++; - printStatement(((dowhileStmt *)stmt)->getBody()); - tabSpace--; - break; + case NODE_FORALLSTMT: + printTabs(); + cout << "For all\n"; + tabSpace++; + printStatement(((forallStmt *)stmt)->getBody()); + tabSpace--; + break; - case NODE_FORALLSTMT: - printTabs(); - cout << "For all\n"; - tabSpace++; - printStatement(((forallStmt *)stmt)->getBody()); - tabSpace--; - break; + case NODE_FIXEDPTSTMT: + printTabs(); + cout << "Fixed Point\n"; + tabSpace++; + printStatement(((fixedPointStmt *)stmt)->getBody()); + tabSpace--; + break; - case NODE_FIXEDPTSTMT: - printTabs(); - cout << "Fixed Point\n"; + case NODE_ITRBFS: + printTabs(); + cout << "ITRBFS\n"; + tabSpace++; + printStatement(((iterateBFS *)stmt)->getBody()); + tabSpace--; + if (((iterateBFS *)stmt)->getRBFS()) + { + cout << "ITRBFS Reverse\n"; tabSpace++; - printStatement(((fixedPointStmt *)stmt)->getBody()); + printStatement(((iterateBFS *)stmt)->getRBFS()->getBody()); tabSpace--; - break; + } + break; - case NODE_ITRBFS: + case NODE_IFSTMT: + printTabs(); + cout << "If statment\n"; + tabSpace++; + printStatement(((ifStmt *)stmt)->getIfBody()); + tabSpace--; + if (((ifStmt *)stmt)->getElseBody()) + { printTabs(); - cout << "ITRBFS\n"; + cout << "Else statment\n"; tabSpace++; - printStatement(((iterateBFS *)stmt)->getBody()); + printStatement(((ifStmt *)stmt)->getElseBody()); tabSpace--; - if (((iterateBFS *)stmt)->getRBFS()) - { - cout << "ITRBFS Reverse\n"; - tabSpace++; - printStatement(((iterateBFS *)stmt)->getRBFS()->getBody()); - tabSpace--; - } - break; - - case NODE_IFSTMT: + } + case NODE_ITERBFSREV: + { printTabs(); - cout << "If statment\n"; + cout << "BFS ITER on transpose of the graph\n"; tabSpace++; - printStatement(((ifStmt *)stmt)->getIfBody()); + printStatement(((iterateBFSReverse *)stmt)->getBody()); tabSpace--; - if (((ifStmt *)stmt)->getElseBody()) - { - printTabs(); - cout << "Else statment\n"; - tabSpace++; - printStatement(((ifStmt *)stmt)->getElseBody()); - tabSpace--; - } break; - + } case NODE_TRANSFERSTMT: { varTransferStmt* cstmt = (varTransferStmt*) stmt; @@ -446,9 +370,8 @@ class printAST } default: break; - } } -}; +} /* usedVariables getVarsBlock(statement *inp_stmt) @@ -517,6 +440,4 @@ usedVariables getDeclBlock(statement *inp_stmt) } } return result; -}*/ - -#endif \ No newline at end of file +}*/ \ No newline at end of file diff --git a/src/analyser/attachProp/attachPropAnalyser.cpp b/src/analyser/attachProp/attachPropAnalyser.cpp index ebceafc7..c1af4e60 100644 --- a/src/analyser/attachProp/attachPropAnalyser.cpp +++ b/src/analyser/attachProp/attachPropAnalyser.cpp @@ -4,7 +4,7 @@ #include #include #include -#include "../analyserUtil.cpp" +#include "../analyserUtil.h" #include "../../ast/ASTHelper.cpp" //Stores the statement pointer and the index in it's parent block @@ -362,9 +362,24 @@ void attachPropAnalyser::analyseStatement(statement *stmt) break; } + case NODE_ITRBFS2: + { + analyseStatement(((iterateBFS2 *)stmt)->getBody()); + iterateReverseBFS *revBFS = ((iterateBFS2 *)stmt)->getRBFS(); + if (revBFS != NULL) + analyseStatement(revBFS->getBody()); + break; + } + case NODE_FORALLSTMT: analyseStatement(((forallStmt *)stmt)->getBody()); break; + + case NODE_ITERBFSREV: + { + analyseStatement(((iterateBFSReverse *)stmt)->getBody()); + break; + } } } diff --git a/src/analyser/blockVars/blockVarsAnalyser.cpp b/src/analyser/blockVars/blockVarsAnalyser.cpp index 2ce916d0..bd2e248d 100644 --- a/src/analyser/blockVars/blockVarsAnalyser.cpp +++ b/src/analyser/blockVars/blockVarsAnalyser.cpp @@ -52,6 +52,7 @@ void blockVarsAnalyser::toString(NODETYPE type) case NODE_FIXEDPTSTMT: cout << "NODE_FIXEDPTSTMT"; break; case NODE_IFSTMT: cout << "NODE_IFSTMT"; break; case NODE_ITRBFS: cout << "NODE_ITRBFS"; break; + case NODE_ITRBFS2: cout << "NODE_ITRBFS2"; break; case NODE_ITRRBFS: cout << "NODE_ITRRBFS"; break; case NODE_EXPR: cout << "NODE_EXPR"; break; case NODE_PROCCALLEXPR: cout << "NODE_PROCCALLEXPR"; break; diff --git a/src/analyser/blockVars/blockVarsAnalyser.h b/src/analyser/blockVars/blockVarsAnalyser.h index ebbb59f3..48348e62 100644 --- a/src/analyser/blockVars/blockVarsAnalyser.h +++ b/src/analyser/blockVars/blockVarsAnalyser.h @@ -104,7 +104,9 @@ class blockVarsAnalyser ASTNodeBlock* initProcCall(proc_callStmt*, ASTNodeBlock*); ASTNodeBlock* initReduction(reductionCallStmt*, ASTNodeBlock*); ASTNodeBlock* initItrBFS(iterateBFS*, ASTNodeBlock*); + ASTNodeBlock* initItrBFS2(iterateBFS2*, ASTNodeBlock*); ASTNodeBlock* initItrRBFS(iterateReverseBFS*, ASTNodeBlock*); + ASTNodeBlock* initItrBFSRev(iterateBFSReverse*, ASTNodeBlock*); ASTNodeBlock* initReturn(returnStmt*, ASTNodeBlock*); //Returns the used variables in each statment @@ -121,15 +123,19 @@ class blockVarsAnalyser usedVariables_t getVarsReduction(reductionCallStmt*); usedVariables_t getVarsFixedPoint(fixedPointStmt*); usedVariables_t getVarsBFS(iterateBFS*); + usedVariables_t getVarsBFS2(iterateBFS2*); usedVariables_t getVarsRBFS(iterateReverseBFS*); usedVariables_t getVarsProcCall(proc_callStmt*); usedVariables_t getVarsExprProcCall(proc_callExpr*); + usedVariables_t getVarsBFSRev(iterateBFSReverse*); // Sets the flag of tableentry of the variables in the parallel section of the statement void setVarsInParallelStatment(statement*); void setVarsInParallelBlock(blockStatement*); void setVarsInParallelForAll(forallStmt*); void setVarsInParallelBFS(iterateBFS*); + void setVarsInParallelBFS2(iterateBFS2*); + void setVarsInParallelBFSRev(iterateBFSReverse*); void setVarsInParallelAssign(assignment*); void setVarsInParallelDeclaration(declaration*); void setVarsInParallelProcCall(proc_callStmt*); diff --git a/src/analyser/blockVars/blockVarsInit.cpp b/src/analyser/blockVars/blockVarsInit.cpp index aef60a0f..e77038dc 100644 --- a/src/analyser/blockVars/blockVarsInit.cpp +++ b/src/analyser/blockVars/blockVarsInit.cpp @@ -40,6 +40,10 @@ ASTNodeBlock* blockVarsAnalyser::initStatement(statement* stmt, ASTNodeBlock* bl return initReduction((reductionCallStmt*)stmt, blockNode); case NODE_ITRBFS: return initItrBFS((iterateBFS*)stmt, blockNode); + case NODE_ITRBFS2: + return initItrBFS2((iterateBFS2*)stmt, blockNode); + case NODE_ITERBFSREV: + return initItrBFSRev((iterateBFSReverse*)stmt, blockNode); case NODE_RETURN: return initReturn((returnStmt*)stmt, blockNode); } @@ -372,6 +376,62 @@ ASTNodeBlock* blockVarsAnalyser::initItrBFS(iterateBFS* iterateBFS, ASTNodeBlock return itr_BFS_RBFS_Start; } +ASTNodeBlock* blockVarsAnalyser::initItrBFS2(iterateBFS2* iterateBFS, ASTNodeBlock* blockNode) +{ + // Create a new block node for start and enc block of the iterateBFS + iterateReverseBFS statement + ASTNodeBlock* itr_BFS_RBFS_Start = new ASTNodeBlock(); + ASTNodeBlock* itr_BFS_RBFS_End = new ASTNodeBlock(); + + // Create a new block node for start and end block of the iterateBFS statement + ASTNodeBlock* iterateBFSStartNode = new ASTNodeBlock(); + ASTNodeBlock* iterateBFSEndNode = new ASTNodeBlock(); + + // Add the start of the iterateBFS statement as a succ of the start block + itr_BFS_RBFS_Start->addSucc(iterateBFSStartNode); + + // Create a new block node for the iterateBFS statement + ASTNodeBlock* iterateBFSCondNode = new ASTNodeBlock(iterateBFS->getIteratorNode()); // it acts like a do while loop + + // Add the used and def variables to use set of the new block + /* No used Variables in the condnode */ + + // Add the passed block as succ of the new block + itr_BFS_RBFS_End->addSucc(blockNode); + + // Add the outer end block to the list of block nodes + blockNodes.push_back(itr_BFS_RBFS_End); + + // If RBFS is present, add it as a succ of the iterateBFS end block + if(iterateBFS->getRBFS() != NULL) + iterateBFSEndNode->addSucc(initItrRBFS(iterateBFS->getRBFS(), itr_BFS_RBFS_End)); + else + iterateBFSEndNode->addSucc(itr_BFS_RBFS_End); + blockNodes.push_back(iterateBFSEndNode); + + // Add the iterateBFS end node as a succ of the iterateBFS cond block + iterateBFSCondNode->addSucc(iterateBFSEndNode); + blockNodes.push_back(iterateBFSCondNode); + + // Add the iterateBFS statement as a succ of the iterateBFS start block and cond block + ASTNodeBlock* iterateBFSBodyStartNode = initStatement(iterateBFS->getBody(), iterateBFSCondNode); + iterateBFSCondNode->addSucc(iterateBFSBodyStartNode); + iterateBFSStartNode->addSucc(iterateBFSBodyStartNode); + + // Add the iterateBFS start block to the list of block nodes + blockNodes.push_back(iterateBFSStartNode); + + // Map the iterateBFS statement's start and end block + addBlockNode(iterateBFS->getIteratorNode(), iterateBFSStartNode, iterateBFSEndNode); + + // Add the iterateBFS statement as a succ of the outer start block + itr_BFS_RBFS_Start->addSucc(iterateBFSStartNode); + blockNodes.push_back(itr_BFS_RBFS_Start); + + // Map the outer iterateBFS statement's start and end block + addBlockNode(iterateBFS, itr_BFS_RBFS_Start, itr_BFS_RBFS_End); + return itr_BFS_RBFS_Start; +} + ASTNodeBlock* blockVarsAnalyser::initItrRBFS(iterateReverseBFS* iterateRBFS, ASTNodeBlock* blockNode) { // Create a new block node for start and end block of the iterateReverseBFS statement @@ -409,6 +469,38 @@ ASTNodeBlock* blockVarsAnalyser::initItrRBFS(iterateReverseBFS* iterateRBFS, AST } +ASTNodeBlock* blockVarsAnalyser::initItrBFSRev(iterateBFSReverse* iterateBFSRev, ASTNodeBlock* blockNode) +{ + + // Create a new block node for start and end block of the iterateBFSRev statement + ASTNodeBlock* iterateBFSStartNode = new ASTNodeBlock(); + ASTNodeBlock* iterateBFSEndNode = new ASTNodeBlock(); + + // Create a new block node for the iterateBFS statement + ASTNodeBlock* iterateBFSCondNode = new ASTNodeBlock(iterateBFSRev->getIteratorNode()); // it acts like a do while loop + + // Add the used and def variables to use set of the new block + /* No used Variables in the condnode */ + + blockNodes.push_back(iterateBFSEndNode); + + // Add the iterateBFSRev end node as a succ of the iterateBFSRev cond block + iterateBFSCondNode->addSucc(iterateBFSEndNode); + blockNodes.push_back(iterateBFSCondNode); + + // Add the iterateBFSRev statement as a succ of the iterateBFSRev start block and cond block + ASTNodeBlock* iterateBFSBodyStartNode = initStatement(iterateBFSRev->getBody(), iterateBFSCondNode); + iterateBFSCondNode->addSucc(iterateBFSBodyStartNode); + iterateBFSStartNode->addSucc(iterateBFSBodyStartNode); + + // Add the iterateBFSRev start block to the list of block nodes + blockNodes.push_back(iterateBFSStartNode); + + // Map the iterateBFSRev statement's start and end block + addBlockNode(iterateBFSRev->getIteratorNode(), iterateBFSStartNode, iterateBFSEndNode); + return iterateBFSStartNode; +} + ASTNodeBlock* blockVarsAnalyser::initReturn(returnStmt* returnStmt, ASTNodeBlock* blockNode) { // Create a new block node for the return statement diff --git a/src/analyser/blockVars/getUsedVars.cpp b/src/analyser/blockVars/getUsedVars.cpp index 70949940..64702d6f 100644 --- a/src/analyser/blockVars/getUsedVars.cpp +++ b/src/analyser/blockVars/getUsedVars.cpp @@ -128,6 +128,12 @@ usedVariables_t blockVarsAnalyser::getVarsBFS(iterateBFS *stmt) return currVars; } +usedVariables_t blockVarsAnalyser::getVarsBFS2(iterateBFS2 *stmt) +{ + usedVariables_t currVars = getVarsStatement(stmt->getBody()); + return currVars; +} + usedVariables_t blockVarsAnalyser::getVarsRBFS(iterateReverseBFS *stmt) { usedVariables_t currVars = getVarsStatement(stmt->getBody()); @@ -139,6 +145,12 @@ usedVariables_t blockVarsAnalyser::getVarsRBFS(iterateReverseBFS *stmt) return currVars; } +usedVariables_t blockVarsAnalyser::getVarsBFSRev(iterateBFSReverse *stmt) +{ + usedVariables_t currVars = getVarsStatement(stmt->getBody()); + return currVars; +} + usedVariables_t blockVarsAnalyser::getVarsForAll(forallStmt *stmt) { usedVariables_t currVars = getVarsStatement(stmt->getBody()); @@ -345,6 +357,9 @@ usedVariables_t blockVarsAnalyser::getVarsStatement(statement *stmt) case NODE_ITRBFS: return getVarsBFS((iterateBFS *)stmt); + case NODE_ITRBFS2: + return getVarsBFS2((iterateBFS2 *)stmt); + case NODE_ITRRBFS: return getVarsRBFS((iterateReverseBFS *)stmt); diff --git a/src/analyser/blockVars/setVarsInParallel.cpp b/src/analyser/blockVars/setVarsInParallel.cpp index 594c7779..ec851950 100644 --- a/src/analyser/blockVars/setVarsInParallel.cpp +++ b/src/analyser/blockVars/setVarsInParallel.cpp @@ -20,6 +20,10 @@ void blockVarsAnalyser::setVarsInParallelStatment(statement* stmt) setVarsInParallelFixedPoint((fixedPointStmt*)stmt); break; case NODE_ITRBFS: setVarsInParallelBFS((iterateBFS*)stmt); break; + case NODE_ITRBFS2: + setVarsInParallelBFS2((iterateBFS2*)stmt); break; + case NODE_ITERBFSREV: + setVarsInParallelBFSRev((iterateBFSReverse*)stmt); break; default: break; } @@ -131,6 +135,36 @@ void blockVarsAnalyser::setVarsInParallelBFS(iterateBFS* bfs) usedVars.merge(getVarsExpr(rbfs->getBFSFilter())); } + // Set the flag of the tableentry of the variables in the parallel section + for (auto var: usedVars.getVariables()) + var->getSymbolInfo()->setInParallelSection(true); +} + +void blockVarsAnalyser::setVarsInParallelBFS2(iterateBFS2* bfs) +{ + // get used variables in the BFS body + usedVariables_t usedVars = getVarsStatement(bfs->getBody()); + + // Check if bfs has a reverse bfs attached + if (bfs->getRBFS() != NULL) + { + iterateReverseBFS* rbfs = bfs->getRBFS(); + // get used variables in the reverse BFS body + usedVars.merge(getVarsStatement(rbfs->getBody())); + if (rbfs->getBFSFilter() != NULL) + usedVars.merge(getVarsExpr(rbfs->getBFSFilter())); + } + + // Set the flag of the tableentry of the variables in the parallel section + for (auto var: usedVars.getVariables()) + var->getSymbolInfo()->setInParallelSection(true); +} + +void blockVarsAnalyser::setVarsInParallelBFSRev(iterateBFSReverse* bfs) +{ + // get used variables in the BFS Rev body + usedVariables_t usedVars = getVarsStatement(bfs->getBody()); + // Set the flag of the tableentry of the variables in the parallel section for (auto var: usedVars.getVariables()) var->getSymbolInfo()->setInParallelSection(true); diff --git a/src/analyser/dataRace/dataRaceAnalyser.cpp b/src/analyser/dataRace/dataRaceAnalyser.cpp index f3708eb6..12715f8b 100644 --- a/src/analyser/dataRace/dataRaceAnalyser.cpp +++ b/src/analyser/dataRace/dataRaceAnalyser.cpp @@ -1,5 +1,5 @@ #include "dataRaceAnalyser.h" -#include "../analyserUtil.cpp" +#include "../analyserUtil.h" #include "../../ast/ASTHelper.cpp" #include "../../symbolutil/SymbolTable.h" #include @@ -634,6 +634,15 @@ void dataRaceAnalyser::analyseStatement(statement *stmt) break; } + case NODE_ITRBFS2: + { + analyseStatement(((iterateBFS2 *)stmt)->getBody()); + iterateReverseBFS *revBFS = ((iterateBFS2 *)stmt)->getRBFS(); + if (revBFS != NULL) + analyseStatement(revBFS->getBody()); + break; + } + case NODE_FORALLSTMT: { forallStmt *currStmt = (forallStmt *)stmt; @@ -642,6 +651,12 @@ void dataRaceAnalyser::analyseStatement(statement *stmt) else analyseStatement(currStmt->getBody()); } + + case NODE_ITERBFSREV: + { + analyseStatement(((iterateBFSReverse *)stmt)->getBody()); + break; + } break; } } diff --git a/src/analyser/deviceVars/deviceVarsAnalyser.cpp b/src/analyser/deviceVars/deviceVarsAnalyser.cpp index b50e9537..01374df9 100644 --- a/src/analyser/deviceVars/deviceVarsAnalyser.cpp +++ b/src/analyser/deviceVars/deviceVarsAnalyser.cpp @@ -320,6 +320,50 @@ lattice deviceVarsAnalyser::analyseItrBFS(iterateBFS* stmt, lattice &inMap) return wrapNode->outMap; } +lattice deviceVarsAnalyser::analyseItrBFS2(iterateBFS2* stmt, lattice &inMap) +{ + ASTNodeWrap *wrapNode = getWrapNode(stmt); + wrapNode->inMap = inMap; + + wrapNode->outMap = wrapNode->inMap; + for (Identifier *iden : wrapNode->usedVars.getVariables(READ)){ + wrapNode->outMap.meet(iden, lattice::GPU_READ); + } + for (Identifier *iden : wrapNode->usedVars.getVariables(WRITE)){ + wrapNode->outMap.meet(iden, lattice::GPU_WRITE); + } + + if(stmt->getRBFS() != nullptr) + { + ASTNodeWrap *revNode = getWrapNode(stmt->getRBFS()); + + for (Identifier *iden : revNode->usedVars.getVariables(READ)){ + wrapNode->outMap.meet(iden, lattice::GPU_READ); + } + for (Identifier *iden : revNode->usedVars.getVariables(WRITE)){ + wrapNode->outMap.meet(iden, lattice::GPU_WRITE); + } + } + + return wrapNode->outMap; +} + +lattice deviceVarsAnalyser::analyseItrBFSRev(iterateBFSReverse* stmt, lattice &inMap) +{ + ASTNodeWrap *wrapNode = getWrapNode(stmt); + wrapNode->inMap = inMap; + + wrapNode->outMap = wrapNode->inMap; + for (Identifier *iden : wrapNode->usedVars.getVariables(READ)){ + wrapNode->outMap.meet(iden, lattice::GPU_READ); + } + for (Identifier *iden : wrapNode->usedVars.getVariables(WRITE)){ + wrapNode->outMap.meet(iden, lattice::GPU_WRITE); + } + + return wrapNode->outMap; +} + lattice deviceVarsAnalyser::analyseUnary(unary_stmt *stmt, lattice &inMap) { Expression *unaryVar = stmt->getUnaryExpr()->getUnaryExpr(); @@ -393,6 +437,10 @@ lattice deviceVarsAnalyser::analyseStatement(statement *stmt, lattice &inMap) return analyseReduction((reductionCallStmt *)stmt, inMap); case NODE_ITRBFS: return analyseItrBFS((iterateBFS *)stmt, inMap); + case NODE_ITRBFS2: + return analyseItrBFS2((iterateBFS2 *)stmt, inMap); + case NODE_ITERBFSREV: + return analyseItrBFSRev((iterateBFSReverse *)stmt, inMap); /* case NODE_REDUCTIONCALLSTMT: return analyseReduction((reductionCallStmt *)stmt, inMap); diff --git a/src/analyser/deviceVars/deviceVarsAnalyser.h b/src/analyser/deviceVars/deviceVarsAnalyser.h index d0601226..ebcb2436 100644 --- a/src/analyser/deviceVars/deviceVarsAnalyser.h +++ b/src/analyser/deviceVars/deviceVarsAnalyser.h @@ -4,7 +4,7 @@ #include //#include "../../ast/ASTNodeTypes.hpp" //#include "../../maincontext/MainContext.hpp" -#include "../analyserUtil.cpp" +#include "../analyserUtil.h" #include "../../ast/ASTHelper.cpp" //#include "../../symbolutil/SymbolTable.h" @@ -311,6 +311,8 @@ class deviceVarsAnalyser lattice analyseProcCall(proc_callStmt*, lattice&); lattice analyseReduction(reductionCallStmt*, lattice&); lattice analyseItrBFS(iterateBFS*, lattice&); + lattice analyseItrBFS2(iterateBFS2*, lattice&); + lattice analyseItrBFSRev(iterateBFSReverse*, lattice&); //Initializes ASTNodeWrap for each statment and collects GPU used variables bool initBlock(blockStatement* blockStmt, list &); @@ -327,6 +329,8 @@ class deviceVarsAnalyser bool initProcCall(proc_callStmt*, list &); bool initReduction(reductionCallStmt*, list &); bool initItrBFS(iterateBFS*, list &); + bool initItrBFS2(iterateBFS2*, list &); + bool initItrBFSRev(iterateBFSReverse*, list &); void printStatement(statement* , int); void printBlock(blockStatement* , int); @@ -368,6 +372,8 @@ class deviceVarsAnalyser statement* transferVarsProcCall(proc_callStmt* stmt, blockStatement* parBlock); statement* transferVarsReduction(reductionCallStmt* stmt, blockStatement* parBlock); statement* transferVarsItrBFS(iterateBFS* stmt, blockStatement* parBlock); + statement* transferVarsItrBFS2(iterateBFS2* stmt, blockStatement* parBlock); + statement* transferVarsItrBFSRev(iterateBFSReverse* stmt, blockStatement* parBlock); }; #endif diff --git a/src/analyser/deviceVars/deviceVarsInit.cpp b/src/analyser/deviceVars/deviceVarsInit.cpp index 3017f49c..69a615c9 100644 --- a/src/analyser/deviceVars/deviceVarsInit.cpp +++ b/src/analyser/deviceVars/deviceVarsInit.cpp @@ -60,6 +60,10 @@ bool deviceVarsAnalyser::initStatement(statement *stmt, list &vars return initReduction((reductionCallStmt *)stmt, vars); case NODE_ITRBFS: return initItrBFS((iterateBFS *)stmt, vars); + case NODE_ITRBFS2: + return initItrBFS2((iterateBFS2 *)stmt, vars); + case NODE_ITERBFSREV: + return initItrBFSRev((iterateBFSReverse *)stmt, vars); /*S case NODE_REDUCTIONCALLSTMT: return analyseReduction((reductionCallStmt *)stmt, inMap); @@ -217,5 +221,49 @@ bool deviceVarsAnalyser::initItrBFS(iterateBFS *stmt, list &vars) gpuUsedVars.merge(revNode->usedVars); } + return true; +} + +bool deviceVarsAnalyser::initItrBFS2(iterateBFS2 *stmt, list &vars) +{ + ASTNodeWrap *stmtNode = initWrapNode(stmt, vars); + stmtNode->usedVars = getVarsStatement(stmt->getBody()); + stmtNode->usedVars.removeVariable(stmt->getIteratorNode(), READ_WRITE); + + stmt->initUsedVariable(stmtNode->usedVars.getVariables()); + gpuUsedVars.merge(stmtNode->usedVars); + + if (stmt->getRBFS() != nullptr) + { + iterateReverseBFS *revStmt = stmt->getRBFS(); + ASTNodeWrap *revNode = initWrapNode(revStmt, vars); + + usedVariables bVars = getVarsExpr(revStmt->getBFSFilter()); + for (Identifier *iden : vars) + bVars.removeVariable(iden, READ_WRITE); + + revNode->usedVars = getVarsStatement(revStmt->getBody()); + + if (bVars.getVariables().size() > 0) { + Identifier *itr = bVars.getVariables(READ_WRITE).front(); + revNode->usedVars.removeVariable(itr, READ_WRITE); + } + + revStmt->initUsedVariable(revNode->usedVars.getVariables()); + gpuUsedVars.merge(revNode->usedVars); + } + + return true; +} + +bool deviceVarsAnalyser::initItrBFSRev(iterateBFSReverse *stmt, list &vars) +{ + ASTNodeWrap *stmtNode = initWrapNode(stmt, vars); + stmtNode->usedVars = getVarsStatement(stmt->getBody()); + stmtNode->usedVars.removeVariable(stmt->getIteratorNode(), READ_WRITE); + + stmt->initUsedVariable(stmtNode->usedVars.getVariables()); + gpuUsedVars.merge(stmtNode->usedVars); + return true; } \ No newline at end of file diff --git a/src/analyser/deviceVars/deviceVarsTransfer.cpp b/src/analyser/deviceVars/deviceVarsTransfer.cpp index 839bd5fb..282ad12c 100644 --- a/src/analyser/deviceVars/deviceVarsTransfer.cpp +++ b/src/analyser/deviceVars/deviceVarsTransfer.cpp @@ -70,6 +70,10 @@ statement* deviceVarsAnalyser::transferVarsStatement(statement* stmt, blockState return transferVarsReduction((reductionCallStmt *)stmt, parBlock); case NODE_ITRBFS: return transferVarsItrBFS((iterateBFS *)stmt, parBlock); + case NODE_ITRBFS2: + return transferVarsItrBFS2((iterateBFS2 *)stmt, parBlock); + case NODE_ITERBFSREV: + return transferVarsItrBFSRev((iterateBFSReverse *)stmt, parBlock); } return stmt; @@ -295,6 +299,24 @@ statement* deviceVarsAnalyser::transferVarsReduction(reductionCallStmt* stmt, bl } statement* deviceVarsAnalyser::transferVarsItrBFS(iterateBFS* stmt, blockStatement *parBlock) +{ + ASTNodeWrap* wrapNode = getWrapNode(stmt); + for(statement* bstmt: transferStatements(wrapNode->inMap, wrapNode->outMap)) + parBlock->addStmtToBlock(bstmt); + + return stmt; +} + +statement* deviceVarsAnalyser::transferVarsItrBFS2(iterateBFS2* stmt, blockStatement *parBlock) +{ + ASTNodeWrap* wrapNode = getWrapNode(stmt); + for(statement* bstmt: transferStatements(wrapNode->inMap, wrapNode->outMap)) + parBlock->addStmtToBlock(bstmt); + + return stmt; +} + +statement* deviceVarsAnalyser::transferVarsItrBFSRev(iterateBFSReverse* stmt, blockStatement *parBlock) { ASTNodeWrap* wrapNode = getWrapNode(stmt); for(statement* bstmt: transferStatements(wrapNode->inMap, wrapNode->outMap)) diff --git a/src/analyser/pushpull/pushpullAnalyser.h b/src/analyser/pushpull/pushpullAnalyser.h index ccd71fe8..c537dd21 100644 --- a/src/analyser/pushpull/pushpullAnalyser.h +++ b/src/analyser/pushpull/pushpullAnalyser.h @@ -1,7 +1,7 @@ #ifndef PUSH_PULL_ANALYSER #define PUSH_PULL_ANALYSER -// #include "../analyserUtil.cpp" +// #include "../analyserUtil.h" #include "../../ast/ASTNodeTypes.hpp" class pushpullAnalyser{ diff --git a/src/ast/ASTHelper.cpp b/src/ast/ASTHelper.cpp index be9ee5cd..ebe1934b 100644 --- a/src/ast/ASTHelper.cpp +++ b/src/ast/ASTHelper.cpp @@ -381,6 +381,22 @@ Type* nodeMapNode = Type::createForNodeMapType(typeId, (Type*) elemType); return nodeMapNode; } +static ASTNode* createHashMapTypeNode(int typeId, ASTNode* keyType, list argList, ASTNode* valType){ + +Type* hashmapNode = Type::createForHashMapType(typeId, (Type*) keyType, argList, (Type*) valType); + +return hashmapNode; + +} + +static ASTNode* createHashSetTypeNode(int typeId, ASTNode* keyType, list argList, ASTNode* innerTypeSize){ + +Type* hashsetNode = Type::createForHashSetType(typeId, (Type*) keyType, argList, (Type*) innerTypeSize); + +return hashsetNode; + +} + static ASTNode* createNodeForArithmeticExpr(ASTNode* expr1,ASTNode* expr2,int operatorType) { Expression* arithmeticExprNode=Expression::nodeForArithmeticExpr((Expression*)expr1,(Expression*)expr2,operatorType); @@ -633,6 +649,38 @@ static ASTNode* createIterateInBFSNode(ASTNode* iterator,ASTNode* graphId,ASTNod iterateBFSNode=iterateBFS::nodeForIterateBFS(id1,id2,nodeCall,id3,(Expression*)filterExpr,(statement*)body, NULL); return iterateBFSNode; } + +static ASTNode* createIterateInBFSNode2(ASTNode* iterator,ASTNode* graphId,ASTNode* procCall,ASTNode* rootNode,ASTNode* filterExpr,ASTNode* body,ASTNode* revBFS) +{ + iterateBFS2* iterateBFSNode; + Identifier* id1=(Identifier*)iterator; + Identifier* id2=(Identifier*)graphId; + Identifier* id3=(Identifier*)rootNode; + proc_callExpr* nodeCall = (proc_callExpr*)procCall; + char* methodName = nodeCall->getMethodId()->getIdentifier(); + string methodString(methodName); + assert(methodString.compare("nodes")==0); + printf("Calling createIterateInBFSNode2\n"); + if(revBFS != NULL) + iterateBFSNode=iterateBFS2::nodeForIterateBFS(id1,id2,nodeCall,id3,(Expression*)filterExpr,(statement*)body,(iterateReverseBFS*)revBFS); + else + iterateBFSNode=iterateBFS2::nodeForIterateBFS(id1,id2,nodeCall,id3,(Expression*)filterExpr,(statement*)body, NULL); + return iterateBFSNode; +} + +static ASTNode* createIterateInBFSReverseNode(ASTNode* iterator,ASTNode* graphId,ASTNode* procCall,ASTNode* rootNode,ASTNode* filterExpr,ASTNode* body) +{ + iterateBFSReverse* iterateBFSRevNode; + Identifier* id1=(Identifier*)iterator; + Identifier* id2=(Identifier*)graphId; + Identifier* id3=(Identifier*)rootNode; + proc_callExpr* nodeCall = (proc_callExpr*)procCall; + char* methodName = nodeCall->getMethodId()->getIdentifier(); + string methodString(methodName); + assert(methodString.compare("nodes")==0); + iterateBFSRevNode=iterateBFSReverse::nodeForIterateBFS(id1,id2,nodeCall,id3,(Expression*)filterExpr,(statement*)body); + return iterateBFSRevNode; +} }; diff --git a/src/ast/ASTNode.hpp b/src/ast/ASTNode.hpp index 98bc1ec8..1ebb3d45 100644 --- a/src/ast/ASTNode.hpp +++ b/src/ast/ASTNode.hpp @@ -11,6 +11,8 @@ using namespace std; class NodeBlockData; +class liveVarsNode; + class ASTNode { protected: @@ -20,6 +22,7 @@ class ASTNode SymbolTable* var_symbTab; SymbolTable* prop_symbTab; NodeBlockData* blockData; + liveVarsNode* liveVarData; public: ASTNode() @@ -68,6 +71,16 @@ class ASTNode return blockData; } + void setLiveVarsNode(liveVarsNode* node) + { + this->liveVarData = node; + } + + liveVarsNode* getLiveVarsNode() + { + return liveVarData; + } + }; #endif diff --git a/src/ast/ASTNodeTypes.hpp b/src/ast/ASTNodeTypes.hpp index a253c1c5..2670ec77 100644 --- a/src/ast/ASTNodeTypes.hpp +++ b/src/ast/ASTNodeTypes.hpp @@ -685,6 +685,7 @@ class Type:public ASTNode list graphPropList; list sizeExprList; Type* innerTypeSize; + Type* outerTargetType; public: Type() @@ -693,6 +694,7 @@ class Type:public ASTNode TargetGraph=NULL; innerTargetType=NULL; sourceGraph=NULL; + outerTargetType=NULL; } static Type* createForPrimitive(int typeIdSent,int rootTypeSent) @@ -759,8 +761,30 @@ class Type:public ASTNode type->innerTargetType = innerType; return type; - } + } + + static Type* createForHashMapType(int typeIdSent, Type* keyType, list argList, Type* valType){ + + Type* type=new Type(); + type->typeId=typeIdSent; + type->innerTargetType = keyType; + type->sizeExprList = argList; + type->outerTargetType = valType; + + return type; + } + static Type* createForHashSetType(int typeIdSent, Type* keyType, list argList, Type* innerTypeSize){ + + Type* type=new Type(); + type->typeId=typeIdSent; + type->innerTargetType = keyType; + type->sizeExprList = argList; + type->innerTypeSize = innerTypeSize; + + return type; + } + Type* copy() { Type* copyType = new Type(); @@ -886,6 +910,11 @@ class Type:public ASTNode return sizeExprList; } + + Type* getOuterTargetType() + { + return outerTargetType; + } }; class formalParam:public ASTNode @@ -2108,6 +2137,11 @@ class fixedPointStmt:public statement return nodeCall; } + Expression* getBFSFilter() + { + return filterExpr; + } + void initUsedVariable(list usedVars) { @@ -2840,4 +2874,270 @@ class varTransferStmt: public statement setTypeofNode(NODE_TRANSFERSTMT); } }; + +class iterateBFSReverse:public statement + { private: + Identifier* iterator; + Identifier* rootNode; + Identifier* graphId; + proc_callExpr* nodeCall; + Expression* filterExpr; + statement* body; + + list usedVars; + MetaDataUsed metadata; + std::set modifiedGlobalVars; + + public: + + iterateBFSReverse() + { + iterator=NULL; + graphId=NULL; + nodeCall = NULL; + rootNode=NULL; + filterExpr=NULL; + body=NULL; + statementType="IterateBFSReverse"; + } + + static iterateBFSReverse* nodeForIterateBFS(Identifier* iterator,Identifier* graphId,proc_callExpr* nodeCall,Identifier* rootNode,Expression* filterExpr,statement* body) + { + iterateBFSReverse* new_iterBFSRev=new iterateBFSReverse(); + new_iterBFSRev->iterator=iterator; + new_iterBFSRev->graphId=graphId; + new_iterBFSRev->rootNode=rootNode; + new_iterBFSRev->nodeCall = nodeCall; + new_iterBFSRev->filterExpr=filterExpr; + new_iterBFSRev->body=body; + new_iterBFSRev->setTypeofNode(NODE_ITERBFSREV); + body->setParent(new_iterBFSRev); + return new_iterBFSRev; + } + + Identifier* getRootNode() + { + return rootNode; + } + + Identifier* getIteratorNode() + { + return iterator; + } + + Identifier* getGraphCandidate() + { + return graphId; + } + + statement* getBody() + { + return body; + } + + proc_callExpr* getMethodCall() + { + return nodeCall; + } + + + void initUsedVariable(list usedVars) + { + this->usedVars = usedVars; + } + + bool getIsMetaUsed() { + return metadata.isMetaUsed; + } + + void setIsMetaUsed() { + metadata.isMetaUsed = true; + } + + bool getIsDataUsed() { + return metadata.isDataUsed; + } + + void setIsDataUsed() { + metadata.isDataUsed = true; + } + + bool getIsSrcUsed() { + return metadata.isSrcUsed; + } + + void setIsSrcUsed() { + metadata.isSrcUsed = true; + } + + bool getIsWeightUsed() { + return metadata.isWeightUsed; + } + + void setIsWeightUsed() { + metadata.isWeightUsed = true; + } + + bool getIsRevMetaUsed() { + return metadata.isRevMetaUsed; + } + + void setIsRevMetaUsed() { + metadata.isRevMetaUsed = true; + } + + MetaDataUsed getMetaDataUsed() { + return metadata; + } + + + void pushModifiedGlobalVariable(TableEntry * te) + { + modifiedGlobalVars.insert(te); + } + + std::set getModifiedGlobalVariables() + { + return modifiedGlobalVars; + } + + }; + + class iterateBFS2:public statement + { private: + Identifier* iterator; + Identifier* rootNode; + Identifier* graphId; + proc_callExpr* nodeCall; + Expression* filterExpr; + statement* body; + iterateReverseBFS* revBFS; + + list usedVars; + MetaDataUsed metadata; + std::set modifiedGlobalVars; + + public: + + iterateBFS2() + { + iterator=NULL; + graphId=NULL; + nodeCall = NULL; + rootNode=NULL; + filterExpr=NULL; + body=NULL; + revBFS=NULL; + statementType="IterateInBFS2"; + } + + static iterateBFS2* nodeForIterateBFS(Identifier* iterator,Identifier* graphId,proc_callExpr* nodeCall,Identifier* rootNode,Expression* filterExpr,statement* body,iterateReverseBFS* revBFS) + { + iterateBFS2* new_iterBFS=new iterateBFS2(); + new_iterBFS->iterator=iterator; + new_iterBFS->graphId=graphId; + new_iterBFS->rootNode=rootNode; + new_iterBFS->nodeCall = nodeCall; + new_iterBFS->filterExpr=filterExpr; + new_iterBFS->body=body; + new_iterBFS->revBFS=revBFS; + new_iterBFS->setTypeofNode(NODE_ITRBFS2); + body->setParent(new_iterBFS); + if(revBFS != NULL) + revBFS->setParent(new_iterBFS); + return new_iterBFS; + } + + Identifier* getRootNode() + { + return rootNode; + } + + Identifier* getIteratorNode() + { + return iterator; + } + + Identifier* getGraphCandidate() + { + return graphId; + } + + statement* getBody() + { + return body; + } + + iterateReverseBFS* getRBFS() + { + return revBFS; + } + + proc_callExpr* getMethodCall() + { + return nodeCall; + } + + + void initUsedVariable(list usedVars) + { + this->usedVars = usedVars; + } + + bool getIsMetaUsed() { + return metadata.isMetaUsed; + } + + void setIsMetaUsed() { + metadata.isMetaUsed = true; + } + + bool getIsDataUsed() { + return metadata.isDataUsed; + } + + void setIsDataUsed() { + metadata.isDataUsed = true; + } + + bool getIsSrcUsed() { + return metadata.isSrcUsed; + } + + void setIsSrcUsed() { + metadata.isSrcUsed = true; + } + + bool getIsWeightUsed() { + return metadata.isWeightUsed; + } + + void setIsWeightUsed() { + metadata.isWeightUsed = true; + } + + bool getIsRevMetaUsed() { + return metadata.isRevMetaUsed; + } + + void setIsRevMetaUsed() { + metadata.isRevMetaUsed = true; + } + + MetaDataUsed getMetaDataUsed() { + return metadata; + } + + + void pushModifiedGlobalVariable(TableEntry * te) + { + modifiedGlobalVars.insert(te); + } + + std::set getModifiedGlobalVariables() + { + return modifiedGlobalVars; + } + + }; #endif diff --git a/src/backends/backend_mpi/dsl_cpp_generator_helper.cpp b/src/backends/backend_mpi/dsl_cpp_generator_helper.cpp index d9e5df6d..9a338798 100644 --- a/src/backends/backend_mpi/dsl_cpp_generator_helper.cpp +++ b/src/backends/backend_mpi/dsl_cpp_generator_helper.cpp @@ -39,6 +39,9 @@ namespace spmpi { break; case TYPE_EDGE: cppString = "int"; + break; + case TYPE_AUTOREF: + cppString = "auto&"; break; default: assert(false); @@ -139,6 +142,31 @@ namespace spmpi { vecString = vecString + ">"; cppString = vecString; break; + } + case TYPE_HASHMAP: + { + string vecString = "HashMap<"; + + char* keyType = (char*)convertToCppType(type->getInnerTargetType() , false); + char* valType = (char*)convertToCppType(type->getOuterTargetType() , false); + string keyString = keyType; + string valString = valType; + string innerString = keyString+','+valString; + vecString = vecString + innerString; + vecString = vecString + ">"; + cppString = vecString; + break; + } + case TYPE_HASHSET: + { + string vecString = "HashSet<"; + + char* keyType = (char*)convertToCppType(type->getInnerTargetType() , false); + string innerString = keyType; + vecString = vecString + innerString; + vecString = vecString + ">"; + cppString = vecString; + break; } default: assert(false); diff --git a/src/backends/backend_mpi/dsl_cpp_statement_generator.cpp b/src/backends/backend_mpi/dsl_cpp_statement_generator.cpp index 46eb018c..59010667 100644 --- a/src/backends/backend_mpi/dsl_cpp_statement_generator.cpp +++ b/src/backends/backend_mpi/dsl_cpp_statement_generator.cpp @@ -1233,6 +1233,28 @@ namespace spmpi { main.pushstr_newL(";"); } else if(type->gettypeId() == TYPE_VECTOR) + { + main.pushstr_space(convertToCppType(type)); + main.pushString(decl->getdeclId()->getIdentifier()); + if (decl->isInitialized()) + { + main.pushString(" = "); + generateExpr(decl->getExpressionAssigned()); + } + main.pushstr_newL(";"); + } + else if(type->gettypeId() == TYPE_HASHMAP) + { + main.pushstr_space(convertToCppType(type)); + main.pushString(decl->getdeclId()->getIdentifier()); + if (decl->isInitialized()) + { + main.pushString(" = "); + generateExpr(decl->getExpressionAssigned()); + } + main.pushstr_newL(";"); + } + else if(type->gettypeId() == TYPE_HASHSET) { main.pushstr_space(convertToCppType(type)); main.pushString(decl->getdeclId()->getIdentifier()); diff --git a/src/maincontext/enum_def.hpp b/src/maincontext/enum_def.hpp index 202fb86a..ac2e5142 100644 --- a/src/maincontext/enum_def.hpp +++ b/src/maincontext/enum_def.hpp @@ -23,6 +23,9 @@ enum TYPE TYPE_CONTAINER, TYPE_NODEMAP, TYPE_VECTOR, + TYPE_HASHMAP, + TYPE_HASHSET, + TYPE_AUTOREF, }; inline bool check_isNodeEdgeType(int typeId) @@ -35,7 +38,7 @@ inline bool check_isPropType(int typeId) } inline bool check_isCollectionType(int typeId) { - return ((typeId == TYPE_LIST)||(typeId==TYPE_SETE)||(typeId==TYPE_SETN)||(typeId == TYPE_UPDATES) || (typeId == TYPE_NODEMAP) || (typeId == TYPE_CONTAINER) || (typeId == TYPE_VECTOR)); + return ((typeId == TYPE_LIST)||(typeId==TYPE_SETE)||(typeId==TYPE_SETN)||(typeId == TYPE_UPDATES) || (typeId == TYPE_NODEMAP) || (typeId == TYPE_CONTAINER) || (typeId == TYPE_VECTOR) || (typeId == TYPE_HASHMAP) || (typeId == TYPE_HASHSET)); } inline bool check_isGraphType(int typeId) { @@ -43,7 +46,7 @@ inline bool check_isGraphType(int typeId) } inline bool check_isPrimitiveType(int typeId) { - return ((typeId==TYPE_BOOL)||(typeId==TYPE_DOUBLE)||(typeId==TYPE_FLOAT)||(typeId==TYPE_LONG)||(typeId==TYPE_INT)); + return ((typeId==TYPE_BOOL)||(typeId==TYPE_DOUBLE)||(typeId==TYPE_FLOAT)||(typeId==TYPE_LONG)||(typeId==TYPE_INT)||(typeId==TYPE_AUTOREF)); } inline bool check_isPropNodeType(int typeId) @@ -82,6 +85,18 @@ inline bool check_isNodeMapType(int typeId) return typeId == TYPE_NODEMAP; +} +inline bool check_isHashMapType(int typeId) +{ + + return typeId == TYPE_HASHMAP; + +} +inline bool check_isHashSetType(int typeId) +{ + + return typeId == TYPE_HASHSET; + } enum REDUCE @@ -147,6 +162,7 @@ enum NODETYPE{ NODE_FIXEDPTSTMT, NODE_IFSTMT, NODE_ITRBFS, + NODE_ITRBFS2, NODE_ITRRBFS, NODE_EXPR, NODE_PROCCALLEXPR, @@ -160,6 +176,7 @@ enum NODETYPE{ NODE_ONADDBLOCK, NODE_ONDELETEBLOCK, NODE_TRANSFERSTMT, + NODE_ITERBFSREV }; diff --git a/src/parser/includeHeader.hpp b/src/parser/includeHeader.hpp index f6f85ada..ae48d384 100644 --- a/src/parser/includeHeader.hpp +++ b/src/parser/includeHeader.hpp @@ -37,11 +37,9 @@ /* UNCOMMENT IT TO GENERATE FOR AMD BACKEND */ #include "../backends/backend_amd/dsl_cpp_generator.h" +/* UNCOMMENT IT TO GENERATE FOR HIP BACKEND */ +#include "../backends/backend_hip/dsl_cpp_generator.h" extern "C" int yyparse(void); -// what would this do ?? -// Why call yyparse and pass void into it ? -// Why return int. -// What does "C" mean ? #endif diff --git a/src/parser/lexer.l b/src/parser/lexer.l index 5265bb56..45a895dc 100644 --- a/src/parser/lexer.l +++ b/src/parser/lexer.l @@ -26,6 +26,7 @@ NEGATE [-] "float" {printf("Type: %s", yytext); return T_FLOAT;} "double" {printf("Type: %s", yytext); return T_DOUBLE;} "bool" {printf("Type: %s", yytext); return T_BOOL;} +"auto&" {printf("Type: %s", yytext); return T_AUTOREF;} "forall" {printf("Keyword-forall: %s", yytext); return T_FORALL;} "for" {printf("For: %s", yytext); return T_FOR;} @@ -44,7 +45,9 @@ NEGATE [-] "fixedPoint" {printf("Keyword fixedPoint"); return T_FIXEDPOINT;} "until" {printf("Keyword until"); return T_UNTIL;} "iterateInBFS" {printf("iterateInBFS"); return T_BFS;} +"iterateInBFS2" {printf("iterateInBFS2"); return T_BFS2;} "iterateInReverse" {printf("iterateInReverse"); return T_REVERSE;} +"iterateInBFSReverse" {printf("iterateInBFSReverse"); return T_BFSREVERSE;} "from" {printf("from"); return T_FROM;} "filter" {printf("filter"); return T_FILTER;} "Incremental" {printf("incremental"); return T_INCREMENTAL;} @@ -129,6 +132,8 @@ NEGATE [-] "container" {printf("container type"); return T_CONTAINER;} "std::vector" {printf ("vector type"); return T_VECTOR;} "nodeMap" {printf("nodeMap type"); return T_NODEMAP;} +"hashMap" {printf("hashMap type"); return T_HASHMAP;} +"hashSet" {printf("hashSet type"); return T_HASHSET;} /* Numbers and Identifies */ diff --git a/src/parser/lrparser.y b/src/parser/lrparser.y index dd3ae3bb..8582bb6e 100644 --- a/src/parser/lrparser.y +++ b/src/parser/lrparser.y @@ -1,4 +1,3 @@ -%define parse.trace %{ #include #include @@ -9,7 +8,7 @@ #include "../analyser/dataRace/dataRaceAnalyser.h" #include "../analyser/deviceVars/deviceVarsAnalyser.h" #include "../analyser/pushpull/pushpullAnalyser.h" - + #include "../analyser/liveVars/liveVarsAnalyser.h" #include "../analyser/blockVars/blockVarsAnalyser.h" #include //#include "../symbolutil/SymbolTableBuilder.cpp" @@ -49,18 +48,19 @@ ASTNodeList* nodeList; tempNode* temporary; } -%token T_INT T_FLOAT T_BOOL T_DOUBLE T_LONG +%token T_INT T_FLOAT T_BOOL T_DOUBLE T_LONG T_AUTOREF %token T_FORALL T_FOR T_P_INF T_INF T_N_INF %token T_FUNC T_IF T_ELSE T_WHILE T_RETURN T_DO T_IN T_FIXEDPOINT T_UNTIL T_FILTER %token T_ADD_ASSIGN T_SUB_ASSIGN T_MUL_ASSIGN T_DIV_ASSIGN T_MOD_ASSIGN T_AND_ASSIGN T_XOR_ASSIGN %token T_OR_ASSIGN T_INC_OP T_DEC_OP T_PTR_OP T_AND_OP T_OR_OP T_LE_OP T_GE_OP T_EQ_OP T_NE_OP %token T_AND T_OR T_SUM T_AVG T_COUNT T_PRODUCT T_MAX T_MIN -%token T_GRAPH T_DIR_GRAPH T_NODE T_EDGE T_UPDATES T_CONTAINER T_NODEMAP, T_VECTOR +%token T_GRAPH T_DIR_GRAPH T_NODE T_EDGE T_UPDATES T_CONTAINER T_NODEMAP T_VECTOR T_HASHMAP T_HASHSET %token T_NP T_EP %token T_LIST T_SET_NODES T_SET_EDGES T_FROM -%token T_BFS T_REVERSE +%token T_BFS T_REVERSE T_BFSREVERSE T_BFS2 %token T_INCREMENTAL T_DECREMENTAL T_STATIC T_DYNAMIC %token T_BATCH T_ONADD T_ONDELETE +%token return_func %token ID @@ -72,10 +72,10 @@ %type function_def function_data return_func function_body param %type paramList %type statement blockstatements assignment declaration proc_call control_flow reduction return_stmt batch_blockstmt on_add_blockstmt on_delete_blockstmt -%type type type1 type2 -%type primitive graph collections property container nodemap, vector +%type type type1 type2 type3 +%type primitive graph collections property container nodemap vector hashmap hashset %type id leftSide rhs expression oid val boolean_expr unary_expr indexExpr tid -%type bfs_abstraction filterExpr reverse_abstraction +%type bfs_abstraction filterExpr reverse_abstraction bfs_reverse_abstraction bfs_abstraction2 %type leftList rightList %type iteration_cf selection_cf %type reductionCall @@ -149,6 +149,7 @@ paramList: param {$$=Util::createPList($1);}; type: type1 {$$ = $1;} | type2 {$$ = $1;} + | type3 {$$ = $1;} param : type1 id { //Identifier* id=(Identifier*)Util::createIdentifierNode($2); Type* type=(Type*)$1; @@ -176,22 +177,24 @@ param : type1 id { //Identifier* id=(Identifier*)Util::createIdentifierNode($2) function_body : blockstatements {$$=$1;}; - statements : {}; - | statements statement {printf ("found one statement\n") ; Util::addToBlock($2); }; + | statements statement { Util::addToBlock($2); }; statement: declaration ';'{$$=$1;}; - |assignment ';'{printf ("found an assignment type statement" ); $$=$1;}; - |proc_call ';' {printf ("found an proc call type statement" );$$=Util::createNodeForProcCallStmt($1);}; - |control_flow {printf ("found an control flow type statement" );$$=$1;}; - |reduction ';'{printf ("found an reduction type statement" );$$=$1;}; - | bfs_abstraction {printf ("found bfs\n") ;$$=$1; }; - | blockstatements {printf ("found block\n") ;$$=$1;}; - | unary_expr ';' {printf ("found unary\n") ;$$=Util::createNodeForUnaryStatements($1);}; - | return_stmt ';' {printf ("found return\n") ;$$ = $1 ;}; - | batch_blockstmt {printf ("found batch\n") ;$$ = $1;}; - | on_add_blockstmt {printf ("found on add block\n") ;$$ = $1;}; - | on_delete_blockstmt {printf ("found delete block\n") ;$$ = $1;}; + |assignment ';'{$$=$1;}; + |proc_call ';' {$$=Util::createNodeForProcCallStmt($1);}; + |control_flow {$$=$1;}; + |reduction ';'{$$=$1;}; + | bfs_abstraction {$$=$1; }; + | bfs_abstraction2 {$$=$1; }; + | bfs_reverse_abstraction {$$=$1;}; + | blockstatements {$$=$1;}; + | unary_expr ';' {$$=Util::createNodeForUnaryStatements($1);}; + | return_stmt ';' {$$ = $1 ;}; + | batch_blockstmt {$$ = $1;}; + | on_add_blockstmt {$$ = $1;}; + | on_delete_blockstmt {$$ = $1;}; + blockstatements : block_begin statements block_end { $$=Util::finishBlock();}; @@ -226,6 +229,9 @@ declaration : type1 id { | type2 id '=' rhs {//Identifier* id=(Identifier*)Util::createIdentifierNode($2); $$=Util::createAssignedDeclNode($1,$2,$4);}; + | type3 id '=' rhs {//Identifier* id=(Identifier*)Util::createIdentifierNode($2); + + $$=Util::createAssignedDeclNode($1,$2,$4);}; type1: primitive {$$=$1; }; | graph {$$=$1;}; @@ -237,7 +243,8 @@ primitive: T_INT { $$=Util::createPrimitiveTypeNode(TYPE_INT);}; | T_BOOL { $$=Util::createPrimitiveTypeNode(TYPE_BOOL);}; | T_DOUBLE { $$=Util::createPrimitiveTypeNode(TYPE_DOUBLE); }; | T_LONG {$$=$$=Util::createPrimitiveTypeNode(TYPE_LONG);}; - + +type3: T_AUTOREF { $$=Util::createPrimitiveTypeNode(TYPE_AUTOREF);}; graph : T_GRAPH { $$=Util::createGraphTypeNode(TYPE_GRAPH,NULL);}; |T_DIR_GRAPH {$$=Util::createGraphTypeNode(TYPE_DIRGRAPH,NULL);}; @@ -251,6 +258,8 @@ collections : T_LIST { $$=Util::createCollectionTypeNode(TYPE_LIST,NULL);}; | container {$$ = $1;} | vector {$$ = $1;} | nodemap {$$ = $1;} + | hashmap {$$ = $1;} + | hashset {$$ = $1;} container : T_CONTAINER '<' type '>' '(' arg_list ',' type ')' {$$ = Util::createContainerTypeNode(TYPE_CONTAINER, $3, $6->AList, $8);} | T_CONTAINER '<' type '>' '(' arg_list ')' { $$ = Util::createContainerTypeNode(TYPE_CONTAINER, $3, $6->AList, NULL);} @@ -263,6 +272,12 @@ vector: T_VECTOR'<' type '>' '(' arg_list ',' type ')' {$$ = Util::createContain $$ = Util::createContainerTypeNode(TYPE_VECTOR, $3, argList, NULL);} nodemap : T_NODEMAP '(' type ')' {$$ = Util::createNodeMapTypeNode(TYPE_NODEMAP, $3);} +hashmap : T_HASHMAP '<' type ',' type '>' { list argList; + $$ = Util::createHashMapTypeNode(TYPE_HASHMAP, $3, argList, $5);} + +hashset : T_HASHSET '<' type '>' { list argList; + $$ = Util::createHashSetTypeNode(TYPE_HASHSET, $3, argList, NULL);} + type2 : T_NODE {$$=Util::createNodeEdgeTypeNode(TYPE_NODE) ;}; | T_EDGE {$$=Util::createNodeEdgeTypeNode(TYPE_EDGE);}; | property {$$=$1;}; @@ -453,11 +468,17 @@ bfs_abstraction : T_BFS '(' id T_IN id '.' proc_call T_FROM id ')' filterExpr bl | T_BFS '(' id T_IN id '.' proc_call T_FROM id ')' filterExpr blockstatements {$$=Util::createIterateInBFSNode($3,$5,$7,$9,$11,$12,NULL) ; }; +bfs_abstraction2 : T_BFS2 '(' id T_IN id '.' proc_call T_FROM id ')' filterExpr blockstatements reverse_abstraction{$$=Util::createIterateInBFSNode2($3,$5,$7,$9,$11,$12,$13) ;}; + | T_BFS2 '(' id T_IN id '.' proc_call T_FROM id ')' filterExpr blockstatements {$$=Util::createIterateInBFSNode2($3,$5,$7,$9,$11,$12,NULL) ; }; + reverse_abstraction : T_REVERSE blockstatements {$$=Util::createIterateInReverseBFSNode(NULL,$2);}; | T_REVERSE '(' boolean_expr ')' blockstatements {$$=Util::createIterateInReverseBFSNode($3,$5);}; +bfs_reverse_abstraction : T_BFSREVERSE '(' id T_IN id '.' proc_call T_FROM id ')' filterExpr blockstatements {$$=Util::createIterateInBFSReverseNode($3,$5,$7,$9,$11,$12);}; + + oid : id '.' id { //Identifier* id1=(Identifier*)Util::createIdentifierNode($1); // Identifier* id2=(Identifier*)Util::createIdentifierNode($1); $$ = Util::createPropIdNode($1,$3); @@ -554,12 +575,21 @@ int main(int argc,char **argv) else { - if(!((strcmp(backendTarget,"omp")==0)|| (strcmp(backendTarget,"amd")==0) || (strcmp(backendTarget,"mpi")==0)||(strcmp(backendTarget,"cuda")==0) || (strcmp(backendTarget,"acc")==0) || (strcmp(backendTarget,"sycl")==0)|| (strcmp(backendTarget,"multigpu")==0))) - - { - fprintf(stderr, "Specified backend target is not implemented in the current version!\n"); - exit(-1); + if(!( + (strcmp(backendTarget,"omp")==0) || + (strcmp(backendTarget,"amd")==0) || + (strcmp(backendTarget,"mpi")==0) || + (strcmp(backendTarget,"cuda")==0) || + (strcmp(backendTarget,"acc")==0) || + (strcmp(backendTarget,"sycl")==0) || + (strcmp(backendTarget,"hip")==0) || + (strcmp(backendTarget,"multigpu")==0) + )) { + + fprintf(stderr, "Specified backend target is not implemented in the current version!\n"); + exit(-1); } + } if(!(staticGen || dynamicGen)) { @@ -634,6 +664,10 @@ int main(int argc,char **argv) spomp::dsl_cpp_generator cpp_backend; std::cout<< "size:" << frontEndContext.getFuncList().size() << '\n'; cpp_backend.setFileName(fileName); + if(optimize) { + liveVarsAnalyser liveness; + liveness.analyse(frontEndContext.getFuncList()); + } cpp_backend.generate(); } else if (strcmp(backendTarget, "mpi") == 0) { @@ -671,7 +705,18 @@ int main(int argc,char **argv) cpp_backend.setFileName(fileName); cpp_backend.generate(); } - else + else if(strcmp(backendTarget, "hip") == 0) { + + std::cout << "Generating HIP Code\n"; + + const unsigned blockSize = 512; + //TODO: This block size can be a command line parameter. + // Hence the assertion. + assert(blockSize > 0 && blockSize <= 1024); + + sphip::DslCppGenerator hip_backend(fileName, blockSize); + hip_backend.Generate(); + } else std::cout<< "invalid backend" << '\n'; } else diff --git a/src/symbolutil/SymbolTableBuilder.cpp b/src/symbolutil/SymbolTableBuilder.cpp index a06ed0dc..24c523a8 100644 --- a/src/symbolutil/SymbolTableBuilder.cpp +++ b/src/symbolutil/SymbolTableBuilder.cpp @@ -45,10 +45,8 @@ bool search_and_connect_toId(SymbolTable *sTab, Identifier *id) TableEntry *tableEntry = sTab->findEntryInST(id); if (tableEntry == NULL) { - // May cause sincere crashes. Request to document the entire symbol table. - // Type *typeNode = Type::createForPrimitive(TYPE_INT, 1); - // TableEntry newTableEntry (id, typeNode) ; - return false ; + return false; + // to be added. } if (id->getSymbolInfo() != NULL) { @@ -284,7 +282,7 @@ void SymbolTableBuilder::buildForStatements(statement *stmt) checkForExpressions(expr); } - if (( backend.compare("amd") == 0 || backend.compare("cuda") == 0 || (backend.compare("sycl") == 0) || (backend.compare("multigpu") == 0)) && assign->lhs_isProp()) + if (( backend.compare("amd") == 0 || backend.compare("cuda") == 0 || (backend.compare("sycl") == 0) || (backend.compare("multigpu") == 0) || (backend.compare("hip") == 0)) && assign->lhs_isProp()) { // This flags device assingments OUTSIDE for //~ std::cout<< "varName1: " << assign->getPropId()->getIdentifier1()->getIdentifier() << '\n'; //~ std::cout<< "varName2: " << assign->getPropId()->getIdentifier2()->getIdentifier() << '\n'; @@ -366,6 +364,15 @@ void SymbolTableBuilder::buildForStatements(statement *stmt) PropAccess *propId = forAll->isSourceField() ? forAll->getPropSource() : NULL; Identifier *iterator = forAll->getIterator(); + + bool createsFine = create_Symbol(currVarSymbT, iterator, new Type()); + /* + Here we are passing an empty instance of type + This works fine but if proper type is required, + Either create a new type for the iterator in forALL + Or infer the type?? + */ + searchSuccess = checkHeaderSymbols(source1, propId, forAll); if (forAll->isSourceExpr()) @@ -385,7 +392,7 @@ void SymbolTableBuilder::buildForStatements(statement *stmt) another forall which is to be generated with omp parallel pragma, and then disable the parallel loop*/ - if ((backend.compare("omp") == 0) || (backend.compare("amd") == 0) || (backend.compare("cuda") == 0) || (backend.compare("multigpu") == 0)|| (backend.compare("acc") == 0) || (backend.compare("mpi") == 0) || (backend.compare("sycl") == 0)) + if ((backend.compare("omp") == 0) || (backend.compare("amd") == 0) || (backend.compare("cuda") == 0) || (backend.compare("multigpu") == 0)|| (backend.compare("acc") == 0) || (backend.compare("mpi") == 0) || (backend.compare("sycl") == 0) || (backend.compare("hip") == 0)) { if (parallelConstruct.size() > 0) { @@ -403,7 +410,7 @@ void SymbolTableBuilder::buildForStatements(statement *stmt) } } - if ((backend.compare("amd") == 0) || backend.compare("cuda") == 0 || (backend.compare("sycl") == 0) || (backend.compare("multigpu") == 0)) + if ((backend.compare("amd") == 0) || backend.compare("cuda") == 0 || (backend.compare("sycl") == 0) || (backend.compare("multigpu") == 0) || (backend.compare("hip") == 0)) { // This flags device assingments INSIDE for std::cout << "FORALL par NAME1:" << forAll->getParent()->getTypeofNode() << '\n'; if (forAll->getParent()->getParent()) @@ -435,6 +442,15 @@ void SymbolTableBuilder::buildForStatements(statement *stmt) { string methodString(extractElem->getMethodId()->getIdentifier()); list argList = extractElem->getArgList(); + list::iterator itr; + for (itr = argList.begin(); itr != argList.end(); itr++) + { + argument *arg = (*itr); + if (arg->isAssignExpr()) + buildForStatements(arg->getAssignExpr()); + else + checkForExpressions(arg->getExpr()); + } if (methodString == nbrCall) { forAll->addAtomicSignalToStatements(); @@ -487,7 +503,7 @@ void SymbolTableBuilder::buildForStatements(statement *stmt) //~ delete_curr_SymbolTable(); - if ((backend.compare("omp") == 0 || backend.compare("amd") == 0 || backend.compare("cuda") == 0 || (backend.compare("multigpu") == 0)|| backend.compare("acc") == 0 || backend.compare("mpi") == 0 || (backend.compare("sycl") == 0)) && forAll->isForall()) + if ((backend.compare("omp") == 0 || backend.compare("amd") == 0 || backend.compare("cuda") == 0 || (backend.compare("multigpu") == 0)|| backend.compare("acc") == 0 || backend.compare("mpi") == 0 || (backend.compare("sycl") == 0) || (backend.compare("hip") == 0)) && forAll->isForall()) { if (forAll->isForall()) { @@ -647,10 +663,6 @@ void SymbolTableBuilder::buildForStatements(statement *stmt) forAll->push_reduction(reducStmt->reduction_op(), reducStmt->getLeftId()); } } - else if (reducStmt->isContainerReduc()) - { - printf ("Skipped symbol table entry for container reduction\n") ; - } else { findSymbolPropId(reducStmt->getPropAccess()); @@ -662,9 +674,59 @@ void SymbolTableBuilder::buildForStatements(statement *stmt) case NODE_ITRBFS: { iterateBFS *iBFS = (iterateBFS *)stmt; + + Identifier *rootNode = iBFS->getRootNode(); + findSymbolId(rootNode); + Identifier *graphId = iBFS->getGraphCandidate(); + findSymbolId(graphId); + + Identifier* iterator = iBFS->getIteratorNode(); + bool createsFine = create_Symbol(currVarSymbT, iterator, new Type()); + /* + Here we are passing an empty instance of type + This works fine but if proper type is required, + Either create a new type for the iterator in forALL + Or infer the type?? + */ + + string backend(backendTarget); + + if ((backend.compare("omp") == 0) || (backend.compare("amd") == 0) || (backend.compare("cuda") == 0) || (backend.compare("multigpu") == 0)|| (backend.compare("acc") == 0) || (backend.compare("mpi") == 0) || (backend.compare("sycl") == 0) || (backend.compare("hip") == 0)) + + { + parallelConstruct.push_back(iBFS); + } + + currentFunc->setIsMetaUsed(); // d_meta is used in itrbfs + iBFS->setIsMetaUsed(); // d_meta is used in itrbfs + currentFunc->setIsDataUsed(); // d_data is used in itrbfs + iBFS->setIsDataUsed(); // d_data is used in itrbfs + currentFunc->setIsWeightUsed(); // d_weight is used in itrbfs + iBFS->setIsWeightUsed(); // d_weight is used in itrbfs + + buildForStatements(iBFS->getBody()); + + iterateReverseBFS *iRevBFS = iBFS->getRBFS(); + if (iRevBFS != NULL) + { + iRevBFS->addAccumulateAssignment(); + buildForStatements(iRevBFS->getBody()); + } + if ((backend.compare("omp") == 0) || (backend.compare("amd") == 0) || (backend.compare("cuda") == 0) || (backend.compare("multigpu") == 0)|| (backend.compare("acc") == 0) || (backend.compare("mpi") == 0) || (backend.compare("sycl") == 0) || (backend.compare("hip") == 0)) + + { + parallelConstruct.pop_back(); + } + + break; + } + + case NODE_ITRBFS2: + { + iterateBFS2 *iBFS = (iterateBFS2 *)stmt; string backend(backendTarget); - if ((backend.compare("omp") == 0) || (backend.compare("amd") == 0) || (backend.compare("cuda") == 0) || (backend.compare("multigpu") == 0)|| (backend.compare("acc") == 0) || (backend.compare("mpi") == 0) || (backend.compare("sycl") == 0)) + if ((backend.compare("omp") == 0) || (backend.compare("amd") == 0) || (backend.compare("cuda") == 0) || (backend.compare("multigpu") == 0)|| (backend.compare("acc") == 0) || (backend.compare("mpi") == 0) || (backend.compare("sycl") == 0) || (backend.compare("hip") == 0)) { parallelConstruct.push_back(iBFS); @@ -685,14 +747,43 @@ void SymbolTableBuilder::buildForStatements(statement *stmt) iRevBFS->addAccumulateAssignment(); buildForStatements(iRevBFS->getBody()); } - if ((backend.compare("omp") == 0) || (backend.compare("amd") == 0) || (backend.compare("cuda") == 0) || (backend.compare("multigpu") == 0)|| (backend.compare("acc") == 0) || (backend.compare("mpi") == 0) || (backend.compare("sycl") == 0)) + if ((backend.compare("omp") == 0) || (backend.compare("amd") == 0) || (backend.compare("cuda") == 0) || (backend.compare("multigpu") == 0)|| (backend.compare("acc") == 0) || (backend.compare("mpi") == 0) || (backend.compare("sycl") == 0) || (backend.compare("hip") == 0)) + + { + parallelConstruct.pop_back(); + } + + break; + } + + case NODE_ITERBFSREV: + { + iterateBFSReverse *iBFS = (iterateBFSReverse *)stmt; + string backend(backendTarget); + + if ((backend.compare("omp") == 0) || (backend.compare("amd") == 0) || (backend.compare("cuda") == 0) || (backend.compare("multigpu") == 0)|| (backend.compare("acc") == 0) || (backend.compare("mpi") == 0) || (backend.compare("sycl") == 0) || (backend.compare("hip") == 0)) + + { + parallelConstruct.push_back(iBFS); + } + currentFunc->setIsMetaUsed(); // d_meta is used in itrbfsrev + iBFS->setIsMetaUsed(); // d_meta is used in itrbfsrev + currentFunc->setIsDataUsed(); // d_data is used in itrbfsrev + iBFS->setIsDataUsed(); // d_data is used in itrbfsrev + currentFunc->setIsWeightUsed(); // d_weight is used in itrbfsrev + iBFS->setIsWeightUsed(); // d_weight is used in itrbfsrev + + buildForStatements(iBFS->getBody()); + + if ((backend.compare("omp") == 0) || (backend.compare("amd") == 0) || (backend.compare("cuda") == 0) || (backend.compare("multigpu") == 0)|| (backend.compare("acc") == 0) || (backend.compare("mpi") == 0) || (backend.compare("sycl") == 0) || (backend.compare("hip") == 0)) { parallelConstruct.pop_back(); } break; } + case NODE_DOWHILESTMT: { dowhileStmt *doStmt = (dowhileStmt *)stmt; @@ -741,6 +832,12 @@ void SymbolTableBuilder::buildForStatements(statement *stmt) preprocessEnv = NULL; break; } + case NODE_UNARYSTMT: + { + unary_stmt* unaryStmt = (unary_stmt*)stmt; + checkForExpressions(unaryStmt->getUnaryExpr()); + break; + } } }