bool JSONExporter::runOnScop(Scop &S) {
std::string FileName = ImportDir + "/" + getFileName(S);
Json::Value jscop = getJSON(S);
Json::StyledWriter writer;
std::string fileContent = writer.write(jscop);
// Write to file.
std::error_code EC;
tool_output_file F(FileName, EC, llvm::sys::fs::F_Text);
std::string FunctionName = S.getFunction().getName();
errs() << "Writing JScop '" << S.getNameStr() << "' in function '"
<< FunctionName << "' to '" << FileName << "'.\n";
if (!EC) {
F.os() << fileContent;
F.os().close();
if (!F.os().has_error()) {
errs() << "\n";
F.keep();
return false;
}
}
errs() << " error opening file for writing!\n";
F.os().clear_error();
return false;
}
std::string JSONImporter::getFileName(Scop &S) const {
std::string FunctionName = S.getFunction().getName();
std::string FileName = FunctionName + "___" + S.getNameStr() + ".jscop";
if (ImportPostfix != "")
FileName += "." + ImportPostfix;
return FileName;
}
// Generate a unique name that is usable as a LLVM name for a scop to name its
// performance counter.
static std::string GetScopUniqueVarname(const Scop &S) {
std::stringstream Name;
std::string EntryString, ExitString;
std::tie(EntryString, ExitString) = S.getEntryExitStr();
Name << "__polly_perf_in_" << std::string(S.getFunction().getName())
<< "_from__" << EntryString << "__to__" << ExitString;
return Name.str();
}
std::string JSONExporter::getFileName(Scop &S) const {
std::string FunctionName = S.getFunction().getName();
std::string FileName = FunctionName + "___" + S.getNameStr() + ".jscop";
return FileName;
}
bool JSONImporter::runOnScop(Scop &S) {
const Dependences &D =
getAnalysis<DependenceInfo>().getDependences(Dependences::AL_Statement);
const DataLayout &DL = S.getFunction().getParent()->getDataLayout();
std::string FileName = ImportDir + "/" + getFileName(S);
std::string FunctionName = S.getFunction().getName();
errs() << "Reading JScop '" << S.getNameStr() << "' in function '"
<< FunctionName << "' from '" << FileName << "'.\n";
ErrorOr<std::unique_ptr<MemoryBuffer>> result =
MemoryBuffer::getFile(FileName);
std::error_code ec = result.getError();
if (ec) {
errs() << "File could not be read: " << ec.message() << "\n";
return false;
}
Json::Reader reader;
Json::Value jscop;
bool parsingSuccessful = reader.parse(result.get()->getBufferStart(), jscop);
if (!parsingSuccessful) {
errs() << "JSCoP file could not be parsed\n";
return false;
}
isl_set *OldContext = S.getContext();
isl_set *NewContext =
isl_set_read_from_str(S.getIslCtx(), jscop["context"].asCString());
for (unsigned i = 0; i < isl_set_dim(OldContext, isl_dim_param); i++) {
isl_id *id = isl_set_get_dim_id(OldContext, isl_dim_param, i);
NewContext = isl_set_set_dim_id(NewContext, isl_dim_param, i, id);
}
isl_set_free(OldContext);
S.setContext(NewContext);
StatementToIslMapTy NewSchedule;
int index = 0;
for (ScopStmt &Stmt : S) {
Json::Value schedule = jscop["statements"][index]["schedule"];
isl_map *m = isl_map_read_from_str(S.getIslCtx(), schedule.asCString());
isl_space *Space = Stmt.getDomainSpace();
// Copy the old tuple id. This is necessary to retain the user pointer,
// that stores the reference to the ScopStmt this schedule belongs to.
m = isl_map_set_tuple_id(m, isl_dim_in,
isl_space_get_tuple_id(Space, isl_dim_set));
for (unsigned i = 0; i < isl_space_dim(Space, isl_dim_param); i++) {
isl_id *id = isl_space_get_dim_id(Space, isl_dim_param, i);
m = isl_map_set_dim_id(m, isl_dim_param, i, id);
}
isl_space_free(Space);
NewSchedule[&Stmt] = m;
index++;
}
if (!D.isValidSchedule(S, &NewSchedule)) {
errs() << "JScop file contains a schedule that changes the "
<< "dependences. Use -disable-polly-legality to continue anyways\n";
for (StatementToIslMapTy::iterator SI = NewSchedule.begin(),
SE = NewSchedule.end();
SI != SE; ++SI)
isl_map_free(SI->second);
return false;
}
auto ScheduleMap = isl_union_map_empty(S.getParamSpace());
for (ScopStmt &Stmt : S) {
if (NewSchedule.find(&Stmt) != NewSchedule.end())
ScheduleMap = isl_union_map_add_map(ScheduleMap, NewSchedule[&Stmt]);
else
ScheduleMap = isl_union_map_add_map(ScheduleMap, Stmt.getSchedule());
}
S.setSchedule(ScheduleMap);
int statementIdx = 0;
for (ScopStmt &Stmt : S) {
int memoryAccessIdx = 0;
for (MemoryAccess *MA : Stmt) {
Json::Value accesses = jscop["statements"][statementIdx]["accesses"]
[memoryAccessIdx]["relation"];
isl_map *newAccessMap =
isl_map_read_from_str(S.getIslCtx(), accesses.asCString());
isl_map *currentAccessMap = MA->getAccessRelation();
if (isl_map_dim(newAccessMap, isl_dim_param) !=
isl_map_dim(currentAccessMap, isl_dim_param)) {
errs() << "JScop file changes the number of parameter dimensions\n";
isl_map_free(currentAccessMap);
isl_map_free(newAccessMap);
return false;
}
isl_id *OutId = isl_map_get_tuple_id(currentAccessMap, isl_dim_out);
newAccessMap = isl_map_set_tuple_id(newAccessMap, isl_dim_out, OutId);
if (MA->isArrayKind()) {
// We keep the old alignment, thus we cannot allow accesses to memory
// locations that were not accessed before if the alignment of the
// access is not the default alignment.
bool SpecialAlignment = true;
if (LoadInst *LoadI = dyn_cast<LoadInst>(MA->getAccessInstruction())) {
SpecialAlignment =
DL.getABITypeAlignment(LoadI->getType()) != LoadI->getAlignment();
} else if (StoreInst *StoreI =
dyn_cast<StoreInst>(MA->getAccessInstruction())) {
SpecialAlignment =
DL.getABITypeAlignment(StoreI->getValueOperand()->getType()) !=
StoreI->getAlignment();
}
if (SpecialAlignment) {
isl_set *newAccessSet = isl_map_range(isl_map_copy(newAccessMap));
isl_set *currentAccessSet =
isl_map_range(isl_map_copy(currentAccessMap));
bool isSubset = isl_set_is_subset(newAccessSet, currentAccessSet);
isl_set_free(newAccessSet);
isl_set_free(currentAccessSet);
if (!isSubset) {
errs() << "JScop file changes the accessed memory\n";
isl_map_free(currentAccessMap);
isl_map_free(newAccessMap);
return false;
}
}
}
// We need to copy the isl_ids for the parameter dimensions to the new
// map. Without doing this the current map would have different
// ids then the new one, even though both are named identically.
for (unsigned i = 0; i < isl_map_dim(currentAccessMap, isl_dim_param);
i++) {
isl_id *id = isl_map_get_dim_id(currentAccessMap, isl_dim_param, i);
newAccessMap = isl_map_set_dim_id(newAccessMap, isl_dim_param, i, id);
}
// Copy the old tuple id. This is necessary to retain the user pointer,
// that stores the reference to the ScopStmt this access belongs to.
isl_id *Id = isl_map_get_tuple_id(currentAccessMap, isl_dim_in);
newAccessMap = isl_map_set_tuple_id(newAccessMap, isl_dim_in, Id);
if (!isl_map_has_equal_space(currentAccessMap, newAccessMap)) {
errs() << "JScop file contains access function with incompatible "
<< "dimensions\n";
isl_map_free(currentAccessMap);
isl_map_free(newAccessMap);
return false;
}
auto NewAccessDomain = isl_map_domain(isl_map_copy(newAccessMap));
auto CurrentAccessDomain = isl_map_domain(isl_map_copy(currentAccessMap));
NewAccessDomain =
isl_set_intersect_params(NewAccessDomain, S.getContext());
CurrentAccessDomain =
isl_set_intersect_params(CurrentAccessDomain, S.getContext());
if (isl_set_is_subset(CurrentAccessDomain, NewAccessDomain) ==
isl_bool_false) {
errs() << "Mapping not defined for all iteration domain elements\n";
isl_set_free(CurrentAccessDomain);
isl_set_free(NewAccessDomain);
isl_map_free(currentAccessMap);
isl_map_free(newAccessMap);
return false;
}
isl_set_free(CurrentAccessDomain);
isl_set_free(NewAccessDomain);
if (!isl_map_is_equal(newAccessMap, currentAccessMap)) {
// Statistics.
++NewAccessMapFound;
newAccessStrings.push_back(accesses.asCString());
MA->setNewAccessRelation(newAccessMap);
} else {
isl_map_free(newAccessMap);
}
isl_map_free(currentAccessMap);
memoryAccessIdx++;
}
statementIdx++;
}
return false;
}