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