isl_test2.cc

   1 #include <assert.h>
   2 #include <stdlib.h>
   3
   4 #include <functional>
   5 #include <iostream>
   6 #include <sstream>
   7 #include <string>
   8 #include <type_traits>
   9 #include <utility>
  10 #include <vector>
  11
  12 #include <isl/cpp.h>
  13
  14 /* A binary isl function that appears in the C++ bindings
  15  * as a unary method in a class T, taking an extra argument
  16  * of type A1 and returning an object of type R.
  17  */
  18 template <typename A1, typename R, typename T>
  19 using binary_fn = R (T::*)(A1) const;
  20
  21 /* A function for selecting an overload of a pointer to a unary C++ method
  22  * based on the single argument type.
  23  * The object type and the return type are meant to be deduced.
  24  */
  25 template <typename A1, typename R, typename T>
  26 static binary_fn<A1, R, T> const arg(const binary_fn<A1, R, T> &fn)
  27 {
  28         return fn;
  29 }
  30
  31 /* A description of the inputs and the output of a binary operation.
  32  */
  33 struct binary {
  34         const char *arg1;
  35         const char *arg2;
  36         const char *res;
  37 };
  38
  39 /* A template function for checking whether two objects
  40  * of the same (isl) type are (obviously) equal.
  41  * The spelling depends on the isl type and
  42  * in particular on whether an equality method is available or
  43  * whether only obvious equality can be tested.
  44  */
  45 template <typename T, typename std::decay<decltype(
  46         std::declval<T>().is_equal(std::declval<T>()))>::type = true>
  47 static bool is_equal(const T &a, const T &b)
  48 {
  49         return a.is_equal(b);
  50 }
  51 template <typename T, typename std::decay<decltype(
  52         std::declval<T>().plain_is_equal(std::declval<T>()))>::type = true>
  53 static bool is_equal(const T &a, const T &b)
  54 {
  55         return a.plain_is_equal(b);
  56 }
  57
  58 /* A helper macro for throwing an isl::exception_invalid with message "msg".
  59  */
  60 #define THROW_INVALID(msg) \
  61         isl::exception::throw_error(isl_error_invalid, msg, __FILE__, __LINE__)
  62
  63 /* Run a sequence of tests of method "fn" with stringification "name" and
  64  * with inputs and output described by "test",
  65  * throwing an exception when an unexpected result is produced.
  66  */
  67 template <typename R, typename T, typename A1>
  68 static void test(isl::ctx ctx, R (T::*fn)(A1) const, const std::string &name,
  69         const std::vector<binary> &tests)
  70 {
  71         for (const auto &test : tests) {
  72                 T obj(ctx, test.arg1);
  73                 A1 arg1(ctx, test.arg2);
  74                 R expected(ctx, test.res);
  75                 const auto &res = (obj.*fn)(arg1);
  76                 std::ostringstream ss;
  77
  78                 if (is_equal(expected, res))
  79                         continue;
  80
  81                 ss << name << "(" << test.arg1 << ", " << test.arg2 << ") =\n"
  82                    << res << "\n"
  83                    << "expecting:\n"
  84                    << test.res;
  85                 THROW_INVALID(ss.str().c_str());
  86         }
  87 }
  88
  89 /* A helper macro that calls test with as implicit initial argument "ctx" and
  90  * as extra argument a stringification of "FN".
  91  */
  92 #define C(FN, ...) test(ctx, FN, #FN, __VA_ARGS__)
  93
  94 /* Perform some basic preimage tests.
  95  */
  96 static void test_preimage(isl::ctx ctx)
  97 {
  98         C(arg<isl::multi_aff>(&isl::set::preimage), {
  99         { "{ B[i,j] : 0 <= i < 10 and 0 <= j < 100 }",
 100           "{ A[j,i] -> B[i,j] }",
 101           "{ A[j,i] : 0 <= i < 10 and 0 <= j < 100 }" },
 102         { "{ rat: B[i,j] : 0 <= i, j and 3 i + 5 j <= 100 }",
 103           "{ A[a,b] -> B[a/2,b/6] }",
 104           "{ rat: A[a,b] : 0 <= a, b and 9 a + 5 b <= 600 }" },
 105         { "{ B[i,j] : 0 <= i, j and 3 i + 5 j <= 100 }",
 106           "{ A[a,b] -> B[a/2,b/6] }",
 107           "{ A[a,b] : 0 <= a, b and 9 a + 5 b <= 600 and "
 108                     "exists i,j : a = 2 i and b = 6 j }" },
 109         { "[n] -> { S[i] : 0 <= i <= 100 }", "[n] -> { S[n] }",
 110           "[n] -> { : 0 <= n <= 100 }" },
 111         { "{ B[i] : 0 <= i < 100 and exists a : i = 4 a }",
 112           "{ A[a] -> B[2a] }",
 113           "{ A[a] : 0 <= a < 50 and exists b : a = 2 b }" },
 114         { "{ B[i] : 0 <= i < 100 and exists a : i = 4 a }",
 115           "{ A[a] -> B[([a/2])] }",
 116           "{ A[a] : 0 <= a < 200 and exists b : [a/2] = 4 b }" },
 117         { "{ B[i,j,k] : 0 <= i,j,k <= 100 }",
 118           "{ A[a] -> B[a,a,a/3] }",
 119           "{ A[a] : 0 <= a <= 100 and exists b : a = 3 b }" },
 120         { "{ B[i,j] : j = [(i)/2] } ", "{ A[i,j] -> B[i/3,j] }",
 121           "{ A[i,j] : j = [(i)/6] and exists a : i = 3 a }" },
 122         });
 123
 124         C(arg<isl::multi_aff>(&isl::union_map::preimage_domain), {
 125         { "{ B[i,j] -> C[2i + 3j] : 0 <= i < 10 and 0 <= j < 100 }",
 126           "{ A[j,i] -> B[i,j] }",
 127           "{ A[j,i] -> C[2i + 3j] : 0 <= i < 10 and 0 <= j < 100 }" },
 128         { "{ B[i] -> C[i]; D[i] -> E[i] }",
 129           "{ A[i] -> B[i + 1] }",
 130           "{ A[i] -> C[i + 1] }" },
 131         { "{ B[i] -> C[i]; B[i] -> E[i] }",
 132           "{ A[i] -> B[i + 1] }",
 133           "{ A[i] -> C[i + 1]; A[i] -> E[i + 1] }" },
 134         { "{ B[i] -> C[([i/2])] }",
 135           "{ A[i] -> B[2i] }",
 136           "{ A[i] -> C[i] }" },
 137         { "{ B[i,j] -> C[([i/2]), ([(i+j)/3])] }",
 138           "{ A[i] -> B[([i/5]), ([i/7])] }",
 139           "{ A[i] -> C[([([i/5])/2]), ([(([i/5])+([i/7]))/3])] }" },
 140         { "[N] -> { B[i] -> C[([N/2]), i, ([N/3])] }",
 141           "[N] -> { A[] -> B[([N/5])] }",
 142           "[N] -> { A[] -> C[([N/2]), ([N/5]), ([N/3])] }" },
 143         { "{ B[i] -> C[i] : exists a : i = 5 a }",
 144           "{ A[i] -> B[2i] }",
 145           "{ A[i] -> C[2i] : exists a : 2i = 5 a }" },
 146         { "{ B[i] -> C[i] : exists a : i = 2 a; "
 147             "B[i] -> D[i] : exists a : i = 2 a + 1 }",
 148           "{ A[i] -> B[2i] }",
 149           "{ A[i] -> C[2i] }" },
 150         { "{ A[i] -> B[i] }", "{ C[i] -> A[(i + floor(i/3))/2] }",
 151           "{ C[i] -> B[j] : 2j = i + floor(i/3) }" },
 152         });
 153
 154         C(arg<isl::multi_aff>(&isl::union_map::preimage_range), {
 155         { "[M] -> { A[a] -> B[a] }", "[M] -> { C[] -> B[floor(M/2)] }",
 156           "[M] -> { A[floor(M/2)] -> C[] }" },
 157         });
 158 }
 159
 160 /* The list of tests to perform.
 161  */
 162 static std::vector<std::pair<const char *, void (*)(isl::ctx)>> tests =
 163 {
 164         { "preimage", &test_preimage },
 165 };
 166
 167 /* Perform some basic checks by means of the C++ bindings.
 168  */
 169 int main(int argc, char **argv)
 170 {
 171         int ret = EXIT_SUCCESS;
 172         struct isl_ctx *ctx;
 173         struct isl_options *options;
 174
 175         options = isl_options_new_with_defaults();
 176         assert(options);
 177         argc = isl_options_parse(options, argc, argv, ISL_ARG_ALL);
 178         ctx = isl_ctx_alloc_with_options(&isl_options_args, options);
 179
 180         try {
 181                 for (const auto &f : tests) {
 182                         std::cout << f.first << "\n";
 183                         f.second(ctx);
 184                 }
 185         } catch (const isl::exception &e) {
 186                 std::cerr << e.what() << "\n";
 187                 ret = EXIT_FAILURE;
 188         }
 189
 190         isl_ctx_free(ctx);
 191         return ret;
 192 }