int main(int argc, char **argv)
{
isl_ctx *ctx;
isl_printer *p;
isl_schedule_constraints *sc;
isl_schedule *schedule;
struct isl_options *options;
options = isl_options_new_with_defaults();
argc = isl_options_parse(options, argc, argv, ISL_ARG_ALL);
ctx = isl_ctx_alloc_with_options(&isl_options_args, options);
sc = isl_schedule_constraints_read_from_file(ctx, stdin);
schedule = isl_schedule_constraints_compute_schedule(sc);
p = isl_printer_to_file(ctx, stdout);
p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_BLOCK);
p = isl_printer_print_schedule(p, schedule);
isl_printer_free(p);
isl_schedule_free(schedule);
isl_ctx_free(ctx);
return p ? EXIT_SUCCESS : EXIT_FAILURE;
}
static bool
graphite_initialize (isl_ctx *ctx)
{
if (number_of_loops (cfun) <= 1
/* FIXME: This limit on the number of basic blocks of a function
should be removed when the SCOP detection is faster. */
|| n_basic_blocks > PARAM_VALUE (PARAM_GRAPHITE_MAX_BBS_PER_FUNCTION))
{
if (dump_file && (dump_flags & TDF_DETAILS))
print_global_statistics (dump_file);
isl_ctx_free (ctx);
return false;
}
scev_reset ();
recompute_all_dominators ();
initialize_original_copy_tables ();
cloog_state = cloog_isl_state_malloc (ctx);
if (dump_file && dump_flags)
dump_function_to_file (current_function_decl, dump_file, dump_flags);
return true;
}
int main()
{
isl_ctx* ctx = isl_ctx_alloc();
isl_ctx_free(ctx);
return 0;
}
/*
* Each test case should name statements S_0, S_1, ...
*/
int test2()
{
printf("TEST 2\n");
isl_ctx *ctx = isl_ctx_alloc();
isl_union_set *domains = isl_union_set_read_from_str(ctx,
"[p_0, p_1, p_2, p_3, p_4, p_5, p_7] -> { S_1[i0, i1] : i0 >= 0 and i0 <= p_0 and i1 >= 0 and i1 <= p_3 and p_2 >= 0; S_0[i0] : i0 >= 0 and i0 <= p_0}");
isl_union_map *deps = isl_union_map_read_from_str(ctx, "[p_0, p_1, p_2, p_3, p_4, p_5, p_7] -> { S_0[i0] -> S_1[o0, o1] : (exists (e0 = [(p_7)/8]: 8o1 = -p_5 + p_7 + 8192i0 - 8192o0 and 8e0 = p_7 and i0 >= 0 and o0 <= p_0 and 8192o0 >= -8p_3 - p_5 + p_7 + 8192i0 and 8192o0 <= -p_5 + p_7 + 8192i0 and p_2 >= 0 and o0 >= 1 + i0)); S_1[i0, i1] -> S_0[o0] : (exists (e0 = [(p_1)/8], e1 = [(p_4)/8], e2 = [(-p_1 + p_7)/8184]: 8192o0 = p_5 - p_7 + 8192i0 + 8i1 and 8e0 = p_1 and 8e1 = p_4 and 8184e2 = -p_1 + p_7 and i1 >= 0 and 8i1 <= 8192p_0 - p_5 + p_7 - 8192i0 and 8184i1 >= 1024 + 1024p_1 - 1023p_5 - p_7 - 8380416i0 and p_2 >= 0 and p_7 <= -1 + p_5 and 8i1 >= 1 + 8p_3 + p_4 - p_5 - 8192i0 and i1 <= p_3 and i0 >= 0 and 8i1 >= 8192 - p_5 + p_7))}");
isl_union_map *schedule = pluto_schedule(domains, deps, options);
if (schedule) {
isl_printer *printer = isl_printer_to_file(ctx, stdout);
isl_printer_print_union_map(printer, schedule);
printf("\n");
isl_printer_free(printer);
// Check if the schedule can be applied to the domain.
domains = isl_union_set_apply(domains, schedule);
}else{
printf("No schedule\n");
}
isl_union_set_free(domains);
isl_union_map_free(deps);
isl_ctx_free(ctx);
}
int main(int argc, char **argv)
{
struct isl_ctx *ctx;
struct isl_map *map;
struct isl_options *options;
isl_printer *p;
int exact;
options = isl_options_new_with_defaults();
assert(options);
argc = isl_options_parse(options, argc, argv, ISL_ARG_ALL);
ctx = isl_ctx_alloc_with_options(&isl_options_args, options);
p = isl_printer_to_file(ctx, stdout);
map = isl_map_read_from_file(ctx, stdin);
map = isl_map_transitive_closure(map, &exact);
if (!exact)
p = isl_printer_print_str(p, "# NOT exact\n");
p = isl_printer_print_map(p, map);
p = isl_printer_end_line(p);
map = isl_map_compute_divs(map);
map = isl_map_coalesce(map);
p = isl_printer_print_str(p, "# coalesced\n");
p = isl_printer_print_map(p, map);
p = isl_printer_end_line(p);
isl_map_free(map);
isl_printer_free(p);
isl_ctx_free(ctx);
return 0;
}
enum lp_result isl_constraints_opt(Matrix *C, Value *obj, Value denom,
enum lp_dir dir, Value *opt)
{
int i;
isl_ctx *ctx = isl_ctx_alloc();
isl_space *dim;
isl_local_space *ls;
isl_mat *eq, *ineq;
isl_basic_set *bset;
isl_aff *aff;
isl_val *v;
enum isl_lp_result res;
int max = dir == lp_max;
eq = extract_equalities(ctx, C);
ineq = extract_inequalities(ctx, C);
dim = isl_space_set_alloc(ctx, 0, C->NbColumns - 2);
ls = isl_local_space_from_space(isl_space_copy(dim));
bset = isl_basic_set_from_constraint_matrices(dim, eq, ineq,
isl_dim_set, isl_dim_div, isl_dim_param, isl_dim_cst);
aff = isl_aff_zero_on_domain(ls);
for (i = 0; i < C->NbColumns - 2; ++i) {
v = isl_val_int_from_gmp(ctx, obj[i]);
aff = isl_aff_set_coefficient_val(aff, isl_dim_in, i, v);
}
v = isl_val_int_from_gmp(ctx, obj[C->NbColumns - 2]);
aff = isl_aff_set_constant_val(aff, v);
v = isl_val_int_from_gmp(ctx, denom);
aff = isl_aff_scale_down_val(aff, v);
if (max)
v = isl_val_floor(isl_basic_set_max_lp_val(bset, aff));
else
v = isl_val_ceil(isl_basic_set_min_lp_val(bset, aff));
if (!v)
res = isl_lp_error;
else if (isl_val_is_nan(v))
res = isl_lp_empty;
else if (!isl_val_is_rat(v))
res = isl_lp_unbounded;
else {
res = isl_lp_ok;
isl_val_get_num_gmp(v, *opt);
}
isl_val_free(v);
isl_aff_free(aff);
isl_basic_set_free(bset);
isl_ctx_free(ctx);
return isl_lp_result2lp_result(res);
}
int main(int argc, char **argv)
{
struct isl_ctx *ctx = isl_ctx_alloc();
struct isl_basic_set *bset;
bset = isl_basic_set_read_from_file(ctx, stdin);
bset = isl_basic_set_detect_equalities(bset);
isl_basic_set_print(bset, stdout, 0, "", "", ISL_FORMAT_POLYLIB);
isl_basic_set_free(bset);
isl_ctx_free(ctx);
return 0;
}
int main(int argc, char **argv)
{
struct isl_ctx *ctx = isl_ctx_alloc();
struct isl_basic_set *bset;
struct isl_mat *samples;
bset = isl_basic_set_read_from_file(ctx, stdin);
samples = isl_basic_set_samples(bset);
isl_mat_print_internal(samples, stdout, 0);
isl_mat_free(samples);
isl_ctx_free(ctx);
return 0;
}
void
graphite_transform_loops (void)
{
int i;
scop_p scop;
bool need_cfg_cleanup_p = false;
vec<scop_p> scops = vNULL;
bb_pbb_htab_type bb_pbb_mapping;
isl_ctx *ctx;
/* If a function is parallel it was most probably already run through graphite
once. No need to run again. */
if (parallelized_function_p (cfun->decl))
return;
ctx = isl_ctx_alloc ();
isl_options_set_on_error (ctx, ISL_ON_ERROR_ABORT);
if (!graphite_initialize (ctx))
return;
the_isl_ctx = ctx;
build_scops (&scops);
if (dump_file && (dump_flags & TDF_DETAILS))
{
print_graphite_statistics (dump_file, scops);
print_global_statistics (dump_file);
}
bb_pbb_mapping.create (10);
FOR_EACH_VEC_ELT (scops, i, scop)
if (dbg_cnt (graphite_scop))
{
scop->ctx = ctx;
build_poly_scop (scop);
if (POLY_SCOP_P (scop)
&& apply_poly_transforms (scop)
&& gloog (scop, bb_pbb_mapping))
need_cfg_cleanup_p = true;
}
bb_pbb_mapping.dispose ();
free_scops (scops);
graphite_finalize (need_cfg_cleanup_p);
the_isl_ctx = NULL;
isl_ctx_free (ctx);
}
int main(int argc, char **argv)
{
struct isl_ctx *ctx = isl_ctx_alloc();
struct isl_basic_set *bset;
struct isl_vec *obj;
struct isl_vec *sol;
isl_int opt;
unsigned dim;
enum isl_lp_result res;
isl_printer *p;
isl_int_init(opt);
bset = isl_basic_set_read_from_file(ctx, stdin);
assert(bset);
obj = isl_vec_read_from_file(ctx, stdin);
assert(obj);
dim = isl_basic_set_total_dim(bset);
assert(obj->size >= dim && obj->size <= dim + 1);
if (obj->size != dim + 1)
obj = isl_vec_lin_to_aff(obj);
else
obj = vec_ror(obj);
res = isl_basic_set_solve_ilp(bset, 0, obj->el, &opt, &sol);
switch (res) {
case isl_lp_error:
fprintf(stderr, "error\n");
return -1;
case isl_lp_empty:
fprintf(stdout, "empty\n");
break;
case isl_lp_unbounded:
fprintf(stdout, "unbounded\n");
break;
case isl_lp_ok:
p = isl_printer_to_file(ctx, stdout);
p = isl_printer_print_vec(p, sol);
p = isl_printer_end_line(p);
p = isl_printer_print_isl_int(p, opt);
p = isl_printer_end_line(p);
isl_printer_free(p);
}
isl_basic_set_free(bset);
isl_vec_free(obj);
isl_vec_free(sol);
isl_ctx_free(ctx);
isl_int_clear(opt);
return 0;
}
Param_Polyhedron *ISL_P2PP(Polyhedron *P, Polyhedron *C,
struct barvinok_options *options)
{
int i, j;
isl_ctx *ctx = isl_ctx_alloc();
isl_space *dim;
isl_basic_set *bset, *context;
isl_vertices *vertices;
unsigned nparam = C->Dimension;
unsigned nvar = P->Dimension - nparam;
Param_Polyhedron *PP = isl_calloc_type(ctx, Param_Polyhedron);
Param_Vertices **next_V;
struct bv_add_chamber_data data;
dim = isl_space_set_alloc(ctx, nparam, nvar);
bset = isl_basic_set_new_from_polylib(P, dim);
dim = isl_space_set_alloc(ctx, nparam, 0);
context = isl_basic_set_new_from_polylib(C, dim);
bset = isl_basic_set_intersect(bset, context);
vertices = isl_basic_set_compute_vertices(bset);
isl_basic_set_free(bset);
PP->Rays = NULL;
PP->nbV = isl_vertices_get_n_vertices(vertices);
PP->Constraints = Polyhedron2Constraints(P);
next_V = &PP->V;
isl_vertices_foreach_vertex(vertices, &add_vertex, &next_V);
data.next_D = &PP->D;
data.vertex_len = (PP->nbV + INT_BITS - 1)/INT_BITS;
isl_vertices_foreach_cell(vertices, &add_chamber, &data);
isl_vertices_free(vertices);
isl_ctx_free(ctx);
return PP;
}
int main(int argc, char **argv)
{
struct isl_ctx *ctx = isl_ctx_alloc();
struct isl_basic_set *bset;
struct isl_vec *sample;
isl_printer *p;
bset = isl_basic_set_read_from_file(ctx, stdin);
sample = isl_basic_set_sample_vec(isl_basic_set_copy(bset));
p = isl_printer_to_file(ctx, stdout);
p = isl_printer_print_vec(p, sample);
p = isl_printer_end_line(p);
isl_printer_free(p);
assert(sample);
if (sample->size > 0)
assert(isl_basic_set_contains(bset, sample));
isl_basic_set_free(bset);
isl_vec_free(sample);
isl_ctx_free(ctx);
return 0;
}
void test1()
{
isl_ctx *ctx = isl_ctx_alloc();
isl_union_set *domains = isl_union_set_read_from_str(ctx,
"[n] -> {S_1[i0, i1] : i0 >= 0 and i0 <= 99 and i1 >= 0 and i1 <= 99; S_0[i0] : i0 >= 0 and i0 <= 99; S_2[i0] : i0 >= 0 and i0 <= 99 }");
isl_union_map *deps = isl_union_map_read_from_str(ctx, "[n] -> {S_1[i0, 99] -> S_0[1 + i0] : i0 >= 0 and i0 <= 98; S_1[i0, i1] -> S_1[i0, 1 + i1] : i0 >= 0 and i0 <= 99 and i1 >= 0 and i1 <= 98; S_1[i0, 99] -> S_1[1 + i0, 0] : i0 >= 0 and i0 <= 98; S_0[i0] -> S_1[i0, 0] : i0 >= 0 and i0 <= 99; S_2[i0] -> S_1[1 + i0, 0] : i0 >= 0 and i0 <= 98; S_0[i0] -> S_2[i0] : i0 >= 0 and i0 <= 99; S_1[i0, 99] -> S_2[i0] : i0 >= 0 and i0 <= 99 }");
isl_union_map *schedule = pluto_schedule(domains, deps, options);
isl_printer *printer = isl_printer_to_file(ctx, stdout);
isl_printer_print_union_map(printer, schedule);
printf("\n");
isl_printer_free(printer);
// Check if the schedule can be applied to the domain.
domains = isl_union_set_apply(domains, schedule);
isl_union_set_free(domains);
isl_union_map_free(deps);
isl_ctx_free(ctx);
}
enum order_sign isl_polyhedron_affine_sign(Polyhedron *D, Matrix *T,
struct barvinok_options *options)
{
int i;
isl_ctx *ctx = isl_ctx_alloc();
isl_space *dim;
isl_local_space *ls;
isl_aff *aff;
isl_basic_set *bset;
isl_val *min, *max = NULL;
isl_val *v;
enum order_sign sign = order_undefined;
assert(D->Dimension == T->NbColumns - 1);
dim = isl_space_set_alloc(ctx, 0, D->Dimension);
ls = isl_local_space_from_space(isl_space_copy(dim));
bset = isl_basic_set_new_from_polylib(D, dim);
aff = isl_aff_zero_on_domain(ls);
for (i = 0; i < D->Dimension; ++i) {
v = isl_val_int_from_gmp(ctx, T->p[0][i]);
aff = isl_aff_set_coefficient_val(aff, isl_dim_in, i, v);
}
v = isl_val_int_from_gmp(ctx, T->p[0][D->Dimension]);
aff = isl_aff_set_constant_val(aff, v);
v = isl_val_int_from_gmp(ctx, T->p[1][D->Dimension]);
aff = isl_aff_scale_down_val(aff, v);
min = isl_basic_set_min_lp_val(bset, aff);
min = isl_val_ceil(min);
assert(min);
if (isl_val_is_nan(min))
sign = order_undefined;
else if (isl_val_is_pos(min))
sign = order_gt;
else {
max = isl_basic_set_max_lp_val(bset, aff);
max = isl_val_floor(max);
assert(max);
if (isl_val_is_neg(max))
sign = order_lt;
else if (isl_val_is_zero(min) && isl_val_is_zero(max))
sign = order_eq;
else if (isl_val_is_zero(min))
sign = order_ge;
else if (isl_val_is_zero(max))
sign = order_le;
else
sign = order_unknown;
}
isl_basic_set_free(bset);
isl_aff_free(aff);
isl_val_free(min);
isl_val_free(max);
isl_ctx_free(ctx);
return sign;
}
int main(int argc, char **argv)
{
isl_ctx *ctx;
int i, nbPol, nbVec, nbMat, func, j, n;
Polyhedron *A, *B, *C, *D, *E, *F, *G;
char s[128];
struct barvinok_options *options = barvinok_options_new_with_defaults();
argc = barvinok_options_parse(options, argc, argv, ISL_ARG_ALL);
ctx = isl_ctx_alloc_with_options(&barvinok_options_args, options);
nbPol = nbVec = nbMat = 0;
fgets(s, 128, stdin);
while ((*s=='#') ||
((sscanf(s, "D %d", &nbPol) < 1) &&
(sscanf(s, "V %d", &nbVec) < 1) &&
(sscanf(s, "M %d", &nbMat) < 1)))
fgets(s, 128, stdin);
for (i = 0; i < nbPol; ++i) {
Matrix *M = Matrix_Read();
A = Constraints2Polyhedron(M, options->MaxRays);
Matrix_Free(M);
fgets(s, 128, stdin);
while ((*s=='#') || (sscanf(s, "F %d", &func)<1))
fgets(s, 128, stdin);
switch(func) {
case 0: {
Value cb, ck;
value_init(cb);
value_init(ck);
fgets(s, 128, stdin);
/* workaround for apparent bug in older gmps */
*strchr(s, '\n') = '\0';
while ((*s=='#') || (value_read(ck, s) != 0)) {
fgets(s, 128, stdin);
/* workaround for apparent bug in older gmps */
*strchr(s, '\n') = '\0';
}
barvinok_count_with_options(A, &cb, options);
if (value_ne(cb, ck))
return -1;
value_clear(cb);
value_clear(ck);
break;
}
case 1:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
B = Polyhedron_Polar(A, options->MaxRays);
Polyhedron_Print(stdout, P_VALUE_FMT, B);
C = Polyhedron_Polar(B, options->MaxRays);
Polyhedron_Print(stdout, P_VALUE_FMT, C);
Polyhedron_Free(C);
Polyhedron_Free(B);
break;
case 2:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
for (j = 0; j < A->NbRays; ++j) {
B = supporting_cone(A, j);
Polyhedron_Print(stdout, P_VALUE_FMT, B);
Polyhedron_Free(B);
}
break;
case 3:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
C = B = NULL;
barvinok_decompose(A,&B,&C);
puts("Pos:");
Polyhedron_Print(stdout, P_VALUE_FMT, B);
puts("Neg:");
Polyhedron_Print(stdout, P_VALUE_FMT, C);
Domain_Free(B);
Domain_Free(C);
break;
case 4: {
Value cm, cb;
struct tms tms_before, tms_between, tms_after;
value_init(cm);
value_init(cb);
Polyhedron_Print(stdout, P_VALUE_FMT, A);
times(&tms_before);
manual_count(A, &cm);
times(&tms_between);
barvinok_count(A, &cb, 100);
times(&tms_after);
printf("manual: ");
value_print(stdout, P_VALUE_FMT, cm);
puts("");
time_diff(&tms_before, &tms_between);
printf("Barvinok: ");
value_print(stdout, P_VALUE_FMT, cb);
puts("");
time_diff(&tms_between, &tms_after);
value_clear(cm);
value_clear(cb);
break;
}
case 5:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
B = triangulate_cone(A, 100);
Polyhedron_Print(stdout, P_VALUE_FMT, B);
check_triangulization(A, B);
Domain_Free(B);
break;
case 6:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
B = remove_equalities(A, options->MaxRays);
Polyhedron_Print(stdout, P_VALUE_FMT, B);
Polyhedron_Free(B);
break;
case 8: {
evalue *EP;
Matrix *M = Matrix_Read();
const char **param_name;
C = Constraints2Polyhedron(M, options->MaxRays);
Matrix_Free(M);
Polyhedron_Print(stdout, P_VALUE_FMT, A);
Polyhedron_Print(stdout, P_VALUE_FMT, C);
EP = barvinok_enumerate_with_options(A, C, options);
param_name = Read_ParamNames(stdin, C->Dimension);
print_evalue(stdout, EP, (const char**)param_name);
evalue_free(EP);
Polyhedron_Free(C);
}
case 9:
Polyhedron_Print(stdout, P_VALUE_FMT, A);
Polyhedron_Polarize(A);
C = B = NULL;
barvinok_decompose(A,&B,&C);
for (D = B; D; D = D->next)
Polyhedron_Polarize(D);
for (D = C; D; D = D->next)
Polyhedron_Polarize(D);
puts("Pos:");
Polyhedron_Print(stdout, P_VALUE_FMT, B);
puts("Neg:");
Polyhedron_Print(stdout, P_VALUE_FMT, C);
Domain_Free(B);
Domain_Free(C);
break;
case 10: {
evalue *EP;
Value cb, ck;
value_init(cb);
value_init(ck);
fgets(s, 128, stdin);
sscanf(s, "%d", &n);
for (j = 0; j < n; ++j) {
Polyhedron *P;
M = Matrix_Read();
P = Constraints2Polyhedron(M, options->MaxRays);
Matrix_Free(M);
A = DomainConcat(P, A);
}
fgets(s, 128, stdin);
/* workaround for apparent bug in older gmps */
*strchr(s, '\n') = '\0';
while ((*s=='#') || (value_read(ck, s) != 0)) {
fgets(s, 128, stdin);
/* workaround for apparent bug in older gmps */
*strchr(s, '\n') = '\0';
}
C = Universe_Polyhedron(0);
EP = barvinok_enumerate_union(A, C, options->MaxRays);
value_set_double(cb, compute_evalue(EP, &ck)+.25);
if (value_ne(cb, ck))
return -1;
Domain_Free(C);
value_clear(cb);
value_clear(ck);
evalue_free(EP);
break;
}
case 11: {
isl_space *dim;
isl_basic_set *bset;
isl_pw_qpolynomial *expected, *computed;
unsigned nparam;
expected = isl_pw_qpolynomial_read_from_file(ctx, stdin);
nparam = isl_pw_qpolynomial_dim(expected, isl_dim_param);
dim = isl_space_set_alloc(ctx, nparam, A->Dimension - nparam);
bset = isl_basic_set_new_from_polylib(A, dim);
computed = isl_basic_set_lattice_width(bset);
computed = isl_pw_qpolynomial_sub(computed, expected);
if (!isl_pw_qpolynomial_is_zero(computed))
return -1;
isl_pw_qpolynomial_free(computed);
break;
}
case 12: {
Vector *sample;
int has_sample;
fgets(s, 128, stdin);
sscanf(s, "%d", &has_sample);
sample = Polyhedron_Sample(A, options);
if (!sample && has_sample)
return -1;
if (sample && !has_sample)
return -1;
if (sample && !in_domain(A, sample->p))
return -1;
Vector_Free(sample);
}
}
Domain_Free(A);
}
for (i = 0; i < nbVec; ++i) {
int ok;
Vector *V = Vector_Read();
Matrix *M = Matrix_Alloc(V->Size, V->Size);
Vector_Copy(V->p, M->p[0], V->Size);
ok = unimodular_complete(M, 1);
assert(ok);
Matrix_Print(stdout, P_VALUE_FMT, M);
Matrix_Free(M);
Vector_Free(V);
}
for (i = 0; i < nbMat; ++i) {
Matrix *U, *V, *S;
Matrix *M = Matrix_Read();
Smith(M, &U, &V, &S);
Matrix_Print(stdout, P_VALUE_FMT, U);
Matrix_Print(stdout, P_VALUE_FMT, V);
Matrix_Print(stdout, P_VALUE_FMT, S);
Matrix_Free(M);
Matrix_Free(U);
Matrix_Free(V);
Matrix_Free(S);
}
isl_ctx_free(ctx);
return 0;
}
void destroy_solver (void) {
if (solution != 0) isl_point_free (solution);
if (solutions != 0) isl_set_free (solutions);
isl_local_space_free (ls);
isl_ctx_free (context);
}
