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 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 __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)'))