diff --git a/CMakeLists.txt b/CMakeLists.txt index 5b0e020..0a7f8ee 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -331,7 +331,9 @@ set(MAIN src/Sapfor.cpp src/Utils/PassManager.h) set(PREDICTOR src/Predictor/PredictScheme.cpp - src/Predictor/PredictScheme.h) + src/Predictor/PredictScheme.h + src/Predictor/PredictSchemeWithLibrary.cpp + src/Predictor/PredictSchemeWithLibrary.h) set(LIBPREDICTOR ${libpred_sources}/cluster.cpp ${libpred_sources}/predictor.cpp diff --git a/src/DirectiveProcessing/directive_creator_base.cpp b/src/DirectiveProcessing/directive_creator_base.cpp index 5138de2..6d6dae5 100644 --- a/src/DirectiveProcessing/directive_creator_base.cpp +++ b/src/DirectiveProcessing/directive_creator_base.cpp @@ -122,6 +122,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai if (found == false) { directive->shadowRenew.push_back(make_pair(key, vector>())); + directive->shadowRenewCorner.push_back(false); const DIST::Array *arrayRef = read; for (int i = 0; i < arrayRef->GetDimSize(); ++i) diff --git a/src/Distribution/DvmhDirective.cpp b/src/Distribution/DvmhDirective.cpp index 421eea8..fa4f1a8 100644 --- a/src/Distribution/DvmhDirective.cpp +++ b/src/Distribution/DvmhDirective.cpp @@ -857,6 +857,11 @@ ParallelDirective::genDirective(File* file, const vectoraddSubscript(*elem); - if (shadowRenew[i1].second.size() > 1 && needCorner(shadowArray, shiftsByAccess, loop)) + bool needCornerFlag = shadowRenew[i1].second.size() > 1 && needCorner(shadowArray, shiftsByAccess, loop); + shadowRenewCorner[i1] = needCornerFlag; + + if (needCornerFlag) { SgExpression* tmp = new SgExpression(ARRAY_OP, newArrayRef, NULL, NULL); p->setLhs(*tmp); diff --git a/src/Distribution/DvmhDirective.h b/src/Distribution/DvmhDirective.h index 0d1b7e0..5d135bb 100644 --- a/src/Distribution/DvmhDirective.h +++ b/src/Distribution/DvmhDirective.h @@ -102,6 +102,7 @@ public: // origin_Name uniqName bounds std::vector, std::vector>>> shadowRenew; std::vector>> shadowRenewShifts; + std::vector shadowRenewCorner; // origin_Name uniqName bounds std::vector, std::vector>>> across; @@ -125,6 +126,7 @@ public: privates = copyFrom.privates; shadowRenew = copyFrom.shadowRenew; shadowRenewShifts = copyFrom.shadowRenewShifts; + shadowRenewCorner = copyFrom.shadowRenewCorner; across = copyFrom.across; acrossShifts = copyFrom.acrossShifts; remoteAccess = copyFrom.remoteAccess; @@ -151,6 +153,7 @@ public: on.clear(); privates.clear(); shadowRenew.clear(); + shadowRenewCorner.clear(); across.clear(); acrossShifts.clear(); reduction.clear(); diff --git a/src/Predictor/PredictScheme.cpp b/src/Predictor/PredictScheme.cpp index 11fb9a9..6d0f959 100644 --- a/src/Predictor/PredictScheme.cpp +++ b/src/Predictor/PredictScheme.cpp @@ -23,6 +23,7 @@ #include "expr_transform.h" #include "../LoopAnalyzer/loop_analyzer.h" #include "CFGraph/CFGraph.h" +#include "../Utils/utils.h" #include "json.hpp" @@ -36,6 +37,109 @@ using std::tuple; using json = nlohmann::json; +void runPredictSchemeOld(SgProject &project, + vector> &topologies, + vector ¶llelRegions, + map> loopGraph, + map> intervals, + map> &SPF_messages) +{ + int maxSizeDist = 0; + for (int z = 0; z < parallelRegions.size(); ++z) + { + const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir(); + const vector ¤tVariant = parallelRegions[z]->GetCurrentVariant(); + + auto &tmp = dataDirectives.distrRules; + vector> currentVar; + for (int z1 = 0; z1 < currentVariant.size(); ++z1) + currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]])); + + for (auto &elem : currentVar) + { + DIST::Array *array = elem.first; + const DistrVariant *var = elem.second; + + int countBlock = 0; + for (int z = 0; z < var->distRule.size(); ++z) + if (var->distRule[z] == dist::BLOCK) + ++countBlock; + maxSizeDist = std::max(maxSizeDist, countBlock); + } + } + + SpfInterval *mainIterval = getMainInterval(&project, intervals, SPF_messages); + topologies.clear(); + if (maxSizeDist) + { + const int procNum = 8; + //TODO: + //topologies = getTopologies(procNum, maxSizeDist); + throw -10; + + const int countOfTop = topologies.size(); + if (countOfTop < 0) + printInternalError(convertFileName(__FILE__).c_str(), __LINE__); + + for (auto &inter : intervals) + initTimeForIntervalTree(countOfTop, inter.second); + + for (int z = 0; z < parallelRegions.size(); ++z) + { + const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir(); + const vector ¤tVariant = parallelRegions[z]->GetCurrentVariant(); + DIST::Arrays &allArrays = parallelRegions[z]->GetAllArraysToModify(); + + auto &tmp = dataDirectives.distrRules; + vector> currentVar; + for (int z1 = 0; z1 < currentVariant.size(); ++z1) + currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]])); + + map parallelDirs; + vector, pair>> allSingleRemotes; + for (int i = project.numberOfFiles() - 1; i >= 0; --i) + { + SgFile *file = &(project.file(i)); + auto fountInfo = findAllDirectives(file, getObjectForFileFromMap(file->filename(), loopGraph), parallelRegions[z]->GetId()); + parallelDirs.insert(fountInfo.begin(), fountInfo.end()); + + auto fountRem = findAllSingleRemotes(file, parallelRegions[z]->GetId(), parallelRegions); + allSingleRemotes.insert(allSingleRemotes.end(), fountRem.begin(), fountRem.end()); + } + //TODO! + //int err = predictScheme(parallelRegions[z], currentVar, allArrays.GetArrays(), parallelDirs, intervals, SPF_messages, allSingleRemotes, maxSizeDist, procNum); + /*if (err != 0) + internalExit = err;*/ + } + + vector tmp = { mainIterval }; + aggregatePredictedTimes(tmp); + + int idx = 0; + int best = -1; + double bestSpeedUp = 0; + for (auto &top : topologies) + { + string outStr = ""; + for (auto &elem : top) + outStr += std::to_string(elem) + " "; + double currS = mainIterval->exec_time / mainIterval->predictedTimes[idx]; + __spf_print(1, "%d: speed up %f for top. %s\n", idx, currS, outStr.c_str()); + + if (best == -1 || bestSpeedUp < currS) + { + bestSpeedUp = currS; + best = idx; + } + ++idx; + } + __spf_print(1, "best topology %d with speed up %f\n", best, bestSpeedUp); + } + else + for (auto &inter : intervals) + initTimeForIntervalTree(0, inter.second); +} + static void fillParallel(SgExpression *exp, ParallelStats &parStats, int &totalScoreComm) { if (exp) diff --git a/src/Predictor/PredictScheme.h b/src/Predictor/PredictScheme.h index a9c91f2..5af4df2 100644 --- a/src/Predictor/PredictScheme.h +++ b/src/Predictor/PredictScheme.h @@ -60,4 +60,6 @@ public: void processFileToPredict(SgFile *file, PredictorStats &predictorCounts); void calculateStatsForPredictor(const std::map>& allFuncInfo, const std::map>& gCovInfo); -void parseDvmDirForPredictor(const std::map, std::pair>& declaredArrays, const std::map& commonBlocks, const std::map>& allFuncInfo, const std::map>& gCovInfo); \ No newline at end of file +void parseDvmDirForPredictor(const std::map, std::pair>& declaredArrays, const std::map& commonBlocks, const std::map>& allFuncInfo, const std::map>& gCovInfo); + +void runPredictSchemeOld(SgProject &project, std::vector> &topologies, std::vector ¶llelRegions, std::map> loopGraph, std::map> intervals, std::map> &SPF_messages); diff --git a/src/Predictor/PredictSchemeWithLibrary.cpp b/src/Predictor/PredictSchemeWithLibrary.cpp new file mode 100644 index 0000000..429dfec --- /dev/null +++ b/src/Predictor/PredictSchemeWithLibrary.cpp @@ -0,0 +1,306 @@ +#include "leak_detector.h" + +#include +#include +#include +#include +#include + +#include "dvm.h" +#include "PredictSchemeWithLibrary.h" +#include "../../projects/libpredictor/include/libpredict/predictor.h" +#include "../DirectiveProcessing/directive_parser.h" +#include "../Distribution/DvmhDirective.h" +#include "../ParallelizationRegions/ParRegions.h" +#include "../GraphLoop/graph_loops_func.h" +#include "../Utils/errors.h" +#include "../Utils/utils.h" + +using std::map; +using std::string; +using std::vector; +using std::pair; +using std::tuple; + +// МОЖЕТ КАК-ТО ВЫЧИСЛЯТЬ ДИРЕКТИВЫ, А ПОТОМ ДЕЛАТЬ ПРОГОНЫ? +double runLibpredictCalc(SgProject &project, + vector topology, + string clusterConfStr, + vector ¶llelRegions, + map> loopGraph, + map> &SPF_messages) +{ + libpredict::RetInit retInit = libpredict::Init(clusterConfStr, topology[0], topology[1], topology[2], topology[3]); + + if (retInit != libpredict::INIT_SUCCESS) { + __spf_print(1, "ERROR: Failed to initialize libpredict with cluster config: %s, return code: %d\n", clusterConfStr.c_str(), (int)retInit); + + std::wstring messageR, messageE; + __spf_printToLongBuf(messageE, L"Failed to initialize libpredict library with cluster config: %s, return code: %d", + to_wstring(clusterConfStr).c_str(), (int)retInit); + __spf_printToLongBuf(messageR, R206); + getObjectForFileFromMap(clusterConfStr.c_str(), SPF_messages).push_back(Messages(ERROR, 1, messageR, messageE, 1063)); + return -1; + } + + // distribute и align из parallelRegions + for (int z = 0; z < parallelRegions.size(); ++z) { + const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir(); + const vector ¤tVariant = parallelRegions[z]->GetCurrentVariant(); + DIST::Arrays &allArrays = parallelRegions[z]->GetAllArraysToModify(); + + auto &tmp = dataDirectives.distrRules; + vector> currentVar; + for (int z1 = 0; z1 < currentVariant.size(); ++z1) + currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]])); + + // distribute + for (const auto& distrRule : currentVar) { + DIST::Array* array = distrRule.first; + const DistrVariant* variant = distrRule.second; + + if (array && variant && !array->IsNotDistribute()) { + size_t arrayId = array->GetId(); + size_t elemSize = array->GetTypeSize(); + + vector axisDistributions; + const auto& arraySizes = array->GetSizes(); + for (int dim = 0; dim < array->GetDimSize(); ++dim) { + size_t dimSize = arraySizes[dim].second - arraySizes[dim].first + 1; + + if (dim < variant->distRule.size() && variant->distRule[dim] == dist::BLOCK) { + axisDistributions.emplace_back(dimSize, libpredict::TypeDistribute::BLOCK); + } else { + axisDistributions.emplace_back(dimSize, libpredict::TypeDistribute::NONE); + } + } + + vector> shadowEdges; + const auto& shadowSpec = array->GetShadowSpec(); + for (int dim = 0; dim < shadowSpec.size() && dim < array->GetDimSize(); ++dim) { + if (dim < variant->distRule.size() && variant->distRule[dim] == dist::BLOCK) { + shadowEdges.emplace_back(shadowSpec[dim].first, shadowSpec[dim].second); + } + } + + libpredict::RetDistribute retDistribute = libpredict::Distribute(arrayId, elemSize, axisDistributions, shadowEdges); + + if (retDistribute != libpredict::DISTRIBUTE_SUCCESS) { + __spf_print(1, "ERROR: Failed to distribute array '%s' (id=%zu) with libpredict, return code: %d\n", + array->GetShortName().c_str(), arrayId, (int)retDistribute); + + std::wstring messageR, messageE; + __spf_printToLongBuf(messageE, L"Failed to distribute array '%s' with libpredict, return code: %d", + to_wstring(array->GetShortName()).c_str(), (int)retDistribute); + __spf_printToLongBuf(messageR, R207); + getObjectForFileFromMap(array->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back( + Messages(ERROR, array->GetDeclInfo().begin()->second, messageR, messageE, 1064)); + } + } + } + + // align + for (const auto& alignRule : dataDirectives.alignRules) { + DIST::Array* alignArray = alignRule.alignArray; + DIST::Array* alignWithArray = alignRule.alignWith; + + if (alignArray && alignWithArray && !alignArray->IsNotDistribute()) { + size_t arrayId = alignArray->GetId(); + size_t distributedArrayId = alignWithArray->GetId(); + size_t elemSize = alignArray->GetTypeSize(); + + const auto& arraySizes = alignArray->GetSizes(); + vector dimensions; + for (int dim = 0; dim < alignArray->GetDimSize(); ++dim) + dimensions.push_back(arraySizes[dim].second - arraySizes[dim].first + 1); + + vector distributionExpressions; + for (int dim = 0; dim < alignWithArray->GetDimSize(); ++dim) { + bool found = false; + for (int i = 0; i < alignRule.alignRuleWith.size(); ++i) { + const auto& ruleWith = alignRule.alignRuleWith[i]; + if (ruleWith.first == dim) { + const auto& rule = ruleWith.second; + if (rule.first == 0) { + // Константа + distributionExpressions.emplace_back(rule.second); + } else { + // Линейное выражение a * I + b + distributionExpressions.emplace_back(i, rule.first, rule.second); + } + found = true; + break; + } + } + if (!found) { + // Нет правила для этого измерения + distributionExpressions.emplace_back(); + } + } + + vector> shadowEdges; + const auto& shadowSpec = alignArray->GetShadowSpec(); + for (int dim = 0; dim < shadowSpec.size() && dim < alignArray->GetDimSize(); ++dim) { + shadowEdges.emplace_back(shadowSpec[dim].first, shadowSpec[dim].second); + } + + libpredict::RetAlign retAlign = libpredict::Align(arrayId, distributedArrayId, elemSize, dimensions, distributionExpressions, shadowEdges); + + if (retAlign != libpredict::ALIGN_SUCCESS) { + __spf_print(1, "ERROR: Failed to align array '%s' (id=%zu) with array '%s' (id=%zu), return code: %d\n", + alignArray->GetShortName().c_str(), arrayId, + alignWithArray->GetShortName().c_str(), distributedArrayId, (int)retAlign); + + std::wstring messageR, messageE; + __spf_printToLongBuf(messageE, L"Failed to align array '%s' with array '%s' using libpredict, return code: %d", + to_wstring(alignArray->GetShortName()).c_str(), + to_wstring(alignWithArray->GetShortName()).c_str(), (int)retAlign); + __spf_printToLongBuf(messageR, R208); + getObjectForFileFromMap(alignArray->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back( + Messages(ERROR, alignArray->GetDeclInfo().begin()->second, messageR, messageE, 1065)); + } + } + } + + // shadow_renew + map parallelDirs; + for (int i = project.numberOfFiles() - 1; i >= 0; --i) { + SgFile *file = &(project.file(i)); + auto fountInfo = findAllDirectives(file, getObjectForFileFromMap(file->filename(), loopGraph), parallelRegions[z]->GetId()); + parallelDirs.insert(fountInfo.begin(), fountInfo.end()); + } + + for (auto& dirPair : parallelDirs) { + LoopGraph* loopPtr = dirPair.first; + ParallelDirective* directive = dirPair.second; + + if (directive && !directive->shadowRenew.empty()) { + for (size_t shadowIdx = 0; shadowIdx < directive->shadowRenew.size(); ++shadowIdx) { + const auto& shadowRenewItem = directive->shadowRenew[shadowIdx]; + const string& arrayName = shadowRenewItem.first.second; // uniqName + const vector>& bounds = shadowRenewItem.second; + + DIST::Array* shadowArray = allArrays.GetArrayByName(arrayName); + if (shadowArray == NULL) + continue; + + if (shadowArray && !shadowArray->IsNotDistribute()) { + size_t arrayId = shadowArray->GetId(); + + vector> shadow_renew; + for (const auto& bound : bounds) { + shadow_renew.emplace_back(static_cast(bound.first), + static_cast(bound.second)); + } + + bool corner = directive->shadowRenewCorner[shadowIdx]; + + size_t number_loop_iterations = loopPtr ? static_cast(loopPtr->countOfIters) : 1; + + libpredict::RetShadowRenew retShadowRenew = libpredict::ShadowRenew(arrayId, shadow_renew, corner, number_loop_iterations); + + if (retShadowRenew != libpredict::SHADOW_RENEW_SUCCESS) { + __spf_print(1, "ERROR: Failed to process shadow_renew for array '%s' (id=%zu), return code: %d\n", + shadowArray->GetShortName().c_str(), arrayId, (int)retShadowRenew); + + std::wstring messageR, messageE; + __spf_printToLongBuf(messageE, L"Failed to process shadow_renew for array '%s' with libpredict, return code: %d", + to_wstring(shadowArray->GetShortName()).c_str(), (int)retShadowRenew); + __spf_printToLongBuf(messageR, R209); + getObjectForFileFromMap(shadowArray->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back( + Messages(ERROR, shadowArray->GetDeclInfo().begin()->second, messageR, messageE, 1066)); + } + } + } + } + } + } + + return libpredict::GetTime(); +} + +void runPredictScheme(SgProject &project, + vector> &topologies, // такой способ передачи разве хочу? + vector ¶llelRegions, + map> loopGraph, + map> &SPF_messages) +{ + // calculating maximum dimension of distribution + int maxSizeDist = 0; + for (int z = 0; z < parallelRegions.size(); ++z) { + const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir(); + const vector ¤tVariant = parallelRegions[z]->GetCurrentVariant(); + + auto &tmp = dataDirectives.distrRules; + vector currentVar; + for (int z1 = 0; z1 < currentVariant.size(); ++z1) + currentVar.push_back(&tmp[z1].second[currentVariant[z1]]); + + for (auto var : currentVar) { + int countBlock = 0; + for (int z = 0; z < var->distRule.size(); ++z) + if (var->distRule[z] == dist::BLOCK) + ++countBlock; + maxSizeDist = countBlock; + } + } + + // calculating name of a cluster configuration file + string clusterConfStr; + if (project.numberOfFiles() > 0) { + string firstFilePath = project.fileName(0); + + size_t lastSlash = firstFilePath.find_last_of("/\\"); + clusterConfStr = firstFilePath.substr(0, lastSlash + 1) + "cluster.conf"; + } + + // iterating through topologies to find most optimal one + topologies = vector>(); + if (maxSizeDist) { + + if (maxSizeDist > 4) maxSizeDist = 4; + + // TODO: look at cluster configuration + size_t n1max = 10; + size_t n2max = (maxSizeDist >= 2) ? 10 : 1; + size_t n3max = (maxSizeDist >= 3) ? 10 : 1; + size_t n4max = (maxSizeDist >= 4) ? 10 : 1; + + for (size_t n1 = 1; n1 <= n1max; ++n1) { + for (size_t n2 = 1; n2 <= n2max; ++n2) { + for (size_t n3 = 1; n3 <= n3max; ++n3) { + for (size_t n4 = 1; n4 <= n4max; ++n4) { + topologies.push_back(vector{n1, n2, n3, n4}); + } + } + } + } + + vector best; + double bestTime = std::numeric_limits::max(); + for (auto &topology : topologies) { + // if (DEBUG) { + // string outStr = ""; + // for (const auto &elem : top) + // outStr += std::to_string(elem) + " "; + // __spf_print(1, "topology %s has time %f\n", outStr.c_str(), currTime); + // } + double currTime = runLibpredictCalc(project, topology, clusterConfStr, parallelRegions, loopGraph, SPF_messages); + + if (currTime == -1) + return; + + if (currTime < bestTime) { + bestTime = currTime; + best = topology; + } + } + string outStr; + for (const auto &elem : best) + outStr += std::to_string(elem) + " "; + + __spf_print(1, "best topology %s with time %f\n", outStr.c_str(), bestTime); + } else { + __spf_print(1, "impossible to calculate best topology: project does not contain distribution directives\n"); + } +} diff --git a/src/Predictor/PredictSchemeWithLibrary.h b/src/Predictor/PredictSchemeWithLibrary.h new file mode 100644 index 0000000..e42d4e5 --- /dev/null +++ b/src/Predictor/PredictSchemeWithLibrary.h @@ -0,0 +1,19 @@ +#pragma once +#include +#include +#include +#include "dvm.h" +#include "graph_calls.h" + +void runPredictScheme(SgProject &project, + std::vector> &topologies, + std::vector ¶llelRegions, + std::map> loopGraph, + std::map> &SPF_messages); + +double runLibpredictCalc(SgProject &project, + std::vector topology, + std::string clusterConfStr, + std::vector ¶llelRegions, + std::map> loopGraph, + std::map> &SPF_messages); diff --git a/src/Sapfor.cpp b/src/Sapfor.cpp index ff10c5c..71bd561 100644 --- a/src/Sapfor.cpp +++ b/src/Sapfor.cpp @@ -57,6 +57,7 @@ #include "expr_transform.h" #include "Predictor/PredictScheme.h" +#include "Predictor/PredictSchemeWithLibrary.h" #include "Predictor/PredictorModel.h" #include "SageAnalysisTool/depInterfaceExt.h" #include "DvmhRegions/DvmhRegionInserter.h" @@ -1728,103 +1729,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne } } else if (curr_regime == PREDICT_SCHEME) - { - int maxSizeDist = 0; - for (int z = 0; z < parallelRegions.size(); ++z) - { - const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir(); - const vector ¤tVariant = parallelRegions[z]->GetCurrentVariant(); - - auto &tmp = dataDirectives.distrRules; - vector> currentVar; - for (int z1 = 0; z1 < currentVariant.size(); ++z1) - currentVar.push_back(make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]])); - - for (auto &elem : currentVar) - { - DIST::Array *array = elem.first; - const DistrVariant *var = elem.second; - - int countBlock = 0; - for (int z = 0; z < var->distRule.size(); ++z) - if (var->distRule[z] == dist::BLOCK) - ++countBlock; - maxSizeDist = std::max(maxSizeDist, countBlock); - } - } - - SpfInterval *mainIterval = getMainInterval(&project, intervals, SPF_messages); - topologies.clear(); - if (maxSizeDist) - { - const int procNum = 8; - //TODO: - //topologies = getTopologies(procNum, maxSizeDist); - throw -10; - - const int countOfTop = topologies.size(); - if (countOfTop < 0) - printInternalError(convertFileName(__FILE__).c_str(), __LINE__); - - for (auto &inter : intervals) - initTimeForIntervalTree(countOfTop, inter.second); - - for (int z = 0; z < parallelRegions.size(); ++z) - { - const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir(); - const vector ¤tVariant = parallelRegions[z]->GetCurrentVariant(); - DIST::Arrays &allArrays = parallelRegions[z]->GetAllArraysToModify(); - - auto &tmp = dataDirectives.distrRules; - vector> currentVar; - for (int z1 = 0; z1 < currentVariant.size(); ++z1) - currentVar.push_back(make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]])); - - map parallelDirs; - vector, pair>> allSingleRemotes; - for (int i = n - 1; i >= 0; --i) - { - SgFile *file = &(project.file(i)); - auto fountInfo = findAllDirectives(file, getObjectForFileFromMap(file->filename(), loopGraph), parallelRegions[z]->GetId()); - parallelDirs.insert(fountInfo.begin(), fountInfo.end()); - - auto fountRem = findAllSingleRemotes(file, parallelRegions[z]->GetId(), parallelRegions); - allSingleRemotes.insert(allSingleRemotes.end(), fountRem.begin(), fountRem.end()); - } - //TODO! - //int err = predictScheme(parallelRegions[z], currentVar, allArrays.GetArrays(), parallelDirs, intervals, SPF_messages, allSingleRemotes, maxSizeDist, procNum); - /*if (err != 0) - internalExit = err;*/ - } - - vector tmp = { mainIterval }; - aggregatePredictedTimes(tmp); - - int idx = 0; - int best = -1; - double bestSpeedUp = 0; - for (auto &top : topologies) - { - string outStr = ""; - for (auto &elem : top) - outStr += std::to_string(elem) + " "; - double currS = mainIterval->exec_time / mainIterval->predictedTimes[idx]; - __spf_print(1, "%d: speed up %f for top. %s\n", idx, currS, outStr.c_str()); - - if (best == -1 || bestSpeedUp < currS) - { - bestSpeedUp = currS; - best = idx; - } - ++idx; - } - __spf_print(1, "best topology %d with speed up %f\n", best, bestSpeedUp); - } - else - for (auto &inter : intervals) - initTimeForIntervalTree(0, inter.second); - - } + runPredictScheme(project, topologies, parallelRegions, loopGraph, SPF_messages); else if (curr_regime == CREATE_INTER_TREE) { if (keepFiles) diff --git a/src/SapforData.h b/src/SapforData.h index 36c1a24..c678a5f 100644 --- a/src/SapforData.h +++ b/src/SapforData.h @@ -132,7 +132,7 @@ std::map allPredictorStats; //for DVM INTERVALS std::map> intervals; // file -> intervals -std::vector> topologies; // current topologies +std::vector> topologies; // current topologies // //for GCOV_PARSER diff --git a/src/Utils/errors.h b/src/Utils/errors.h index 274e779..c108a9e 100644 --- a/src/Utils/errors.h +++ b/src/Utils/errors.h @@ -78,6 +78,10 @@ enum typeMessage { WARR, ERROR, NOTE }; // 60 "Format misplaced" // 61 "Array has declaration area conflict" // 62 "need to move common declaration to main for DECLATE" +// 63 "Failed to initialize libpredict library" +// 64 "Failed to distribute array with libpredict" +// 65 "Failed to align array with libpredict" +// 66 "Failed to process shadow_renew with libpredict" // // 20xx TRANSFORM GROUP // 01 "can not convert array assign to loop" @@ -305,7 +309,7 @@ static void printStackTrace() { }; } \ } while (0) -// Свободный - R206 +// Свободный - R209 // Гайд по русификации сообщений: При добавлении нового сообщения, меняется последний сводобный идентификатор. // В этом файле остаются только спецификаторы, для которых будет заполнен текст. Полный текст пишется в файле // russian_errors_text.txt. Спецификаторы там тоже сохраняются, по ним в визуализаторе будет восстановлен @@ -504,6 +508,14 @@ static const wchar_t *R183 = L"R183:"; static const wchar_t *R184 = L"R184:%s"; //1062 static const wchar_t* R205 = L"R205:%s#%s"; +//1063 +static const wchar_t* R206 = L"R206:"; +//1064 +static const wchar_t* R207 = L"R207:"; +//1065 +static const wchar_t* R208 = L"R208:"; +//1066 +static const wchar_t* R209 = L"R209:"; //2001 static const wchar_t *R94 = L"R94:"; diff --git a/src/VisualizerCalls/get_information.cpp b/src/VisualizerCalls/get_information.cpp index a2b02c9..ae93433 100644 --- a/src/VisualizerCalls/get_information.cpp +++ b/src/VisualizerCalls/get_information.cpp @@ -950,7 +950,7 @@ int SPF_ModifyArrayDistribution(void*& context, int winHandler, short *options, extern map allPredictorStats; extern map> intervals; -extern vector> topologies; +extern vector> topologies; int SPF_CreateParallelVariant(void*& context, int winHandler, short *options, short *projName, short *folderName, int64_t *variants, int *varLen, string &output, string &outputMessage, string &predictorStats) @@ -1807,7 +1807,7 @@ static int inline runModificationPass(passes passName, short* projName, short* f runPassesForVisualizer(projName, { passName }, folderName); //fill data - // newFiles: < , > + // newFiles: <����� ������ ��� ���, ���������� �����> string newFile; if (SgFile::switchToFile(outFileName.c_str()) == -1) @@ -2376,7 +2376,7 @@ const wstring Sapfor_RunAnalysis(const char* analysisName_c, const char* options retCode = SPF_GetArrayLinks(context, winHandler, optSh, projSh, result, output, outputMessage); else if (whichRun == "SPF_GetMaxMinBlockDistribution") retCode = SPF_GetMaxMinBlockDistribution(context, winHandler, optSh, projSh, result, output, outputMessage); - else if (whichRun == "SPF_hangeDirectory") // russian C + else if (whichRun == "SPF_�hangeDirectory") // russian C { if (options_c == NULL) printInternalError(convertFileName(__FILE__).c_str(), __LINE__);