void Dependences::collectInfo(Scop &S, isl_union_map **Read,
isl_union_map **Write, isl_union_map **MayWrite,
isl_union_map **Schedule) {
isl_space *Space = S.getParamSpace();
*Read = isl_union_map_empty(isl_space_copy(Space));
*Write = isl_union_map_empty(isl_space_copy(Space));
*MayWrite = isl_union_map_empty(isl_space_copy(Space));
*Schedule = isl_union_map_empty(Space);
for (Scop::iterator SI = S.begin(), SE = S.end(); SI != SE; ++SI) {
ScopStmt *Stmt = *SI;
for (ScopStmt::memacc_iterator MI = Stmt->memacc_begin(),
ME = Stmt->memacc_end(); MI != ME; ++MI) {
isl_set *domcp = Stmt->getDomain();
isl_map *accdom = (*MI)->getAccessRelation();
accdom = isl_map_intersect_domain(accdom, domcp);
if ((*MI)->isRead())
*Read = isl_union_map_add_map(*Read, accdom);
else
*Write = isl_union_map_add_map(*Write, accdom);
}
*Schedule = isl_union_map_add_map(*Schedule, Stmt->getScattering());
}
}
Json::Value JSONExporter::getJSON(Scop &scop) const {
Json::Value root;
root["name"] = S->getRegion().getNameStr();
root["context"] = S->getContextStr();
root["statements"];
for (Scop::iterator SI = S->begin(), SE = S->end(); SI != SE; ++SI) {
ScopStmt *Stmt = *SI;
Json::Value statement;
statement["name"] = Stmt->getBaseName();
statement["domain"] = Stmt->getDomainStr();
statement["schedule"] = Stmt->getScatteringStr();
statement["accesses"];
for (ScopStmt::memacc_iterator MI = Stmt->memacc_begin(),
ME = Stmt->memacc_end();
MI != ME; ++MI) {
Json::Value access;
access["kind"] = (*MI)->isRead() ? "read" : "write";
access["relation"] = (*MI)->getAccessRelationStr();
statement["accesses"].append(access);
}
root["statements"].append(statement);
}
return root;
}
SetVector<Value *> ClastStmtCodeGen::getGPUValues(unsigned &OutputBytes) {
SetVector<Value *> Values;
OutputBytes = 0;
// Record the memory reference base addresses.
for (Scop::iterator SI = S->begin(), SE = S->end(); SI != SE; ++SI) {
ScopStmt *Stmt = *SI;
for (SmallVector<MemoryAccess *, 8>::iterator I = Stmt->memacc_begin(),
E = Stmt->memacc_end();
I != E; ++I) {
Value *BaseAddr = const_cast<Value *>((*I)->getBaseAddr());
Values.insert((BaseAddr));
// FIXME: we assume that there is one and only one array to be written
// in a SCoP.
int NumWrites = 0;
if ((*I)->isWrite()) {
++NumWrites;
assert(NumWrites <= 1 &&
"We support at most one array to be written in a SCoP.");
if (const PointerType *PT =
dyn_cast<PointerType>(BaseAddr->getType())) {
Type *T = PT->getArrayElementType();
const ArrayType *ATy = dyn_cast<ArrayType>(T);
OutputBytes = getArraySizeInBytes(ATy);
}
}
}
}
return Values;
}
ScopStmt::ScopStmt(Scop &parent, SmallVectorImpl<unsigned> &Scatter)
: Parent(parent), BB(NULL), IVS(0) {
BaseName = "FinalRead";
// Build iteration domain.
std::string IterationDomainString = "{[i0] : i0 = 0}";
Domain = isl_set_read_from_str(Parent.getCtx(), IterationDomainString.c_str(),
-1);
Domain = isl_set_add_dims(Domain, isl_dim_param, Parent.getNumParams());
Domain = isl_set_set_tuple_name(Domain, getBaseName());
// Build scattering.
unsigned ScatDim = Parent.getMaxLoopDepth() * 2 + 1;
isl_dim *dim = isl_dim_alloc(Parent.getCtx(), Parent.getNumParams(), 1,
ScatDim);
dim = isl_dim_set_tuple_name(dim, isl_dim_out, "scattering");
dim = isl_dim_set_tuple_name(dim, isl_dim_in, getBaseName());
isl_basic_map *bmap = isl_basic_map_universe(isl_dim_copy(dim));
isl_int v;
isl_int_init(v);
isl_constraint *c = isl_equality_alloc(dim);
isl_int_set_si(v, -1);
isl_constraint_set_coefficient(c, isl_dim_out, 0, v);
// TODO: This is incorrect. We should not use a very large number to ensure
// that this statement is executed last.
isl_int_set_si(v, 200000000);
isl_constraint_set_constant(c, v);
bmap = isl_basic_map_add_constraint(bmap, c);
isl_int_clear(v);
Scattering = isl_map_from_basic_map(bmap);
// Build memory accesses, use SetVector to keep the order of memory accesses
// and prevent the same memory access inserted more than once.
SetVector<const Value*> BaseAddressSet;
for (Scop::const_iterator SI = Parent.begin(), SE = Parent.end(); SI != SE;
++SI) {
ScopStmt *Stmt = *SI;
for (MemoryAccessVec::const_iterator I = Stmt->memacc_begin(),
E = Stmt->memacc_end(); I != E; ++I)
BaseAddressSet.insert((*I)->getBaseAddr());
}
for (SetVector<const Value*>::iterator BI = BaseAddressSet.begin(),
BE = BaseAddressSet.end(); BI != BE; ++BI)
MemAccs.push_back(new MemoryAccess(*BI, this));
IsReduction = false;
}
bool JSONImporter::runOnScop(Scop &scop) {
S = &scop;
Region &R = S->getRegion();
Dependences *D = &getAnalysis<Dependences>();
std::string FileName = ImportDir + "/" + getFileName(S);
std::string FunctionName = R.getEntry()->getParent()->getName();
errs() << "Reading JScop '" << R.getNameStr() << "' in function '"
<< FunctionName << "' from '" << FileName << "'.\n";
OwningPtr<MemoryBuffer> result;
error_code ec = MemoryBuffer::getFile(FileName, result);
if (ec) {
errs() << "File could not be read: " << ec.message() << "\n";
return false;
}
Json::Reader reader;
Json::Value jscop;
bool parsingSuccessful = reader.parse(result->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 &NewScattering = *(new StatementToIslMapTy());
int index = 0;
for (Scop::iterator SI = S->begin(), SE = S->end(); SI != SE; ++SI) {
Json::Value schedule = jscop["statements"][index]["schedule"];
isl_map *m = isl_map_read_from_str(S->getIslCtx(), schedule.asCString());
isl_space *Space = (*SI)->getDomainSpace();
// Copy the old tuple id. This is necessary to retain the user pointer,
// that stores the reference to the ScopStmt this scattering belongs to.
m = isl_map_set_tuple_id(m, isl_dim_in,
isl_space_get_tuple_id(Space, isl_dim_set));
isl_space_free(Space);
NewScattering[*SI] = m;
index++;
}
if (!D->isValidScattering(&NewScattering)) {
errs() << "JScop file contains a scattering that changes the "
<< "dependences. Use -disable-polly-legality to continue anyways\n";
return false;
}
for (Scop::iterator SI = S->begin(), SE = S->end(); SI != SE; ++SI) {
ScopStmt *Stmt = *SI;
if (NewScattering.find(Stmt) != NewScattering.end())
Stmt->setScattering(NewScattering[Stmt]);
}
int statementIdx = 0;
for (Scop::iterator SI = S->begin(), SE = S->end(); SI != SE; ++SI) {
ScopStmt *Stmt = *SI;
int memoryAccessIdx = 0;
for (ScopStmt::memacc_iterator MI = Stmt->memacc_begin(),
ME = Stmt->memacc_end();
MI != ME; ++MI) {
Json::Value accesses = jscop["statements"][statementIdx]["accesses"][
memoryAccessIdx]["relation"];
isl_map *newAccessMap =
isl_map_read_from_str(S->getIslCtx(), accesses.asCString());
isl_map *currentAccessMap = (*MI)->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;
}
// 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;
}
if (isl_map_dim(newAccessMap, isl_dim_out) != 1) {
errs() << "New access map in JScop file should be single dimensional\n";
isl_map_free(currentAccessMap);
isl_map_free(newAccessMap);
return false;
}
if (!isl_map_is_equal(newAccessMap, currentAccessMap)) {
// Statistics.
++NewAccessMapFound;
newAccessStrings.push_back(accesses.asCString());
(*MI)->setNewAccessRelation(newAccessMap);
} else {
isl_map_free(newAccessMap);
}
isl_map_free(currentAccessMap);
memoryAccessIdx++;
}
statementIdx++;
}
return false;
}