550 lines
13 KiB
Python
550 lines
13 KiB
Python
|
# Copyright 2016-2017 Tobias Grosser
|
||
|
|
#
|
||
|
|
# Use of this software is governed by the MIT license
|
||
|
|
#
|
||
|
|
# Written by Tobias Grosser, Weststrasse 47, CH-8003, Zurich
|
||
|
|
|
||
|
|
import sys
|
||
|
|
import isl
|
||
|
|
|
||
|
|
# Test that isl objects can be constructed.
|
||
|
|
#
|
||
|
|
# This tests:
|
||
|
|
# - construction from a string
|
||
|
|
# - construction from an integer
|
||
|
|
# - static constructor without a parameter
|
||
|
|
# - conversion construction
|
||
|
|
# - construction of empty union set
|
||
|
|
#
|
||
|
|
# The tests to construct from integers and strings cover functionality that
|
||
|
|
# is also tested in the parameter type tests, but here the presence of
|
||
|
|
# multiple overloaded constructors and overload resolution is tested.
|
||
|
|
#
|
||
|
|
def test_constructors():
|
||
|
|
zero1 = isl.val("0")
|
||
|
|
assert zero1.is_zero()
|
||
|
|
|
||
|
|
zero2 = isl.val(0)
|
||
|
|
assert zero2.is_zero()
|
||
|
|
|
||
|
|
zero3 = isl.val.zero()
|
||
|
|
assert zero3.is_zero()
|
||
|
|
|
||
|
|
bs = isl.basic_set("{ [1] }")
|
||
|
|
result = isl.set("{ [1] }")
|
||
|
|
s = isl.set(bs)
|
||
|
|
assert s.is_equal(result)
|
||
|
|
|
||
|
|
us = isl.union_set("{ A[1]; B[2, 3] }")
|
||
|
|
empty = isl.union_set.empty()
|
||
|
|
assert us.is_equal(us.union(empty))
|
||
|
|
|
||
|
|
|
||
|
|
# Test integer function parameters for a particular integer value.
|
||
|
|
#
|
||
|
|
def test_int(i):
|
||
|
|
val_int = isl.val(i)
|
||
|
|
val_str = isl.val(str(i))
|
||
|
|
assert val_int.eq(val_str)
|
||
|
|
|
||
|
|
|
||
|
|
# Test integer function parameters.
|
||
|
|
#
|
||
|
|
# Verify that extreme values and zero work.
|
||
|
|
#
|
||
|
|
def test_parameters_int():
|
||
|
|
test_int(sys.maxsize)
|
||
|
|
test_int(-sys.maxsize - 1)
|
||
|
|
test_int(0)
|
||
|
|
|
||
|
|
|
||
|
|
# Test isl objects parameters.
|
||
|
|
#
|
||
|
|
# Verify that isl objects can be passed as lvalue and rvalue parameters.
|
||
|
|
# Also verify that isl object parameters are automatically type converted if
|
||
|
|
# there is an inheritance relation. Finally, test function calls without
|
||
|
|
# any additional parameters, apart from the isl object on which
|
||
|
|
# the method is called.
|
||
|
|
#
|
||
|
|
def test_parameters_obj():
|
||
|
|
a = isl.set("{ [0] }")
|
||
|
|
b = isl.set("{ [1] }")
|
||
|
|
c = isl.set("{ [2] }")
|
||
|
|
expected = isl.set("{ [i] : 0 <= i <= 2 }")
|
||
|
|
|
||
|
|
tmp = a.union(b)
|
||
|
|
res_lvalue_param = tmp.union(c)
|
||
|
|
assert res_lvalue_param.is_equal(expected)
|
||
|
|
|
||
|
|
res_rvalue_param = a.union(b).union(c)
|
||
|
|
assert res_rvalue_param.is_equal(expected)
|
||
|
|
|
||
|
|
a2 = isl.basic_set("{ [0] }")
|
||
|
|
assert a.is_equal(a2)
|
||
|
|
|
||
|
|
two = isl.val(2)
|
||
|
|
half = isl.val("1/2")
|
||
|
|
res_only_this_param = two.inv()
|
||
|
|
assert res_only_this_param.eq(half)
|
||
|
|
|
||
|
|
|
||
|
|
# Test different kinds of parameters to be passed to functions.
|
||
|
|
#
|
||
|
|
# This includes integer and isl object parameters.
|
||
|
|
#
|
||
|
|
def test_parameters():
|
||
|
|
test_parameters_int()
|
||
|
|
test_parameters_obj()
|
||
|
|
|
||
|
|
|
||
|
|
# Test that isl objects are returned correctly.
|
||
|
|
#
|
||
|
|
# This only tests that after combining two objects, the result is successfully
|
||
|
|
# returned.
|
||
|
|
#
|
||
|
|
def test_return_obj():
|
||
|
|
one = isl.val("1")
|
||
|
|
two = isl.val("2")
|
||
|
|
three = isl.val("3")
|
||
|
|
|
||
|
|
res = one.add(two)
|
||
|
|
|
||
|
|
assert res.eq(three)
|
||
|
|
|
||
|
|
|
||
|
|
# Test that integer values are returned correctly.
|
||
|
|
#
|
||
|
|
def test_return_int():
|
||
|
|
one = isl.val("1")
|
||
|
|
neg_one = isl.val("-1")
|
||
|
|
zero = isl.val("0")
|
||
|
|
|
||
|
|
assert one.sgn() > 0
|
||
|
|
assert neg_one.sgn() < 0
|
||
|
|
assert zero.sgn() == 0
|
||
|
|
|
||
|
|
|
||
|
|
# Test that isl_bool values are returned correctly.
|
||
|
|
#
|
||
|
|
# In particular, check the conversion to bool in case of true and false.
|
||
|
|
#
|
||
|
|
def test_return_bool():
|
||
|
|
empty = isl.set("{ : false }")
|
||
|
|
univ = isl.set("{ : }")
|
||
|
|
|
||
|
|
b_true = empty.is_empty()
|
||
|
|
b_false = univ.is_empty()
|
||
|
|
|
||
|
|
assert b_true
|
||
|
|
assert not b_false
|
||
|
|
|
||
|
|
|
||
|
|
# Test that strings are returned correctly.
|
||
|
|
# Do so by calling overloaded isl.ast_build.from_expr methods.
|
||
|
|
#
|
||
|
|
def test_return_string():
|
||
|
|
context = isl.set("[n] -> { : }")
|
||
|
|
build = isl.ast_build.from_context(context)
|
||
|
|
pw_aff = isl.pw_aff("[n] -> { [n] }")
|
||
|
|
set = isl.set("[n] -> { : n >= 0 }")
|
||
|
|
|
||
|
|
expr = build.expr_from(pw_aff)
|
||
|
|
expected_string = "n"
|
||
|
|
assert expected_string == expr.to_C_str()
|
||
|
|
|
||
|
|
expr = build.expr_from(set)
|
||
|
|
expected_string = "n >= 0"
|
||
|
|
assert expected_string == expr.to_C_str()
|
||
|
|
|
||
|
|
|
||
|
|
# Test that return values are handled correctly.
|
||
|
|
#
|
||
|
|
# Test that isl objects, integers, boolean values, and strings are
|
||
|
|
# returned correctly.
|
||
|
|
#
|
||
|
|
def test_return():
|
||
|
|
test_return_obj()
|
||
|
|
test_return_int()
|
||
|
|
test_return_bool()
|
||
|
|
test_return_string()
|
||
|
|
|
||
|
|
|
||
|
|
# A class that is used to test isl.id.user.
|
||
|
|
#
|
||
|
|
class S:
|
||
|
|
def __init__(self):
|
||
|
|
self.value = 42
|
||
|
|
|
||
|
|
|
||
|
|
# Test isl.id.user.
|
||
|
|
#
|
||
|
|
# In particular, check that the object attached to an identifier
|
||
|
|
# can be retrieved again.
|
||
|
|
#
|
||
|
|
def test_user():
|
||
|
|
id = isl.id("test", 5)
|
||
|
|
id2 = isl.id("test2")
|
||
|
|
id3 = isl.id("S", S())
|
||
|
|
assert id.user() == 5, f"unexpected user object {id.user()}"
|
||
|
|
assert id2.user() is None, f"unexpected user object {id2.user()}"
|
||
|
|
s = id3.user()
|
||
|
|
assert isinstance(s, S), f"unexpected user object {s}"
|
||
|
|
assert s.value == 42, f"unexpected user object {s}"
|
||
|
|
|
||
|
|
|
||
|
|
# Test that foreach functions are modeled correctly.
|
||
|
|
#
|
||
|
|
# Verify that closures are correctly called as callback of a 'foreach'
|
||
|
|
# function and that variables captured by the closure work correctly. Also
|
||
|
|
# check that the foreach function handles exceptions thrown from
|
||
|
|
# the closure and that it propagates the exception.
|
||
|
|
#
|
||
|
|
def test_foreach():
|
||
|
|
s = isl.set("{ [0]; [1]; [2] }")
|
||
|
|
|
||
|
|
list = []
|
||
|
|
|
||
|
|
def add(bs):
|
||
|
|
list.append(bs)
|
||
|
|
|
||
|
|
s.foreach_basic_set(add)
|
||
|
|
|
||
|
|
assert len(list) == 3
|
||
|
|
assert list[0].is_subset(s)
|
||
|
|
assert list[1].is_subset(s)
|
||
|
|
assert list[2].is_subset(s)
|
||
|
|
assert not list[0].is_equal(list[1])
|
||
|
|
assert not list[0].is_equal(list[2])
|
||
|
|
assert not list[1].is_equal(list[2])
|
||
|
|
|
||
|
|
def fail(bs):
|
||
|
|
raise Exception("fail")
|
||
|
|
|
||
|
|
caught = False
|
||
|
|
try:
|
||
|
|
s.foreach_basic_set(fail)
|
||
|
|
except:
|
||
|
|
caught = True
|
||
|
|
assert caught
|
||
|
|
|
||
|
|
|
||
|
|
# Test the functionality of "foreach_scc" functions.
|
||
|
|
#
|
||
|
|
# In particular, test it on a list of elements that can be completely sorted
|
||
|
|
# but where two of the elements ("a" and "b") are incomparable.
|
||
|
|
#
|
||
|
|
def test_foreach_scc():
|
||
|
|
list = isl.id_list(3)
|
||
|
|
sorted = [isl.id_list(3)]
|
||
|
|
data = {
|
||
|
|
"a": isl.map("{ [0] -> [1] }"),
|
||
|
|
"b": isl.map("{ [1] -> [0] }"),
|
||
|
|
"c": isl.map("{ [i = 0:1] -> [i] }"),
|
||
|
|
}
|
||
|
|
for k, v in data.items():
|
||
|
|
list = list.add(k)
|
||
|
|
id = data["a"].space().domain().identity_multi_pw_aff_on_domain()
|
||
|
|
|
||
|
|
def follows(a, b):
|
||
|
|
map = data[b.name()].apply_domain(data[a.name()])
|
||
|
|
return not map.lex_ge_at(id).is_empty()
|
||
|
|
|
||
|
|
def add_single(scc):
|
||
|
|
assert scc.size() == 1
|
||
|
|
sorted[0] = sorted[0].concat(scc)
|
||
|
|
|
||
|
|
list.foreach_scc(follows, add_single)
|
||
|
|
assert sorted[0].size() == 3
|
||
|
|
assert sorted[0].at(0).name() == "b"
|
||
|
|
assert sorted[0].at(1).name() == "c"
|
||
|
|
assert sorted[0].at(2).name() == "a"
|
||
|
|
|
||
|
|
|
||
|
|
# Test the functionality of "every" functions.
|
||
|
|
#
|
||
|
|
# In particular, test the generic functionality and
|
||
|
|
# test that exceptions are properly propagated.
|
||
|
|
#
|
||
|
|
def test_every():
|
||
|
|
us = isl.union_set("{ A[i]; B[j] }")
|
||
|
|
|
||
|
|
def is_empty(s):
|
||
|
|
return s.is_empty()
|
||
|
|
|
||
|
|
assert not us.every_set(is_empty)
|
||
|
|
|
||
|
|
def is_non_empty(s):
|
||
|
|
return not s.is_empty()
|
||
|
|
|
||
|
|
assert us.every_set(is_non_empty)
|
||
|
|
|
||
|
|
def in_A(s):
|
||
|
|
return s.is_subset(isl.set("{ A[x] }"))
|
||
|
|
|
||
|
|
assert not us.every_set(in_A)
|
||
|
|
|
||
|
|
def not_in_A(s):
|
||
|
|
return not s.is_subset(isl.set("{ A[x] }"))
|
||
|
|
|
||
|
|
assert not us.every_set(not_in_A)
|
||
|
|
|
||
|
|
def fail(s):
|
||
|
|
raise Exception("fail")
|
||
|
|
|
||
|
|
caught = False
|
||
|
|
try:
|
||
|
|
us.ever_set(fail)
|
||
|
|
except:
|
||
|
|
caught = True
|
||
|
|
assert caught
|
||
|
|
|
||
|
|
|
||
|
|
# Check basic construction of spaces.
|
||
|
|
#
|
||
|
|
def test_space():
|
||
|
|
unit = isl.space.unit()
|
||
|
|
set_space = unit.add_named_tuple("A", 3)
|
||
|
|
map_space = set_space.add_named_tuple("B", 2)
|
||
|
|
|
||
|
|
set = isl.set.universe(set_space)
|
||
|
|
map = isl.map.universe(map_space)
|
||
|
|
assert set.is_equal(isl.set("{ A[*,*,*] }"))
|
||
|
|
assert map.is_equal(isl.map("{ A[*,*,*] -> B[*,*] }"))
|
||
|
|
|
||
|
|
|
||
|
|
# Construct a simple schedule tree with an outer sequence node and
|
||
|
|
# a single-dimensional band node in each branch, with one of them
|
||
|
|
# marked coincident.
|
||
|
|
#
|
||
|
|
def construct_schedule_tree():
|
||
|
|
A = isl.union_set("{ A[i] : 0 <= i < 10 }")
|
||
|
|
B = isl.union_set("{ B[i] : 0 <= i < 20 }")
|
||
|
|
|
||
|
|
node = isl.schedule_node.from_domain(A.union(B))
|
||
|
|
node = node.child(0)
|
||
|
|
|
||
|
|
filters = isl.union_set_list(A).add(B)
|
||
|
|
node = node.insert_sequence(filters)
|
||
|
|
|
||
|
|
f_A = isl.multi_union_pw_aff("[ { A[i] -> [i] } ]")
|
||
|
|
node = node.child(0)
|
||
|
|
node = node.child(0)
|
||
|
|
node = node.insert_partial_schedule(f_A)
|
||
|
|
node = node.member_set_coincident(0, True)
|
||
|
|
node = node.ancestor(2)
|
||
|
|
|
||
|
|
f_B = isl.multi_union_pw_aff("[ { B[i] -> [i] } ]")
|
||
|
|
node = node.child(1)
|
||
|
|
node = node.child(0)
|
||
|
|
node = node.insert_partial_schedule(f_B)
|
||
|
|
node = node.ancestor(2)
|
||
|
|
|
||
|
|
return node.schedule()
|
||
|
|
|
||
|
|
|
||
|
|
# Test basic schedule tree functionality.
|
||
|
|
#
|
||
|
|
# In particular, create a simple schedule tree and
|
||
|
|
# - check that the root node is a domain node
|
||
|
|
# - test map_descendant_bottom_up
|
||
|
|
# - test foreach_descendant_top_down
|
||
|
|
# - test every_descendant
|
||
|
|
#
|
||
|
|
def test_schedule_tree():
|
||
|
|
schedule = construct_schedule_tree()
|
||
|
|
root = schedule.root()
|
||
|
|
|
||
|
|
assert type(root) == isl.schedule_node_domain
|
||
|
|
|
||
|
|
count = [0]
|
||
|
|
|
||
|
|
def inc_count(node):
|
||
|
|
count[0] += 1
|
||
|
|
return node
|
||
|
|
|
||
|
|
root = root.map_descendant_bottom_up(inc_count)
|
||
|
|
assert count[0] == 8
|
||
|
|
|
||
|
|
def fail_map(node):
|
||
|
|
raise Exception("fail")
|
||
|
|
return node
|
||
|
|
|
||
|
|
caught = False
|
||
|
|
try:
|
||
|
|
root.map_descendant_bottom_up(fail_map)
|
||
|
|
except:
|
||
|
|
caught = True
|
||
|
|
assert caught
|
||
|
|
|
||
|
|
count = [0]
|
||
|
|
|
||
|
|
def inc_count(node):
|
||
|
|
count[0] += 1
|
||
|
|
return True
|
||
|
|
|
||
|
|
root.foreach_descendant_top_down(inc_count)
|
||
|
|
assert count[0] == 8
|
||
|
|
|
||
|
|
count = [0]
|
||
|
|
|
||
|
|
def inc_count(node):
|
||
|
|
count[0] += 1
|
||
|
|
return False
|
||
|
|
|
||
|
|
root.foreach_descendant_top_down(inc_count)
|
||
|
|
assert count[0] == 1
|
||
|
|
|
||
|
|
def is_not_domain(node):
|
||
|
|
return type(node) != isl.schedule_node_domain
|
||
|
|
|
||
|
|
assert root.child(0).every_descendant(is_not_domain)
|
||
|
|
assert not root.every_descendant(is_not_domain)
|
||
|
|
|
||
|
|
def fail(node):
|
||
|
|
raise Exception("fail")
|
||
|
|
|
||
|
|
caught = False
|
||
|
|
try:
|
||
|
|
root.every_descendant(fail)
|
||
|
|
except:
|
||
|
|
caught = True
|
||
|
|
assert caught
|
||
|
|
|
||
|
|
domain = root.domain()
|
||
|
|
filters = [isl.union_set("{}")]
|
||
|
|
|
||
|
|
def collect_filters(node):
|
||
|
|
if type(node) == isl.schedule_node_filter:
|
||
|
|
filters[0] = filters[0].union(node.filter())
|
||
|
|
return True
|
||
|
|
|
||
|
|
root.every_descendant(collect_filters)
|
||
|
|
assert domain.is_equal(filters[0])
|
||
|
|
|
||
|
|
|
||
|
|
# Test marking band members for unrolling.
|
||
|
|
# "schedule" is the schedule created by construct_schedule_tree.
|
||
|
|
# It schedules two statements, with 10 and 20 instances, respectively.
|
||
|
|
# Unrolling all band members therefore results in 30 at-domain calls
|
||
|
|
# by the AST generator.
|
||
|
|
#
|
||
|
|
def test_ast_build_unroll(schedule):
|
||
|
|
root = schedule.root()
|
||
|
|
|
||
|
|
def mark_unroll(node):
|
||
|
|
if type(node) == isl.schedule_node_band:
|
||
|
|
node = node.member_set_ast_loop_unroll(0)
|
||
|
|
return node
|
||
|
|
|
||
|
|
root = root.map_descendant_bottom_up(mark_unroll)
|
||
|
|
schedule = root.schedule()
|
||
|
|
|
||
|
|
count_ast = [0]
|
||
|
|
|
||
|
|
def inc_count_ast(node, build):
|
||
|
|
count_ast[0] += 1
|
||
|
|
return node
|
||
|
|
|
||
|
|
build = isl.ast_build()
|
||
|
|
build = build.set_at_each_domain(inc_count_ast)
|
||
|
|
ast = build.node_from(schedule)
|
||
|
|
assert count_ast[0] == 30
|
||
|
|
|
||
|
|
|
||
|
|
# Test basic AST generation from a schedule tree.
|
||
|
|
#
|
||
|
|
# In particular, create a simple schedule tree and
|
||
|
|
# - generate an AST from the schedule tree
|
||
|
|
# - test at_each_domain
|
||
|
|
# - test unrolling
|
||
|
|
#
|
||
|
|
def test_ast_build():
|
||
|
|
schedule = construct_schedule_tree()
|
||
|
|
|
||
|
|
count_ast = [0]
|
||
|
|
|
||
|
|
def inc_count_ast(node, build):
|
||
|
|
count_ast[0] += 1
|
||
|
|
return node
|
||
|
|
|
||
|
|
build = isl.ast_build()
|
||
|
|
build_copy = build.set_at_each_domain(inc_count_ast)
|
||
|
|
ast = build.node_from(schedule)
|
||
|
|
assert count_ast[0] == 0
|
||
|
|
count_ast[0] = 0
|
||
|
|
ast = build_copy.node_from(schedule)
|
||
|
|
assert count_ast[0] == 2
|
||
|
|
build = build_copy
|
||
|
|
count_ast[0] = 0
|
||
|
|
ast = build.node_from(schedule)
|
||
|
|
assert count_ast[0] == 2
|
||
|
|
|
||
|
|
do_fail = True
|
||
|
|
count_ast_fail = [0]
|
||
|
|
|
||
|
|
def fail_inc_count_ast(node, build):
|
||
|
|
count_ast_fail[0] += 1
|
||
|
|
if do_fail:
|
||
|
|
raise Exception("fail")
|
||
|
|
return node
|
||
|
|
|
||
|
|
build = isl.ast_build()
|
||
|
|
build = build.set_at_each_domain(fail_inc_count_ast)
|
||
|
|
caught = False
|
||
|
|
try:
|
||
|
|
ast = build.node_from(schedule)
|
||
|
|
except:
|
||
|
|
caught = True
|
||
|
|
assert caught
|
||
|
|
assert count_ast_fail[0] > 0
|
||
|
|
build_copy = build
|
||
|
|
build_copy = build_copy.set_at_each_domain(inc_count_ast)
|
||
|
|
count_ast[0] = 0
|
||
|
|
ast = build_copy.node_from(schedule)
|
||
|
|
assert count_ast[0] == 2
|
||
|
|
count_ast_fail[0] = 0
|
||
|
|
do_fail = False
|
||
|
|
ast = build.node_from(schedule)
|
||
|
|
assert count_ast_fail[0] == 2
|
||
|
|
|
||
|
|
test_ast_build_unroll(schedule)
|
||
|
|
|
||
|
|
|
||
|
|
# Test basic AST expression generation from an affine expression.
|
||
|
|
#
|
||
|
|
def test_ast_build_expr():
|
||
|
|
pa = isl.pw_aff("[n] -> { [n + 1] }")
|
||
|
|
build = isl.ast_build.from_context(pa.domain())
|
||
|
|
|
||
|
|
op = build.expr_from(pa)
|
||
|
|
assert type(op) == isl.ast_expr_op_add
|
||
|
|
assert op.n_arg() == 2
|
||
|
|
|
||
|
|
|
||
|
|
# Test the isl Python interface
|
||
|
|
#
|
||
|
|
# This includes:
|
||
|
|
# - Object construction
|
||
|
|
# - Different parameter types
|
||
|
|
# - Different return types
|
||
|
|
# - isl.id.user
|
||
|
|
# - Foreach functions
|
||
|
|
# - Foreach SCC function
|
||
|
|
# - Every functions
|
||
|
|
# - Spaces
|
||
|
|
# - Schedule trees
|
||
|
|
# - AST generation
|
||
|
|
# - AST expression generation
|
||
|
|
#
|
||
|
|
test_constructors()
|
||
|
|
test_parameters()
|
||
|
|
test_return()
|
||
|
|
test_user()
|
||
|
|
test_foreach()
|
||
|
|
test_foreach_scc()
|
||
|
|
test_every()
|
||
|
|
test_space()
|
||
|
|
test_schedule_tree()
|
||
|
|
test_ast_build()
|
||
|
|
test_ast_build_expr()
|