/* A structure containing the output of dependence analysis:
* - n_source dependences
- * - a subset of the sink for which definitely no source could be found
- * - a subset of the sink for which possibly no source could be found
+ * - a wrapped subset of the sink for which definitely no source could be found
+ * - a wrapped subset of the sink for which possibly no source could be found
*/
struct isl_flow {
isl_set *must_no_source;
* sorted first.
* If they both share no levels, then the order is irrelevant.
* Otherwise, if p1 appears before p2, then it should be sorted first.
+ * For more generic initial schedules, it is possible that neither
+ * p1 nor p2 appears before the other, or at least not in any obvious way.
+ * We therefore also check if p2 appears before p1, in which case p2
+ * should be sorted first.
+ * If not, we try to order the two statements based on the description
+ * of the iteration domains. This results in an arbitrary, but fairly
+ * stable ordering.
*/
static int access_sort_cmp(const void *p1, const void *p2)
{
const struct isl_access_sort_info *i1, *i2;
int level1, level2;
+ uint32_t h1, h2;
i1 = (const struct isl_access_sort_info *) p1;
i2 = (const struct isl_access_sort_info *) p2;
return level1 - level2;
level1 = i1->acc->level_before(i1->source_data, i2->source_data);
+ if (level1 % 2)
+ return -1;
+
+ level2 = i1->acc->level_before(i2->source_data, i1->source_data);
+ if (level2 % 2)
+ return 1;
- return (level1 % 2) ? -1 : 1;
+ h1 = isl_map_get_hash(i1->source_map);
+ h2 = isl_map_get_hash(i2->source_map);
+ return h1 > h2 ? 1 : h1 < h2 ? -1 : 0;
}
/* Sort the must source accesses in order of increasing number of shared
return -1;
for (i = 0; i < deps->n_source; ++i) {
- if (isl_map_fast_is_empty(deps->dep[i].map))
+ if (isl_map_plain_is_empty(deps->dep[i].map))
continue;
if (fn(isl_map_copy(deps->dep[i].map), deps->dep[i].must,
deps->dep[i].data, user) < 0)
/* Return a copy of the subset of the sink for which no source could be found.
*/
-__isl_give isl_set *isl_flow_get_no_source(__isl_keep isl_flow *deps, int must)
+__isl_give isl_map *isl_flow_get_no_source(__isl_keep isl_flow *deps, int must)
{
if (!deps)
return NULL;
if (must)
- return isl_set_copy(deps->must_no_source);
+ return isl_set_unwrap(isl_set_copy(deps->must_no_source));
else
- return isl_set_copy(deps->may_no_source);
+ return isl_set_unwrap(isl_set_copy(deps->may_no_source));
}
void isl_flow_free(__isl_take isl_flow *deps)
int k, level;
int depth = 2 * isl_map_dim(acc->source[j].map, isl_dim_in) + 1;
- if (isl_map_fast_is_empty(temp_rel[j]))
+ if (isl_map_plain_is_empty(temp_rel[j]))
return 0;
for (k = j - 1; k >= 0; --k) {
copy = isl_map_copy(temp_rel[j]);
T = last_later_source(acc, copy, j, sink_level, k,
level, &trest);
- if (isl_map_fast_is_empty(T)) {
+ if (isl_map_plain_is_empty(T)) {
isl_set_free(trest);
isl_map_free(T);
continue;
for (k = 0; k < acc->n_must; ++k) {
int plevel;
- if (isl_map_fast_is_empty(may_rel[k]) &&
- isl_map_fast_is_empty(must_rel[k]))
+ if (isl_map_plain_is_empty(may_rel[k]) &&
+ isl_map_plain_is_empty(must_rel[k]))
continue;
plevel = acc->level_before(acc->source[k].data,
maydo = isl_set_empty_like(mustdo);
if (!mustdo || !maydo)
goto error;
- if (isl_set_fast_is_empty(mustdo))
+ if (isl_set_plain_is_empty(mustdo))
goto done;
must_rel = isl_alloc_array(ctx, struct isl_map *, acc->n_must);
intermediate_sources(acc, may_rel, j, level);
- if (isl_set_fast_is_empty(mustdo) &&
- isl_set_fast_is_empty(maydo))
+ if (isl_set_plain_is_empty(mustdo) &&
+ isl_set_plain_is_empty(maydo))
break;
}
for (j = j - 1; j >= 0; --j) {
may_rel[j]);
}
- if (isl_set_fast_is_empty(mustdo) &&
- isl_set_fast_is_empty(maydo))
+ if (isl_set_plain_is_empty(mustdo) &&
+ isl_set_plain_is_empty(maydo))
break;
}
if (!res->dep[j].map)
goto error2;
}
- res->must_no_source = isl_set_apply(res->must_no_source,
- isl_map_copy(domain_map));
- res->may_no_source = isl_set_apply(res->may_no_source,
- isl_map_copy(domain_map));
if (!res->must_no_source || !res->may_no_source)
goto error2;
}
+/* Keep track of some information about a schedule for a given
+ * access. In particular, keep track of which dimensions
+ * have a constant value and of the actual constant values.
+ */
+struct isl_sched_info {
+ int *is_cst;
+ isl_vec *cst;
+};
+
+static void sched_info_free(__isl_take struct isl_sched_info *info)
+{
+ if (!info)
+ return;
+ isl_vec_free(info->cst);
+ free(info->is_cst);
+ free(info);
+}
+
+/* Extract information on the constant dimensions of the schedule
+ * for a given access. The "map" is of the form
+ *
+ * [S -> D] -> A
+ *
+ * with S the schedule domain, D the iteration domain and A the data domain.
+ */
+static __isl_give struct isl_sched_info *sched_info_alloc(
+ __isl_keep isl_map *map)
+{
+ isl_ctx *ctx;
+ isl_dim *dim;
+ struct isl_sched_info *info;
+ int i, n;
+
+ if (!map)
+ return NULL;
+
+ dim = isl_dim_unwrap(isl_dim_domain(isl_map_get_dim(map)));
+ if (!dim)
+ return NULL;
+ n = isl_dim_size(dim, isl_dim_in);
+ isl_dim_free(dim);
+
+ ctx = isl_map_get_ctx(map);
+ info = isl_alloc_type(ctx, struct isl_sched_info);
+ if (!info)
+ return NULL;
+ info->is_cst = isl_alloc_array(ctx, int, n);
+ info->cst = isl_vec_alloc(ctx, n);
+ if (!info->is_cst || !info->cst)
+ goto error;
+
+ for (i = 0; i < n; ++i)
+ info->is_cst[i] = isl_map_plain_is_fixed(map, isl_dim_in, i,
+ &info->cst->el[i]);
+
+ return info;
+error:
+ sched_info_free(info);
+ return NULL;
+}
+
struct isl_compute_flow_data {
isl_union_map *must_source;
isl_union_map *may_source;
isl_union_map *must_dep;
isl_union_map *may_dep;
- isl_union_set *must_no_source;
- isl_union_set *may_no_source;
+ isl_union_map *must_no_source;
+ isl_union_map *may_no_source;
int count;
int must;
isl_dim *dim;
- isl_dim *sink_dim;
- isl_dim **source_dim;
+ struct isl_sched_info *sink_info;
+ struct isl_sched_info **source_info;
isl_access_info *accesses;
};
{
int eq;
isl_dim *dim;
+ struct isl_sched_info *info;
struct isl_compute_flow_data *data;
data = (struct isl_compute_flow_data *)user;
return 0;
}
- dim = isl_dim_unwrap(isl_dim_domain(isl_map_get_dim(map)));
- data->source_dim[data->count] = dim;
+ info = sched_info_alloc(map);
+ data->source_info[data->count] = info;
data->accesses = isl_access_info_add_source(data->accesses,
- map, data->must, dim);
+ map, data->must, info);
data->count++;
return -1;
}
+/* Determine the shared nesting level and the "textual order" of
+ * the given accesses.
+ *
+ * We first determine the minimal schedule dimension for both accesses.
+ *
+ * If among those dimensions, we can find one where both have a fixed
+ * value and if moreover those values are different, then the previous
+ * dimension is the last shared nesting level and the textual order
+ * is determined based on the order of the fixed values.
+ * If no such fixed values can be found, then we set the shared
+ * nesting level to the minimal schedule dimension, with no textual ordering.
+ */
static int before(void *first, void *second)
{
- isl_dim *dim1 = first;
- isl_dim *dim2 = second;
+ struct isl_sched_info *info1 = first;
+ struct isl_sched_info *info2 = second;
int n1, n2;
+ int i;
- n1 = isl_dim_size(dim1, isl_dim_in);
- n2 = isl_dim_size(dim2, isl_dim_in);
+ n1 = info1->cst->size;
+ n2 = info2->cst->size;
if (n2 < n1)
n1 = n2;
- return 2 * n1 + (dim1 < dim2);
+ for (i = 0; i < n1; ++i) {
+ if (!info1->is_cst[i])
+ continue;
+ if (!info2->is_cst[i])
+ continue;
+ if (isl_int_eq(info1->cst->el[i], info2->cst->el[i]))
+ continue;
+ return 2 * i + isl_int_lt(info1->cst->el[i], info2->cst->el[i]);
+ }
+
+ return 2 * n1;
}
/* Given a sink access, look for all the source accesses that access
ctx = isl_map_get_ctx(map);
data->accesses = NULL;
- data->sink_dim = NULL;
- data->source_dim = NULL;
+ data->sink_info = NULL;
+ data->source_info = NULL;
data->count = 0;
data->dim = isl_dim_range(isl_map_get_dim(map));
&count_matching_array, data) < 0)
goto error;
- data->sink_dim = isl_dim_unwrap(isl_dim_domain(isl_map_get_dim(map)));
- data->source_dim = isl_calloc_array(ctx, isl_dim *, data->count);
+ data->sink_info = sched_info_alloc(map);
+ data->source_info = isl_calloc_array(ctx, struct isl_sched_info *,
+ data->count);
data->accesses = isl_access_info_alloc(isl_map_copy(map),
- data->sink_dim, &before, data->count);
+ data->sink_info, &before, data->count);
+ if (!data->sink_info || !data->source_info || !data->accesses)
+ goto error;
data->count = 0;
data->must = 1;
if (isl_union_map_foreach_map(data->must_source,
if (!flow)
goto error;
- data->must_no_source = isl_union_set_union(data->must_no_source,
- isl_union_set_from_set(isl_set_copy(flow->must_no_source)));
- data->may_no_source = isl_union_set_union(data->may_no_source,
- isl_union_set_from_set(isl_set_copy(flow->may_no_source)));
+ data->must_no_source = isl_union_map_union(data->must_no_source,
+ isl_union_map_from_map(isl_flow_get_no_source(flow, 1)));
+ data->may_no_source = isl_union_map_union(data->may_no_source,
+ isl_union_map_from_map(isl_flow_get_no_source(flow, 0)));
for (i = 0; i < flow->n_source; ++i) {
isl_union_map *dep;
isl_flow_free(flow);
- isl_dim_free(data->sink_dim);
- if (data->source_dim) {
+ sched_info_free(data->sink_info);
+ if (data->source_info) {
for (i = 0; i < data->count; ++i)
- isl_dim_free(data->source_dim[i]);
- free(data->source_dim);
+ sched_info_free(data->source_info[i]);
+ free(data->source_info);
}
isl_dim_free(data->dim);
isl_map_free(map);
return 0;
error:
isl_access_info_free(data->accesses);
- isl_dim_free(data->sink_dim);
- if (data->source_dim) {
+ sched_info_free(data->sink_info);
+ if (data->source_info) {
for (i = 0; i < data->count; ++i)
- isl_dim_free(data->source_dim[i]);
- free(data->source_dim);
+ sched_info_free(data->source_info[i]);
+ free(data->source_info);
}
isl_dim_free(data->dim);
isl_map_free(map);
__isl_take isl_union_map *may_source,
__isl_take isl_union_map *schedule,
__isl_give isl_union_map **must_dep, __isl_give isl_union_map **may_dep,
- __isl_give isl_union_set **must_no_source,
- __isl_give isl_union_set **may_no_source)
+ __isl_give isl_union_map **must_no_source,
+ __isl_give isl_union_map **may_no_source)
{
isl_dim *dim;
isl_union_map *range_map = NULL;
isl_union_map_empty(isl_dim_copy(dim)) : NULL;
data.may_dep = may_dep ? isl_union_map_empty(isl_dim_copy(dim)) : NULL;
data.must_no_source = must_no_source ?
- isl_union_set_empty(isl_dim_copy(dim)) : NULL;
+ isl_union_map_empty(isl_dim_copy(dim)) : NULL;
data.may_no_source = may_no_source ?
- isl_union_set_empty(isl_dim_copy(dim)) : NULL;
+ isl_union_map_empty(isl_dim_copy(dim)) : NULL;
isl_dim_free(dim);
*may_dep = data.may_dep;
}
if (must_no_source) {
- data.must_no_source = isl_union_set_apply(data.must_no_source,
- isl_union_map_copy(range_map));
+ data.must_no_source = isl_union_map_apply_domain(
+ data.must_no_source, isl_union_map_copy(range_map));
*must_no_source = data.must_no_source;
}
if (may_no_source) {
- data.may_no_source = isl_union_set_apply(data.may_no_source,
- isl_union_map_copy(range_map));
+ data.may_no_source = isl_union_map_apply_domain(
+ data.may_no_source, isl_union_map_copy(range_map));
*may_no_source = data.may_no_source;
}
isl_union_map_free(may_source);
isl_union_map_free(data.must_dep);
isl_union_map_free(data.may_dep);
- isl_union_set_free(data.must_no_source);
- isl_union_set_free(data.may_no_source);
+ isl_union_map_free(data.must_no_source);
+ isl_union_map_free(data.may_no_source);
if (must_dep)
*must_dep = NULL;
projects / platform / upstream / isl.git / blobdiff