Huawei_Technology
/
MindSpore-AKG
Not watched
1
0
Fork 0
Code
Releases 1 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: efe42ee8fe
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'efe42ee8fe'
${ noResults }
MindSpore-AKG/third_party/patch/isl/isl-influence.patch

574 lines
21 kB
Raw Blame History 

  1. unchanged:

  2. --- isl_0.22/include/isl/options.h	2021-01-26 13:29:02.345994411 +0100

  3. +++ isl/include/isl/options.h	2021-01-26 13:25:07.713990422 +0100

  4. @@ -49,6 +49,13 @@ int isl_options_get_coalesce_bounded_wra

  5.  isl_stat isl_options_set_coalesce_preserve_locals(isl_ctx *ctx, int val);

  6.  int isl_options_get_coalesce_preserve_locals(isl_ctx *ctx);

  7.  

  8. +/* ====================== AKG influence patch -- start ====================== */

  9. +isl_stat isl_options_set_akg_print_debug(isl_ctx *ctx, int val);

  10. +int isl_options_get_akg_print_debug(isl_ctx *ctx);

  11. +isl_stat isl_options_set_akg_influence_scheduler(isl_ctx *ctx, int val);

  12. +int isl_options_get_akg_influence_scheduler(isl_ctx *ctx);

  13. +/* ======================= AKG influence patch -- end ======================= */

  14. +

  15.  #if defined(__cplusplus)

  16.  }

  17.  #endif

  18. unchanged:

  19. --- isl_0.22/include/isl/schedule.h	2021-01-26 13:29:02.345994411 +0100

  20. +++ isl/include/isl/schedule.h	2021-01-26 13:25:07.713990422 +0100

  21. @@ -9,7 +9,7 @@

  22.  #include <isl/set_type.h>

  23.  #include <isl/list.h>

  24.  #include <isl/printer_type.h>

  25. -

  26. +#include <isl/vec.h>

  27.  #if defined(__cplusplus)

  28.  extern "C" {

  29.  #endif

  30. @@ -209,6 +209,57 @@ __isl_give isl_printer *isl_printer_prin

  31.  void isl_schedule_dump(__isl_keep isl_schedule *schedule);

  32.  __isl_give char *isl_schedule_to_str(__isl_keep isl_schedule *schedule);

  33.  

  34. +/* ====================== AKG influence patch -- start ====================== */

  35. +

  36. +/* --- Exports --- */

  37. +

  38. +/* export hidden types */

  39. +struct isl_sched_node;

  40. +typedef struct isl_sched_node isl_sched_node;

  41. +struct isl_sched_edge;

  42. +typedef struct isl_sched_edge isl_sched_edge;

  43. +struct isl_sched_graph;

  44. +typedef struct isl_sched_graph isl_sched_graph;

  45. +

  46. +/* isl_sched_node functions */

  47. +int isl_sched_node_par_coef_offset(struct isl_sched_node *node);

  48. +int isl_sched_node_cst_coef_offset(struct isl_sched_node *node);

  49. +__isl_give isl_map *isl_sched_node_extract_schedule(struct isl_sched_node *node);

  50. +

  51. +/* isl vec functions */

  52. +int isl_inf_vec_get_size( isl_vec* vec);

  53. +/* export isl_sched_edge functions */

  54. +/* export isl_sched_graph functions */

  55. +isl_stat isl_sched_graph_init(struct isl_sched_graph *graph,

  56. +	__isl_keep isl_schedule_constraints *sc);

  57. +void isl_sched_graph_free(isl_ctx *ctx, struct isl_sched_graph *graph);

  58. +__isl_give isl_schedule_node *isl_schedule_node_compute_schedule(isl_schedule_node *node,

  59. +	struct isl_sched_graph *graph);

  60. +

  61. +/* --- New functions --- */

  62. +

  63. +/* isl_sched_node functions */

  64. +int isl_sched_node_get_nparam(const struct isl_sched_node *node);

  65. +int isl_sched_node_get_nvar(const struct isl_sched_node *node);

  66. +

  67. +/* isl_vec functions */

  68. +int  isl_influence_int_eq(isl_vec* v, int pos1, int pos2);

  69. +isl_val*  isl_influence_vec_get_elem(isl_vec*, int pos);

  70. +/* isl_sched_graph functions */

  71. +struct isl_sched_node* isl_sched_graph_get_node(struct isl_sched_graph *graph, int i);

  72. +

  73. +/* --- AKG influence --- */

  74. +extern isl_basic_set* (*isl_influence_set_coef)(

  75. +    isl_ctx *ctx, struct isl_sched_graph *graph, isl_basic_set *bset);

  76. +extern isl_basic_set* (*isl_influence_set_equal)(

  77. +    isl_ctx *ctx, struct isl_sched_graph *graph, isl_basic_set *bset);

  78. +extern int (*isl_influence_maxvar)(struct isl_sched_graph* graph);

  79. +extern int (*isl_influence_check_coincident)(struct isl_sched_graph* graph, isl_vec* sol);

  80. +extern struct isl_sched_graph* (*isl_influence_sol_list_free)(struct isl_sched_graph* graph);

  81. +extern struct isl_sched_graph* (*isl_influence_sol_add_elem)(isl_vec* sol, struct isl_sched_graph* graph);

  82. +extern int(*isl_influence_sol_get_elem)(int sched, int pos, struct isl_sched_graph* graph);

  83. +/* ======================= AKG influence patch -- end ======================= */

  84. +

  85.  #if defined(__cplusplus)

  86.  }

  87.  #endif

  88. unchanged:

  89. --- isl_0.22/isl_options.c	2021-01-26 13:29:02.313994410 +0100

  90. +++ isl/isl_options.c	2021-01-26 13:25:07.713990422 +0100

  91. @@ -228,6 +228,12 @@ ISL_ARG_BOOL(struct isl_options, print_s

  92.  	"print statistics for every isl_ctx")

  93.  ISL_ARG_ULONG(struct isl_options, max_operations, 0,

  94.  	"max-operations", 0, "default number of maximal operations per isl_ctx")

  95. +/* ====================== AKG influence patch -- start ====================== */

  96. +ISL_ARG_BOOL(struct isl_options, akg_print_debug, 0, "print-debug", 0,

  97. +	"print debug info")

  98. +ISL_ARG_BOOL(struct isl_options, akg_influence_scheduler, 0, "influence-schedule", 0,

  99. +	"update scheduler coefficients")

  100. +/* ======================= AKG influence patch -- end ======================= */

  101.  ISL_ARG_VERSION(print_version)

  102.  ISL_ARGS_END

  103.  

  104. @@ -402,3 +408,14 @@ ISL_CTX_SET_BOOL_DEF(isl_options, struct

  105.  	ast_build_allow_or)

  106.  ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,

  107.  	ast_build_allow_or)

  108. +

  109. +/* ====================== AKG influence patch -- start ====================== */

  110. +ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,

  111. +	akg_print_debug)

  112. +ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,

  113. +	akg_print_debug)

  114. +ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,

  115. +	akg_influence_scheduler)

  116. +ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,

  117. +	akg_influence_scheduler)

  118. +/* ======================= AKG influence patch -- end ======================= */

  119. unchanged:

  120. --- isl_0.22/isl_options_private.h	2021-01-26 13:29:02.317994410 +0100

  121. +++ isl/isl_options_private.h	2021-01-26 13:25:07.713990422 +0100

  122. @@ -71,6 +71,10 @@ struct isl_options {

  123.  

  124.  	int			print_stats;

  125.  	unsigned long		max_operations;

  126. +/* ====================== AKG influence patch -- start ====================== */

  127. +	int			akg_print_debug;

  128. +	int			akg_influence_scheduler;

  129. +/* ======================= AKG influence patch -- end ======================= */

  130.  };

  131.  

  132.  #endif

  133. diff -u isl/isl_scheduler.c isl/isl_scheduler.c

  134. --- isl/isl_scheduler.c	2021-02-05 09:56:15.186697283 +0100

  135. +++ isl/isl_scheduler.c	2021-03-31 14:49:38.568015437 +0200

  136. @@ -39,7 +39,6 @@

  137.  #include <isl_morph.h>

  138.  #include <isl/ilp.h>

  139.  #include <isl_val_private.h>

  140. -

  141.  /*

  142.   * The scheduling algorithm implemented in this file was inspired by

  143.   * Bondhugula et al., "Automatic Transformations for Communication-Minimized

  144. @@ -303,6 +302,12 @@

  145.  	return is_condition(edge) || is_conditional_validity(edge);

  146.  }

  147.  

  148. +/* ====================== AKG influence patch -- start ====================== */

  149. +struct isl_influence_list;

  150. +struct isl_influence_equal_list;

  151. +struct isl_influence_sol_list;

  152. +/* ======================= AKG influence patch -- end ======================= */

  153. +

  154.  /* Internal information about the dependence graph used during

  155.   * the construction of the schedule.

  156.   *

  157. @@ -395,6 +400,11 @@

  158.  	int weak;

  159.  

  160.  	int max_weight;

  161. +/* ====================== AKG influence patch -- start ====================== */

  162. +	struct isl_influence_list *inf_list;

  163. +	struct isl_influence_equal_list *inf_equal_list;

  164. +	struct isl_influenec_sol_list* inf_sol_list;

  165. +/* ======================= AKG influence patch -- end ======================= */

  166.  };

  167.  

  168.  /* Initialize node_table based on the list of nodes.

  169. @@ -757,6 +767,8 @@

  170.  		isl_hash_table_free(ctx, graph->edge_table[i]);

  171.  	isl_hash_table_free(ctx, graph->node_table);

  172.  	isl_basic_set_free(graph->lp);

  173. +	if(isl_influence_sol_list_free)

  174. +		graph=isl_influence_sol_list_free(graph);

  175.  }

  176.  

  177.  /* For each "set" on which this function is called, increment

  178. @@ -1233,7 +1245,6 @@

  179.  		return isl_stat_error;

  180.  	if (compressed && (!hull || !compress || !decompress))

  181.  		return isl_stat_error;

  182. -

  183.  	return isl_stat_ok;

  184.  error:

  185.  	isl_set_free(set);

  186. @@ -3222,6 +3233,7 @@

  187.   * In particular, the non-triviality region enforces that at least

  188.   * one of the linear combinations in the rows of node->indep is non-zero.

  189.   */

  190. +

  191.  static __isl_give isl_vec *solve_lp(isl_ctx *ctx, struct isl_sched_graph *graph)

  192.  {

  193.  	int i;

  194. @@ -3237,16 +3249,68 @@

  195.  			trivial = construct_trivial(node, node->indep);

  196.  		else

  197.  			trivial = isl_mat_zero(ctx, 0, 0);

  198. +		

  199.  		graph->region[i].trivial = trivial;

  200.  	}

  201.  	lp = isl_basic_set_copy(graph->lp);

  202. +/* ====================== AKG influence patch -- start ====================== */

  203. +	isl_basic_set *lp_backup;

  204. +	isl_basic_set *lp_backup_inf;

  205. +	const int akg_influence = isl_options_get_akg_influence_scheduler(ctx);

  206. +	const int akg_debug = isl_options_get_akg_print_debug(ctx);

  207. +	if (akg_influence)

  208. +	{

  209. +		lp_backup = isl_basic_set_copy(graph->lp);

  210. +		lp = isl_influence_set_coef(ctx, graph, lp);

  211. +		lp = isl_influence_set_equal(ctx, graph, lp);

  212. +		lp_backup_inf = isl_basic_set_copy(lp);

  213. +  	}

  214. +/* ======================= AKG influence patch -- end ======================= */

  215.  	sol = isl_tab_basic_set_non_trivial_lexmin(lp, 2, graph->n,

  216.  				       graph->region, &check_conflict, graph);

  217. +/* ====================== AKG influence patch -- start ====================== */

  218. +	if (akg_influence)

  219. +	{

  220. +		if(sol->size == 0)

  221. +		{

  222. +			if (akg_debug >= 1)  fprintf(stderr, "\ninfluence schedule did not find solution, relax region and try again::\n");

  223. +			isl_vec_free(sol);

  224. +

  225. +			for(int i=0; i< graph->n;i++)

  226. +			{

  227. +				isl_mat_free(graph->region[i].trivial);

  228. +				graph->region[i].trivial = isl_mat_zero(ctx,0,0);

  229. +			}

  230. +

  231. +			sol = isl_tab_basic_set_non_trivial_lexmin(lp_backup_inf, 2, graph->n, graph->region, &check_conflict, graph);

  232. +

  233. +			if (sol->size == 0)

  234. +		    {

  235. +				if (akg_debug >= 1)  fprintf(stderr, "\ninfluence schedule did not find solution, another try with use_coincidence=0:\n");

  236. +			} else

  237. +			{

  238. +				isl_basic_set_free(lp_backup);	

  239. +			}

  240. +

  241. +		}

  242. +		else

  243. +	    {

  244. +			isl_basic_set_free(lp_backup);	

  245. +			isl_basic_set_free(lp_backup_inf);

  246. +		}

  247. +	}

  248. +

  249. +	if (!sol->size)

  250. +	{

  251. +		if (akg_debug >= 1)

  252. +			fprintf(stderr, "solve_lp did not find solution for dimension: %d\n",graph->n_row);

  253. +	}

  254. +

  255. +/* ======================= AKG influence patch -- end ======================= */

  256.  	for (i = 0; i < graph->n; ++i)

  257.  		isl_mat_free(graph->region[i].trivial);

  258.  	return sol;

  259.  }

  260. -

  261.  /* Extract the coefficients for the variables of "node" from "sol".

  262.   *

  263.   * Each schedule coefficient c_i_x is represented as the difference

  264. @@ -3271,6 +3335,12 @@

  265.  	if (!csol)

  266.  		return NULL;

  267.  

  268. +/* ====================== AKG influence patch -- start ====================== */

  269. +	isl_ctx* const ctx = isl_vec_get_ctx(sol);

  270. +	const int akg_influence = isl_options_get_akg_influence_scheduler(ctx);

  271. +	const int akg_debug = isl_options_get_akg_print_debug(ctx);

  272. +

  273. +/* ======================= AKG influence patch -- end ======================= */

  274.  	for (i = 0; i < node->nvar; ++i) {

  275.  		pos = 1 + node_var_coef_pos(node, i);

  276.  		if (node->nonneg)

  277. @@ -3304,10 +3374,15 @@

  278.  	if (sol->size == 0)

  279.  		isl_die(sol->ctx, isl_error_internal,

  280.  			"no solution found", goto error);

  281. -	if (graph->n_total_row >= graph->max_row)

  282. +/* ====================== AKG influence patch -- start ====================== */

  283. +	isl_ctx* const ctx = isl_vec_get_ctx(sol);

  284. +	const int akg_influence = isl_options_get_akg_influence_scheduler(ctx);

  285. +	const int akg_debug = isl_options_get_akg_print_debug(ctx);

  286. +

  287. +	if (!akg_influence && graph->n_total_row >= graph->max_row)

  288.  		isl_die(sol->ctx, isl_error_internal,

  289.  			"too many schedule rows", goto error);

  290. -

  291. +	/* ======================= AKG influence patch -- end ======================= */

  292.  	for (i = 0; i < graph->n; ++i) {

  293.  		struct isl_sched_node *node = &graph->node[i];

  294.  		int pos;

  295. @@ -3325,11 +3400,13 @@

  296.  			goto error;

  297.  		pos = node_cst_coef_offset(node);

  298.  		node->sched = isl_mat_set_element(node->sched,

  299. -					row, 0, sol->el[1 + pos]);

  300. +				row, 0, sol->el[1 + pos]);

  301.  		pos = node_par_coef_offset(node);

  302.  		for (j = 0; j < node->nparam; ++j)

  303. +    	{

  304.  			node->sched = isl_mat_set_element(node->sched,

  305.  					row, 1 + j, sol->el[1 + pos + j]);

  306. +    	}

  307.  		for (j = 0; j < node->nvar; ++j)

  308.  			node->sched = isl_mat_set_element(node->sched,

  309.  					row, 1 + node->nparam + j, csol->el[j]);

  310. @@ -3340,6 +3417,14 @@

  311.  

  312.  	graph->n_row++;

  313.  	graph->n_total_row++;

  314. +/* ====================== AKG influence patch -- start ====================== */

  315. +	if (akg_influence && graph->n_row  == graph->maxvar)

  316. +	{

  317. +		if(graph->n_row  < isl_influence_maxvar(graph)){

  318. +			graph->maxvar++;

  319. +		}

  320. +	}

  321. +/* ======================= AKG influence patch -- end ======================= */

  322.  

  323.  	return 0;

  324.  error:

  325. @@ -3917,14 +4002,16 @@

  326.  static int compute_maxvar(struct isl_sched_graph *graph)

  327.  {

  328.  	int i;

  329. -

  330.  	graph->maxvar = 0;

  331.  	for (i = 0; i < graph->n; ++i) {

  332.  		struct isl_sched_node *node = &graph->node[i];

  333.  		int nvar;

  334.  

  335. -		if (node_update_vmap(node) < 0)

  336. +/* ====================== AKG influence patch -- start ====================== */

  337. +		if (node_update_vmap(node) < 0) {

  338.  			return -1;

  339. +		}

  340. +/* ======================= AKG influence patch -- end ======================= */

  341.  		nvar = node->nvar + graph->n_row - node->rank;

  342.  		if (nvar > graph->maxvar)

  343.  			graph->maxvar = nvar;

  344. @@ -3968,6 +4055,10 @@

  345.  	sub->max_row = graph->max_row;

  346.  	sub->n_total_row = graph->n_total_row;

  347.  	sub->band_start = graph->band_start;

  348. +/* ====================== AKG influence patch -- start ====================== */

  349. +	sub->inf_list = graph->inf_list;

  350. +	sub->inf_equal_list = graph->inf_equal_list;

  351. +/* ======================= AKG influence patch -- end ======================= */

  352.  

  353.  	return isl_stat_ok;

  354.  }

  355. @@ -3997,6 +4088,11 @@

  356.  {

  357.  	struct isl_sched_graph split = { 0 };

  358.  

  359. +/* ====================== AKG influence patch -- start ====================== */

  360. +	const int akg_influence = isl_options_get_akg_influence_scheduler(ctx);

  361. +	const int akg_debug = isl_options_get_akg_print_debug(ctx);

  362. +/* ======================= AKG influence patch -- end ======================= */

  363. +

  364.  	if (extract_sub_graph(ctx, graph, node_pred, edge_pred, data,

  365.  				&split) < 0)

  366.  		goto error;

  367. @@ -5396,6 +5492,30 @@

  368.  		return NULL;

  369.  

  370.  	lp = isl_basic_set_copy(graph->lp);

  371. +/* ====================== AKG influence patch -- start ====================== */

  372. +	const int akg_influence = isl_options_get_akg_influence_scheduler(ctx);

  373. +	const int akg_debug = isl_options_get_akg_print_debug(ctx);

  374. +	if (akg_influence)

  375. +	{

  376. +		isl_basic_set *lp_backup = isl_basic_set_copy(graph->lp);

  377. +		lp = isl_influence_set_coef(ctx, graph, lp);

  378. +		lp = isl_influence_set_equal(ctx, graph, lp);

  379. +		isl_vec *sol = non_neg_lexmin(graph, lp, n_edge, want_integral);

  380. +		if (sol->size == 0)

  381. +		{

  382. +      if (akg_debug >= 1) {

  383. +        fprintf(stderr, "\ncarry_lp hack failed, restoring previous lp problem\n");

  384. +      }

  385. +			sol = non_neg_lexmin(graph, lp_backup, n_edge, want_integral);

  386. +		}

  387. +		else

  388. +		{

  389. +			isl_basic_set_free(lp_backup);

  390. +		}

  391. +

  392. +    return sol;

  393. +	}

  394. +/* ======================= AKG influence patch -- end ======================= */

  395.  	return non_neg_lexmin(graph, lp, n_edge, want_integral);

  396.  }

  397.  

  398. @@ -5991,6 +6111,11 @@

  399.  	int use_coincidence;

  400.  	int force_coincidence = 0;

  401.  	int check_conditional;

  402. +	int coincidence_relaxed=0;

  403. +/* ====================== AKG influence patch -- start ====================== */

  404. +	const int akg_influence = isl_options_get_akg_influence_scheduler(ctx);

  405. +	const int akg_debug = isl_options_get_akg_print_debug(ctx);

  406. +/* ======================= AKG influence patch -- end ======================= */

  407.  

  408.  	if (sort_sccs(graph) < 0)

  409.  		return isl_stat_error;

  410. @@ -5998,10 +6123,17 @@

  411.  	clear_local_edges(graph);

  412.  	check_conditional = need_condition_check(graph);

  413.  	has_coincidence = has_any_coincidence(graph);

  414. -

  415.  	if (ctx->opt->schedule_outer_coincidence)

  416.  		force_coincidence = 1;

  417.  

  418. +

  419. +	if(akg_influence){

  420. +		int previous_coincidence = has_coincidence;

  421. +		int isl_maxvar = isl_influence_maxvar(graph);

  422. +		if(graph->maxvar > isl_maxvar)

  423. +			graph->maxvar = isl_maxvar;

  424. +	}

  425. +	

  426.  	use_coincidence = has_coincidence;

  427.  	while (graph->n_row < graph->maxvar) {

  428.  		isl_vec *sol;

  429. @@ -6014,19 +6146,34 @@

  430.  		if (setup_lp(ctx, graph, use_coincidence) < 0)

  431.  			return isl_stat_error;

  432.  		sol = solve_lp(ctx, graph);

  433. -		if (!sol)

  434. +		if(akg_influence && sol->size)

  435. +			graph=isl_influence_sol_add_elem(sol,graph);

  436. +		if(!sol)

  437. +    {

  438.  			return isl_stat_error;

  439. +    }

  440.  		if (sol->size == 0) {

  441. +			/* ====================== AKG influence patch -- start ====================== */

  442. +      		if (akg_influence && akg_debug >= 1) {

  443. +        		fprintf(stderr, "No solution!\n");

  444. +      		}

  445. +			/* ======================= AKG influence patch -- end ======================= */

  446.  			int empty = graph->n_total_row == graph->band_start;

  447.  

  448.  			isl_vec_free(sol);

  449.  			if (use_coincidence && (!force_coincidence || !empty)) {

  450.  				use_coincidence = 0;

  451. +				coincidence_relaxed=1;

  452.  				continue;

  453.  			}

  454.  			return isl_stat_ok;

  455.  		}

  456.  		coincident = !has_coincidence || use_coincidence;

  457. +		

  458. +		if(akg_influence && graph->n > 1){

  459. +			coincident=isl_influence_check_coincident(graph,sol);

  460. +		}

  461. +			

  462.  		if (update_schedule(graph, sol, coincident) < 0)

  463.  			return isl_stat_error;

  464.  

  465. @@ -7688,6 +7835,10 @@

  466.  

  467.  	if (graph->scc <= 1 || isl_options_get_schedule_whole_component(ctx))

  468.  		return compute_schedule_wcc_whole(node, graph);

  469. +/* ====================== AKG influence patch -- start ====================== */

  470. +  else if (isl_options_get_akg_influence_scheduler(ctx))

  471. +    return compute_schedule_wcc_whole(node, graph);

  472. +/* ======================= AKG influence patch -- end ======================= */

  473.  	else

  474.  		return compute_schedule_wcc_clustering(node, graph);

  475.  }

  476. @@ -7735,6 +7886,10 @@

  477.  	else

  478.  		node = isl_schedule_node_insert_sequence(node, filters);

  479.  

  480. +/* ====================== AKG influence patch -- start ====================== */

  481. +	const int akg_influence = isl_options_get_akg_influence_scheduler(ctx);

  482. +	const int akg_debug = isl_options_get_akg_print_debug(ctx);

  483. +/* ======================= AKG influence patch -- end ======================= */

  484.  	for (component = 0; component < graph->scc; ++component) {

  485.  		node = isl_schedule_node_child(node, component);

  486.  		node = isl_schedule_node_child(node, 0);

  487. @@ -7775,7 +7930,10 @@

  488.  			return isl_schedule_node_free(node);

  489.  	}

  490.  

  491. -	if (graph->scc > 1)

  492. +/* ====================== AKG influence patch -- start ====================== */

  493. +	const int akg_influence = isl_options_get_akg_influence_scheduler(ctx);

  494. +	if (graph->scc > 1 && akg_influence == 0)

  495. +/* ======================= AKG influence patch -- end ======================= */

  496.  		return compute_component_schedule(node, graph, 1);

  497.  

  498.  	return compute_schedule_wcc(node, graph);

  499. @@ -7806,6 +7964,11 @@

  500.  	isl_union_set *domain;

  501.  	isl_size n;

  502.  

  503. +/* ====================== AKG influence patch -- start ====================== */

  504. +	const int akg_influence = isl_options_get_akg_influence_scheduler(ctx);

  505. +	const int akg_debug = isl_options_get_akg_print_debug(ctx);

  506. +/* ======================= AKG influence patch -- end ======================= */

  507. +

  508.  	sc = isl_schedule_constraints_align_params(sc);

  509.  

  510.  	domain = isl_schedule_constraints_get_domain(sc);

  511. @@ -7852,0 +8016,62 @@

  512. +

  513. +/* ====================== AKG influence patch -- start ====================== */

  514. +isl_basic_set* (*isl_influence_set_coef)(

  515. +    isl_ctx *ctx, struct isl_sched_graph *graph, isl_basic_set *bset) = { 0 };

  516. +isl_basic_set* (*isl_influence_set_equal)(

  517. +    isl_ctx *ctx, struct isl_sched_graph *graph, isl_basic_set *bset) = { 0 };

  518. +int (*isl_influence_maxvar)(struct isl_sched_graph* graph) = { 0 };

  519. +int (*isl_influence_check_coincident)(struct isl_sched_graph *graph,isl_vec* sol) = { 0 };

  520. +struct isl_sched_graph* (*isl_influence_sol_list_free)(struct isl_sched_graph* graph) = { 0 } ;

  521. +struct isl_sched_graph* (*isl_influence_sol_add_elem)(isl_vec* sol, struct isl_sched_graph* graph) = { 0 };

  522. +int  (*isl_influence_sol_get_elem)(int sched, int pos, struct isl_sched_graph* graph) = { 0 };

  523. +int  isl_sched_node_par_coef_offset(struct isl_sched_node *node) {

  524. +  return node_par_coef_offset(node);

  525. +}

  526. +

  527. +int isl_sched_node_cst_coef_offset(struct isl_sched_node *node) {

  528. +  return node_cst_coef_offset(node);

  529. +}

  530. +

  531. +__isl_give isl_map *isl_sched_node_extract_schedule(struct isl_sched_node *node) {

  532. +  return node_extract_schedule(node);

  533. +}

  534. +

  535. +int isl_sched_node_get_nparam(const struct isl_sched_node *node) {

  536. +  return node->nparam;

  537. +}

  538. +

  539. +int isl_sched_node_get_nvar(const struct isl_sched_node *node) {

  540. +  return node->nvar;

  541. +}

  542. +

  543. +int isl_influence_int_eq(isl_vec* v, int pos1, int pos2)

  544. +{

  545. +  return isl_int_eq(v->el[pos1],v->el[pos2]);

  546. +}

  547. +

  548. +isl_val* isl_influence_vec_get_elem(isl_vec* v, int pos)

  549. +{

  550. +  return isl_vec_get_element_val(v,pos);

  551. +}

  552. +isl_stat isl_sched_graph_init(struct isl_sched_graph *graph,

  553. +	__isl_keep isl_schedule_constraints *sc) {

  554. +  return graph_init(graph, sc);

  555. +}

  556. +

  557. +void isl_sched_graph_free(isl_ctx *ctx, struct isl_sched_graph *graph) {

  558. +  graph_free(ctx, graph);

  559. +}

  560. +

  561. +__isl_give isl_schedule_node *isl_schedule_node_compute_schedule(isl_schedule_node *node,

  562. +	struct isl_sched_graph *graph) {

  563. +  return compute_schedule(node, graph);

  564. +}

  565. +

  566. +struct isl_sched_node* isl_sched_graph_get_node(struct isl_sched_graph *graph, int i) {

  567. +  return &graph->node[i];

  568. +}

  569. +

  570. +int isl_inf_vec_get_size(isl_vec* vec){

  571. +  return(int) vec->size;

  572. +}

  573. +/* ======================= AKG influence patch -- end ======================= */