polly/utils/pyscop/isl.py

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']