isl_band.c

   1 /*
   2  * Copyright 2011      INRIA Saclay
   3  * Copyright 2012-2013 Ecole Normale Superieure
   4  *
   5  * Use of this software is governed by the MIT license
   6  *
   7  * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
   8  * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
   9  * 91893 Orsay, France
  10  * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
  11  */
  12
  13 #include <isl_band_private.h>
  14 #include <isl_schedule_private.h>
  15
  16 #undef BASE
  17 #define BASE band
  18
  19 #include <isl_list_templ.c>
  20
  21 isl_ctx *isl_band_get_ctx(__isl_keep isl_band *band)
  22 {
  23         return band ? isl_union_pw_multi_aff_get_ctx(band->pma) : NULL;
  24 }
  25
  26 __isl_give isl_band *isl_band_alloc(isl_ctx *ctx)
  27 {
  28         isl_band *band;
  29
  30         band = isl_calloc_type(ctx, isl_band);
  31         if (!band)
  32                 return NULL;
  33
  34         band->ref = 1;
  35
  36         return band;
  37 }
  38
  39 /* Create a duplicate of the given band.  The duplicate refers
  40  * to the same schedule and parent as the input, but does not
  41  * increment their reference counts.
  42  */
  43 __isl_give isl_band *isl_band_dup(__isl_keep isl_band *band)
  44 {
  45         int i;
  46         isl_ctx *ctx;
  47         isl_band *dup;
  48
  49         if (!band)
  50                 return NULL;
  51
  52         ctx = isl_band_get_ctx(band);
  53         dup = isl_band_alloc(ctx);
  54         if (!dup)
  55                 return NULL;
  56
  57         dup->n = band->n;
  58         dup->coincident = isl_alloc_array(ctx, int, band->n);
  59         if (band->n && !dup->coincident)
  60                 goto error;
  61
  62         for (i = 0; i < band->n; ++i)
  63                 dup->coincident[i] = band->coincident[i];
  64
  65         dup->pma = isl_union_pw_multi_aff_copy(band->pma);
  66         dup->schedule = band->schedule;
  67         dup->parent = band->parent;
  68
  69         if (!dup->pma)
  70                 goto error;
  71
  72         return dup;
  73 error:
  74         isl_band_free(dup);
  75         return NULL;
  76 }
  77
  78 /* We not only increment the reference count of the band,
  79  * but also that of the schedule that contains this band.
  80  * This ensures that the schedule won't disappear while there
  81  * is still a reference to the band outside of the schedule.
  82  * There is no need to increment the reference count of the parent
  83  * band as the parent band is part of the same schedule.
  84  */
  85 __isl_give isl_band *isl_band_copy(__isl_keep isl_band *band)
  86 {
  87         if (!band)
  88                 return NULL;
  89
  90         band->ref++;
  91         band->schedule->ref++;
  92         return band;
  93 }
  94
  95 /* If this is not the last reference to the band (the one from within the
  96  * schedule), then we also need to decrement the reference count of the
  97  * containing schedule as it was incremented in isl_band_copy.
  98  */
  99 __isl_null isl_band *isl_band_free(__isl_take isl_band *band)
 100 {
 101         if (!band)
 102                 return NULL;
 103
 104         if (--band->ref > 0) {
 105                 isl_schedule_free(band->schedule);
 106                 return NULL;
 107         }
 108
 109         isl_union_pw_multi_aff_free(band->pma);
 110         isl_band_list_free(band->children);
 111         free(band->coincident);
 112         free(band);
 113
 114         return NULL;
 115 }
 116
 117 int isl_band_has_children(__isl_keep isl_band *band)
 118 {
 119         if (!band)
 120                 return -1;
 121
 122         return band->children != NULL;
 123 }
 124
 125 __isl_give isl_band_list *isl_band_get_children(
 126         __isl_keep isl_band *band)
 127 {
 128         if (!band)
 129                 return NULL;
 130         if (!band->children)
 131                 isl_die(isl_band_get_ctx(band), isl_error_invalid,
 132                         "band has no children", return NULL);
 133         return isl_band_list_dup(band->children);
 134 }
 135
 136 int isl_band_n_member(__isl_keep isl_band *band)
 137 {
 138         return band ? band->n : 0;
 139 }
 140
 141 /* Is the given scheduling dimension coincident within the band and
 142  * with respect to the coincidence constraints.
 143  */
 144 int isl_band_member_is_coincident(__isl_keep isl_band *band, int pos)
 145 {
 146         if (!band)
 147                 return -1;
 148
 149         if (pos < 0 || pos >= band->n)
 150                 isl_die(isl_band_get_ctx(band), isl_error_invalid,
 151                         "invalid member position", return -1);
 152
 153         return band->coincident[pos];
 154 }
 155
 156 /* Return the schedule that leads up to this band.
 157  */
 158 __isl_give isl_union_map *isl_band_get_prefix_schedule(
 159         __isl_keep isl_band *band)
 160 {
 161         isl_union_set *domain;
 162         isl_union_pw_multi_aff *prefix;
 163         isl_band *a;
 164
 165         if (!band)
 166                 return NULL;
 167
 168         prefix = isl_union_pw_multi_aff_copy(band->pma);
 169         domain = isl_union_pw_multi_aff_domain(prefix);
 170         prefix = isl_union_pw_multi_aff_from_domain(domain);
 171
 172         for (a = band->parent; a; a = a->parent) {
 173                 isl_union_pw_multi_aff *partial;
 174
 175                 partial = isl_union_pw_multi_aff_copy(a->pma);
 176                 prefix = isl_union_pw_multi_aff_flat_range_product(partial,
 177                                                                    prefix);
 178         }
 179
 180         return isl_union_map_from_union_pw_multi_aff(prefix);
 181 }
 182
 183 /* Return the schedule of the band in isolation.
 184  */
 185 __isl_give isl_union_pw_multi_aff *
 186 isl_band_get_partial_schedule_union_pw_multi_aff(__isl_keep isl_band *band)
 187 {
 188         return band ? isl_union_pw_multi_aff_copy(band->pma) : NULL;
 189 }
 190
 191 /* Return the schedule of the band in isolation.
 192  */
 193 __isl_give isl_union_map *isl_band_get_partial_schedule(
 194         __isl_keep isl_band *band)
 195 {
 196         isl_union_pw_multi_aff *sched;
 197
 198         sched = isl_band_get_partial_schedule_union_pw_multi_aff(band);
 199         return isl_union_map_from_union_pw_multi_aff(sched);
 200 }
 201
 202 __isl_give isl_union_pw_multi_aff *
 203 isl_band_get_suffix_schedule_union_pw_multi_aff(__isl_keep isl_band *band);
 204
 205 /* Return the schedule for the given band list.
 206  * For each band in the list, the schedule is composed of the partial
 207  * and suffix schedules of that band.
 208  */
 209 __isl_give isl_union_pw_multi_aff *
 210 isl_band_list_get_suffix_schedule_union_pw_multi_aff(
 211         __isl_keep isl_band_list *list)
 212 {
 213         isl_ctx *ctx;
 214         int i, n;
 215         isl_space *space;
 216         isl_union_pw_multi_aff *suffix;
 217
 218         if (!list)
 219                 return NULL;
 220
 221         ctx = isl_band_list_get_ctx(list);
 222         space = isl_space_alloc(ctx, 0, 0, 0);
 223         suffix = isl_union_pw_multi_aff_empty(space);
 224         n = isl_band_list_n_band(list);
 225         for (i = 0; i < n; ++i) {
 226                 isl_band *el;
 227                 isl_union_pw_multi_aff *partial;
 228                 isl_union_pw_multi_aff *suffix_i;
 229
 230                 el = isl_band_list_get_band(list, i);
 231                 partial = isl_band_get_partial_schedule_union_pw_multi_aff(el);
 232                 suffix_i = isl_band_get_suffix_schedule_union_pw_multi_aff(el);
 233                 suffix_i = isl_union_pw_multi_aff_flat_range_product(
 234                                 partial, suffix_i);
 235                 suffix = isl_union_pw_multi_aff_union_add(suffix, suffix_i);
 236
 237                 isl_band_free(el);
 238         }
 239
 240         return suffix;
 241 }
 242
 243 /* Return the schedule for the given band list.
 244  * For each band in the list, the schedule is composed of the partial
 245  * and suffix schedules of that band.
 246  */
 247 __isl_give isl_union_map *isl_band_list_get_suffix_schedule(
 248         __isl_keep isl_band_list *list)
 249 {
 250         isl_union_pw_multi_aff *suffix;
 251
 252         suffix = isl_band_list_get_suffix_schedule_union_pw_multi_aff(list);
 253         return isl_union_map_from_union_pw_multi_aff(suffix);
 254 }
 255
 256 /* Return the schedule for the forest underneath the given band.
 257  */
 258 __isl_give isl_union_pw_multi_aff *
 259 isl_band_get_suffix_schedule_union_pw_multi_aff(__isl_keep isl_band *band)
 260 {
 261         isl_union_pw_multi_aff *suffix;
 262
 263         if (!band)
 264                 return NULL;
 265
 266         if (!isl_band_has_children(band)) {
 267                 isl_union_set *domain;
 268
 269                 suffix = isl_union_pw_multi_aff_copy(band->pma);
 270                 domain = isl_union_pw_multi_aff_domain(suffix);
 271                 suffix = isl_union_pw_multi_aff_from_domain(domain);
 272         } else {
 273                 isl_band_list *list;
 274
 275                 list = isl_band_get_children(band);
 276                 suffix =
 277                     isl_band_list_get_suffix_schedule_union_pw_multi_aff(list);
 278                 isl_band_list_free(list);
 279         }
 280
 281         return suffix;
 282 }
 283
 284 /* Return the schedule for the forest underneath the given band.
 285  */
 286 __isl_give isl_union_map *isl_band_get_suffix_schedule(
 287         __isl_keep isl_band *band)
 288 {
 289         isl_union_pw_multi_aff *suffix;
 290
 291         suffix = isl_band_get_suffix_schedule_union_pw_multi_aff(band);
 292         return isl_union_map_from_union_pw_multi_aff(suffix);
 293 }
 294
 295 /* Call "fn" on each band (recursively) in the list
 296  * in depth-first post-order.
 297  */
 298 int isl_band_list_foreach_band(__isl_keep isl_band_list *list,
 299         int (*fn)(__isl_keep isl_band *band, void *user), void *user)
 300 {
 301         int i, n;
 302
 303         if (!list)
 304                 return -1;
 305
 306         n = isl_band_list_n_band(list);
 307         for (i = 0; i < n; ++i) {
 308                 isl_band *band;
 309                 int r = 0;
 310
 311                 band = isl_band_list_get_band(list, i);
 312                 if (isl_band_has_children(band)) {
 313                         isl_band_list *children;
 314
 315                         children = isl_band_get_children(band);
 316                         r = isl_band_list_foreach_band(children, fn, user);
 317                         isl_band_list_free(children);
 318                 }
 319
 320                 if (!band)
 321                         r = -1;
 322                 if (r == 0)
 323                         r = fn(band, user);
 324
 325                 isl_band_free(band);
 326                 if (r)
 327                         return r;
 328         }
 329
 330         return 0;
 331 }
 332
 333 /* Internal data used during the construction of the schedule
 334  * for the tile loops.
 335  *
 336  * sizes contains the tile sizes
 337  * scale is set if the tile loops should be scaled
 338  * tiled collects the result for a single statement
 339  * res collects the result for all statements
 340  */
 341 struct isl_band_tile_data {
 342         isl_multi_val *sizes;
 343         isl_union_pw_multi_aff *res;
 344         isl_pw_multi_aff *tiled;
 345         int scale;
 346 };
 347
 348 /* Given part of the schedule of a band, construct the corresponding
 349  * schedule for the tile loops based on the tile sizes in data->sizes
 350  * and add the result to data->tiled.
 351  *
 352  * If data->scale is set, then dimension i of the schedule will be
 353  * of the form
 354  *
 355  *      m_i * floor(s_i(x) / m_i)
 356  *
 357  * where s_i(x) refers to the original schedule and m_i is the tile size.
 358  * If data->scale is not set, then dimension i of the schedule will be
 359  * of the form
 360  *
 361  *      floor(s_i(x) / m_i)
 362  *
 363  */
 364 static int multi_aff_tile(__isl_take isl_set *set,
 365         __isl_take isl_multi_aff *ma, void *user)
 366 {
 367         struct isl_band_tile_data *data = user;
 368         isl_pw_multi_aff *pma;
 369         int i, n;
 370         isl_val *v;
 371
 372         n = isl_multi_aff_dim(ma, isl_dim_out);
 373
 374         for (i = 0; i < n; ++i) {
 375                 isl_aff *aff;
 376
 377                 aff = isl_multi_aff_get_aff(ma, i);
 378                 v = isl_multi_val_get_val(data->sizes, i);
 379
 380                 aff = isl_aff_scale_down_val(aff, isl_val_copy(v));
 381                 aff = isl_aff_floor(aff);
 382                 if (data->scale)
 383                         aff = isl_aff_scale_val(aff, isl_val_copy(v));
 384                 isl_val_free(v);
 385
 386                 ma = isl_multi_aff_set_aff(ma, i, aff);
 387         }
 388
 389         pma = isl_pw_multi_aff_alloc(set, ma);
 390         data->tiled = isl_pw_multi_aff_union_add(data->tiled, pma);
 391
 392         return 0;
 393 }
 394
 395 /* Given part of the schedule of a band, construct the corresponding
 396  * schedule for the tile loops based on the tile sizes in data->sizes
 397  * and add the result to data->res.
 398  */
 399 static int pw_multi_aff_tile(__isl_take isl_pw_multi_aff *pma, void *user)
 400 {
 401         struct isl_band_tile_data *data = user;
 402
 403         data->tiled = isl_pw_multi_aff_empty(isl_pw_multi_aff_get_space(pma));
 404
 405         if (isl_pw_multi_aff_foreach_piece(pma, &multi_aff_tile, data) < 0)
 406                 goto error;
 407
 408         isl_pw_multi_aff_free(pma);
 409         data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res,
 410                                                                 data->tiled);
 411
 412         return 0;
 413 error:
 414         isl_pw_multi_aff_free(pma);
 415         isl_pw_multi_aff_free(data->tiled);
 416         return -1;
 417 }
 418
 419 /* Given the schedule of a band, construct the corresponding
 420  * schedule for the tile loops based on the given tile sizes
 421  * and return the result.
 422  */
 423 static isl_union_pw_multi_aff *isl_union_pw_multi_aff_tile(
 424         __isl_take isl_union_pw_multi_aff *sched,
 425         __isl_keep isl_multi_val *sizes)
 426 {
 427         isl_ctx *ctx;
 428         isl_space *space;
 429         struct isl_band_tile_data data = { sizes };
 430
 431         ctx = isl_multi_val_get_ctx(sizes);
 432
 433         space = isl_union_pw_multi_aff_get_space(sched);
 434         data.res = isl_union_pw_multi_aff_empty(space);
 435         data.scale = isl_options_get_tile_scale_tile_loops(ctx);
 436
 437         if (isl_union_pw_multi_aff_foreach_pw_multi_aff(sched,
 438                                                 &pw_multi_aff_tile, &data) < 0)
 439                 goto error;
 440
 441         isl_union_pw_multi_aff_free(sched);
 442         return data.res;
 443 error:
 444         isl_union_pw_multi_aff_free(sched);
 445         isl_union_pw_multi_aff_free(data.res);
 446         return NULL;
 447 }
 448
 449 /* Extract the range space from "pma" and store it in *user.
 450  * All entries are expected to have the same range space, so we can
 451  * stop after extracting the range space from the first entry.
 452  */
 453 static int extract_range_space(__isl_take isl_pw_multi_aff *pma, void *user)
 454 {
 455         isl_space **space = user;
 456
 457         *space = isl_space_range(isl_pw_multi_aff_get_space(pma));
 458         isl_pw_multi_aff_free(pma);
 459
 460         return -1;
 461 }
 462
 463 /* Extract the range space of "band".  All entries in band->pma should
 464  * have the same range space.  Furthermore, band->pma should have at least
 465  * one entry.
 466  */
 467 static __isl_give isl_space *band_get_range_space(__isl_keep isl_band *band)
 468 {
 469         isl_space *space;
 470
 471         if (!band)
 472                 return NULL;
 473
 474         space = NULL;
 475         isl_union_pw_multi_aff_foreach_pw_multi_aff(band->pma,
 476                                                 &extract_range_space, &space);
 477
 478         return space;
 479 }
 480
 481 /* Construct and return an isl_multi_val in the given space, with as entries
 482  * the first elements of "v", padded with ones if the size of "v" is smaller
 483  * than the dimension of "space".
 484  */
 485 static __isl_give isl_multi_val *multi_val_from_vec(__isl_take isl_space *space,
 486         __isl_take isl_vec *v)
 487 {
 488         isl_ctx *ctx;
 489         isl_multi_val *mv;
 490         int i, n, size;
 491
 492         if (!space || !v)
 493                 goto error;
 494
 495         ctx = isl_space_get_ctx(space);
 496         mv = isl_multi_val_zero(space);
 497         n = isl_multi_val_dim(mv, isl_dim_set);
 498         size = isl_vec_size(v);
 499         if (n < size)
 500                 size = n;
 501
 502         for (i = 0; i < size; ++i) {
 503                 isl_val *val = isl_vec_get_element_val(v, i);
 504                 mv = isl_multi_val_set_val(mv, i, val);
 505         }
 506         for (i = size; i < n; ++i)
 507                 mv = isl_multi_val_set_val(mv, i, isl_val_one(ctx));
 508
 509         isl_vec_free(v);
 510         return mv;
 511 error:
 512         isl_space_free(space);
 513         isl_vec_free(v);
 514         return NULL;
 515 }
 516
 517 /* Tile the given band using the specified tile sizes.
 518  * The given band is modified to refer to the tile loops and
 519  * a child band is created to refer to the point loops.
 520  * The children of this point loop band are the children
 521  * of the original band.
 522  *
 523  * If the scale tile loops option is set, then the tile loops
 524  * are scaled by the tile sizes.  If the shift point loops option is set,
 525  * then the point loops are shifted to start at zero.
 526  * In particular, these options affect the tile and point loop schedules
 527  * as follows
 528  *
 529  *      scale   shift   original        tile            point
 530  *
 531  *      0       0       i               floor(i/s)      i
 532  *      1       0       i               s * floor(i/s)  i
 533  *      0       1       i               floor(i/s)      i - s * floor(i/s)
 534  *      1       1       i               s * floor(i/s)  i - s * floor(i/s)
 535  */
 536 int isl_band_tile(__isl_keep isl_band *band, __isl_take isl_vec *sizes)
 537 {
 538         isl_ctx *ctx;
 539         isl_band *child;
 540         isl_band_list *list = NULL;
 541         isl_union_pw_multi_aff *sched = NULL, *child_sched = NULL;
 542         isl_space *space;
 543         isl_multi_val *mv_sizes;
 544
 545         if (!band || !sizes)
 546                 goto error;
 547
 548         ctx = isl_vec_get_ctx(sizes);
 549         child = isl_band_dup(band);
 550         list = isl_band_list_alloc(ctx, 1);
 551         list = isl_band_list_add(list, child);
 552         if (!list)
 553                 goto error;
 554
 555         space = band_get_range_space(band);
 556         mv_sizes = multi_val_from_vec(space, isl_vec_copy(sizes));
 557         sched = isl_union_pw_multi_aff_copy(band->pma);
 558         sched = isl_union_pw_multi_aff_tile(sched, mv_sizes);
 559
 560         child_sched = isl_union_pw_multi_aff_copy(child->pma);
 561         if (isl_options_get_tile_shift_point_loops(ctx)) {
 562                 isl_union_pw_multi_aff *scaled;
 563                 scaled = isl_union_pw_multi_aff_copy(sched);
 564                 if (!isl_options_get_tile_scale_tile_loops(ctx))
 565                         scaled = isl_union_pw_multi_aff_scale_multi_val(scaled,
 566                                                 isl_multi_val_copy(mv_sizes));
 567                 child_sched = isl_union_pw_multi_aff_sub(child_sched, scaled);
 568         }
 569         isl_multi_val_free(mv_sizes);
 570         if (!sched || !child_sched)
 571                 goto error;
 572
 573         child->children = band->children;
 574         band->children = list;
 575         child->parent = band;
 576         isl_union_pw_multi_aff_free(band->pma);
 577         band->pma = sched;
 578         isl_union_pw_multi_aff_free(child->pma);
 579         child->pma = child_sched;
 580
 581         isl_vec_free(sizes);
 582         return 0;
 583 error:
 584         isl_union_pw_multi_aff_free(sched);
 585         isl_union_pw_multi_aff_free(child_sched);
 586         isl_band_list_free(list);
 587         isl_vec_free(sizes);
 588         return -1;
 589 }
 590
 591 /* Internal data structure used inside isl_union_pw_multi_aff_drop.
 592  *
 593  * "pos" is the position of the first dimension to drop.
 594  * "n" is the number of dimensions to drop.
 595  * "res" accumulates the result.
 596  */
 597 struct isl_union_pw_multi_aff_drop_data {
 598         int pos;
 599         int n;
 600         isl_union_pw_multi_aff *res;
 601 };
 602
 603 /* Drop the data->n output dimensions starting at data->pos from "pma"
 604  * and add the result to data->res.
 605  */
 606 static int pw_multi_aff_drop(__isl_take isl_pw_multi_aff *pma, void *user)
 607 {
 608         struct isl_union_pw_multi_aff_drop_data *data = user;
 609
 610         pma = isl_pw_multi_aff_drop_dims(pma, isl_dim_out, data->pos, data->n);
 611
 612         data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res, pma);
 613         if (!data->res)
 614                 return -1;
 615
 616         return 0;
 617 }
 618
 619 /* Drop the "n" output dimensions starting at "pos" from "sched".
 620  */
 621 static isl_union_pw_multi_aff *isl_union_pw_multi_aff_drop(
 622         __isl_take isl_union_pw_multi_aff *sched, int pos, int n)
 623 {
 624         isl_space *space;
 625         struct isl_union_pw_multi_aff_drop_data data = { pos, n };
 626
 627         space = isl_union_pw_multi_aff_get_space(sched);
 628         data.res = isl_union_pw_multi_aff_empty(space);
 629
 630         if (isl_union_pw_multi_aff_foreach_pw_multi_aff(sched,
 631                                                 &pw_multi_aff_drop, &data) < 0)
 632                 data.res = isl_union_pw_multi_aff_free(data.res);
 633
 634         isl_union_pw_multi_aff_free(sched);
 635         return data.res;
 636 }
 637
 638 /* Drop the "n" dimensions starting at "pos" from "band".
 639  */
 640 static int isl_band_drop(__isl_keep isl_band *band, int pos, int n)
 641 {
 642         int i;
 643         isl_union_pw_multi_aff *sched;
 644
 645         if (!band)
 646                 return -1;
 647         if (n == 0)
 648                 return 0;
 649
 650         sched = isl_union_pw_multi_aff_copy(band->pma);
 651         sched = isl_union_pw_multi_aff_drop(sched, pos, n);
 652         if (!sched)
 653                 return -1;
 654
 655         isl_union_pw_multi_aff_free(band->pma);
 656         band->pma = sched;
 657
 658         for (i = pos + n; i < band->n; ++i)
 659                 band->coincident[i - n] = band->coincident[i];
 660
 661         band->n -= n;
 662
 663         return 0;
 664 }
 665
 666 /* Split the given band into two nested bands, one with the first "pos"
 667  * dimensions of "band" and one with the remaining band->n - pos dimensions.
 668  */
 669 int isl_band_split(__isl_keep isl_band *band, int pos)
 670 {
 671         isl_ctx *ctx;
 672         isl_band *child;
 673         isl_band_list *list;
 674
 675         if (!band)
 676                 return -1;
 677
 678         ctx = isl_band_get_ctx(band);
 679
 680         if (pos < 0 || pos > band->n)
 681                 isl_die(ctx, isl_error_invalid, "position out of bounds",
 682                         return -1);
 683
 684         child = isl_band_dup(band);
 685         if (isl_band_drop(child, 0, pos) < 0)
 686                 child = isl_band_free(child);
 687         list = isl_band_list_alloc(ctx, 1);
 688         list = isl_band_list_add(list, child);
 689         if (!list)
 690                 return -1;
 691
 692         if (isl_band_drop(band, pos, band->n - pos) < 0) {
 693                 isl_band_list_free(list);
 694                 return -1;
 695         }
 696
 697         child->children = band->children;
 698         band->children = list;
 699         child->parent = band;
 700
 701         return 0;
 702 }
 703
 704 __isl_give isl_printer *isl_printer_print_band(__isl_take isl_printer *p,
 705         __isl_keep isl_band *band)
 706 {
 707         isl_union_map *prefix, *partial, *suffix;
 708
 709         prefix = isl_band_get_prefix_schedule(band);
 710         partial = isl_band_get_partial_schedule(band);
 711         suffix = isl_band_get_suffix_schedule(band);
 712
 713         p = isl_printer_print_str(p, "(");
 714         p = isl_printer_print_union_map(p, prefix);
 715         p = isl_printer_print_str(p, ",");
 716         p = isl_printer_print_union_map(p, partial);
 717         p = isl_printer_print_str(p, ",");
 718         p = isl_printer_print_union_map(p, suffix);
 719         p = isl_printer_print_str(p, ")");
 720
 721         isl_union_map_free(prefix);
 722         isl_union_map_free(partial);
 723         isl_union_map_free(suffix);
 724
 725         return p;
 726 }