f98ee40f4b
This is an ongoing series of commits that are reformatting our Python code. This catches the last of the python files to reformat. Since they where so few I bunched them together. Reformatting is done with `black`. If you end up having problems merging this commit because you have made changes to a python file, the best way to handle that is to run git checkout --ours <yourfile> and then reformat it with black. If you run into any problems, post to discourse about it and we will try to help. RFC Thread below: https://discourse.llvm.org/t/rfc-document-and-standardize-python-code-style Reviewed By: jhenderson, #libc, Mordante, sivachandra Differential Revision: https://reviews.llvm.org/D150784
588 lines
17 KiB
Python
588 lines
17 KiB
Python
from ctypes import *
|
|
|
|
isl = cdll.LoadLibrary("libisl.so")
|
|
|
|
|
|
class Context:
|
|
defaultInstance = None
|
|
instances = {}
|
|
|
|
def __init__(self):
|
|
ptr = isl.isl_ctx_alloc()
|
|
self.ptr = ptr
|
|
Context.instances[ptr] = self
|
|
|
|
def __del__(self):
|
|
isl.isl_ctx_free(self)
|
|
|
|
def from_param(self):
|
|
return self.ptr
|
|
|
|
@staticmethod
|
|
def from_ptr(ptr):
|
|
return Context.instances[ptr]
|
|
|
|
@staticmethod
|
|
def getDefaultInstance():
|
|
if Context.defaultInstance == None:
|
|
Context.defaultInstance = Context()
|
|
|
|
return Context.defaultInstance
|
|
|
|
|
|
class IslObject:
|
|
def __init__(self, string="", ctx=None, ptr=None):
|
|
self.initialize_isl_methods()
|
|
if ptr != None:
|
|
self.ptr = ptr
|
|
self.ctx = self.get_isl_method("get_ctx")(self)
|
|
return
|
|
|
|
if ctx == None:
|
|
ctx = Context.getDefaultInstance()
|
|
|
|
self.ctx = ctx
|
|
self.ptr = self.get_isl_method("read_from_str")(ctx, string, -1)
|
|
|
|
def __del__(self):
|
|
self.get_isl_method("free")(self)
|
|
|
|
def from_param(self):
|
|
return self.ptr
|
|
|
|
@property
|
|
def context(self):
|
|
return self.ctx
|
|
|
|
def __repr__(self):
|
|
p = Printer(self.ctx)
|
|
self.to_printer(p)
|
|
return p.getString()
|
|
|
|
def __str__(self):
|
|
p = Printer(self.ctx)
|
|
self.to_printer(p)
|
|
return p.getString()
|
|
|
|
@staticmethod
|
|
def isl_name():
|
|
return "No isl name available"
|
|
|
|
def initialize_isl_methods(self):
|
|
if hasattr(self.__class__, "initialized"):
|
|
return
|
|
|
|
self.__class__.initalized = True
|
|
self.get_isl_method("read_from_str").argtypes = [Context, c_char_p, c_int]
|
|
self.get_isl_method("copy").argtypes = [self.__class__]
|
|
self.get_isl_method("copy").restype = c_int
|
|
self.get_isl_method("free").argtypes = [self.__class__]
|
|
self.get_isl_method("get_ctx").argtypes = [self.__class__]
|
|
self.get_isl_method("get_ctx").restype = Context.from_ptr
|
|
getattr(isl, "isl_printer_print_" + self.isl_name()).argtypes = [
|
|
Printer,
|
|
self.__class__,
|
|
]
|
|
|
|
def get_isl_method(self, name):
|
|
return getattr(isl, "isl_" + self.isl_name() + "_" + name)
|
|
|
|
def to_printer(self, printer):
|
|
getattr(isl, "isl_printer_print_" + self.isl_name())(printer, self)
|
|
|
|
|
|
class BSet(IslObject):
|
|
@staticmethod
|
|
def from_ptr(ptr):
|
|
if not ptr:
|
|
return
|
|
return BSet(ptr=ptr)
|
|
|
|
@staticmethod
|
|
def isl_name():
|
|
return "basic_set"
|
|
|
|
|
|
class Set(IslObject):
|
|
@staticmethod
|
|
def from_ptr(ptr):
|
|
if not ptr:
|
|
return
|
|
return Set(ptr=ptr)
|
|
|
|
@staticmethod
|
|
def isl_name():
|
|
return "set"
|
|
|
|
|
|
class USet(IslObject):
|
|
@staticmethod
|
|
def from_ptr(ptr):
|
|
if not ptr:
|
|
return
|
|
return USet(ptr=ptr)
|
|
|
|
@staticmethod
|
|
def isl_name():
|
|
return "union_set"
|
|
|
|
|
|
class BMap(IslObject):
|
|
@staticmethod
|
|
def from_ptr(ptr):
|
|
if not ptr:
|
|
return
|
|
return BMap(ptr=ptr)
|
|
|
|
def __mul__(self, set):
|
|
return self.intersect_domain(set)
|
|
|
|
@staticmethod
|
|
def isl_name():
|
|
return "basic_map"
|
|
|
|
|
|
class Map(IslObject):
|
|
@staticmethod
|
|
def from_ptr(ptr):
|
|
if not ptr:
|
|
return
|
|
return Map(ptr=ptr)
|
|
|
|
def __mul__(self, set):
|
|
return self.intersect_domain(set)
|
|
|
|
@staticmethod
|
|
def isl_name():
|
|
return "map"
|
|
|
|
@staticmethod
|
|
def lex_lt(dim):
|
|
dim = isl.isl_dim_copy(dim)
|
|
return isl.isl_map_lex_lt(dim)
|
|
|
|
@staticmethod
|
|
def lex_le(dim):
|
|
dim = isl.isl_dim_copy(dim)
|
|
return isl.isl_map_lex_le(dim)
|
|
|
|
@staticmethod
|
|
def lex_gt(dim):
|
|
dim = isl.isl_dim_copy(dim)
|
|
return isl.isl_map_lex_gt(dim)
|
|
|
|
@staticmethod
|
|
def lex_ge(dim):
|
|
dim = isl.isl_dim_copy(dim)
|
|
return isl.isl_map_lex_ge(dim)
|
|
|
|
|
|
class UMap(IslObject):
|
|
@staticmethod
|
|
def from_ptr(ptr):
|
|
if not ptr:
|
|
return
|
|
return UMap(ptr=ptr)
|
|
|
|
@staticmethod
|
|
def isl_name():
|
|
return "union_map"
|
|
|
|
|
|
class Dim(IslObject):
|
|
@staticmethod
|
|
def from_ptr(ptr):
|
|
if not ptr:
|
|
return
|
|
return Dim(ptr=ptr)
|
|
|
|
@staticmethod
|
|
def isl_name():
|
|
return "dim"
|
|
|
|
def initialize_isl_methods(self):
|
|
if hasattr(self.__class__, "initialized"):
|
|
return
|
|
|
|
self.__class__.initalized = True
|
|
self.get_isl_method("copy").argtypes = [self.__class__]
|
|
self.get_isl_method("copy").restype = c_int
|
|
self.get_isl_method("free").argtypes = [self.__class__]
|
|
self.get_isl_method("get_ctx").argtypes = [self.__class__]
|
|
self.get_isl_method("get_ctx").restype = Context.from_ptr
|
|
|
|
def __repr__(self):
|
|
return str(self)
|
|
|
|
def __str__(self):
|
|
|
|
dimParam = isl.isl_dim_size(self, 1)
|
|
dimIn = isl.isl_dim_size(self, 2)
|
|
dimOut = isl.isl_dim_size(self, 3)
|
|
|
|
if dimIn:
|
|
return "<dim In:%s, Out:%s, Param:%s>" % (dimIn, dimOut, dimParam)
|
|
|
|
return "<dim Set:%s, Param:%s>" % (dimOut, dimParam)
|
|
|
|
|
|
class Printer:
|
|
FORMAT_ISL = 0
|
|
FORMAT_POLYLIB = 1
|
|
FORMAT_POLYLIB_CONSTRAINTS = 2
|
|
FORMAT_OMEGA = 3
|
|
FORMAT_C = 4
|
|
FORMAT_LATEX = 5
|
|
FORMAT_EXT_POLYLIB = 6
|
|
|
|
def __init__(self, ctx=None):
|
|
if ctx == None:
|
|
ctx = Context.getDefaultInstance()
|
|
|
|
self.ctx = ctx
|
|
self.ptr = isl.isl_printer_to_str(ctx)
|
|
|
|
def setFormat(self, format):
|
|
self.ptr = isl.isl_printer_set_output_format(self, format)
|
|
|
|
def from_param(self):
|
|
return self.ptr
|
|
|
|
def __del__(self):
|
|
isl.isl_printer_free(self)
|
|
|
|
def getString(self):
|
|
return isl.isl_printer_get_str(self)
|
|
|
|
|
|
functions = [
|
|
# Unary properties
|
|
("is_empty", BSet, [BSet], c_int),
|
|
("is_empty", Set, [Set], c_int),
|
|
("is_empty", USet, [USet], c_int),
|
|
("is_empty", BMap, [BMap], c_int),
|
|
("is_empty", Map, [Map], c_int),
|
|
("is_empty", UMap, [UMap], c_int),
|
|
# ("is_universe", Set, [Set], c_int),
|
|
# ("is_universe", Map, [Map], c_int),
|
|
("is_single_valued", Map, [Map], c_int),
|
|
("is_bijective", Map, [Map], c_int),
|
|
("is_wrapping", BSet, [BSet], c_int),
|
|
("is_wrapping", Set, [Set], c_int),
|
|
# Binary properties
|
|
("is_equal", BSet, [BSet, BSet], c_int),
|
|
("is_equal", Set, [Set, Set], c_int),
|
|
("is_equal", USet, [USet, USet], c_int),
|
|
("is_equal", BMap, [BMap, BMap], c_int),
|
|
("is_equal", Map, [Map, Map], c_int),
|
|
("is_equal", UMap, [UMap, UMap], c_int),
|
|
# is_disjoint missing
|
|
# ("is_subset", BSet, [BSet, BSet], c_int),
|
|
("is_subset", Set, [Set, Set], c_int),
|
|
("is_subset", USet, [USet, USet], c_int),
|
|
("is_subset", BMap, [BMap, BMap], c_int),
|
|
("is_subset", Map, [Map, Map], c_int),
|
|
("is_subset", UMap, [UMap, UMap], c_int),
|
|
# ("is_strict_subset", BSet, [BSet, BSet], c_int),
|
|
("is_strict_subset", Set, [Set, Set], c_int),
|
|
("is_strict_subset", USet, [USet, USet], c_int),
|
|
("is_strict_subset", BMap, [BMap, BMap], c_int),
|
|
("is_strict_subset", Map, [Map, Map], c_int),
|
|
("is_strict_subset", UMap, [UMap, UMap], c_int),
|
|
# Unary Operations
|
|
("complement", Set, [Set], Set),
|
|
("reverse", BMap, [BMap], BMap),
|
|
("reverse", Map, [Map], Map),
|
|
("reverse", UMap, [UMap], UMap),
|
|
# Projection missing
|
|
("range", BMap, [BMap], BSet),
|
|
("range", Map, [Map], Set),
|
|
("range", UMap, [UMap], USet),
|
|
("domain", BMap, [BMap], BSet),
|
|
("domain", Map, [Map], Set),
|
|
("domain", UMap, [UMap], USet),
|
|
("identity", Set, [Set], Map),
|
|
("identity", USet, [USet], UMap),
|
|
("deltas", BMap, [BMap], BSet),
|
|
("deltas", Map, [Map], Set),
|
|
("deltas", UMap, [UMap], USet),
|
|
("coalesce", Set, [Set], Set),
|
|
("coalesce", USet, [USet], USet),
|
|
("coalesce", Map, [Map], Map),
|
|
("coalesce", UMap, [UMap], UMap),
|
|
("detect_equalities", BSet, [BSet], BSet),
|
|
("detect_equalities", Set, [Set], Set),
|
|
("detect_equalities", USet, [USet], USet),
|
|
("detect_equalities", BMap, [BMap], BMap),
|
|
("detect_equalities", Map, [Map], Map),
|
|
("detect_equalities", UMap, [UMap], UMap),
|
|
("convex_hull", Set, [Set], Set),
|
|
("convex_hull", Map, [Map], Map),
|
|
("simple_hull", Set, [Set], Set),
|
|
("simple_hull", Map, [Map], Map),
|
|
("affine_hull", BSet, [BSet], BSet),
|
|
("affine_hull", Set, [Set], BSet),
|
|
("affine_hull", USet, [USet], USet),
|
|
("affine_hull", BMap, [BMap], BMap),
|
|
("affine_hull", Map, [Map], BMap),
|
|
("affine_hull", UMap, [UMap], UMap),
|
|
("polyhedral_hull", Set, [Set], Set),
|
|
("polyhedral_hull", USet, [USet], USet),
|
|
("polyhedral_hull", Map, [Map], Map),
|
|
("polyhedral_hull", UMap, [UMap], UMap),
|
|
# Power missing
|
|
# Transitive closure missing
|
|
# Reaching path lengths missing
|
|
("wrap", BMap, [BMap], BSet),
|
|
("wrap", Map, [Map], Set),
|
|
("wrap", UMap, [UMap], USet),
|
|
("unwrap", BSet, [BMap], BMap),
|
|
("unwrap", Set, [Map], Map),
|
|
("unwrap", USet, [UMap], UMap),
|
|
("flatten", Set, [Set], Set),
|
|
("flatten", Map, [Map], Map),
|
|
("flatten_map", Set, [Set], Map),
|
|
# Dimension manipulation missing
|
|
# Binary Operations
|
|
("intersect", BSet, [BSet, BSet], BSet),
|
|
("intersect", Set, [Set, Set], Set),
|
|
("intersect", USet, [USet, USet], USet),
|
|
("intersect", BMap, [BMap, BMap], BMap),
|
|
("intersect", Map, [Map, Map], Map),
|
|
("intersect", UMap, [UMap, UMap], UMap),
|
|
("intersect_domain", BMap, [BMap, BSet], BMap),
|
|
("intersect_domain", Map, [Map, Set], Map),
|
|
("intersect_domain", UMap, [UMap, USet], UMap),
|
|
("intersect_range", BMap, [BMap, BSet], BMap),
|
|
("intersect_range", Map, [Map, Set], Map),
|
|
("intersect_range", UMap, [UMap, USet], UMap),
|
|
("union", BSet, [BSet, BSet], Set),
|
|
("union", Set, [Set, Set], Set),
|
|
("union", USet, [USet, USet], USet),
|
|
("union", BMap, [BMap, BMap], Map),
|
|
("union", Map, [Map, Map], Map),
|
|
("union", UMap, [UMap, UMap], UMap),
|
|
("subtract", Set, [Set, Set], Set),
|
|
("subtract", Map, [Map, Map], Map),
|
|
("subtract", USet, [USet, USet], USet),
|
|
("subtract", UMap, [UMap, UMap], UMap),
|
|
("apply", BSet, [BSet, BMap], BSet),
|
|
("apply", Set, [Set, Map], Set),
|
|
("apply", USet, [USet, UMap], USet),
|
|
("apply_domain", BMap, [BMap, BMap], BMap),
|
|
("apply_domain", Map, [Map, Map], Map),
|
|
("apply_domain", UMap, [UMap, UMap], UMap),
|
|
("apply_range", BMap, [BMap, BMap], BMap),
|
|
("apply_range", Map, [Map, Map], Map),
|
|
("apply_range", UMap, [UMap, UMap], UMap),
|
|
("gist", BSet, [BSet, BSet], BSet),
|
|
("gist", Set, [Set, Set], Set),
|
|
("gist", USet, [USet, USet], USet),
|
|
("gist", BMap, [BMap, BMap], BMap),
|
|
("gist", Map, [Map, Map], Map),
|
|
("gist", UMap, [UMap, UMap], UMap),
|
|
# Lexicographic Optimizations
|
|
# partial_lexmin missing
|
|
("lexmin", BSet, [BSet], BSet),
|
|
("lexmin", Set, [Set], Set),
|
|
("lexmin", USet, [USet], USet),
|
|
("lexmin", BMap, [BMap], BMap),
|
|
("lexmin", Map, [Map], Map),
|
|
("lexmin", UMap, [UMap], UMap),
|
|
("lexmax", BSet, [BSet], BSet),
|
|
("lexmax", Set, [Set], Set),
|
|
("lexmax", USet, [USet], USet),
|
|
("lexmax", BMap, [BMap], BMap),
|
|
("lexmax", Map, [Map], Map),
|
|
("lexmax", UMap, [UMap], UMap),
|
|
# Undocumented
|
|
("lex_lt_union_set", USet, [USet, USet], UMap),
|
|
("lex_le_union_set", USet, [USet, USet], UMap),
|
|
("lex_gt_union_set", USet, [USet, USet], UMap),
|
|
("lex_ge_union_set", USet, [USet, USet], UMap),
|
|
]
|
|
keep_functions = [
|
|
# Unary properties
|
|
("get_dim", BSet, [BSet], Dim),
|
|
("get_dim", Set, [Set], Dim),
|
|
("get_dim", USet, [USet], Dim),
|
|
("get_dim", BMap, [BMap], Dim),
|
|
("get_dim", Map, [Map], Dim),
|
|
("get_dim", UMap, [UMap], Dim),
|
|
]
|
|
|
|
|
|
def addIslFunction(object, name):
|
|
functionName = "isl_" + object.isl_name() + "_" + name
|
|
islFunction = getattr(isl, functionName)
|
|
if len(islFunction.argtypes) == 1:
|
|
f = lambda a: islFunctionOneOp(islFunction, a)
|
|
elif len(islFunction.argtypes) == 2:
|
|
f = lambda a, b: islFunctionTwoOp(islFunction, a, b)
|
|
object.__dict__[name] = f
|
|
|
|
|
|
def islFunctionOneOp(islFunction, ops):
|
|
ops = getattr(isl, "isl_" + ops.isl_name() + "_copy")(ops)
|
|
return islFunction(ops)
|
|
|
|
|
|
def islFunctionTwoOp(islFunction, opOne, opTwo):
|
|
opOne = getattr(isl, "isl_" + opOne.isl_name() + "_copy")(opOne)
|
|
opTwo = getattr(isl, "isl_" + opTwo.isl_name() + "_copy")(opTwo)
|
|
return islFunction(opOne, opTwo)
|
|
|
|
|
|
for (operation, base, operands, ret) in functions:
|
|
functionName = "isl_" + base.isl_name() + "_" + operation
|
|
islFunction = getattr(isl, functionName)
|
|
if len(operands) == 1:
|
|
islFunction.argtypes = [c_int]
|
|
elif len(operands) == 2:
|
|
islFunction.argtypes = [c_int, c_int]
|
|
|
|
if ret == c_int:
|
|
islFunction.restype = ret
|
|
else:
|
|
islFunction.restype = ret.from_ptr
|
|
|
|
addIslFunction(base, operation)
|
|
|
|
|
|
def addIslFunctionKeep(object, name):
|
|
functionName = "isl_" + object.isl_name() + "_" + name
|
|
islFunction = getattr(isl, functionName)
|
|
if len(islFunction.argtypes) == 1:
|
|
f = lambda a: islFunctionOneOpKeep(islFunction, a)
|
|
elif len(islFunction.argtypes) == 2:
|
|
f = lambda a, b: islFunctionTwoOpKeep(islFunction, a, b)
|
|
object.__dict__[name] = f
|
|
|
|
|
|
def islFunctionOneOpKeep(islFunction, ops):
|
|
return islFunction(ops)
|
|
|
|
|
|
def islFunctionTwoOpKeep(islFunction, opOne, opTwo):
|
|
return islFunction(opOne, opTwo)
|
|
|
|
|
|
for (operation, base, operands, ret) in keep_functions:
|
|
functionName = "isl_" + base.isl_name() + "_" + operation
|
|
islFunction = getattr(isl, functionName)
|
|
if len(operands) == 1:
|
|
islFunction.argtypes = [c_int]
|
|
elif len(operands) == 2:
|
|
islFunction.argtypes = [c_int, c_int]
|
|
|
|
if ret == c_int:
|
|
islFunction.restype = ret
|
|
else:
|
|
islFunction.restype = ret.from_ptr
|
|
|
|
addIslFunctionKeep(base, operation)
|
|
|
|
isl.isl_ctx_free.argtypes = [Context]
|
|
isl.isl_basic_set_read_from_str.argtypes = [Context, c_char_p, c_int]
|
|
isl.isl_set_read_from_str.argtypes = [Context, c_char_p, c_int]
|
|
isl.isl_basic_set_copy.argtypes = [BSet]
|
|
isl.isl_basic_set_copy.restype = c_int
|
|
isl.isl_set_copy.argtypes = [Set]
|
|
isl.isl_set_copy.restype = c_int
|
|
isl.isl_set_copy.argtypes = [Set]
|
|
isl.isl_set_copy.restype = c_int
|
|
isl.isl_set_free.argtypes = [Set]
|
|
isl.isl_basic_set_get_ctx.argtypes = [BSet]
|
|
isl.isl_basic_set_get_ctx.restype = Context.from_ptr
|
|
isl.isl_set_get_ctx.argtypes = [Set]
|
|
isl.isl_set_get_ctx.restype = Context.from_ptr
|
|
isl.isl_basic_set_get_dim.argtypes = [BSet]
|
|
isl.isl_basic_set_get_dim.restype = Dim.from_ptr
|
|
isl.isl_set_get_dim.argtypes = [Set]
|
|
isl.isl_set_get_dim.restype = Dim.from_ptr
|
|
isl.isl_union_set_get_dim.argtypes = [USet]
|
|
isl.isl_union_set_get_dim.restype = Dim.from_ptr
|
|
|
|
isl.isl_basic_map_read_from_str.argtypes = [Context, c_char_p, c_int]
|
|
isl.isl_map_read_from_str.argtypes = [Context, c_char_p, c_int]
|
|
isl.isl_basic_map_free.argtypes = [BMap]
|
|
isl.isl_map_free.argtypes = [Map]
|
|
isl.isl_basic_map_copy.argtypes = [BMap]
|
|
isl.isl_basic_map_copy.restype = c_int
|
|
isl.isl_map_copy.argtypes = [Map]
|
|
isl.isl_map_copy.restype = c_int
|
|
isl.isl_map_get_ctx.argtypes = [Map]
|
|
isl.isl_basic_map_get_ctx.argtypes = [BMap]
|
|
isl.isl_basic_map_get_ctx.restype = Context.from_ptr
|
|
isl.isl_map_get_ctx.argtypes = [Map]
|
|
isl.isl_map_get_ctx.restype = Context.from_ptr
|
|
isl.isl_basic_map_get_dim.argtypes = [BMap]
|
|
isl.isl_basic_map_get_dim.restype = Dim.from_ptr
|
|
isl.isl_map_get_dim.argtypes = [Map]
|
|
isl.isl_map_get_dim.restype = Dim.from_ptr
|
|
isl.isl_union_map_get_dim.argtypes = [UMap]
|
|
isl.isl_union_map_get_dim.restype = Dim.from_ptr
|
|
isl.isl_printer_free.argtypes = [Printer]
|
|
isl.isl_printer_to_str.argtypes = [Context]
|
|
isl.isl_printer_print_basic_set.argtypes = [Printer, BSet]
|
|
isl.isl_printer_print_set.argtypes = [Printer, Set]
|
|
isl.isl_printer_print_basic_map.argtypes = [Printer, BMap]
|
|
isl.isl_printer_print_map.argtypes = [Printer, Map]
|
|
isl.isl_printer_get_str.argtypes = [Printer]
|
|
isl.isl_printer_get_str.restype = c_char_p
|
|
isl.isl_printer_set_output_format.argtypes = [Printer, c_int]
|
|
isl.isl_printer_set_output_format.restype = c_int
|
|
isl.isl_dim_size.argtypes = [Dim, c_int]
|
|
isl.isl_dim_size.restype = c_int
|
|
|
|
isl.isl_map_lex_lt.argtypes = [c_int]
|
|
isl.isl_map_lex_lt.restype = Map.from_ptr
|
|
isl.isl_map_lex_le.argtypes = [c_int]
|
|
isl.isl_map_lex_le.restype = Map.from_ptr
|
|
isl.isl_map_lex_gt.argtypes = [c_int]
|
|
isl.isl_map_lex_gt.restype = Map.from_ptr
|
|
isl.isl_map_lex_ge.argtypes = [c_int]
|
|
isl.isl_map_lex_ge.restype = Map.from_ptr
|
|
|
|
isl.isl_union_map_compute_flow.argtypes = [
|
|
c_int,
|
|
c_int,
|
|
c_int,
|
|
c_int,
|
|
c_void_p,
|
|
c_void_p,
|
|
c_void_p,
|
|
c_void_p,
|
|
]
|
|
|
|
|
|
def dependences(sink, must_source, may_source, schedule):
|
|
sink = getattr(isl, "isl_" + sink.isl_name() + "_copy")(sink)
|
|
must_source = getattr(isl, "isl_" + must_source.isl_name() + "_copy")(must_source)
|
|
may_source = getattr(isl, "isl_" + may_source.isl_name() + "_copy")(may_source)
|
|
schedule = getattr(isl, "isl_" + schedule.isl_name() + "_copy")(schedule)
|
|
must_dep = c_int()
|
|
may_dep = c_int()
|
|
must_no_source = c_int()
|
|
may_no_source = c_int()
|
|
isl.isl_union_map_compute_flow(
|
|
sink,
|
|
must_source,
|
|
may_source,
|
|
schedule,
|
|
byref(must_dep),
|
|
byref(may_dep),
|
|
byref(must_no_source),
|
|
byref(may_no_source),
|
|
)
|
|
|
|
return (
|
|
UMap.from_ptr(must_dep),
|
|
UMap.from_ptr(may_dep),
|
|
USet.from_ptr(must_no_source),
|
|
USet.from_ptr(may_no_source),
|
|
)
|
|
|
|
|
|
__all__ = ["Set", "Map", "Printer", "Context"]
|