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 "fail"
caught = False
try:
us.ever_set(fail)
except:
caught = True
assert(caught)
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)
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 "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 "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]))
def __init__(self, **kwargs):
if 'filter' in kwargs:
filter_ = kwargs.pop('filter')
else:
filter_ = None
super().__init__(**kwargs)
if filter_ is None or isinstance(filter_, str):
filter_ = isl.union_set(filter_ or '{}')
self.filter: isl.union_set = filter_
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()
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()
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)))
def get_instance_set(self):
return isl.union_set(ctx=self.ctx,
ptr=pet.pet_scop_get_instance_set(self.ptr))
def get_instance_set(self):
return isl.union_set(ctx=self.ctx,
ptr=pet.pet_scop_get_instance_set(self.ptr))
def __init__(self, domain=None, **kwargs):
super().__init__(**kwargs)
if domain is None or isinstance(domain, str):
domain = isl.union_set(domain or '{}')
self.domain: isl.union_set = domain
def cuda_tile(tree, tile_size, permutation=None):
assert tree.parallel_tilable()
box_size, lowers, strides = tree.outermost_band_box()
n = len(box_size)
tile_size = tile_size[:n]
real_tile_size = [tile_size[i] * strides[i] for i in range(n)]
filled_box_size = [
-(-box_size[i] // (real_tile_size[i])) * real_tile_size[i]
for i in range(n)
]
fake_args = ['i%d' % i for i in range(n)]
thread_fake_constraints = [
f'({i} mod {stride}) = (({lower}) mod {stride})'
f' and 0 <= {i} - ({lower}) < {size}' for i, lower, stride, size in
zip(fake_args, lowers, strides, filled_box_size)
]
thread_fake_named_tuple = f'_thread[{", ".join(fake_args)}]'
thread_fake_statement = isl.union_set(
f'{{ {thread_fake_named_tuple} : {" and ".join(thread_fake_constraints)} }}'
).coalesce()
block_fake_constraints = [
f'({i} mod {stride}) = (({lower}) mod {stride})'
f' and 0 <= {i} - ({lower}) < {size}'
f' and ({i} mod {rt_size}) = (({lower}) mod {rt_size})'
for i, lower, stride, size, rt_size in zip(
fake_args, lowers, strides, filled_box_size, real_tile_size)
]
block_fake_named_tuple = f'_block[{", ".join(fake_args)}]'
block_fake_statement = isl.union_set(
f'{{ {block_fake_named_tuple} : {" and ".join(block_fake_constraints)} }}'
).coalesce()
old_domain = tree.domain()
tree.add_to_domain(thread_fake_statement)
tree.add_to_domain(block_fake_statement)
band = tree.outermost_band()
for i in range(n):
s = band.schedule.at(i).union_add(
isl.pw_aff(
f'{{ {thread_fake_named_tuple} -> [({fake_args[i]})] }}'))
band.schedule = band.schedule.set_at(i, s.coalesce())
s = band.schedule.at(i).union_add(
isl.pw_aff(
f'{{ {block_fake_named_tuple} -> [({fake_args[i]})] }}'))
band.schedule = band.schedule.set_at(i, s.coalesce())
fake_branch = SequenceNode()
fake_branch.add_child(FilterNode(filter='{%s}' % thread_fake_named_tuple))
fake_branch.add_child(FilterNode(filter='{%s}' % block_fake_named_tuple))
kernel_branch = FilterNode(filter=old_domain)
if band.child:
kernel_branch.child = band.child
fake_branch.add_child(kernel_branch)
band.child = fake_branch
if permutation is not None:
band.permute(*permutation)
band.tile(*real_tile_size)
band.insert_before(MarkNode('bind=blockIdx'))
child = band.child
child.insert_before(MarkNode('bind=threadIdx'))
kernel = child.child
kernel.insert_before(MarkNode('clear(bind)'))
