summaryloggraphiclog1graphiclog2commitcommitdifftreerefseditfork
rawpatchinlineside by side (parent: 115bd71)
rawpatchinlineside by side (parent: 115bd71)
| author | Sven Verdoolaege <skimo@kotnet.org> | |
| Wed, 18 Dec 2013 11:05:32 +0000 (18 12:05 +0100) | ||
| committer | Sven Verdoolaege <skimo@kotnet.org> | |
| Sun, 22 Dec 2013 07:16:53 +0000 (22 08:16 +0100) |
This should allow the user to deterministically limit the effort
spent on a computation.
Requested-by: Tobias Grosser <tobias@grosser.es>
Signed-off-by: Sven Verdoolaege <skimo@kotnet.org>
spent on a computation.
Requested-by: Tobias Grosser <tobias@grosser.es>
Signed-off-by: Sven Verdoolaege <skimo@kotnet.org>
diff --git a/doc/user.pod b/doc/user.pod
--- a/doc/user.pod
+++ b/doc/user.pod
isl_ctx *isl_ctx_alloc();
void isl_ctx_free(isl_ctx *ctx);
+The user can impose a bound on the number of low-level I<operations>
+that can be performed by an C<isl_ctx>. This bound can be set and
+retrieved using the following functions. A bound of zero means that
+no bound is imposed. The number of operations performed can be
+reset using C<isl_ctx_reset_operations>. Note that the number
+of low-level operations needed to perform a high-level computation
+may differ significantly across different versions
+of C<isl>, but it should be the same across different platforms
+for the same version of C<isl>.
+
+ void isl_ctx_set_max_operations(isl_ctx *ctx,
+ unsigned long max_operations);
+ unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
+ void isl_ctx_reset_operations(isl_ctx *ctx);
+
=head2 Values
An C<isl_val> represents an integer value, a rational value
diff --git a/include/isl/ctx.h b/include/isl/ctx.h
--- a/include/isl/ctx.h
+++ b/include/isl/ctx.h
isl_error_unknown,
isl_error_internal,
isl_error_invalid,
+ isl_error_quota,
isl_error_unsupported
};
struct isl_ctx;
void isl_ctx_resume(isl_ctx *ctx);
int isl_ctx_aborted(isl_ctx *ctx);
+void isl_ctx_set_max_operations(isl_ctx *ctx, unsigned long max_operations);
+unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
+void isl_ctx_reset_operations(isl_ctx *ctx);
+
#define ISL_ARG_CTX_DECL(prefix,st,args) \
st *isl_ctx_peek_ ## prefix(isl_ctx *ctx);
diff --git a/isl_ctx.c b/isl_ctx.c
--- a/isl_ctx.c
+++ b/isl_ctx.c
ctx->error = isl_error_none;
+ ctx->operations = 0;
+ isl_ctx_set_max_operations(ctx, ctx->opt->max_operations);
+
return ctx;
error:
isl_args_free(args, user_opt);
ctx->ref--;
}
+/* Print statistics on usage.
+ */
+static void print_stats(isl_ctx *ctx)
+{
+ fprintf(stderr, "operations: %lu\n", ctx->operations);
+}
+
void isl_ctx_free(struct isl_ctx *ctx)
{
if (!ctx)
"isl_ctx freed, but some objects still reference it",
return);
+ if (ctx->opt->print_stats)
+ print_stats(ctx);
+
isl_hash_table_clear(&ctx->id_table);
isl_blk_clear_cache(ctx);
isl_int_clear(ctx->zero);
return -1;
return isl_args_parse(ctx->user_args, argc, argv, ctx->user_opt, flags);
}
+
+/* Set the maximal number of iterations of "ctx" to "max_operations".
+ */
+void isl_ctx_set_max_operations(isl_ctx *ctx, unsigned long max_operations)
+{
+ if (!ctx)
+ return;
+ ctx->max_operations = max_operations;
+}
+
+/* Return the maximal number of iterations of "ctx".
+ */
+unsigned long isl_ctx_get_max_operations(isl_ctx *ctx)
+{
+ return ctx ? ctx->max_operations : 0;
+}
+
+/* Reset the number of operations performed by "ctx".
+ */
+void isl_ctx_reset_operations(isl_ctx *ctx)
+{
+ if (!ctx)
+ return;
+ ctx->operations = 0;
+}
diff --git a/isl_ctx_private.h b/isl_ctx_private.h
--- a/isl_ctx_private.h
+++ b/isl_ctx_private.h
enum isl_error error;
int abort;
+
+ unsigned long operations;
+ unsigned long max_operations;
};
diff --git a/isl_options.c b/isl_options.c
--- a/isl_options.c
+++ b/isl_options.c
"ast-build-allow-else", 1, "generate if statements with else branches")
ISL_ARG_BOOL(struct isl_options, ast_build_allow_or, 0,
"ast-build-allow-or", 1, "generate if conditions with disjunctions")
+ISL_ARG_BOOL(struct isl_options, print_stats, 0, "print-stats", 0,
+ "print statistics for every isl_ctx")
+ISL_ARG_ULONG(struct isl_options, max_operations, 0,
+ "max-operations", 0, "default number of maximal operations per isl_ctx")
ISL_ARG_VERSION(print_version)
ISL_ARGS_END
diff --git a/isl_options_private.h b/isl_options_private.h
--- a/isl_options_private.h
+++ b/isl_options_private.h
int ast_build_scale_strides;
int ast_build_allow_else;
int ast_build_allow_or;
+
+ int print_stats;
+ unsigned long max_operations;
};
#endif
diff --git a/isl_tab.c b/isl_tab.c
--- a/isl_tab.c
+++ b/isl_tab.c
int i, j;
int sgn;
int t;
+ isl_ctx *ctx;
struct isl_mat *mat = tab->mat;
struct isl_tab_var *var;
unsigned off = 2 + tab->M;
- if (tab->mat->ctx->abort) {
- isl_ctx_set_error(tab->mat->ctx, isl_error_abort);
+ ctx = isl_tab_get_ctx(tab);
+ if (ctx->abort) {
+ isl_ctx_set_error(ctx, isl_error_abort);
return -1;
}
+ if (ctx->max_operations && ctx->operations >= ctx->max_operations)
+ isl_die(ctx, isl_error_quota,
+ "maximal number of operations exceeded", return -1);
+ ctx->operations++;
isl_int_swap(mat->row[row][0], mat->row[row][off + col]);
sgn = isl_int_sgn(mat->row[row][0]);