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"]
Codebase Browser
llvm