1 # Copyright 2016-2017 Tobias Grosser
3 # Use of this software is governed by the MIT license
5 # Written by Tobias Grosser, Weststrasse 47, CH-8003, Zurich
10 # Test that isl objects can be constructed.
13 # - construction from a string
14 # - construction from an integer
15 # - static constructor without a parameter
16 # - conversion construction
18 # The tests to construct from integers and strings cover functionality that
19 # is also tested in the parameter type tests, but here the presence of
20 # multiple overloaded constructors and overload resolution is tested.
22 def test_constructors():
24 assert(zero1
.is_zero())
27 assert(zero2
.is_zero())
29 zero3
= isl
.val
.zero()
30 assert(zero3
.is_zero())
32 bs
= isl
.basic_set("{ [1] }")
33 result
= isl
.set("{ [1] }")
35 assert(s
.is_equal(result
))
37 # Test integer function parameters for a particular integer value.
41 val_str
= isl
.val(str(i
))
42 assert(val_int
.eq(val_str
))
44 # Test integer function parameters.
46 # Verify that extreme values and zero work.
48 def test_parameters_int():
50 test_int(-sys
.maxsize
- 1)
53 # Test isl objects parameters.
55 # Verify that isl objects can be passed as lvalue and rvalue parameters.
56 # Also verify that isl object parameters are automatically type converted if
57 # there is an inheritance relation. Finally, test function calls without
58 # any additional parameters, apart from the isl object on which
59 # the method is called.
61 def test_parameters_obj():
62 a
= isl
.set("{ [0] }")
63 b
= isl
.set("{ [1] }")
64 c
= isl
.set("{ [2] }")
65 expected
= isl
.set("{ [i] : 0 <= i <= 2 }")
68 res_lvalue_param
= tmp
.union(c
)
69 assert(res_lvalue_param
.is_equal(expected
))
71 res_rvalue_param
= a
.union(b
).union(c
)
72 assert(res_rvalue_param
.is_equal(expected
))
74 a2
= isl
.basic_set("{ [0] }")
75 assert(a
.is_equal(a2
))
79 res_only_this_param
= two
.inv()
80 assert(res_only_this_param
.eq(half
))
82 # Test different kinds of parameters to be passed to functions.
84 # This includes integer and isl object parameters.
86 def test_parameters():
90 # Test that isl objects are returned correctly.
92 # This only tests that after combining two objects, the result is successfully
95 def test_return_obj():
102 assert(res
.eq(three
))
104 # Test that integer values are returned correctly.
106 def test_return_int():
108 neg_one
= isl
.val("-1")
111 assert(one
.sgn() > 0)
112 assert(neg_one
.sgn() < 0)
113 assert(zero
.sgn() == 0)
115 # Test that isl_bool values are returned correctly.
117 # In particular, check the conversion to bool in case of true and false.
119 def test_return_bool():
120 empty
= isl
.set("{ : false }")
121 univ
= isl
.set("{ : }")
123 b_true
= empty
.is_empty()
124 b_false
= univ
.is_empty()
129 # Test that strings are returned correctly.
130 # Do so by calling overloaded isl.ast_build.from_expr methods.
132 def test_return_string():
133 context
= isl
.set("[n] -> { : }")
134 build
= isl
.ast_build
.from_context(context
)
135 pw_aff
= isl
.pw_aff("[n] -> { [n] }")
136 set = isl
.set("[n] -> { : n >= 0 }")
138 expr
= build
.expr_from(pw_aff
)
139 expected_string
= "n"
140 assert(expected_string
== expr
.to_C_str())
142 expr
= build
.expr_from(set)
143 expected_string
= "n >= 0"
144 assert(expected_string
== expr
.to_C_str())
146 # Test that return values are handled correctly.
148 # Test that isl objects, integers, boolean values, and strings are
149 # returned correctly.
157 # Test that foreach functions are modeled correctly.
159 # Verify that closures are correctly called as callback of a 'foreach'
160 # function and that variables captured by the closure work correctly. Also
161 # check that the foreach function handles exceptions thrown from
162 # the closure and that it propagates the exception.
165 s
= isl
.set("{ [0]; [1]; [2] }")
170 s
.foreach_basic_set(add
)
172 assert(len(list) == 3)
173 assert(list[0].is_subset(s
))
174 assert(list[1].is_subset(s
))
175 assert(list[2].is_subset(s
))
176 assert(not list[0].is_equal(list[1]))
177 assert(not list[0].is_equal(list[2]))
178 assert(not list[1].is_equal(list[2]))
185 s
.foreach_basic_set(fail
)
190 # Test the functionality of "every" functions.
192 # In particular, test the generic functionality and
193 # test that exceptions are properly propagated.
196 us
= isl
.union_set("{ A[i]; B[j] }")
200 assert(not us
.every_set(is_empty
))
203 return not s
.is_empty()
204 assert(us
.every_set(is_non_empty
))
207 return s
.is_subset(isl
.set("{ A[x] }"))
208 assert(not us
.every_set(in_A
))
211 return not s
.is_subset(isl
.set("{ A[x] }"))
212 assert(not us
.every_set(not_in_A
))
224 # Construct a simple schedule tree with an outer sequence node and
225 # a single-dimensional band node in each branch, with one of them
228 def construct_schedule_tree():
229 A
= isl
.union_set("{ A[i] : 0 <= i < 10 }")
230 B
= isl
.union_set("{ B[i] : 0 <= i < 20 }")
232 node
= isl
.schedule_node
.from_domain(A
.union(B
))
235 filters
= isl
.union_set_list(A
).add(B
)
236 node
= node
.insert_sequence(filters
)
238 f_A
= isl
.multi_union_pw_aff("[ { A[i] -> [i] } ]")
241 node
= node
.insert_partial_schedule(f_A
)
242 node
= node
.member_set_coincident(0, True)
243 node
= node
.ancestor(2)
245 f_B
= isl
.multi_union_pw_aff("[ { B[i] -> [i] } ]")
248 node
= node
.insert_partial_schedule(f_B
)
249 node
= node
.ancestor(2)
251 return node
.schedule()
253 # Test basic schedule tree functionality.
255 # In particular, create a simple schedule tree and
256 # - check that the root node is a domain node
257 # - test map_descendant_bottom_up
258 # - test foreach_descendant_top_down
259 # - test every_descendant
261 def test_schedule_tree():
262 schedule
= construct_schedule_tree()
263 root
= schedule
.root()
265 assert(type(root
) == isl
.schedule_node_domain
)
271 root
= root
.map_descendant_bottom_up(inc_count
)
272 assert(count
[0] == 8)
279 root
.map_descendant_bottom_up(fail_map
)
288 root
.foreach_descendant_top_down(inc_count
)
289 assert(count
[0] == 8)
295 root
.foreach_descendant_top_down(inc_count
)
296 assert(count
[0] == 1)
298 def is_not_domain(node
):
299 return type(node
) != isl
.schedule_node_domain
300 assert(root
.child(0).every_descendant(is_not_domain
))
301 assert(not root
.every_descendant(is_not_domain
))
307 root
.every_descendant(fail
)
312 domain
= root
.domain()
313 filters
= [isl
.union_set("{}")]
314 def collect_filters(node
):
315 if type(node
) == isl
.schedule_node_filter
:
316 filters
[0] = filters
[0].union(node
.filter())
318 root
.every_descendant(collect_filters
)
319 assert(domain
.is_equal(filters
[0]))
321 # Test marking band members for unrolling.
322 # "schedule" is the schedule created by construct_schedule_tree.
323 # It schedules two statements, with 10 and 20 instances, respectively.
324 # Unrolling all band members therefore results in 30 at-domain calls
325 # by the AST generator.
327 def test_ast_build_unroll(schedule
):
328 root
= schedule
.root()
329 def mark_unroll(node
):
330 if type(node
) == isl
.schedule_node_band
:
331 node
= node
.member_set_ast_loop_unroll(0)
333 root
= root
.map_descendant_bottom_up(mark_unroll
)
334 schedule
= root
.schedule()
337 def inc_count_ast(node
, build
):
341 build
= isl
.ast_build()
342 build
= build
.set_at_each_domain(inc_count_ast
)
343 ast
= build
.node_from(schedule
)
344 assert(count_ast
[0] == 30)
346 # Test basic AST generation from a schedule tree.
348 # In particular, create a simple schedule tree and
349 # - generate an AST from the schedule tree
350 # - test at_each_domain
353 def test_ast_build():
354 schedule
= construct_schedule_tree()
357 def inc_count_ast(node
, build
):
361 build
= isl
.ast_build()
362 build_copy
= build
.set_at_each_domain(inc_count_ast
)
363 ast
= build
.node_from(schedule
)
364 assert(count_ast
[0] == 0)
366 ast
= build_copy
.node_from(schedule
)
367 assert(count_ast
[0] == 2)
370 ast
= build
.node_from(schedule
)
371 assert(count_ast
[0] == 2)
375 def fail_inc_count_ast(node
, build
):
376 count_ast_fail
[0] += 1
380 build
= isl
.ast_build()
381 build
= build
.set_at_each_domain(fail_inc_count_ast
)
384 ast
= build
.node_from(schedule
)
388 assert(count_ast_fail
[0] > 0)
390 build_copy
= build_copy
.set_at_each_domain(inc_count_ast
)
392 ast
= build_copy
.node_from(schedule
)
393 assert(count_ast
[0] == 2)
394 count_ast_fail
[0] = 0
396 ast
= build
.node_from(schedule
)
397 assert(count_ast_fail
[0] == 2)
399 test_ast_build_unroll(schedule
);
401 # Test basic AST expression generation from an affine expression.
403 def test_ast_build_expr():
404 pa
= isl
.pw_aff("[n] -> { [n + 1] }")
405 build
= isl
.ast_build
.from_context(pa
.domain())
407 op
= build
.expr_from(pa
)
408 assert(type(op
) == isl
.ast_expr_op_add
)
409 assert(op
.n_arg() == 2)
411 # Test the isl Python interface
414 # - Object construction
415 # - Different parameter types
416 # - Different return types
417 # - Foreach functions
421 # - AST expression generation
430 test_ast_build_expr();