1 #include <isl/id.h> 2 #include <isl/val.h> 3 #include <isl/schedule.h> 4 #include <isl/stream.h> 5 #include <isl_schedule_private.h> 6 #include <isl_schedule_tree.h> 7 8 /* An enumeration of the various keys that may appear in a YAML mapping 9 * of a schedule. 10 */ 11 enum isl_schedule_key { 12 isl_schedule_key_error = -1, 13 isl_schedule_key_child, 14 isl_schedule_key_coincident, 15 isl_schedule_key_context, 16 isl_schedule_key_contraction, 17 isl_schedule_key_domain, 18 isl_schedule_key_expansion, 19 isl_schedule_key_extension, 20 isl_schedule_key_filter, 21 isl_schedule_key_guard, 22 isl_schedule_key_leaf, 23 isl_schedule_key_mark, 24 isl_schedule_key_options, 25 isl_schedule_key_permutable, 26 isl_schedule_key_schedule, 27 isl_schedule_key_sequence, 28 isl_schedule_key_set, 29 isl_schedule_key_end 30 }; 31 32 /* Textual representations of the YAML keys for an isl_schedule object. 33 */ 34 static char *key_str[] = { 35 [isl_schedule_key_child] = "child", 36 [isl_schedule_key_coincident] = "coincident", 37 [isl_schedule_key_context] = "context", 38 [isl_schedule_key_contraction] = "contraction", 39 [isl_schedule_key_domain] = "domain", 40 [isl_schedule_key_expansion] = "expansion", 41 [isl_schedule_key_extension] = "extension", 42 [isl_schedule_key_filter] = "filter", 43 [isl_schedule_key_guard] = "guard", 44 [isl_schedule_key_leaf] = "leaf", 45 [isl_schedule_key_mark] = "mark", 46 [isl_schedule_key_options] = "options", 47 [isl_schedule_key_permutable] = "permutable", 48 [isl_schedule_key_schedule] = "schedule", 49 [isl_schedule_key_sequence] = "sequence", 50 [isl_schedule_key_set] = "set", 51 }; 52 53 #undef KEY 54 #define KEY enum isl_schedule_key 55 #undef KEY_ERROR 56 #define KEY_ERROR isl_schedule_key_error 57 #undef KEY_END 58 #define KEY_END isl_schedule_key_end 59 #undef KEY_STR 60 #define KEY_STR key_str 61 #undef KEY_EXTRACT 62 #define KEY_EXTRACT extract_key 63 #undef KEY_GET 64 #define KEY_GET get_key 65 #include "extract_key.c" 66 67 static __isl_give isl_schedule_tree *isl_stream_read_schedule_tree( 68 __isl_keep isl_stream *s); 69 70 /* Read a subtree with context root node from "s". 71 */ 72 static __isl_give isl_schedule_tree *read_context(__isl_keep isl_stream *s) 73 { 74 isl_set *context = NULL; 75 isl_schedule_tree *tree; 76 isl_ctx *ctx; 77 struct isl_token *tok; 78 enum isl_schedule_key key; 79 char *str; 80 isl_bool more; 81 82 ctx = isl_stream_get_ctx(s); 83 84 key = get_key(s); 85 86 if (isl_stream_yaml_next(s) < 0) 87 return NULL; 88 89 tok = isl_stream_next_token(s); 90 if (!tok) { 91 isl_stream_error(s, NULL, "unexpected EOF"); 92 return NULL; 93 } 94 str = isl_token_get_str(ctx, tok); 95 context = isl_set_read_from_str(ctx, str); 96 free(str); 97 isl_token_free(tok); 98 99 more = isl_stream_yaml_next(s); 100 if (more < 0) 101 goto error; 102 if (!more) { 103 tree = isl_schedule_tree_from_context(context); 104 } else { 105 key = get_key(s); 106 if (key != isl_schedule_key_child) 107 isl_die(ctx, isl_error_invalid, "expecting child", 108 goto error); 109 if (isl_stream_yaml_next(s) < 0) 110 goto error; 111 tree = isl_stream_read_schedule_tree(s); 112 tree = isl_schedule_tree_insert_context(tree, context); 113 } 114 115 return tree; 116 error: 117 isl_set_free(context); 118 return NULL; 119 } 120 121 /* Read a subtree with domain root node from "s". 122 */ 123 static __isl_give isl_schedule_tree *read_domain(__isl_keep isl_stream *s) 124 { 125 isl_union_set *domain = NULL; 126 isl_schedule_tree *tree; 127 isl_ctx *ctx; 128 struct isl_token *tok; 129 enum isl_schedule_key key; 130 char *str; 131 isl_bool more; 132 133 ctx = isl_stream_get_ctx(s); 134 135 key = get_key(s); 136 137 if (isl_stream_yaml_next(s) < 0) 138 return NULL; 139 140 tok = isl_stream_next_token(s); 141 if (!tok) { 142 isl_stream_error(s, NULL, "unexpected EOF"); 143 return NULL; 144 } 145 str = isl_token_get_str(ctx, tok); 146 domain = isl_union_set_read_from_str(ctx, str); 147 free(str); 148 isl_token_free(tok); 149 150 more = isl_stream_yaml_next(s); 151 if (more < 0) 152 goto error; 153 if (!more) { 154 tree = isl_schedule_tree_from_domain(domain); 155 } else { 156 key = get_key(s); 157 if (key != isl_schedule_key_child) 158 isl_die(ctx, isl_error_invalid, "expecting child", 159 goto error); 160 if (isl_stream_yaml_next(s) < 0) 161 goto error; 162 tree = isl_stream_read_schedule_tree(s); 163 tree = isl_schedule_tree_insert_domain(tree, domain); 164 } 165 166 return tree; 167 error: 168 isl_union_set_free(domain); 169 return NULL; 170 } 171 172 /* Read a subtree with expansion root node from "s". 173 */ 174 static __isl_give isl_schedule_tree *read_expansion(isl_stream *s) 175 { 176 isl_ctx *ctx; 177 isl_union_pw_multi_aff *contraction = NULL; 178 isl_union_map *expansion = NULL; 179 isl_schedule_tree *tree = NULL; 180 isl_bool more; 181 182 ctx = isl_stream_get_ctx(s); 183 184 do { 185 struct isl_token *tok; 186 enum isl_schedule_key key; 187 char *str; 188 189 key = get_key(s); 190 if (isl_stream_yaml_next(s) < 0) 191 goto error; 192 193 switch (key) { 194 case isl_schedule_key_contraction: 195 isl_union_pw_multi_aff_free(contraction); 196 tok = isl_stream_next_token(s); 197 str = isl_token_get_str(ctx, tok); 198 contraction = isl_union_pw_multi_aff_read_from_str(ctx, 199 str); 200 free(str); 201 isl_token_free(tok); 202 if (!contraction) 203 goto error; 204 break; 205 case isl_schedule_key_expansion: 206 isl_union_map_free(expansion); 207 tok = isl_stream_next_token(s); 208 str = isl_token_get_str(ctx, tok); 209 expansion = isl_union_map_read_from_str(ctx, str); 210 free(str); 211 isl_token_free(tok); 212 if (!expansion) 213 goto error; 214 break; 215 case isl_schedule_key_child: 216 isl_schedule_tree_free(tree); 217 tree = isl_stream_read_schedule_tree(s); 218 if (!tree) 219 goto error; 220 break; 221 default: 222 isl_die(ctx, isl_error_invalid, "unexpected key", 223 goto error); 224 } 225 } while ((more = isl_stream_yaml_next(s)) == isl_bool_true); 226 227 if (more < 0) 228 goto error; 229 230 if (!contraction) 231 isl_die(ctx, isl_error_invalid, "missing contraction", 232 goto error); 233 if (!expansion) 234 isl_die(ctx, isl_error_invalid, "missing expansion", 235 goto error); 236 237 if (!tree) 238 return isl_schedule_tree_from_expansion(contraction, expansion); 239 return isl_schedule_tree_insert_expansion(tree, contraction, expansion); 240 error: 241 isl_schedule_tree_free(tree); 242 isl_union_pw_multi_aff_free(contraction); 243 isl_union_map_free(expansion); 244 return NULL; 245 } 246 247 /* Read a subtree with extension root node from "s". 248 */ 249 static __isl_give isl_schedule_tree *read_extension(isl_stream *s) 250 { 251 isl_union_map *extension = NULL; 252 isl_schedule_tree *tree; 253 isl_ctx *ctx; 254 struct isl_token *tok; 255 enum isl_schedule_key key; 256 char *str; 257 isl_bool more; 258 259 ctx = isl_stream_get_ctx(s); 260 261 key = get_key(s); 262 263 if (isl_stream_yaml_next(s) < 0) 264 return NULL; 265 266 tok = isl_stream_next_token(s); 267 if (!tok) { 268 isl_stream_error(s, NULL, "unexpected EOF"); 269 return NULL; 270 } 271 str = isl_token_get_str(ctx, tok); 272 extension = isl_union_map_read_from_str(ctx, str); 273 free(str); 274 isl_token_free(tok); 275 276 more = isl_stream_yaml_next(s); 277 if (more < 0) 278 goto error; 279 if (!more) { 280 tree = isl_schedule_tree_from_extension(extension); 281 } else { 282 key = get_key(s); 283 if (key != isl_schedule_key_child) 284 isl_die(ctx, isl_error_invalid, "expecting child", 285 goto error); 286 if (isl_stream_yaml_next(s) < 0) 287 goto error; 288 tree = isl_stream_read_schedule_tree(s); 289 tree = isl_schedule_tree_insert_extension(tree, extension); 290 } 291 292 return tree; 293 error: 294 isl_union_map_free(extension); 295 return NULL; 296 } 297 298 /* Read a subtree with filter root node from "s". 299 */ 300 static __isl_give isl_schedule_tree *read_filter(__isl_keep isl_stream *s) 301 { 302 isl_union_set *filter = NULL; 303 isl_schedule_tree *tree; 304 isl_ctx *ctx; 305 struct isl_token *tok; 306 enum isl_schedule_key key; 307 char *str; 308 isl_bool more; 309 310 ctx = isl_stream_get_ctx(s); 311 312 key = get_key(s); 313 314 if (isl_stream_yaml_next(s) < 0) 315 return NULL; 316 317 tok = isl_stream_next_token(s); 318 if (!tok) { 319 isl_stream_error(s, NULL, "unexpected EOF"); 320 return NULL; 321 } 322 str = isl_token_get_str(ctx, tok); 323 filter = isl_union_set_read_from_str(ctx, str); 324 free(str); 325 isl_token_free(tok); 326 327 more = isl_stream_yaml_next(s); 328 if (more < 0) 329 goto error; 330 if (!more) { 331 tree = isl_schedule_tree_from_filter(filter); 332 } else { 333 key = get_key(s); 334 if (key != isl_schedule_key_child) 335 isl_die(ctx, isl_error_invalid, "expecting child", 336 goto error); 337 if (isl_stream_yaml_next(s) < 0) 338 goto error; 339 tree = isl_stream_read_schedule_tree(s); 340 tree = isl_schedule_tree_insert_filter(tree, filter); 341 } 342 343 return tree; 344 error: 345 isl_union_set_free(filter); 346 return NULL; 347 } 348 349 /* Read a subtree with guard root node from "s". 350 */ 351 static __isl_give isl_schedule_tree *read_guard(isl_stream *s) 352 { 353 isl_set *guard = NULL; 354 isl_schedule_tree *tree; 355 isl_ctx *ctx; 356 struct isl_token *tok; 357 enum isl_schedule_key key; 358 char *str; 359 isl_bool more; 360 361 ctx = isl_stream_get_ctx(s); 362 363 key = get_key(s); 364 365 if (isl_stream_yaml_next(s) < 0) 366 return NULL; 367 368 tok = isl_stream_next_token(s); 369 if (!tok) { 370 isl_stream_error(s, NULL, "unexpected EOF"); 371 return NULL; 372 } 373 str = isl_token_get_str(ctx, tok); 374 guard = isl_set_read_from_str(ctx, str); 375 free(str); 376 isl_token_free(tok); 377 378 more = isl_stream_yaml_next(s); 379 if (more < 0) 380 goto error; 381 if (!more) { 382 tree = isl_schedule_tree_from_guard(guard); 383 } else { 384 key = get_key(s); 385 if (key != isl_schedule_key_child) 386 isl_die(ctx, isl_error_invalid, "expecting child", 387 goto error); 388 if (isl_stream_yaml_next(s) < 0) 389 goto error; 390 tree = isl_stream_read_schedule_tree(s); 391 tree = isl_schedule_tree_insert_guard(tree, guard); 392 } 393 394 return tree; 395 error: 396 isl_set_free(guard); 397 return NULL; 398 } 399 400 /* Read a subtree with mark root node from "s". 401 */ 402 static __isl_give isl_schedule_tree *read_mark(isl_stream *s) 403 { 404 isl_id *mark; 405 isl_schedule_tree *tree; 406 isl_ctx *ctx; 407 struct isl_token *tok; 408 enum isl_schedule_key key; 409 char *str; 410 isl_bool more; 411 412 ctx = isl_stream_get_ctx(s); 413 414 key = get_key(s); 415 416 if (isl_stream_yaml_next(s) < 0) 417 return NULL; 418 419 tok = isl_stream_next_token(s); 420 if (!tok) { 421 isl_stream_error(s, NULL, "unexpected EOF"); 422 return NULL; 423 } 424 str = isl_token_get_str(ctx, tok); 425 mark = isl_id_alloc(ctx, str, NULL); 426 free(str); 427 isl_token_free(tok); 428 429 more = isl_stream_yaml_next(s); 430 if (more < 0) 431 goto error; 432 if (!more) { 433 isl_die(ctx, isl_error_invalid, "expecting child", 434 goto error); 435 } else { 436 key = get_key(s); 437 if (key != isl_schedule_key_child) 438 isl_die(ctx, isl_error_invalid, "expecting child", 439 goto error); 440 if (isl_stream_yaml_next(s) < 0) 441 goto error; 442 tree = isl_stream_read_schedule_tree(s); 443 tree = isl_schedule_tree_insert_mark(tree, mark); 444 } 445 446 return tree; 447 error: 448 isl_id_free(mark); 449 return NULL; 450 } 451 452 #undef EL_BASE 453 #define EL_BASE val 454 455 #include <isl_list_read_yaml_templ.c> 456 457 /* Read a sequence of integers from "s" (representing the coincident 458 * property of a band node). 459 */ 460 static __isl_give isl_val_list *read_coincident(__isl_keep isl_stream *s) 461 { 462 return isl_stream_yaml_read_val_list(s); 463 } 464 465 /* Set the (initial) coincident properties of "band" according to 466 * the (initial) elements of "coincident". 467 */ 468 static __isl_give isl_schedule_band *set_coincident( 469 __isl_take isl_schedule_band *band, __isl_take isl_val_list *coincident) 470 { 471 int i; 472 isl_size n, m; 473 474 n = isl_schedule_band_n_member(band); 475 m = isl_val_list_n_val(coincident); 476 if (n < 0 || m < 0) 477 band = isl_schedule_band_free(band); 478 479 for (i = 0; i < n && i < m; ++i) { 480 isl_val *v; 481 482 v = isl_val_list_get_val(coincident, i); 483 if (!v) 484 band = isl_schedule_band_free(band); 485 band = isl_schedule_band_member_set_coincident(band, i, 486 !isl_val_is_zero(v)); 487 isl_val_free(v); 488 } 489 isl_val_list_free(coincident); 490 return band; 491 } 492 493 /* Read a subtree with band root node from "s". 494 */ 495 static __isl_give isl_schedule_tree *read_band(isl_stream *s) 496 { 497 isl_multi_union_pw_aff *schedule = NULL; 498 isl_schedule_tree *tree = NULL; 499 isl_val_list *coincident = NULL; 500 isl_union_set *options = NULL; 501 isl_ctx *ctx; 502 isl_schedule_band *band; 503 int permutable = 0; 504 isl_bool more; 505 506 ctx = isl_stream_get_ctx(s); 507 508 do { 509 struct isl_token *tok; 510 enum isl_schedule_key key; 511 char *str; 512 isl_val *v; 513 514 key = get_key(s); 515 if (isl_stream_yaml_next(s) < 0) 516 goto error; 517 518 switch (key) { 519 case isl_schedule_key_schedule: 520 schedule = isl_multi_union_pw_aff_free(schedule); 521 tok = isl_stream_next_token(s); 522 if (!tok) { 523 isl_stream_error(s, NULL, "unexpected EOF"); 524 goto error; 525 } 526 str = isl_token_get_str(ctx, tok); 527 schedule = isl_multi_union_pw_aff_read_from_str(ctx, 528 str); 529 free(str); 530 isl_token_free(tok); 531 if (!schedule) 532 goto error; 533 break; 534 case isl_schedule_key_coincident: 535 coincident = read_coincident(s); 536 if (!coincident) 537 goto error; 538 break; 539 case isl_schedule_key_permutable: 540 v = isl_stream_read_val(s); 541 permutable = !isl_val_is_zero(v); 542 isl_val_free(v); 543 break; 544 case isl_schedule_key_options: 545 isl_union_set_free(options); 546 tok = isl_stream_next_token(s); 547 str = isl_token_get_str(ctx, tok); 548 options = isl_union_set_read_from_str(ctx, str); 549 free(str); 550 isl_token_free(tok); 551 if (!options) 552 goto error; 553 break; 554 case isl_schedule_key_child: 555 isl_schedule_tree_free(tree); 556 tree = isl_stream_read_schedule_tree(s); 557 if (!tree) 558 goto error; 559 break; 560 default: 561 isl_die(ctx, isl_error_invalid, "unexpected key", 562 goto error); 563 } 564 } while ((more = isl_stream_yaml_next(s)) == isl_bool_true); 565 566 if (more < 0) 567 goto error; 568 569 if (!schedule) 570 isl_die(ctx, isl_error_invalid, "missing schedule", goto error); 571 572 band = isl_schedule_band_from_multi_union_pw_aff(schedule); 573 band = isl_schedule_band_set_permutable(band, permutable); 574 if (coincident) 575 band = set_coincident(band, coincident); 576 if (options) 577 band = isl_schedule_band_set_ast_build_options(band, options); 578 if (tree) 579 tree = isl_schedule_tree_insert_band(tree, band); 580 else 581 tree = isl_schedule_tree_from_band(band); 582 583 return tree; 584 error: 585 isl_val_list_free(coincident); 586 isl_union_set_free(options); 587 isl_schedule_tree_free(tree); 588 isl_multi_union_pw_aff_free(schedule); 589 return NULL; 590 } 591 592 #undef EL_BASE 593 #define EL_BASE schedule_tree 594 595 #include <isl_list_read_yaml_templ.c> 596 597 /* Read a subtree with root node of type "type" from "s". 598 * The node is represented by a sequence of children. 599 */ 600 static __isl_give isl_schedule_tree *read_children(isl_stream *s, 601 enum isl_schedule_node_type type) 602 { 603 isl_schedule_tree_list *list; 604 605 isl_token_free(isl_stream_next_token(s)); 606 607 if (isl_stream_yaml_next(s) < 0) 608 return NULL; 609 610 list = isl_stream_yaml_read_schedule_tree_list(s); 611 612 return isl_schedule_tree_from_children(type, list); 613 } 614 615 /* Read a subtree with sequence root node from "s". 616 */ 617 static __isl_give isl_schedule_tree *read_sequence(isl_stream *s) 618 { 619 return read_children(s, isl_schedule_node_sequence); 620 } 621 622 /* Read a subtree with set root node from "s". 623 */ 624 static __isl_give isl_schedule_tree *read_set(isl_stream *s) 625 { 626 return read_children(s, isl_schedule_node_set); 627 } 628 629 /* Read a schedule (sub)tree from "s". 630 * 631 * We first determine the type of the root node based on the first 632 * mapping key and then hand over to a function tailored to reading 633 * nodes of this type. 634 */ 635 static __isl_give isl_schedule_tree *isl_stream_read_schedule_tree( 636 struct isl_stream *s) 637 { 638 enum isl_schedule_key key; 639 struct isl_token *tok; 640 isl_schedule_tree *tree = NULL; 641 isl_bool more; 642 643 if (isl_stream_yaml_read_start_mapping(s) < 0) 644 return NULL; 645 more = isl_stream_yaml_next(s); 646 if (more < 0) 647 return NULL; 648 if (!more) { 649 isl_stream_error(s, NULL, "missing key"); 650 return NULL; 651 } 652 653 tok = isl_stream_next_token(s); 654 key = extract_key(s, tok); 655 isl_stream_push_token(s, tok); 656 if (key < 0) 657 return NULL; 658 switch (key) { 659 case isl_schedule_key_context: 660 tree = read_context(s); 661 break; 662 case isl_schedule_key_domain: 663 tree = read_domain(s); 664 break; 665 case isl_schedule_key_contraction: 666 case isl_schedule_key_expansion: 667 tree = read_expansion(s); 668 break; 669 case isl_schedule_key_extension: 670 tree = read_extension(s); 671 break; 672 case isl_schedule_key_filter: 673 tree = read_filter(s); 674 break; 675 case isl_schedule_key_guard: 676 tree = read_guard(s); 677 break; 678 case isl_schedule_key_leaf: 679 isl_token_free(isl_stream_next_token(s)); 680 tree = isl_schedule_tree_leaf(isl_stream_get_ctx(s)); 681 break; 682 case isl_schedule_key_mark: 683 tree = read_mark(s); 684 break; 685 case isl_schedule_key_sequence: 686 tree = read_sequence(s); 687 break; 688 case isl_schedule_key_set: 689 tree = read_set(s); 690 break; 691 case isl_schedule_key_schedule: 692 case isl_schedule_key_coincident: 693 case isl_schedule_key_options: 694 case isl_schedule_key_permutable: 695 tree = read_band(s); 696 break; 697 case isl_schedule_key_child: 698 isl_die(isl_stream_get_ctx(s), isl_error_unsupported, 699 "cannot identify node type", return NULL); 700 case isl_schedule_key_end: 701 case isl_schedule_key_error: 702 return NULL; 703 } 704 705 if (isl_stream_yaml_read_end_mapping(s) < 0) 706 return isl_schedule_tree_free(tree); 707 708 return tree; 709 } 710 711 /* Read an isl_schedule from "s". 712 */ 713 __isl_give isl_schedule *isl_stream_read_schedule(isl_stream *s) 714 { 715 isl_ctx *ctx; 716 isl_schedule_tree *tree; 717 718 if (!s) 719 return NULL; 720 721 ctx = isl_stream_get_ctx(s); 722 tree = isl_stream_read_schedule_tree(s); 723 return isl_schedule_from_schedule_tree(ctx, tree); 724 } 725 726 /* Read an isl_schedule from "input". 727 */ 728 __isl_give isl_schedule *isl_schedule_read_from_file(isl_ctx *ctx, FILE *input) 729 { 730 struct isl_stream *s; 731 isl_schedule *schedule; 732 733 s = isl_stream_new_file(ctx, input); 734 if (!s) 735 return NULL; 736 schedule = isl_stream_read_schedule(s); 737 isl_stream_free(s); 738 739 return schedule; 740 } 741 742 #undef TYPE_BASE 743 #define TYPE_BASE schedule 744 #include "isl_read_from_str_templ.c" 745
Indexes created Tue Mar 03 05:31:39 UTC 2026