70  * the (non single valued) inverse schedule "executed".
72  * We extend the schedule with the iteration domain
83  * The extended inverse schedule is clearly single valued
86  * to be executed from the current schedule domain.
109  * after recording the current inverse schedule in the build.
137  * domain.  "executed" is the original inverse schedule from which "map"
184  * the inverse schedule "executed" and add it to data->list.
187  * schedule "time", then we need to continue the generation process
189  * Note that the inverse schedule being single-valued may depend
207  * we may in rare cases fail to recognize that the inverse schedule
307 /* Generate an AST after having handled the complete schedule
309  * if we are generating an AST from a schedule tree.
959  * is defined over the internal schedule space of "build".
1398  * the schedule domain "bounds" and return the node encapsulated
1401  * "executed" is the current inverse schedule, taking into account
1414  * callbacks, we record the current inverse schedule in the build.
1440  * inverse schedule.  This ensures that if we are working on a slice
1441  * of the domain based on information available in the inverse schedule
1443  * in the inverse schedule.  This operation also eliminates the current
1444  * dimension from the inverse schedule making sure no inner dimensions depend
1652  * the schedule domain "bounds" and return the node encapsulated
1655  * "executed" is the current inverse schedule, taking into account
1802 /* Generate code for the schedule domain "bounds"
1813  * We therefore need to compute that part of the schedule domain that
1957 /* Generate code for the schedule domains in "scc"
2056  * If no code is generated (because the intersection of the inverse schedule
2310 /* Separate the schedule domains of "executed".
2801  * dimension, for that part of the schedule domain that lies in the
2811  * schedule domain that have the same value at the current dimension.
2813  * intersecting with class and schedule domain, hoping that the
2862  * the schedule domain, the atomic option domain and the class domain.
2867  * the schedule domains of individual domains because we are working
2868  * within a single component so that non-overlapping schedule domains
2875  * "domain" is the intersection of the schedule domain and the class domain,
2912 /* Split up the schedule domain into uniform basic sets,
2915  * Do this for that part of the schedule domain that lies in the
2919  * of the schedule domain, but this does not make a difference
2920  * since we are going to intersect it with the domain of the inverse schedule.
2921  * If it includes schedule domain constraints, then they may involve
2967  * from the schedule domain.
2969  * For unrolling, the actual schedule domain is needed (with divs that
3095  * - the "schedule domain" is the domain of "executed"
3174  * has been applied, in case the schedule was specified as a union map.
3197  * has been applied, in case the schedule was specified as a schedule tree
3263  * has been applied, in case the schedule was specified as a schedule tree
3325  * has been applied, in case the schedule was specified as a schedule tree.
3330  * The schedule domain is broken up or combined into basic sets
3332  * schedule node, which may be either atomic, separate, unroll or
3334  * split the schedule domain into disjoint basic sets.
3338  * In the other cases, we need the global schedule domain.
3341  * schedule domain (with divs that may refer to the current dimension)
3350  * If the schedule domain involves a disjunction that is purely based on
3412  * schedule dimensions.
3470  * has been applied, in case the schedule was specified as a schedule tree.
3471  * In particular, do so for the specified subset of the schedule domain.
3521  * has been applied, in case the schedule was specified as a schedule tree.
3523  * of the schedule domain, "before", "isolated", "after" and "other",
3565  * has been applied, in case the schedule was specified as a schedule tree.
3588  * has been applied, in case the schedule was specified as a schedule tree.
3590  * We first check if the user has specified an isolated schedule domain
3591  * and that we are not already outside of this isolated schedule domain.
3592  * If so, we break up the schedule domain into iterations that
3605  * In the special case where at least one element of the schedule
3608  * elements need to be scheduled before, break up the schedule domain
3613  * AST for the entire inverse schedule.
3695  * depending on whether the schedule was specified as a schedule tree.
3736  * The component inverse schedule is specified as the "map" fields
3880 /* Construct a shifted inverse schedule based on the original inverse schedule,
3883  * The original inverse schedule is specified as the "map" fields
3900  * unchanged, and apply this map to the original schedule domain.
3902  * For example, for the original schedule
3911  * to the schedule of the "A" domain and the mapping
3915  * to the schedule of the "B" domain.
4015  * given that the schedule domain is "shifted strided".
4017  * The component inverse schedule is specified as the "map" fields
4020  * The schedule domain being "shifted strided" means that the differences
4031  * Based on this information, we construct a new inverse schedule in
4033  * Since this involves the introduction of a new schedule dimension,
4037  * in a mapping that represents the new schedule domain in terms of the
4038  * old schedule domain.
4088 /* Does any node in the schedule tree rooted at the current schedule node
4089  * of "build" depend on outer schedule nodes?
4105  * The component inverse schedule is specified as the "map" fields
4112  * the schedule domains of the individual domains are all strided,
4114  * of schedule domains not being strided anymore.
4116  * The simplest example is the schedule
4120  * Both schedule domains are strided, but their union is not.
4121  * This function detects such cases and then rewrites the schedule to
4125  * In the new schedule, the schedule domains have the same offset (modulo
4126  * the stride), ensuring that the union of schedule domains is also strided.
4130  * nothing to do.   Similarly, if the current schedule dimension has
4132  * In particular, we need at least two domains where the current schedule
4134  * Finally, in case of a schedule map input,
4135  * if any of the options refer to the current schedule dimension,
4137  * in terms of the new schedule domain, but that would introduce constraints
4140  * In the case of a schedule tree input, we bail out if any of
4141  * the descendants of the current schedule node refer to outer
4142  * schedule nodes in any way.
4167  * If some of them were skipped, then if we apply separation, the schedule
4375  * The context constraints apply to the schedule domain,
4378  * to the range of the prefix schedule for both domain and
4687  * iteration domains.  The set is the schedule domain, i.e., the domain
4688  * of the inverse schedule, while the map is the inverse schedule itself.
4700  * data->domain[i].set contains the domain of the inverse schedule
4701  * for domain "i", i.e., elements in the schedule domain.
4703  * If we are inside a band of a schedule tree and there is a pair
4704  * of elements in the two domains that is schedule together by
4705  * the current band, then we check if any element of "i" may be schedule
4901 /* Given an inverse schedule in terms of the external build schedule, i.e.,
4905  * with E the external build schedule and S the additional schedule "space",
4906  * reformulate the inverse schedule in terms of the internal schedule domain,
4943  * "space" is the space of the additional part of the schedule.
4950  * the (inverse) schedule refers to the external build domain and needs to
4960  * The build is extended to include the additional part of the schedule.
4962  * in data->build refer only to the additional part of the schedule
4966  * After having adjusted inverse schedule and build, we start generating
5046 			"invalid nested schedule space", goto error);  in generate_code_set()
5072  * schedule domain representation.  Otherwise, it refers to the external
5124 /* Generate an AST that visits the elements in the domain of "schedule"
5133  * If the space S is not parametric, then the range space(s) of "schedule"
5136  * If the range of "schedule" consists of several spaces, then an AST
5145  * The main computation is performed on an inverse schedule (with
5146  * the schedule domain in the domain and the elements to be executed
5150 	__isl_keep isl_ast_build *build, __isl_take isl_union_map *schedule)  in isl_ast_build_node_from_schedule_map()  argument
5158 	schedule = isl_union_map_coalesce(schedule);  in isl_ast_build_node_from_schedule_map()
5159 	schedule = isl_union_map_remove_redundancies(schedule);  in isl_ast_build_node_from_schedule_map()
5160 	executed = isl_union_map_reverse(schedule);  in isl_ast_build_node_from_schedule_map()
5173 	__isl_keep isl_ast_build *build, __isl_take isl_union_map *schedule)  in isl_ast_build_ast_from_schedule()  argument
5175 	return isl_ast_build_node_from_schedule_map(build, schedule);  in isl_ast_build_ast_from_schedule()
5209 /* Check that the band partial schedule "partial" does not filter out
5242  * Otherwise, we extend the build and the inverse schedule with
5243  * the additional space/partial schedule and continue generating
5245  * As soon as we have extended the inverse schedule with the additional
5246  * partial schedule, we look for equalities that may exists between
5354  * constraints on the outer schedule dimensions or original parameters.
5359  * are specified in terms of the input schedule, we first need
5360  * to map them to the internal schedule domain.
5368  * the schedule tree (apart from the root domain node), we generate
5472  * Extend the inverse schedule with the extension applied to current
5474  * in terms of the input schedule, it first needs to be transformed
5475  * to refer to the internal schedule.
5510  * unless the resulting inverse schedule is empty, in which
5642  * The caller is responsible for recording the current inverse schedule
5658  * The caller is responsible for recording the current inverse schedule
5684  * callbacks, we record the current inverse schedule in the build.
5845  * An initial inverse schedule is created that maps a zero-dimensional
5846  * schedule space to the node domain.
5848  * is replaced by the same zero-dimensional schedule space.
5905 /* Generate an AST that visits the elements in the domain of "schedule"
5906  * in the relative order specified by the schedule tree.
5912  * The construction starts at the root node of the schedule,
5916 	__isl_keep isl_ast_build *build, __isl_take isl_schedule *schedule)  in isl_ast_build_node_from_schedule()  argument
5921 	if (!build || !schedule)  in isl_ast_build_node_from_schedule()
5926 	node = isl_schedule_get_root(schedule);  in isl_ast_build_node_from_schedule()
5929 	isl_schedule_free(schedule);  in isl_ast_build_node_from_schedule()
5939 	isl_schedule_free(schedule);  in isl_ast_build_node_from_schedule()