/* Given a relation "map" between instances of two statements A and B, * does it relate every instance of A (according to the domain of "src") * to every instance of B (according to the domain of "dst")? */ static isl_bool covers_src_and_dst(__isl_keep isl_map *map, struct ppcg_grouping_leaf *src, struct ppcg_grouping_leaf *dst) { isl_space *space; isl_set *set1, *set2; isl_bool is_subset; space = isl_space_domain(isl_map_get_space(map)); set1 = isl_union_set_extract_set(src->domain, space); set2 = isl_map_domain(isl_map_copy(map)); is_subset = isl_set_is_subset(set1, set2); isl_set_free(set1); isl_set_free(set2); if (is_subset < 0 || !is_subset) return is_subset; space = isl_space_range(isl_map_get_space(map)); set1 = isl_union_set_extract_set(dst->domain, space); set2 = isl_map_range(isl_map_copy(map)); is_subset = isl_set_is_subset(set1, set2); isl_set_free(set1); isl_set_free(set2); return is_subset; }
int isl_map_contains_point(__isl_keep isl_map *map, __isl_keep isl_point *point) { int i; int found = 0; if (!map || !point) return -1; map = isl_map_copy(map); map = isl_map_compute_divs(map); if (!map) return -1; for (i = 0; i < map->n; ++i) { found = isl_basic_map_contains_point(map->p[i], point); if (found < 0) goto error; if (found) break; } isl_map_free(map); return found; error: isl_map_free(map); return -1; }
/// @brief Update the scattering in a Scop using the scoplib description of /// the scattering. bool ScopLib::updateScattering() { if (!scoplib) return false; StatementToIslMapTy *NewScattering = readScattering(PollyScop, scoplib); if (!NewScattering) return false; if (!D->isValidScattering(NewScattering)) { freeStmtToIslMap(NewScattering); errs() << "OpenScop file contains a scattering that changes the " << "dependences. Use -disable-polly-legality to continue anyways\n"; return false; } for (Scop::iterator SI = PollyScop->begin(), SE = PollyScop->end(); SI != SE; ++SI) { ScopStmt *Stmt = *SI; if (NewScattering->find(Stmt) != NewScattering->end()) Stmt->setScattering(isl_map_copy((*NewScattering)[Stmt])); } freeStmtToIslMap(NewScattering); return true; }
/* Check if the constraints in "map" imply any stride on output dimension "pos", * independently of any other output dimensions, and * return the results in the form of an offset and a stride. * * Convert the input to a set with only the input dimensions and * the single output dimension such that it be passed to * isl_set_get_stride_info and convert the result back to * an expression defined over the domain of "map". */ __isl_give isl_stride_info *isl_map_get_range_stride_info( __isl_keep isl_map *map, int pos) { isl_stride_info *si; isl_set *set; map = isl_map_copy(map); map = isl_map_project_onto(map, isl_dim_out, pos, 1); pos = isl_map_dim(map, isl_dim_in); set = isl_map_wrap(map); si = isl_set_get_stride_info(set, pos); isl_set_free(set); if (!si) return NULL; si->offset = isl_aff_domain_factor_domain(si->offset); if (!si->offset) return isl_stride_info_free(si); return si; }
/* Given a relation "map" between instances of two statements A and B, * are pairs of related instances executed together in the input schedule? * That is, is each pair of instances assigned the same value * by the corresponding prefix schedules? * * In particular, select the subset of "map" that has pairs of elements * with the same value for the prefix schedules and then check * if "map" is still a subset of the result. */ static isl_bool matches_prefix(__isl_keep isl_map *map, struct ppcg_grouping_leaf *src, struct ppcg_grouping_leaf *dst) { isl_union_map *umap, *equal; isl_multi_union_pw_aff *src_prefix, *dst_prefix, *prefix; isl_bool is_subset; src_prefix = isl_multi_union_pw_aff_copy(src->prefix); dst_prefix = isl_multi_union_pw_aff_copy(dst->prefix); prefix = isl_multi_union_pw_aff_union_add(src_prefix, dst_prefix); umap = isl_union_map_from_map(isl_map_copy(map)); equal = isl_union_map_copy(umap); equal = isl_union_map_eq_at_multi_union_pw_aff(equal, prefix); is_subset = isl_union_map_is_subset(umap, equal); isl_union_map_free(umap); isl_union_map_free(equal); return is_subset; }
CloogUnionDomain *Cloog::buildCloogUnionDomain() { CloogUnionDomain *DU = cloog_union_domain_alloc(S->getNumParams()); for (Scop::iterator SI = S->begin(), SE = S->end(); SI != SE; ++SI) { ScopStmt *Stmt = *SI; if (Stmt->isFinalRead()) continue; CloogScattering *Scattering= cloog_scattering_from_isl_map(isl_map_copy(Stmt->getScattering())); CloogDomain *Domain = cloog_domain_from_isl_set(isl_set_copy(Stmt->getDomain())); std::string entryName = Stmt->getBaseName(); char *Name = (char*)malloc(sizeof(char) * (entryName.size() + 1)); strcpy(Name, entryName.c_str()); DU = cloog_union_domain_add_domain(DU, Name, Domain, Scattering, Stmt); } return DU; }
static void pdr_stride_in_loop (mpz_t stride, graphite_dim_t depth, poly_dr_p pdr) { poly_bb_p pbb = PDR_PBB (pdr); isl_map *map; isl_set *set; isl_aff *aff; isl_space *dc; isl_constraint *lma, *c; isl_int islstride; graphite_dim_t time_depth; unsigned offset, nt; unsigned i; /* XXX isl rewrite following comments. */ /* Builds a partial difference equations and inserts them into pointset powerset polyhedron P. Polyhedron is assumed to have the format: T|I|T'|I'|G|S|S'|l1|l2. TIME_DEPTH is the time dimension w.r.t. which we are differentiating. OFFSET represents the number of dimensions between columns t_{time_depth} and t'_{time_depth}. DIM_SCTR is the number of scattering dimensions. It is essentially the dimensionality of the T vector. The following equations are inserted into the polyhedron P: | t_1 = t_1' | ... | t_{time_depth-1} = t'_{time_depth-1} | t_{time_depth} = t'_{time_depth} + 1 | t_{time_depth+1} = t'_{time_depth + 1} | ... | t_{dim_sctr} = t'_{dim_sctr}. */ /* Add the equality: t_{time_depth} = t'_{time_depth} + 1. This is the core part of this alogrithm, since this constraint asks for the memory access stride (difference) between two consecutive points in time dimensions. */ /* Add equalities: | t1 = t1' | ... | t_{time_depth-1} = t'_{time_depth-1} | t_{time_depth+1} = t'_{time_depth+1} | ... | t_{dim_sctr} = t'_{dim_sctr} This means that all the time dimensions are equal except for time_depth, where the constraint is t_{depth} = t'_{depth} + 1 step. More to this: we should be careful not to add equalities to the 'coupled' dimensions, which happens when the one dimension is stripmined dimension, and the other dimension corresponds to the point loop inside stripmined dimension. */ /* pdr->accesses: [P1..nb_param,I1..nb_domain]->[a,S1..nb_subscript] ??? [P] not used for PDRs? pdr->extent: [a,S1..nb_subscript] pbb->domain: [P1..nb_param,I1..nb_domain] pbb->transformed: [P1..nb_param,I1..nb_domain]->[T1..Tnb_sctr] [T] includes local vars (currently unused) First we create [P,I] -> [T,a,S]. */ map = isl_map_flat_range_product (isl_map_copy (pbb->transformed), isl_map_copy (pdr->accesses)); /* Add a dimension for L: [P,I] -> [T,a,S,L].*/ map = isl_map_add_dims (map, isl_dim_out, 1); /* Build a constraint for "lma[S] - L == 0", effectively calculating L in terms of subscripts. */ lma = build_linearized_memory_access (map, pdr); /* And add it to the map, so we now have: [P,I] -> [T,a,S,L] : lma([S]) == L. */ map = isl_map_add_constraint (map, lma); /* Then we create [P,I,P',I'] -> [T,a,S,L,T',a',S',L']. */ map = isl_map_flat_product (map, isl_map_copy (map)); /* Now add the equality T[time_depth] == T'[time_depth]+1. This will force L' to be the linear address at T[time_depth] + 1. */ time_depth = psct_dynamic_dim (pbb, depth); /* Length of [a,S] plus [L] ... */ offset = 1 + isl_map_dim (pdr->accesses, isl_dim_out); /* ... plus [T]. */ offset += isl_map_dim (pbb->transformed, isl_dim_out); c = isl_equality_alloc (isl_local_space_from_space (isl_map_get_space (map))); c = isl_constraint_set_coefficient_si (c, isl_dim_out, time_depth, 1); c = isl_constraint_set_coefficient_si (c, isl_dim_out, offset + time_depth, -1); c = isl_constraint_set_constant_si (c, 1); map = isl_map_add_constraint (map, c); /* Now we equate most of the T/T' elements (making PITaSL nearly the same is (PITaSL)', except for one dimension, namely for 'depth' (an index into [I]), after translating to index into [T]. Take care to not produce an empty map, which indicates we wanted to equate two dimensions that are already coupled via the above time_depth dimension. Happens with strip mining where several scatter dimension are interdependend. */ /* Length of [T]. */ nt = pbb_nb_scattering_transform (pbb) + pbb_nb_local_vars (pbb); for (i = 0; i < nt; i++) if (i != time_depth) { isl_map *temp = isl_map_equate (isl_map_copy (map), isl_dim_out, i, isl_dim_out, offset + i); if (isl_map_is_empty (temp)) isl_map_free (temp); else { isl_map_free (map); map = temp; } } /* Now maximize the expression L' - L. */ set = isl_map_range (map); dc = isl_set_get_space (set); aff = isl_aff_zero_on_domain (isl_local_space_from_space (dc)); aff = isl_aff_set_coefficient_si (aff, isl_dim_in, offset - 1, -1); aff = isl_aff_set_coefficient_si (aff, isl_dim_in, offset + offset - 1, 1); isl_int_init (islstride); isl_set_max (set, aff, &islstride); isl_int_get_gmp (islstride, stride); isl_int_clear (islstride); isl_aff_free (aff); isl_set_free (set); if (dump_file && (dump_flags & TDF_DETAILS)) { char *str; void (*gmp_free) (void *, size_t); fprintf (dump_file, "\nStride in BB_%d, DR_%d, depth %d:", pbb_index (pbb), PDR_ID (pdr), (int) depth); str = mpz_get_str (0, 10, stride); fprintf (dump_file, " %s ", str); mp_get_memory_functions (NULL, NULL, &gmp_free); (*gmp_free) (str, strlen (str) + 1); } }
static void *isl_obj_map_copy(void *v) { return isl_map_copy((struct isl_map *)v); }
/** * Converts a SCoP as extracted by PolyOpt's auto-scop detection * into ISL representation. * * bugs/limitations: * (a) not robust to union of iteration domains in scoplib * (b) code is leaking, need proper copy constructor that duplicates all * ISL structures. */ int PolyOptISLRepresentation::convertScoplibToISL (scoplib_scop_p scop) { int i; isl_union_map* all_reads = NULL; isl_union_map* all_writes = NULL; isl_union_map* all_scheds = NULL; isl_ctx* ctxt = isl_ctx_alloc(); // 1. Prepare the arrays of unique names for statements and arrays. char buffer[32]; int nb_statements; scoplib_statement_p s; for (nb_statements = 0, s = scop->statement; s; s = s->next, nb_statements++) ; char* stmt_names[nb_statements]; for (i = 0; i < nb_statements; ++i) { sprintf (buffer, "S_%d", i); stmt_names[i] = strdup (buffer); } char* array_names[scop->nb_arrays]; for (i = 0; i < scop->nb_arrays; ++i) array_names[i] = strdup (((SgVariableSymbol*)(scop->arrays[i]))->get_name().str()); isl_union_map* umap; int stmt_id; for (s = scop->statement, stmt_id = 0; s; s = s->next, ++stmt_id) { isl_union_map* all_reads_stmt = NULL; isl_union_map* all_writes_stmt = NULL; isl_space* sp = NULL; for (i = 0; i < scop->nb_arrays; ++i) { sp = build_isl_space (scop, s, i+1, ctxt); // 1. Handle access matrices. scoplib_matrix_p m; int k; for (k = 0, m = s->read, umap = all_reads_stmt; k < 2; k++, m = s->write, umap = all_writes_stmt) { isl_map* acc_map = NULL; int row_pos = 0; do { acc_map = build_access_function (scop, s, m, sp, ctxt, &row_pos, i+1); if (acc_map) { acc_map = isl_map_set_tuple_name (acc_map, isl_dim_in, stmt_names[stmt_id]); acc_map = isl_map_set_tuple_name (acc_map, isl_dim_out, array_names[i]); if (umap == NULL) umap = isl_union_map_from_map (isl_map_copy (acc_map)); else umap = isl_union_map_union (umap, isl_union_map_from_map (isl_map_copy (acc_map))); isl_map_free (acc_map); } } while (acc_map != NULL); if (k == 0) all_reads_stmt = umap; else all_writes_stmt = umap; } } // Store the union of access functions of statement i. stmt_accfunc_read.push_back (all_reads_stmt); stmt_accfunc_write.push_back (all_writes_stmt); // 2. Handle iteration domains. isl_set* dom = build_iteration_domain (scop, s, sp, ctxt); dom = isl_set_set_tuple_name (dom, stmt_names[stmt_id]); if (all_reads_stmt != NULL) all_reads_stmt = isl_union_map_intersect_domain (isl_union_map_copy (all_reads_stmt), isl_union_set_from_set (isl_set_copy (dom))); if (all_writes_stmt != NULL) all_writes_stmt = isl_union_map_intersect_domain (all_writes_stmt, isl_union_set_from_set (isl_set_copy (dom))); // Store the iteration domain of statement i. stmt_iterdom.push_back (dom); // Store the union of access functions of statement i after intersection by domain. stmt_read_domain.push_back (all_reads_stmt); stmt_write_domain.push_back (all_writes_stmt); // Unionize the result. if (all_reads == NULL) all_reads = isl_union_map_copy (all_reads_stmt); else all_reads = isl_union_map_union (all_reads, isl_union_map_copy (all_reads_stmt)); if (all_writes == NULL) all_writes = isl_union_map_copy (all_writes_stmt); else all_writes = isl_union_map_union (all_writes, isl_union_map_copy (all_writes_stmt)); // isl_union_map_free (all_reads_stmt); // isl_union_map_free (all_writes_stmt); // 3. Handle schedules. isl_map* sched = build_schedule (scop, s, sp, ctxt); sched = isl_map_set_tuple_name (sched, isl_dim_in, stmt_names[stmt_id]); if (all_scheds == NULL) all_scheds = isl_union_map_from_map (isl_map_copy (sched)); else all_scheds = isl_union_map_union (all_scheds, isl_union_map_from_map (isl_map_copy (sched))); // Store the schedule of statement i. stmt_schedule.push_back (sched); // 4. Finalize info about the statement. stmt_body.push_back (((SgNode*)(s->body))->unparseToCompleteString()); stmt_body_ir.push_back ((SgNode*)(s->body)); } // // Debug. // isl_printer* pr = isl_printer_to_file (ctxt, stdout); // std::cout << "UNION MAP READS" << std::endl; // isl_printer_print_union_map(pr, all_reads); // printf ("\n"); // std::cout << "UNION MAP WRITES" << std::endl; // isl_printer_print_union_map(pr, all_writes); // printf ("\n"); // std::cout << "UNION MAP SCHEDULES" << std::endl; // isl_printer_print_union_map(pr, all_scheds); // printf ("\n"); for (std::vector<std::string>::iterator i = stmt_body.begin(); i != stmt_body.end(); ++i) std::cout << "stmt body: " << *i << std::endl; // Finalize SCoP representation. scop_nb_arrays = scop->nb_arrays; scop_nb_statements = stmt_schedule.size(); scop_reads = all_reads; scop_writes = all_writes; scop_scheds = all_scheds; return EXIT_SUCCESS; }