From 1ccad10bd6f09df41f1e3d4c6a3e4e75fe45109a Mon Sep 17 00:00:00 2001 From: Sven Verdoolaege Date: Thu, 3 Apr 2014 10:53:04 +0200 Subject: [PATCH] break up access relations into may_read/may_write/must_write in interface We currently only make a distinction between may accesses and must accesses. At the level of an individual access expression, we even only have a single (possibly argument dependent) access relation. If we want to keep track of the accesses performed by a function called from a function call, we will need to make a further distinction between reads and writes. Furthermore, if member accesses are involved, then a function may access elements from different spaces through the same argument. The access relations therefore need to be changed into union maps. In this commit we only change the outside interface and keep the current internal representation for now. The internal changes will take place in further commits. Signed-off-by: Sven Verdoolaege --- expr.c | 161 ++++++++++++++++++++++++++++++++++++++++++++++++++++++---- expr.h | 6 ++- include/pet.h | 26 +++++++--- scop.c | 6 ++- 4 files changed, 179 insertions(+), 20 deletions(-) diff --git a/expr.c b/expr.c index 0215ae0..b7b04b0 100644 --- a/expr.c +++ b/expr.c @@ -1931,8 +1931,8 @@ error: * * [D[i] -> id[]] -> A[a] */ -__isl_give isl_map *pet_expr_tag_access(__isl_keep pet_expr *expr, - __isl_take isl_map *access) +__isl_give isl_union_map *pet_expr_tag_access(__isl_keep pet_expr *expr, + __isl_take isl_union_map *access) { isl_space *space; isl_multi_aff *add_tag; @@ -1941,14 +1941,14 @@ __isl_give isl_map *pet_expr_tag_access(__isl_keep pet_expr *expr, if (expr->type != pet_expr_access) isl_die(pet_expr_get_ctx(expr), isl_error_invalid, "not an access expression", - return isl_map_free(access)); + return isl_union_map_free(access)); id = isl_id_copy(expr->acc.ref_id); space = pet_expr_access_get_domain_space(expr); space = isl_space_from_domain(space); space = isl_space_set_tuple_id(space, isl_dim_out, id); add_tag = isl_multi_aff_domain_map(space); - access = isl_map_preimage_domain_multi_aff(access, add_tag); + access = isl_union_map_preimage_domain_multi_aff(access, add_tag); return access; } @@ -1956,7 +1956,7 @@ __isl_give isl_map *pet_expr_tag_access(__isl_keep pet_expr *expr, /* Return the relation mapping pairs of domain iterations and argument * values to the corresponding accessed data elements. */ -__isl_give isl_map *pet_expr_access_get_dependent_access( +static __isl_give isl_map *pet_expr_access_get_dependent_access( __isl_keep pet_expr *expr) { isl_map *access; @@ -1980,6 +1980,76 @@ __isl_give isl_map *pet_expr_access_get_dependent_access( return access; } +/* Return an empty access relation for access expression "expr". + */ +static __isl_give isl_union_map *empty_access_relation( + __isl_keep pet_expr *expr) +{ + return isl_union_map_empty(pet_expr_access_get_parameter_space(expr)); +} + +/* Return the may read access relation associated to "expr" + * that maps pairs of domain iterations and argument values + * to the corresponding accessed data elements. + * + * Since the accesses are currently represented by a single access relation, + * we return the entire access relation if "expr" is a read and + * an empty relation if it is not. + */ +__isl_give isl_union_map *pet_expr_access_get_dependent_may_read( + __isl_keep pet_expr *expr) +{ + isl_map *access; + + if (!expr) + return NULL; + if (!pet_expr_access_is_read(expr)) + return empty_access_relation(expr); + access = pet_expr_access_get_dependent_access(expr); + return isl_union_map_from_map(access); +} + +/* Return the may write access relation associated to "expr" + * that maps pairs of domain iterations and argument values + * to the corresponding accessed data elements. + * + * Since the accesses are currently represented by a single access relation, + * we return the entire access relation if "expr" is a write and + * an empty relation if it is not. + */ +__isl_give isl_union_map *pet_expr_access_get_dependent_may_write( + __isl_keep pet_expr *expr) +{ + isl_map *access; + + if (!expr) + return NULL; + if (!pet_expr_access_is_write(expr)) + return empty_access_relation(expr); + access = pet_expr_access_get_dependent_access(expr); + return isl_union_map_from_map(access); +} + +/* Return the must write access relation associated to "expr" + * that maps pairs of domain iterations and argument values + * to the corresponding accessed data elements. + * + * Since the accesses are currently represented by a single access relation, + * we return the entire access relation when "expr" is a write. + */ +__isl_give isl_union_map *pet_expr_access_get_dependent_must_write( + __isl_keep pet_expr *expr) +{ + isl_map *access; + + if (!expr) + return NULL; + if (!pet_expr_access_is_write(expr)) + return empty_access_relation(expr); + access = pet_expr_access_get_dependent_access(expr); + return isl_union_map_from_map(access); +} + /* Return the relation mapping domain iterations to all possibly * accessed data elements. * In particular, take the access relation and project out the values @@ -2009,6 +2079,40 @@ __isl_give isl_map *pet_expr_access_get_may_access(__isl_keep pet_expr *expr) return access; } +/* Return the relation mapping domain iterations to all possibly + * read data elements. + * + * Since the accesses are currently represented by a single access relation, + * we return the may access relation if "expr" is a read and + * an empty relation if it is not. + */ +__isl_give isl_union_map *pet_expr_access_get_may_read( + __isl_keep pet_expr *expr) +{ + if (!expr) + return NULL; + if (!pet_expr_access_is_read(expr)) + return empty_access_relation(expr); + return isl_union_map_from_map(pet_expr_access_get_may_access(expr)); +} + +/* Return the relation mapping domain iterations to all possibly + * written data elements. + * + * Since the accesses are currently represented by a single access relation, + * we return the may access relation if "expr" is a write and + * an empty relation if it is not. + */ +__isl_give isl_union_map *pet_expr_access_get_may_write( + __isl_keep pet_expr *expr) +{ + if (!expr) + return NULL; + if (!pet_expr_access_is_write(expr)) + return empty_access_relation(expr); + return isl_union_map_from_map(pet_expr_access_get_may_access(expr)); +} + /* Return a relation mapping domain iterations to definitely * accessed data elements, assuming the statement containing * the expression is executed. @@ -2016,7 +2120,8 @@ __isl_give isl_map *pet_expr_access_get_may_access(__isl_keep pet_expr *expr) * If there are no arguments, then all elements are accessed. * Otherwise, we conservatively return an empty relation. */ -__isl_give isl_map *pet_expr_access_get_must_access(__isl_keep pet_expr *expr) +static __isl_give isl_map *pet_expr_access_get_must_access( + __isl_keep pet_expr *expr) { isl_space *space; @@ -2035,19 +2140,55 @@ __isl_give isl_map *pet_expr_access_get_must_access(__isl_keep pet_expr *expr) return isl_map_empty(space); } +/* Return a relation mapping domain iterations to definitely + * written data elements, assuming the statement containing + * the expression is executed. + * + * Since the accesses are currently represented by a single access relation, + * we return the must access relation if "expr" is a write and + * an empty relation if it is not. + */ +__isl_give isl_union_map *pet_expr_access_get_must_write( + __isl_keep pet_expr *expr) +{ + if (!expr) + return NULL; + if (!pet_expr_access_is_write(expr)) + return empty_access_relation(expr); + return isl_union_map_from_map(pet_expr_access_get_must_access(expr)); +} + /* Return the relation mapping domain iterations to all possibly - * accessed data elements, with its domain tagged with the reference + * read data elements, with its domain tagged with the reference * identifier. */ -__isl_give isl_map *pet_expr_access_get_tagged_may_access( +__isl_give isl_union_map *pet_expr_access_get_tagged_may_read( __isl_keep pet_expr *expr) { - isl_map *access; + isl_union_map *access; + + if (!expr) + return NULL; + + access = pet_expr_access_get_may_read(expr); + access = pet_expr_tag_access(expr, access); + + return access; +} + +/* Return the relation mapping domain iterations to all possibly + * written data elements, with its domain tagged with the reference + * identifier. + */ +__isl_give isl_union_map *pet_expr_access_get_tagged_may_write( + __isl_keep pet_expr *expr) +{ + isl_union_map *access; if (!expr) return NULL; - access = pet_expr_access_get_may_access(expr); + access = pet_expr_access_get_may_write(expr); access = pet_expr_tag_access(expr, access); return access; diff --git a/expr.h b/expr.h index 77a12ae..199e991 100644 --- a/expr.h +++ b/expr.h @@ -137,6 +137,8 @@ __isl_give isl_space *pet_expr_access_get_domain_space( __isl_keep pet_expr *expr); __isl_give isl_space *pet_expr_access_get_data_space(__isl_keep pet_expr *expr); +__isl_give isl_map *pet_expr_access_get_may_access(__isl_keep pet_expr *expr); + __isl_give pet_expr *pet_expr_map_access(__isl_take pet_expr *expr, __isl_give pet_expr *(*fn)(__isl_take pet_expr *expr, void *user), void *user); @@ -175,8 +177,8 @@ __isl_give pet_expr *pet_expr_anonymize(__isl_take pet_expr *expr); __isl_give pet_expr *pet_expr_gist(__isl_take pet_expr *expr, __isl_keep isl_set *context, __isl_keep isl_union_map *value_bounds); -__isl_give isl_map *pet_expr_tag_access(__isl_keep pet_expr *expr, - __isl_take isl_map *access); +__isl_give isl_union_map *pet_expr_tag_access(__isl_keep pet_expr *expr, + __isl_take isl_union_map *access); __isl_give pet_expr *pet_expr_access_subscript(__isl_take pet_expr *base, __isl_take pet_expr *index); diff --git a/include/pet.h b/include/pet.h index 0c5c6d3..8c90407 100644 --- a/include/pet.h +++ b/include/pet.h @@ -185,14 +185,28 @@ __isl_give isl_multi_pw_aff *pet_expr_access_get_index( __isl_keep pet_expr *expr); /* Return the potential read access relation of access expression "expr". */ -__isl_give isl_map *pet_expr_access_get_may_access(__isl_keep pet_expr *expr); -/* Return the definite access relation of access expression "expr". */ -__isl_give isl_map *pet_expr_access_get_must_access(__isl_keep pet_expr *expr); -/* Return the argument dependent access relation of access expression "expr". */ -__isl_give isl_map *pet_expr_access_get_dependent_access( +__isl_give isl_union_map *pet_expr_access_get_may_read( + __isl_keep pet_expr *expr); +/* Return the potential write access relation of access expression "expr". */ +__isl_give isl_union_map *pet_expr_access_get_may_write( + __isl_keep pet_expr *expr); +/* Return the definite write access relation of access expression "expr". */ +__isl_give isl_union_map *pet_expr_access_get_must_write( + __isl_keep pet_expr *expr); +/* Return the argument dependent potential read access relation of "expr". */ +__isl_give isl_union_map *pet_expr_access_get_dependent_may_read( + __isl_keep pet_expr *expr); +/* Return the argument dependent potential write access relation of "expr". */ +__isl_give isl_union_map *pet_expr_access_get_dependent_may_write( + __isl_keep pet_expr *expr); +/* Return the argument dependent definite write access relation of "expr". */ +__isl_give isl_union_map *pet_expr_access_get_dependent_must_write( __isl_keep pet_expr *expr); /* Return the tagged potential read access relation of access "expr". */ -__isl_give isl_map *pet_expr_access_get_tagged_may_access( +__isl_give isl_union_map *pet_expr_access_get_tagged_may_read( + __isl_keep pet_expr *expr); +/* Return the tagged potential write access relation of access "expr". */ +__isl_give isl_union_map *pet_expr_access_get_tagged_may_write( __isl_keep pet_expr *expr); /* Return the name of the function called by "expr". */ diff --git a/scop.c b/scop.c index 2a9752c..f15e6ae 100644 --- a/scop.c +++ b/scop.c @@ -2352,12 +2352,14 @@ static __isl_give isl_union_map *expr_collect_access(__isl_keep pet_expr *expr, int tag, __isl_take isl_union_map *accesses, __isl_keep isl_set *domain) { isl_map *access; + isl_union_map *umap; access = pet_expr_access_get_may_access(expr); access = isl_map_intersect_domain(access, isl_set_copy(domain)); + umap = isl_union_map_from_map(access); if (tag) - access = pet_expr_tag_access(expr, access); - return isl_union_map_add_map(accesses, access); + umap = pet_expr_tag_access(expr, umap); + return isl_union_map_union(accesses, umap); } /* Internal data structure for expr_collect_accesses. -- 2.11.4.GIT