isl_test_cpp.cc

   1 /* Copyright 2016-2017 Tobias Grosser
   2  *
   3  * Use of this software is governed by the MIT license
   4  *
   5  * Written by Tobias Grosser, Weststrasse 47, CH-8003, Zurich
   6  */
   7
   8 #include <vector>
   9 #include <string>
  10 #include <limits.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14
  15 #include <isl/options.h>
  16 #include <isl/typed_cpp.h>
  17
  18 static void die_impl(const char *file, int line, const char *message)
  19 {
  20         fprintf(stderr, "Assertion failed in %s:%d %s\n", file, line, message);
  21         exit(EXIT_FAILURE);
  22 }
  23
  24 static void assert_impl(bool condition, const char *file, int line,
  25         const char *message)
  26 {
  27         if (condition)
  28                 return;
  29
  30         return die_impl(file, line, message);
  31 }
  32
  33 #define die(msg) die_impl(__FILE__, __LINE__, msg)
  34 #undef assert
  35 #define assert(exp) assert_impl(exp, __FILE__, __LINE__, #exp)
  36
  37 #include "isl_test_cpp-generic.cc"
  38
  39 /* Test that isl_bool values are returned correctly.
  40  *
  41  * In particular, check the conversion to bool in case of true and false, and
  42  * exception throwing in case of error.
  43  */
  44 static void test_return_bool(isl::ctx ctx)
  45 {
  46         isl::set empty(ctx, "{ : false }");
  47         isl::set univ(ctx, "{ : }");
  48         isl::set null;
  49
  50         bool b_true = empty.is_empty();
  51         bool b_false = univ.is_empty();
  52         bool caught = false;
  53         try {
  54                 null.is_empty();
  55                 die("no exception raised");
  56         } catch (const isl::exception_invalid &e) {
  57                 caught = true;
  58         }
  59
  60         assert(b_true);
  61         assert(!b_false);
  62         assert(caught);
  63 }
  64
  65 /* Test that return values are handled correctly.
  66  *
  67  * Test that isl C++ objects, integers, boolean values, and strings are
  68  * returned correctly.
  69  */
  70 static void test_return(isl::ctx ctx)
  71 {
  72         test_return_obj(ctx);
  73         test_return_int(ctx);
  74         test_return_bool(ctx);
  75         test_return_string(ctx);
  76 }
  77
  78 /* Test that foreach functions are modeled correctly.
  79  *
  80  * Verify that lambdas are correctly called as callback of a 'foreach'
  81  * function and that variables captured by the lambda work correctly. Also
  82  * check that the foreach function handles exceptions thrown from
  83  * the lambda and that it propagates the exception.
  84  */
  85 static void test_foreach(isl::ctx ctx)
  86 {
  87         isl::set s(ctx, "{ [0]; [1]; [2] }");
  88
  89         std::vector<isl::basic_set> basic_sets;
  90
  91         auto add_to_vector = [&] (isl::basic_set bs) {
  92                 basic_sets.push_back(bs);
  93         };
  94
  95         s.foreach_basic_set(add_to_vector);
  96
  97         assert(basic_sets.size() == 3);
  98         assert(isl::set(basic_sets[0]).is_subset(s));
  99         assert(isl::set(basic_sets[1]).is_subset(s));
 100         assert(isl::set(basic_sets[2]).is_subset(s));
 101         assert(!basic_sets[0].is_equal(basic_sets[1]));
 102
 103         auto fail = [&] (isl::basic_set bs) {
 104                 throw "fail";
 105         };
 106
 107         bool caught = false;
 108         try {
 109                 s.foreach_basic_set(fail);
 110                 die("no exception raised");
 111         } catch (char const *s) {
 112                 caught = true;
 113         }
 114         assert(caught);
 115 }
 116
 117 /* Test the functionality of "every" functions.
 118  *
 119  * In particular, test the generic functionality and
 120  * test that exceptions are properly propagated.
 121  */
 122 static void test_every(isl::ctx ctx)
 123 {
 124         isl::union_set us(ctx, "{ A[i]; B[j] }");
 125
 126         test_every_generic(ctx);
 127
 128         auto fail = [] (isl::set s) -> bool {
 129                 throw "fail";
 130         };
 131         bool caught = false;
 132         try {
 133                 us.every_set(fail);
 134                 die("no exception raised");
 135         } catch (char const *s) {
 136                 caught = true;
 137         }
 138         assert(caught);
 139 }
 140
 141 /* Test that an exception is generated for an isl error and
 142  * that the error message is captured by the exception.
 143  * Also check that the exception can be copied and that copying
 144  * does not throw any exceptions.
 145  */
 146 static void test_exception(isl::ctx ctx)
 147 {
 148         isl::multi_union_pw_aff mupa(ctx, "[]");
 149         isl::exception copy;
 150
 151         static_assert(std::is_nothrow_copy_constructible<isl::exception>::value,
 152                 "exceptions must be nothrow-copy-constructible");
 153         static_assert(std::is_nothrow_assignable<isl::exception,
 154                                                 isl::exception>::value,
 155                 "exceptions must be nothrow-assignable");
 156
 157         try {
 158                 auto umap = isl::union_map::from(mupa);
 159         } catch (const isl::exception_unsupported &error) {
 160                 die("caught wrong exception");
 161         } catch (const isl::exception &error) {
 162                 assert(strstr(error.what(), "without explicit domain"));
 163                 copy = error;
 164         }
 165         assert(strstr(copy.what(), "without explicit domain"));
 166 }
 167
 168 /* Test basic schedule tree functionality.
 169  *
 170  * In particular, create a simple schedule tree and
 171  * - perform some generic tests
 172  * - test map_descendant_bottom_up in the failing case
 173  * - test foreach_descendant_top_down
 174  * - test every_descendant
 175  */
 176 static void test_schedule_tree(isl::ctx ctx)
 177 {
 178         auto root = test_schedule_tree_generic(ctx);
 179
 180         auto fail_map = [](isl::schedule_node node) {
 181                 throw "fail";
 182                 return node;
 183         };
 184         auto caught = false;
 185         try {
 186                 root.map_descendant_bottom_up(fail_map);
 187                 die("no exception raised");
 188         } catch (char const *s) {
 189                 caught = true;
 190         }
 191         assert(caught);
 192
 193         int count = 0;
 194         auto inc_count = [&count](isl::schedule_node node) {
 195                 count++;
 196                 return true;
 197         };
 198         root.foreach_descendant_top_down(inc_count);
 199         assert(count == 8);
 200
 201         count = 0;
 202         auto inc_count_once = [&count](isl::schedule_node node) {
 203                 count++;
 204                 return false;
 205         };
 206         root.foreach_descendant_top_down(inc_count_once);
 207         assert(count == 1);
 208
 209         auto is_not_domain = [](isl::schedule_node node) {
 210                 return !node.isa<isl::schedule_node_domain>();
 211         };
 212         assert(root.child(0).every_descendant(is_not_domain));
 213         assert(!root.every_descendant(is_not_domain));
 214
 215         auto fail = [](isl::schedule_node node) {
 216                 throw "fail";
 217                 return true;
 218         };
 219         caught = false;
 220         try {
 221                 root.every_descendant(fail);
 222                 die("no exception raised");
 223         } catch (char const *s) {
 224                 caught = true;
 225         }
 226         assert(caught);
 227
 228         auto domain = root.as<isl::schedule_node_domain>().domain();
 229         auto filters = isl::union_set(ctx, "{}");
 230         auto collect_filters = [&filters](isl::schedule_node node) {
 231                 if (node.isa<isl::schedule_node_filter>()) {
 232                         auto filter = node.as<isl::schedule_node_filter>();
 233                         filters = filters.unite(filter.filter());
 234                 }
 235                 return true;
 236         };
 237         root.every_descendant(collect_filters);
 238         assert(domain.is_equal(filters));
 239 }
 240
 241 /* Test basic AST generation from a schedule tree.
 242  *
 243  * In particular, create a simple schedule tree and
 244  * - perform some generic tests
 245  * - test at_each_domain in the failing case
 246  */
 247 static void test_ast_build(isl::ctx ctx)
 248 {
 249         auto schedule = test_ast_build_generic(ctx);
 250
 251         bool do_fail = true;
 252         int count_ast_fail = 0;
 253         auto fail_inc_count_ast =
 254             [&count_ast_fail, &do_fail](isl::ast_node node,
 255                                         isl::ast_build build) {
 256                 count_ast_fail++;
 257                 if (do_fail)
 258                         throw "fail";
 259                 return node;
 260         };
 261         auto build = isl::ast_build(ctx);
 262         build = build.set_at_each_domain(fail_inc_count_ast);
 263         auto caught = false;
 264         try {
 265                 auto ast = build.node_from(schedule);
 266         } catch (char const *s) {
 267                 caught = true;
 268         }
 269         assert(caught);
 270         assert(count_ast_fail > 0);
 271         auto build_copy = build;
 272         int count_ast = 0;
 273         auto inc_count_ast =
 274             [&count_ast](isl::ast_node node, isl::ast_build build) {
 275                 count_ast++;
 276                 return node;
 277         };
 278         build_copy = build_copy.set_at_each_domain(inc_count_ast);
 279         auto ast = build_copy.node_from(schedule);
 280         assert(count_ast == 2);
 281         count_ast_fail = 0;
 282         do_fail = false;
 283         ast = build.node_from(schedule);
 284         assert(count_ast_fail == 2);
 285 }
 286
 287 /* Basic test of the templated interface.
 288  *
 289  * Intersecting the domain of an access relation
 290  * with statement instances should be allowed,
 291  * while intersecting the range with statement instances
 292  * should result in a compile-time error.
 293  */
 294 static void test_typed(isl::ctx ctx)
 295 {
 296         struct ST {};
 297         struct AR {};
 298         isl::typed::map<ST, AR> access(ctx, "{ S[i, j] -> A[i] }");
 299         isl::typed::set<ST> instances(ctx, "{ S[i, j] : 0 <= i, j < 10 }");
 300
 301 #ifndef COMPILE_ERROR
 302         access.intersect_domain(instances);
 303 #else
 304         access.intersect_range(instances);
 305 #endif
 306 }
 307
 308 /* Test the (unchecked) isl C++ interface
 309  *
 310  * This includes:
 311  *  - The isl C <-> C++ pointer interface
 312  *  - Object construction
 313  *  - Different parameter types
 314  *  - Different return types
 315  *  - Foreach functions
 316  *  - Exceptions
 317  *  - Spaces
 318  *  - Schedule trees
 319  *  - AST generation
 320  *  - AST expression generation
 321  *  - Templated interface
 322  */
 323 int main()
 324 {
 325         isl_ctx *ctx = isl_ctx_alloc();
 326
 327         isl_options_set_on_error(ctx, ISL_ON_ERROR_ABORT);
 328
 329         test_pointer(ctx);
 330         test_constructors(ctx);
 331         test_parameters(ctx);
 332         test_return(ctx);
 333         test_foreach(ctx);
 334         test_every(ctx);
 335         test_exception(ctx);
 336         test_space(ctx);
 337         test_schedule_tree(ctx);
 338         test_ast_build(ctx);
 339         test_ast_build_expr(ctx);
 340         test_typed(ctx);
 341
 342         isl_ctx_free(ctx);
 343
 344         return EXIT_SUCCESS;
 345 }