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; }