Lines Matching refs:executed
63 __isl_take isl_union_map *executed,
66 __isl_take isl_union_map *executed, __isl_take isl_ast_build *build,
70 * the (non single valued) inverse schedule "executed".
75 * In particular, if executed has the form
86 * to be executed from the current schedule domain.
88 static isl_stat generate_non_single_valued(__isl_take isl_map *executed,
97 identity = isl_set_identity(isl_map_range(isl_map_copy(executed)));
98 executed = isl_map_domain_product(executed, identity);
101 list = generate_code(isl_union_map_from_map(executed), build, 1);
112 __isl_keep isl_map *executed, __isl_keep isl_ast_build *build)
121 isl_union_map_from_map(isl_map_copy(executed)));
135 /* Generate a call expression for the single executed
137 * domain. "executed" is the original inverse schedule from which "map"
138 * has been derived. In particular, "map" is either identical to "executed"
139 * or it is the result of gisting "executed" with respect to the build domain.
140 * "executed" is only used if there is an at_each_domain callback.
153 static isl_stat add_domain(__isl_take isl_map *executed,
172 graft = at_each_domain(graft, executed, build);
174 isl_map_free(executed);
184 * the inverse schedule "executed" and add it to data->list.
195 * the executed relation, possibly introducing a disjunctive guard
218 static isl_stat generate_domain(__isl_take isl_map *executed, void *user)
227 executed = isl_map_intersect_domain(executed, domain);
228 empty = isl_map_is_empty(executed);
232 isl_map_free(executed);
236 sv = isl_map_plain_is_single_valued(executed);
240 return add_domain(executed, isl_map_copy(executed), data);
242 executed = isl_map_coalesce(executed);
243 map = isl_map_copy(executed);
251 map = isl_map_copy(executed);
253 return generate_non_single_valued(executed, data);
256 return add_domain(executed, map, data);
259 isl_map_free(executed);
280 __isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
291 user_build = isl_ast_build_set_executed(user_build, executed);
305 __isl_take isl_union_map *executed);
320 __isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
325 if (!build || !executed)
332 return build_ast_from_child(build, node, executed);
336 return call_create_leaf(executed, build);
338 ctx = isl_union_map_get_ctx(executed);
340 if (isl_union_map_foreach_map(executed, &generate_domain, &data) < 0)
346 isl_union_map_free(executed);
383 * in the domain of "executed". In principle, we only need to plug
389 __isl_take isl_union_map *executed, __isl_keep isl_ast_build *build)
392 executed);
854 * Other constraints will make sure that the for loop is only executed
1142 * for which some code is executed.
1266 * for which some code is executed.
1314 * "domain" is the subset of "bounds" for which some code is executed.
1401 * "executed" is the current inverse schedule, taking into account
1403 * "domain" is the domain of "executed", with inner dimensions projected out.
1408 * from intersecting "executed" with "bounds" in add_node.
1470 __isl_take isl_union_map *executed,
1491 build = isl_ast_build_set_executed(build, isl_union_map_copy(executed));
1504 executed = isl_union_map_free(executed);
1510 executed = plug_in_values(executed, sub_build);
1518 children = generate_next_level(executed,
1655 * "executed" is the current inverse schedule, taking into account
1657 * "domain" is the domain of "executed", with inner dimensions projected out.
1691 static __isl_give isl_ast_graft *create_node(__isl_take isl_union_map *executed,
1703 return create_node_scaled(executed, bounds, domain, build);
1710 return create_node_scaled(executed, bounds, domain, build);
1719 executed = isl_union_map_free(executed);
1721 if (executed && isl_val_is_divisible_by(data.m, d))
1729 if (isl_union_map_foreach_map(executed, &map_check_scaled,
1732 executed = isl_union_map_free(executed);
1755 executed = isl_union_map_apply_domain(executed,
1763 return create_node_scaled(executed, bounds, domain, build);
1817 __isl_take isl_ast_graft_list *list, __isl_take isl_union_map *executed,
1826 executed = isl_union_map_intersect_domain(executed, uset);
1827 empty = isl_union_map_is_empty(executed);
1833 uset = isl_union_map_domain(isl_union_map_copy(executed));
1847 graft = create_node(executed, bounds, domain,
1857 isl_union_map_free(executed);
1942 __isl_keep isl_union_map *executed,
1947 * "executed" and "build" are extra arguments to be passed to add_node.
1951 isl_union_map *executed;
2006 isl_union_map_copy(data->executed), bset,
2044 generate_sorted_domains(scc, data->executed, data->build));
2068 __isl_keep isl_union_map *executed, __isl_keep isl_ast_build *build)
2084 return add_node(data.list, isl_union_map_copy(executed),
2089 data.executed = executed;
2123 * "executed" and "build" are extra arguments to be passed
2132 isl_union_map *executed;
2158 list = generate_sorted_domains(scc, data->executed, data->build);
2192 __isl_keep isl_union_map *executed, __isl_keep isl_ast_build *build)
2202 return generate_sorted_domains(domain_list, executed, build);
2208 data.executed = executed;
2234 /* Extract implicit bounds on the current dimension for the executed "map".
2250 /* Extract explicit bounds on the current dimension for the executed "map".
2310 /* Separate the schedule domains of "executed".
2312 * That is, break up the domain of "executed" into basic sets,
2316 * "space" is the (single) domain space of "executed".
2319 __isl_take isl_space *space, __isl_take isl_union_map *executed,
2329 if (isl_union_map_foreach_map(executed, &separate_domain, &data) < 0)
2332 isl_union_map_free(executed);
2704 * "executed" and "build" are inputs to compute_domains.
2705 * "schedule_domain" is the domain of "executed".
2720 isl_union_map *executed;
2929 isl_union_map *executed;
2935 executed = isl_union_map_copy(domains->executed);
2936 executed = isl_union_map_intersect_domain(executed,
2938 empty = isl_union_map_is_empty(executed);
2940 isl_union_map_free(executed);
2945 domain = separate_schedule_domains(space, executed, domains->build);
3095 * - the "schedule domain" is the domain of "executed"
3111 __isl_keep isl_union_map *executed, __isl_keep isl_ast_build *build)
3123 if (!executed)
3126 ctx = isl_union_map_get_ctx(executed);
3129 schedule_domain = isl_union_map_domain(isl_union_map_copy(executed));
3144 domains.executed = executed;
3181 __isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
3186 domain_list = compute_domains(executed, build);
3187 list = generate_parallel_domains(domain_list, executed, build);
3190 isl_union_map_free(executed);
3200 * We perform separation on the domain of "executed" and then generate
3204 __isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
3213 isl_union_map_copy(executed), build);
3216 list = generate_parallel_domains(domain_list, executed, build);
3219 isl_union_map_free(executed);
3227 * "executed" and "build" are inputs to generate_shifted_component_tree_unroll.
3231 isl_union_map *executed;
3256 data->list = add_node(data->list, isl_union_map_copy(data->executed),
3270 __isl_take isl_union_map *executed, __isl_take isl_set *domain,
3273 struct isl_ast_unroll_tree_data data = { executed, build, NULL };
3279 isl_union_map_free(executed);
3357 __isl_take isl_union_map *executed, __isl_take isl_ast_build *build,
3372 return generate_shifted_component_tree_separate(executed,
3375 schedule_domain = isl_union_map_domain(isl_union_map_copy(executed));
3379 return generate_shifted_component_tree_unroll(executed, domain,
3398 list = generate_parallel_domains(domain_list, executed, build);
3401 isl_union_map_free(executed);
3406 isl_union_map_free(executed);
3479 __isl_keep isl_union_map *executed, __isl_take isl_set *domain,
3488 executed = isl_union_map_copy(executed);
3489 executed = isl_union_map_intersect_domain(executed, uset);
3490 empty = isl_union_map_is_empty(executed);
3495 isl_union_map_free(executed);
3507 list = generate_shifted_component_tree_base(executed,
3515 isl_union_map_free(executed);
3527 __isl_take isl_union_map *executed, __isl_take isl_set *before,
3533 res = generate_shifted_component_tree_part(executed, before, build, 0);
3534 list = generate_shifted_component_tree_part(executed, isolated,
3537 list = generate_shifted_component_tree_part(executed, after, build, 0);
3539 list = generate_shifted_component_tree_part(executed, other, build, 0);
3542 isl_union_map_free(executed);
3574 __isl_take isl_union_map *executed, __isl_take isl_set *isolated,
3583 return generate_shifted_component_parts(executed, isl_set_copy(empty),
3616 __isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
3632 executed = isl_union_map_free(executed);
3634 return generate_shifted_component_tree_base(executed, build, 0);
3636 schedule_domain = isl_union_map_domain(isl_union_map_copy(executed));
3649 return generate_shifted_component_tree_base(executed, build, 0);
3671 executed = isl_union_map_free(executed);
3673 return generate_shifted_component_only_after(executed, isolated,
3681 return generate_shifted_component_parts(executed, before, isolated,
3686 isl_union_map_free(executed);
3698 __isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
3701 return generate_shifted_component_tree(executed, build);
3703 return generate_shifted_component_flat(executed, build);
3721 isl_union_map *executed;
3724 executed = isl_union_map_from_map(map);
3727 executed = isl_union_map_add_map(executed, map);
3730 return executed;
3743 isl_union_map *executed;
3745 executed = construct_component_executed(domain, order, n);
3746 return generate_shifted_component(executed, build);
3965 isl_union_map *executed;
3975 executed = isl_union_map_empty(isl_space_copy(space));
4002 executed = isl_union_map_add_map(executed, map_i);
4009 executed = isl_union_map_free(executed);
4011 return executed;
4052 isl_union_map *executed;
4066 executed = construct_shifted_executed(domain, order, n, stride, mv,
4076 list = generate_shifted_component(executed, build);
4767 __isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
4771 isl_size n = isl_union_map_n_map(executed);
4788 if (isl_union_map_foreach_map(executed, &extract_domain, &next) < 0)
4832 isl_union_map_free(executed);
4840 * If "executed" is empty, i.e., no code needs to be generated,
4846 * If "executed" lives in a single space, i.e., if code needs to be
4853 __isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
4859 if (!build || !executed)
4862 if (isl_union_map_is_empty(executed)) {
4864 isl_union_map_free(executed);
4874 return generate_inner_level(executed, build);
4876 n = isl_union_map_n_map(executed);
4880 return generate_shifted_component(executed, build);
4882 return generate_components(executed, build);
4884 isl_union_map_free(executed);
4890 * internal, executed and build are the inputs to generate_code.
4895 isl_union_map *executed;
4922 __isl_take isl_union_map *executed, __isl_keep isl_space *space,
4932 executed = isl_union_map_apply_domain(executed,
4934 return executed;
4937 /* Generate an AST that visits the elements in the range of data->executed
4954 * constraints to the executed relation. Adding these constraints
4956 * However, we do not want to divide the executed relation into
4977 isl_union_map *executed;
4982 executed = isl_union_map_copy(data->executed);
4983 executed = isl_union_map_intersect_domain(executed,
4988 executed = internal_executed(executed, space, data->build);
4993 executed = isl_union_map_intersect_params(executed, domain);
4999 list = generate_next_level(executed, build);
5008 /* Generate an AST that visits the elements in the range of data->executed
5055 /* Generate an AST that visits the elements in the range of "executed"
5064 * If the space S is not parametric, then the domain space(s) of "executed"
5067 * If the domain of "executed" consists of several spaces, then an AST
5075 * We essentially run over all the spaces in the domain of "executed"
5079 __isl_take isl_union_map *executed, __isl_take isl_ast_build *build,
5092 isl_union_map_get_space(executed));
5096 executed = isl_union_map_align_params(executed, space);
5097 if (!executed || !build)
5103 data.executed = executed;
5107 universe = isl_union_map_universe(isl_union_map_copy(executed));
5114 isl_union_map_free(executed);
5119 isl_union_map_free(executed);
5146 * the schedule domain in the domain and the elements to be executed
5147 * in the range) called "executed".
5154 isl_union_map *executed;
5160 executed = isl_union_map_reverse(schedule);
5161 list = generate_code(executed, isl_ast_build_copy(build), 0);
5178 /* Generate an AST that visits the elements in the domain of "executed"
5181 * The relation "executed" maps the outer generated loop iterators
5182 * to the domain elements executed by those iterations.
5190 * then they can be executed in any order.
5197 __isl_take isl_union_map *executed)
5202 list = generate_inner_level(executed, isl_ast_build_copy(build));
5210 * any statement instances, as specified by the range of "executed".
5214 __isl_keep isl_union_map *executed)
5219 instances = isl_union_map_range(isl_union_map_copy(executed));
5229 isl_die(isl_union_map_get_ctx(executed), isl_error_invalid,
5235 /* Generate an AST that visits the elements in the domain of "executed"
5238 * The relation "executed" maps the outer generated loop iterators
5239 * to the domain elements executed by those iterations.
5251 __isl_take isl_union_map *executed)
5261 if (!build || n < 0 || !executed)
5265 return build_ast_from_child(build, node, executed);
5272 if (check_band_schedule_total_on_instances(extra, executed) < 0)
5273 executed = isl_union_map_free(executed);
5278 executed = isl_union_map_domain_product(executed, extra_umap);
5279 executed = isl_union_map_detect_equalities(executed);
5292 list = generate_next_level(executed, build);
5299 isl_union_map_free(executed);
5346 /* Generate an AST that visits the elements in the domain of "executed"
5350 * The relation "executed" maps the outer generated loop iterators
5351 * to the domain elements executed by those iterations.
5358 * to the domain of "executed". Since the context constraints
5380 __isl_take isl_union_map *executed)
5404 executed = isl_union_map_intersect_domain(executed,
5408 node, executed);
5426 /* Generate an AST that visits the elements in the domain of "executed"
5430 * The relation "executed" maps the outer generated loop iterators
5431 * to the domain elements executed by those iterations.
5438 __isl_take isl_union_map *executed)
5445 isl_union_map_get_space(executed));
5447 n1 = isl_union_map_dim(executed, isl_dim_param);
5448 executed = isl_union_map_apply_range(executed, expansion);
5449 n2 = isl_union_map_dim(executed, isl_dim_param);
5457 return build_ast_from_child(build, node, executed);
5461 isl_union_map_free(executed);
5465 /* Generate an AST that visits the elements in the domain of "executed"
5469 * The relation "executed" maps the outer generated loop iterators
5470 * to the domain elements executed by those iterations.
5479 __isl_take isl_union_map *executed)
5496 executed = isl_union_map_union(executed, extension);
5498 return build_ast_from_child(build, node, executed);
5501 /* Generate an AST that visits the elements in the domain of "executed"
5505 * The relation "executed" maps the outer generated loop iterators
5506 * to the domain elements executed by those iterations.
5508 * We simply intersect the iteration domain (i.e., the range of "executed")
5513 * If the result of the intersection is equal to the original "executed"
5520 __isl_take isl_union_map *executed)
5530 orig = isl_union_map_copy(executed);
5531 if (!build || !node || !executed)
5536 isl_union_map_get_space(executed));
5537 n1 = isl_union_map_dim(executed, isl_dim_param);
5538 executed = isl_union_map_intersect_range(executed, filter);
5539 n2 = isl_union_map_dim(executed, isl_dim_param);
5547 unchanged = isl_union_map_is_subset(orig, executed);
5548 empty = isl_union_map_is_empty(executed);
5552 isl_union_map_free(executed);
5557 return build_ast_from_child(build, node, executed);
5563 isl_union_map_free(executed);
5568 isl_union_map_free(executed);
5573 /* Generate an AST that visits the elements in the domain of "executed"
5577 * The relation "executed" maps the outer generated loop iterators
5578 * to the domain elements executed by those iterations.
5588 __isl_take isl_union_map *executed)
5619 node, executed);
5676 /* Generate an AST that visits the elements in the domain of "executed"
5680 * The relation "executed" maps the outer generated loop iterators
5681 * to the domain elements executed by those iterations.
5692 __isl_take isl_union_map *executed)
5699 build = isl_ast_build_set_executed(build, isl_union_map_copy(executed));
5705 list = build_ast_from_child(isl_ast_build_copy(build), node, executed);
5725 __isl_take isl_union_map *executed);
5727 /* Generate an AST that visits the elements in the domain of "executed"
5731 * The relation "executed" maps the outer generated loop iterators
5732 * to the domain elements executed by those iterations.
5739 __isl_take isl_union_map *executed)
5758 child, isl_union_map_copy(executed));
5763 isl_union_map_free(executed);
5768 /* Generate an AST that visits the elements in the domain of "executed"
5771 * The relation "executed" maps the outer generated loop iterators
5772 * to the domain elements executed by those iterations.
5776 * The children of a set node may be executed in any order,
5781 __isl_take isl_union_map *executed)
5791 return build_ast_from_leaf(build, node, executed);
5793 return build_ast_from_band(build, node, executed);
5795 return build_ast_from_context(build, node, executed);
5800 return build_ast_from_expansion(build, node, executed);
5802 return build_ast_from_extension(build, node, executed);
5804 return build_ast_from_filter(build, node, executed);
5806 return build_ast_from_guard(build, node, executed);
5808 return build_ast_from_mark(build, node, executed);
5811 return build_ast_from_sequence(build, node, executed);
5817 isl_union_map_free(executed);
5824 /* Generate an AST that visits the elements in the domain of "executed"
5828 * The relation "executed" maps the outer generated loop iterators
5829 * to the domain elements executed by those iterations.
5836 __isl_take isl_union_map *executed)
5839 return build_ast_from_schedule_node(build, node, executed);
5851 * to the executed relation. Adding these constraints
5853 * However, we do not want to divide the executed relation into
5862 isl_union_map *executed;
5893 executed = isl_union_map_from_domain_and_range(schedule_domain, domain);
5894 list = build_ast_from_child(isl_ast_build_copy(build), node, executed);