isl_scheduler.h

Go to the documentation of this file.

#ifndef ISL_SCHEDULER_H
#define ISL_SCHEDULER_H
 
#include <isl/aff_type.h>
#include <isl/hash.h>
#include <isl/id_type.h>
#include <isl/map_type.h>
#include <isl/map_to_basic_set.h>
#include <isl/mat.h>
#include <isl/space_type.h>
#include <isl/set_type.h>
#include <isl/val_type.h>
#include <isl/vec.h>
#include <isl/union_map_type.h>
 
#include "isl_schedule_constraints.h"
#include "isl_tab.h"
 
/* Internal information about a node that is used during the construction
 * of a schedule.
 * space represents the original space in which the domain lives;
 *  that is, the space is not affected by compression
 * sched is a matrix representation of the schedule being constructed
 *  for this node; if compressed is set, then this schedule is
 *  defined over the compressed domain space
 * sched_map is an isl_map representation of the same (partial) schedule
 *  sched_map may be NULL; if compressed is set, then this map
 *  is defined over the uncompressed domain space
 * rank is the number of linearly independent rows in the linear part
 *  of sched
 * the rows of "vmap" represent a change of basis for the node
 *  variables; the first rank rows span the linear part of
 *  the schedule rows; the remaining rows are linearly independent
 * the rows of "indep" represent linear combinations of the schedule
 * coefficients that are non-zero when the schedule coefficients are
 * linearly independent of previously computed schedule rows.
 * start is the first variable in the LP problem in the sequences that
 *  represents the schedule coefficients of this node
 * nvar is the dimension of the (compressed) domain
 * nparam is the number of parameters or 0 if we are not constructing
 *  a parametric schedule
 *
 * If compressed is set, then hull represents the constraints
 * that were used to derive the compression, while compress and
 * decompress map the original space to the compressed space and
 * vice versa.
 *
 * scc is the index of SCC (or WCC) this node belongs to
 *
 * "cluster" is only used inside extract_clusters and identifies
 * the cluster of SCCs that the node belongs to.
 *
 * coincident contains a boolean for each of the rows of the schedule,
 * indicating whether the corresponding scheduling dimension satisfies
 * the coincidence constraints in the sense that the corresponding
 * dependence distances are zero.
 *
 * If the schedule_treat_coalescing option is set, then
 * "sizes" contains the sizes of the (compressed) instance set
 * in each direction.  If there is no fixed size in a given direction,
 * then the corresponding size value is set to infinity.
 * If the schedule_treat_coalescing option or the schedule_max_coefficient
 * option is set, then "max" contains the maximal values for
 * schedule coefficients of the (compressed) variables.  If no bound
 * needs to be imposed on a particular variable, then the corresponding
 * value is negative.
 * If not NULL, then "bounds" contains a non-parametric set
 * in the compressed space that is bounded by the size in each direction.
 */
struct isl_sched_node {
  isl_space *space;
  int compressed;
  isl_set *hull;
  isl_multi_aff *compress;
  isl_pw_multi_aff *decompress;
  isl_mat *sched;
  isl_map *sched_map;
  int  rank;
  isl_mat *indep;
  isl_mat *vmap;
  int  start;
  int  nvar;
  int  nparam;
 
  int  scc;
  int  cluster;
 
  int *coincident;
 
  isl_multi_val *sizes;
  isl_basic_set *bounds;
  isl_vec *max;
};
 
int isl_sched_node_scc_exactly(struct isl_sched_node *node, int scc);
 
isl_stat isl_sched_node_update_vmap(struct isl_sched_node *node);
__isl_give isl_multi_aff *isl_sched_node_extract_partial_schedule_multi_aff(
  struct isl_sched_node *node, int first, int n);
 
/* An edge in the dependence graph.  An edge may be used to
 * ensure validity of the generated schedule, to minimize the dependence
 * distance or both
 *
 * map is the dependence relation, with i -> j in the map if j depends on i
 * tagged_condition and tagged_validity contain the union of all tagged
 *  condition or conditional validity dependence relations that
 *  specialize the dependence relation "map"; that is,
 *  if (i -> a) -> (j -> b) is an element of "tagged_condition"
 *  or "tagged_validity", then i -> j is an element of "map".
 *  If these fields are NULL, then they represent the empty relation.
 * src is the source node
 * dst is the sink node
 *
 * types is a bit vector containing the types of this edge.
 * validity is set if the edge is used to ensure correctness
 * coincidence is used to enforce zero dependence distances
 * proximity is set if the edge is used to minimize dependence distances
 * condition is set if the edge represents a condition
 *  for a conditional validity schedule constraint
 * local can only be set for condition edges and indicates that
 *  the dependence distance over the edge should be zero
 * conditional_validity is set if the edge is used to conditionally
 *  ensure correctness
 *
 * For validity edges, start and end mark the sequence of inequality
 * constraints in the LP problem that encode the validity constraint
 * corresponding to this edge.
 *
 * During clustering, an edge may be marked "no_merge" if it should
 * not be used to merge clusters.
 * The weight is also only used during clustering and it is
 * an indication of how many schedule dimensions on either side
 * of the schedule constraints can be aligned.
 * If the weight is negative, then this means that this edge was postponed
 * by has_bounded_distances or any_no_merge.  The original weight can
 * be retrieved by adding 1 + graph->max_weight, with "graph"
 * the graph containing this edge.
 */
struct isl_sched_edge {
  isl_map *map;
  isl_union_map *tagged_condition;
  isl_union_map *tagged_validity;
 
  struct isl_sched_node *src;
  struct isl_sched_node *dst;
 
  unsigned types;
 
  int start;
  int end;
 
  int no_merge;
  int weight;
};
 
int isl_sched_edge_has_type(struct isl_sched_edge *edge,
  enum isl_edge_type type);
int isl_sched_edge_is_condition(struct isl_sched_edge *edge);
int isl_sched_edge_is_conditional_validity(struct isl_sched_edge *edge);
int isl_sched_edge_scc_exactly(struct isl_sched_edge *edge, int scc);
int isl_sched_edge_is_proximity(struct isl_sched_edge *edge);
 
/* Internal information about the dependence graph used during
 * the construction of the schedule.
 *
 * intra_hmap is a cache, mapping dependence relations to their dual,
 *  for dependences from a node to itself, possibly without
 *  coefficients for the parameters
 * intra_hmap_param is a cache, mapping dependence relations to their dual,
 *  for dependences from a node to itself, including coefficients
 *  for the parameters
 * inter_hmap is a cache, mapping dependence relations to their dual,
 *  for dependences between distinct nodes
 * if compression is involved then the key for these maps
 * is the original, uncompressed dependence relation, while
 * the value is the dual of the compressed dependence relation.
 *
 * n is the number of nodes
 * node is the list of nodes
 * maxvar is the maximal number of variables over all nodes
 * max_row is the allocated number of rows in the schedule
 * n_row is the current (maximal) number of linearly independent
 *  rows in the node schedules
 * n_total_row is the current number of rows in the node schedules
 * band_start is the starting row in the node schedules of the current band
 * root is set to the original dependence graph from which this graph
 *  is derived through splitting.  If this graph is not the result of
 *  splitting, then the root field points to the graph itself.
 *
 * sorted contains a list of node indices sorted according to the
 *  SCC to which a node belongs
 *
 * n_edge is the number of edges
 * edge is the list of edges
 * max_edge contains the maximal number of edges of each type;
 *  in particular, it contains the number of edges in the inital graph.
 * edge_table contains pointers into the edge array, hashed on the source
 *  and sink spaces; there is one such table for each type;
 *  a given edge may be referenced from more than one table
 *  if the corresponding relation appears in more than one of the
 *  sets of dependences; however, for each type there is only
 *  a single edge between a given pair of source and sink space
 *  in the entire graph
 *
 * node_table contains pointers into the node array, hashed on the space tuples
 *
 * region contains a list of variable sequences that should be non-trivial
 *
 * lp contains the (I)LP problem used to obtain new schedule rows
 *
 * src_scc and dst_scc are the source and sink SCCs of an edge with
 *  conflicting constraints
 *
 * scc represents the number of components
 * weak is set if the components are weakly connected
 *
 * max_weight is used during clustering and represents the maximal
 * weight of the relevant proximity edges.
 */
struct isl_sched_graph {
  isl_map_to_basic_set *intra_hmap;
  isl_map_to_basic_set *intra_hmap_param;
  isl_map_to_basic_set *inter_hmap;
 
  struct isl_sched_node *node;
  int n;
  int maxvar;
  int max_row;
  int n_row;
 
  int *sorted;
 
  int n_total_row;
  int band_start;
 
  struct isl_sched_graph *root;
 
  struct isl_sched_edge *edge;
  int n_edge;
  int max_edge[isl_edge_last + 1];
  struct isl_hash_table *edge_table[isl_edge_last + 1];
 
  struct isl_hash_table *node_table;
  struct isl_trivial_region *region;
 
  isl_basic_set *lp;
 
  int src_scc;
  int dst_scc;
 
  int scc;
  int weak;
 
  int max_weight;
};
 
isl_stat isl_sched_graph_init(struct isl_sched_graph *graph,
  __isl_keep isl_schedule_constraints *sc);
void isl_sched_graph_free(isl_ctx *ctx, struct isl_sched_graph *graph);
 
int isl_sched_graph_is_node(struct isl_sched_graph *graph,
  struct isl_sched_node *node);
isl_bool isl_sched_graph_has_validity_edge(struct isl_sched_graph *graph,
  struct isl_sched_node *src, struct isl_sched_node *dst);
 
struct isl_sched_node *isl_sched_graph_find_node(isl_ctx *ctx,
  struct isl_sched_graph *graph, __isl_keep isl_space *space);
 
isl_stat isl_sched_graph_detect_ccs(isl_ctx *ctx, struct isl_sched_graph *graph,
  isl_bool (*follows)(int i, int j, void *user));
 
__isl_give isl_union_set *isl_sched_graph_extract_scc(isl_ctx *ctx,
  struct isl_sched_graph *graph, int scc);
__isl_give isl_union_set_list *isl_sched_graph_extract_sccs(isl_ctx *ctx,
  struct isl_sched_graph *graph);
isl_stat isl_sched_graph_extract_sub_graph(isl_ctx *ctx,
  struct isl_sched_graph *graph,
  int (*node_pred)(struct isl_sched_node *node, int data),
  int (*edge_pred)(struct isl_sched_edge *edge, int data),
  int data, struct isl_sched_graph *sub);
isl_stat isl_sched_graph_compute_maxvar(struct isl_sched_graph *graph);
isl_stat isl_schedule_node_compute_wcc_band(isl_ctx *ctx,
  struct isl_sched_graph *graph);
__isl_give isl_schedule_node *isl_schedule_node_compute_finish_band(
  __isl_take isl_schedule_node *node, struct isl_sched_graph *graph,
  int initialized);
 
#endif