context.c

   1 /*
   2  * Copyright 2011      Leiden University. All rights reserved.
   3  * Copyright 2014      Ecole Normale Superieure. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  *    1. Redistributions of source code must retain the above copyright
  10  *       notice, this list of conditions and the following disclaimer.
  11  *
  12  *    2. Redistributions in binary form must reproduce the above
  13  *       copyright notice, this list of conditions and the following
  14  *       disclaimer in the documentation and/or other materials provided
  15  *       with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY LEIDEN UNIVERSITY ''AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LEIDEN UNIVERSITY OR
  21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  24  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * The views and conclusions contained in the software and documentation
  30  * are those of the authors and should not be interpreted as
  31  * representing official policies, either expressed or implied, of
  32  * Leiden University.
  33  */
  34
  35 #include <isl/aff.h>
  36
  37 #include "context.h"
  38
  39 /* A pet_context represents the context in which a pet_expr
  40  * in converted to an affine expression.
  41  *
  42  * "domain" prescribes the domain space of the affine expressions.
  43  *
  44  * "assignments" maps variable names to their currently known values.
  45  * The domains of the values are equal to "domain".
  46  * If a variable has been assigned an unknown value (possibly because
  47  * it may be assigned a different expression in each iteration) or a value
  48  * that is not an affine expression, then the corresponding isl_pw_aff
  49  * is set to NaN.
  50  *
  51  * If "allow_nested" is set, then the affine expression created
  52  * in this context may involve new parameters that encode a pet_expr.
  53  */
  54 struct pet_context {
  55         int ref;
  56
  57         isl_space *domain;
  58         isl_id_to_pw_aff *assignments;
  59         int allow_nested;
  60 };
  61
  62 /* Create a pet_context with the given domain, assignments,
  63  * and value for allow_nested.
  64  */
  65 static __isl_give pet_context *context_alloc(__isl_take isl_space *domain,
  66         __isl_take isl_id_to_pw_aff *assignments, int allow_nested)
  67 {
  68         pet_context *pc;
  69
  70         if (!domain || !assignments)
  71                 goto error;
  72
  73         pc = isl_calloc_type(isl_space_get_ctx(domain), struct pet_context);
  74         if (!pc)
  75                 goto error;
  76
  77         pc->ref = 1;
  78         pc->domain = domain;
  79         pc->assignments = assignments;
  80         pc->allow_nested = allow_nested;
  81
  82         return pc;
  83 error:
  84         isl_space_free(domain);
  85         isl_id_to_pw_aff_free(assignments);
  86         return NULL;
  87 }
  88
  89 /* Create a pet_context with the given domain.
  90  *
  91  * Initially, there are no assigned values and parameters that
  92  * encode a pet_expr are not allowed.
  93  */
  94 __isl_give pet_context *pet_context_alloc(__isl_take isl_space *domain)
  95 {
  96         isl_id_to_pw_aff *assignments;
  97
  98         if (!domain)
  99                 return NULL;
 100
 101         assignments = isl_id_to_pw_aff_alloc(isl_space_get_ctx(domain), 0);;
 102         return context_alloc(domain, assignments, 0);
 103 }
 104
 105 /* Return an independent duplicate of "pc".
 106  */
 107 static __isl_give pet_context *pet_context_dup(__isl_keep pet_context *pc)
 108 {
 109         pet_context *dup;
 110
 111         if (!pc)
 112                 return NULL;
 113
 114         dup = context_alloc(isl_space_copy(pc->domain),
 115                             isl_id_to_pw_aff_copy(pc->assignments),
 116                             pc->allow_nested);
 117
 118         return dup;
 119 }
 120
 121 /* Return a pet_context that is equal to "pc" and that has only one reference.
 122  */
 123 static __isl_give pet_context *pet_context_cow(__isl_take pet_context *pc)
 124 {
 125         if (!pc)
 126                 return NULL;
 127
 128         if (pc->ref == 1)
 129                 return pc;
 130         pc->ref--;
 131         return pet_context_dup(pc);
 132 }
 133
 134 /* Return an extra reference to "pc".
 135  */
 136 __isl_give pet_context *pet_context_copy(__isl_keep pet_context *pc)
 137 {
 138         if (!pc)
 139                 return NULL;
 140
 141         pc->ref++;
 142         return pc;
 143 }
 144
 145 /* Free a reference to "pc" and return NULL.
 146  */
 147 __isl_null pet_context *pet_context_free(__isl_take pet_context *pc)
 148 {
 149         if (!pc)
 150                 return NULL;
 151         if (--pc->ref > 0)
 152                 return NULL;
 153
 154         isl_space_free(pc->domain);
 155         isl_id_to_pw_aff_free(pc->assignments);
 156         free(pc);
 157         return NULL;
 158 }
 159
 160 /* Return the isl_ctx in which "pc" was created.
 161  */
 162 isl_ctx *pet_context_get_ctx(__isl_keep pet_context *pc)
 163 {
 164         return pc ? isl_space_get_ctx(pc->domain) : NULL;
 165 }
 166
 167 /* Return the domain space of "pc".
 168  */
 169 __isl_give isl_space *pet_context_get_space(__isl_keep pet_context *pc)
 170 {
 171         if (!pc)
 172                 return NULL;
 173         return isl_space_copy(pc->domain);
 174 }
 175
 176 /* Return the dimension of the domain space of "pc".
 177  */
 178 unsigned pet_context_dim(__isl_keep pet_context *pc)
 179 {
 180         if (!pc)
 181                 return 0;
 182         return isl_space_dim(pc->domain, isl_dim_set);
 183 }
 184
 185 /* Return the assignments of "pc".
 186  */
 187 __isl_give isl_id_to_pw_aff *pet_context_get_assignments(
 188         __isl_keep pet_context *pc)
 189 {
 190         if (!pc)
 191                 return NULL;
 192         return isl_id_to_pw_aff_copy(pc->assignments);
 193 }
 194
 195 /* Is "id" assigned any value in "pc"?
 196  */
 197 int pet_context_is_assigned(__isl_keep pet_context *pc, __isl_keep isl_id *id)
 198 {
 199         if (!pc || !id)
 200                 return -1;
 201         return isl_id_to_pw_aff_has(pc->assignments, id);
 202 }
 203
 204 /* Return the value assigned to "id" in "pc".
 205  */
 206 __isl_give isl_pw_aff *pet_context_get_value(__isl_keep pet_context *pc,
 207         __isl_take isl_id *id)
 208 {
 209         if (!pc || !id)
 210                 goto error;
 211
 212         return isl_id_to_pw_aff_get(pc->assignments, id);
 213 error:
 214         isl_id_free(id);
 215         return NULL;
 216 }
 217
 218 /* Assign the value "value" to "id" in "pc", replacing the previously
 219  * assigned value, if any.
 220  */
 221 __isl_give pet_context *pet_context_set_value(__isl_take pet_context *pc,
 222         __isl_take isl_id *id, isl_pw_aff *value)
 223 {
 224         pc = pet_context_cow(pc);
 225         if (!pc)
 226                 goto error;
 227         pc->assignments = isl_id_to_pw_aff_set(pc->assignments, id, value);
 228         if (!pc->assignments)
 229                 return pet_context_free(pc);
 230         return pc;
 231 error:
 232         isl_id_free(id);
 233         isl_pw_aff_free(value);
 234         return NULL;
 235 }
 236
 237 /* Remove any assignment to "id" in "pc".
 238  */
 239 __isl_give pet_context *pet_context_clear_value(__isl_keep pet_context *pc,
 240         __isl_take isl_id *id)
 241 {
 242         pc = pet_context_cow(pc);
 243         if (!pc)
 244                 goto error;
 245         pc->assignments = isl_id_to_pw_aff_drop(pc->assignments, id);
 246         if (!pc->assignments)
 247                 return pet_context_free(pc);
 248         return pc;
 249 error:
 250         isl_id_free(id);
 251         return NULL;
 252 }
 253
 254 /* Return a piecewise affine expression defined on the specified domain
 255  * that represents NaN.
 256  */
 257 static __isl_give isl_pw_aff *nan_on_domain(__isl_take isl_space *space)
 258 {
 259         return isl_pw_aff_nan_on_domain(isl_local_space_from_space(space));
 260 }
 261
 262 /* Assign the value NaN to "id" in "pc", marked it as having an unknown
 263  * value.
 264  */
 265 __isl_give pet_context *pet_context_mark_unknown(__isl_take pet_context *pc,
 266         __isl_take isl_id *id)
 267 {
 268         isl_pw_aff *pa;
 269
 270         pa = nan_on_domain(pet_context_get_space(pc));
 271         pc = pet_context_set_value(pc, id, pa);
 272
 273         return pc;
 274 }
 275
 276 /* Are affine expressions created in this context allowed to involve
 277  * parameters that encode a pet_expr?
 278  */
 279 int pet_context_allow_nesting(__isl_keep pet_context *pc)
 280 {
 281         if (!pc)
 282                 return -1;
 283         return pc->allow_nested;
 284 }
 285
 286 /* Allow affine expressions created in this context to involve
 287  * parameters that encode a pet_expr based on the value of "allow_nested".
 288  */
 289 __isl_give pet_context *pet_context_set_allow_nested(__isl_take pet_context *pc,
 290         int allow_nested)
 291 {
 292         if (!pc)
 293                 return NULL;
 294         if (pc->allow_nested == allow_nested)
 295                 return pc;
 296         pc = pet_context_cow(pc);
 297         if (!pc)
 298                 return NULL;
 299         pc->allow_nested = allow_nested;
 300         return pc;
 301 }
 302
 303 void pet_context_dump(__isl_keep pet_context *pc)
 304 {
 305         if (!pc)
 306                 return;
 307         fprintf(stderr, "domain: ");
 308         isl_space_dump(pc->domain);
 309         fprintf(stderr, "assignments: ");
 310         isl_id_to_pw_aff_dump(pc->assignments);
 311         fprintf(stderr, "nesting allowed: %d\n", pc->allow_nested);
 312 }