def CreateTILE(self, BLOCK):
i = 0
is_i = isl.Set(self.cl.statements[i].domain_map)
print is_i
tile = is_i
j =0
for symvar in self.tile_statements[i].tile_iterators:
tile = tile.add_dims(isl.dim_type.param, 1)
tile = tile.set_dim_name(isl.dim_type.param, tile.dim(isl.dim_type.param)-1, symvar)
if(j==1):
c = isl.Constraint.ineq_from_names(tile.get_space(), {symvar: 1, 1:1})
else:
c = isl.Constraint.ineq_from_names(tile.get_space(), {symvar: 1, 1:0})
tile = tile.add_constraint(c)
bl = int(BLOCK[j])
if(j==0):
c = isl.Constraint.ineq_from_names(tile.get_space(), {self.tile_statements[i].iterators[j]: -1, symvar:bl, 1:bl-1})
tile = tile.add_constraint(c)
c = isl.Constraint.ineq_from_names(tile.get_space(), {self.tile_statements[i].iterators[j]: 1, symvar:-bl})
tile = tile.add_constraint(c)
else:
symvar2 = self.tile_statements[i].tile_iterators[0]
c = isl.Constraint.ineq_from_names(tile.get_space(), {self.tile_statements[i].iterators[j]: -1, symvar:bl, 1:0, self.tile_statements[i].iterators[j-1]: 1, symvar2:-bl})
tile = tile.add_constraint(c)
c = isl.Constraint.ineq_from_names(tile.get_space(), {self.tile_statements[i].iterators[j]: 1, symvar:-bl, self.tile_statements[i].iterators[j-1]: -1, symvar2:bl, 1:bl-1})
tile = tile.add_constraint(c)
# j <= 15 + 16jj
j = j+1
# add bounds
constr = ' '
for j in range(0, len(self.cl.statements[i].bounds)):
stuff = self.cl.statements[i].bounds
constr = constr + ' and ' + ' 0 <= ' + self.tile_statements[i].tile_iterators[j] + '*' + BLOCK[j] + ' <= ' + stuff[j]['ub'] + '-' + stuff[j]['lb'] + ' '
str_tile = str(tile)
#str_tile = str_tile.replace('}', constr + ' }')
print '--------'
print str_tile
tile = isl.Set(str_tile)
# --------------------------------------
self.tile_statements[i].TILE = tile
def test_lexmin():
print(
isl.Set("""{ [s] : exists a,b,c :
0 <= a <= 5 and 1 <= b <= 4 and 2 <= c <= 7 and
((2 <= b and b <= 3) implies (a <= 1 or a >= 3)) and
((not (c < 5 or b > 3)) implies (a > 2 and c < 3)) and s = a + b + c }
""").lexmin())
def data_5():
program = mat_mul_2D_fixed()
partitioners_A = dist.partition(program['A'], [0, 1], [4, 3], [12, 12],
"col")
partitioners_B = dist.partition(program['B'], [0, 1], [3, 4], [12, 12],
"row")
partitioners_C = dist.partition(program['C'], [0, 1], [3, 4], [12, 12],
"row")
str_schedule = "[r0, r1]->{Send_A[p0, p1, i1, i2]->[0, p0, p1, i1, i2]; Send_B[p0, p1, i1, i2]->[1, p0, p1, i1, i2]; Receive_A[p0, p1, i1, i2]->[2, p0, p1, i1, i2]; Receive_B[p0, p1, i1, i2]->[3, p0, p1, i1, i2]; S0[i, j, k]->[4, 0, 0, i, j]}"
# context = isl.Set("[r0, r1]->{:r0=1 and r1=1}") #Correct
# context = isl.Set("[r0, r1]->{:r0=0 and r1=0}") #Correct
# context = isl.Set("[r0, r1]->{:r0=0 and r1=1}") #Correct
context = isl.Set("[r0, r1]->{:}")
return {
'S0_dom': program['S0_dom'],
'A': program['A'],
'B': program['B'],
'C': program['C'],
'Access_A': program['Access_A'],
'Access_B': program['Access_B'],
'Access_C': program['Access_C'],
'pr_partitioner_A': partitioners_A['pr'],
'ps_partitioner_A': partitioners_A['ps'],
'pr_partitioner_B': partitioners_B['pr'],
'ps_partitioner_B': partitioners_B['ps'],
'pr_partitioner_C': partitioners_C['pr'],
'ps_partitioner_C': partitioners_C['ps'],
'str_schedule': str_schedule,
'context': context
}
def data_6():
# C(i) = A(i,k) + B(i,k)
program = matrix_matrix_add_fixed()
partitioners_A = dist.partition(program['A'], [0, 1], [3, 3], [9, 9],
"row")
partitioners_B = dist.partition(program['B'], [0, 1], [3, 3], [9, 9],
"row")
partitioners_C = dist.partition(program['C'], [0], [9], [9], "row")
str_schedule = "[r0, r1]->{Send_A[p0, p1, i1, i2]->[0, p0, p1, i1, i2]; Send_B[p0, p1, i1, i2]->[1, p0, p1, i1, i2]; Receive_A[p0, p1, i1, i2]->[2, p0, p1, i1, i2]; Receive_B[p0, p1, i1, i2]->[3, p0, p1, i1, i2]; S0[i, k]->[4, 0, 0, i, k]}"
# context = isl.Set("[r0, r1]->{:r0=1 and r1=1}")
context = isl.Set("[r0, r1]->{:r0=0 and r1=0}")
# context = isl.Set("[r0, r1]->{:}")
return {
'S0_dom': program['S0_dom'],
'A': program['A'],
'B': program['B'],
'C': program['C'],
'Access_A': program['Access_A'],
'Access_B': program['Access_B'],
'Access_C': program['Access_C'],
'pr_partitioner_A': partitioners_A['pr'],
'ps_partitioner_A': partitioners_A['ps'],
'pr_partitioner_B': partitioners_B['pr'],
'ps_partitioner_B': partitioners_B['ps'],
'pr_partitioner_C': partitioners_C['pr'],
'ps_partitioner_C': partitioners_C['ps'],
'str_schedule': str_schedule,
'context': context
}
def SymbolicTuple(n):
symb = []
for i in range(0, n):
symb.append("xoxo" + str(i))
koma = ','.join(symb)
tuple = "[" + koma + "]->{[" + koma + "]}"
return [isl.Set(tuple), symb]
def CreateTILEbis(self):
i = 0
self.tile_statements[i].TILE_VLD = self.tile_statements[i].TILE
tilevld = self.tile_statements[i].TILE
Rapply = self.GetRapply(self.tile_statements[i].iterators,
self.tile_statements[i].tile_iterators,
self.cl.params)
print Rapply
tilebis = self.Project(
tilevld.apply(Rapply).coalesce(),
self.tile_statements[i].tile_iterators).coalesce()
print tilebis
loop_x = iscc.isl_ast_codegen(tilebis)
print loop_x
rtile = []
for dep in self.cl.deps:
rtile.append(
tiling_schedule.get_RTILE(
tilebis, self.tile_statements[0].tile_iterators,
dep.relation, False, 1))
vis.Vis(tilebis, self.cl.statements[0].bounds, self.cl.deps,
isl.Set(self.cl.statements[0].domain_map))
def vec_add():
S0_dom = isl.Set("[N]->{S0[i]: 0 <= i <= N}")
Access_A = isl.Map("{S0[i]->A[i]}")
Access_B = isl.Map("{S0[i]->B[i]}")
Access_C = isl.Map("{S0[i]->C[i]}")
A = isl.Set("[N]->{A[i]: 0<=i<N}")
B = isl.Set("[N]->{B[i]: 0<=i<N}")
C = isl.Set("[N]->{C[i]: 0<=i<N}")
return {
'S0_dom': S0_dom,
'Access_A': Access_A,
'Access_B': Access_B,
'Access_C': Access_C,
'A': A,
'B': B,
'C': C
}
def matrix_matrix_add_fixed():
S0_dom = isl.Set("{S0[i,k]: 0 <= i < 9 and 0 <= k < 9}")
Access_A = isl.Map("{S0[i,k]->A[i,k]}")
Access_B = isl.Map("{S0[i,k]->B[i,k]}")
Access_C = isl.Map("{S0[i,k]->C[i]}")
A = isl.Set("{A[i,k]: 0<=i<9 and 0<=k<9}")
B = isl.Set("{B[i,k]: 0<=i<9 and 0<=k<9}")
C = isl.Set("{C[i]: 0<=i<9}")
return {
'S0_dom': S0_dom,
'Access_A': Access_A,
'Access_B': Access_B,
'Access_C': Access_C,
'A': A,
'B': B,
'C': C
}
def test_error_on_invalid_index():
ctx = isl.Context()
my_set = isl.Set(
"{ [k, l] : 3l >= -k and 3l <= 10 - k "
"and k >=0 and k <= 2 }",
context=ctx)
p = my_set.sample_point()
with pytest.raises(isl.Error):
p.get_coordinate_val(isl.dim_type.set, 99999999)
def mat_mul_2D_fixed():
S0_dom = isl.Set(
"{S0[i, j, k]: 0 <= i < 12 and 0 <= j < 12 and 0 <= k < 12}")
Access_A = isl.Map("{S0[i, j, k]->A[i, k]}")
Access_B = isl.Map("{S0[i, j, k]->B[k, j]}")
Access_C = isl.Map("{S0[i, j, k]->C[i, j, k]}")
A = isl.Set("{A[i,j]: 0<=i<12 and 0<=j<12}")
B = isl.Set("{B[i,j]: 0<=i<12 and 0<=j<12}")
C = isl.Set("{C[i,j,k]: 0<=i<12 and 0<=j<12 and 0<=k<12}")
return {
'S0_dom': S0_dom,
'Access_A': Access_A,
'Access_B': Access_B,
'Access_C': Access_C,
'A': A,
'B': B,
'C': C
}
def mat_mul_2D():
S0_dom = isl.Set(
"[N]->{S0[i, j, k]: 0 <= i < N and 0 <= j < N and 0 <= k < N}")
Access_A = isl.Map("{S0[i, j, k]->A[i, k]}")
Access_B = isl.Map("{S0[i, j, k]->B[k, j]}")
Access_C = isl.Map("{S0[i, j, k]->C[i, j, k]}")
A = isl.Set("[N]->{A[i,j]: 0<=i<N and 0<=j<N}")
B = isl.Set("[N]->{B[i,j]: 0<=i<N and 0<=j<N}")
C = isl.Set("[N]->{C[i,j,k]: 0<=i<N and 0<=j<N and 0<=k<N}")
return {
'S0_dom': S0_dom,
'Access_A': Access_A,
'Access_B': Access_B,
'Access_C': Access_C,
'A': A,
'B': B,
'C': C
}
def isl_ast_codegen_map(m):
b = isl.AstBuild.from_context(isl.Set("{:}"))
ast = b.ast_from_schedule(m)
p = isl.Printer.to_str(isl.DEFAULT_CONTEXT)
p = p.set_output_format(isl.format.C)
p.flush()
p = p.print_ast_node(ast)
return p.get_str()
def test_affs_from_space():
s = isl.Set("[n] -> {[i,j,k]: 0<=i,j,k<n}")
v = isl.affs_from_space(s.space)
myset = (v[0].le_set(v["i"] + v["j"])
& (v["i"] + v["j"]).lt_set(v["n"])
& (v[0].le_set(v["i"]))
& (v["i"].le_set(13 + v["n"])))
print(myset)
def test_error_on_invalid_index():
ctx = isl.Context()
my_set = isl.Set("{ [k, l] : 3l >= -k and 3l <= 10 - k "
"and k >=0 and k <= 2 }", context=ctx)
p = my_set.sample_point()
try:
p.get_coordinate_val(isl.dim_type.set, 99999999)
except isl.Error:
pass
else:
assert False
def set(self, domain, name=''):
if domain[0] != '[':
domain = ISLFactory.validate(domain, name)
if '(' in domain:
domain = self.replaceUFs(domain)
try:
return isl.Set(domain, self._context)
except Exception as ex:
print("ERROR: Set '%s' caused error '%s'" % (domain, str(ex)))
raise ex
def isl_ast_codegen(S):
b = isl.AstBuild.from_context(isl.Set("{:}"))
m = isl.Map.from_domain_and_range(S, S)
m = isl.Map.identity(m.get_space())
m = isl.Map.from_domain(S)
ast = b.ast_from_schedule(m)
p = isl.Printer.to_str(isl.DEFAULT_CONTEXT)
p = p.set_output_format(isl.format.C)
p.flush()
p = p.print_ast_node(ast)
return p.get_str()
def test_subst_into_pwaff():
from pymbolic.primitives import Variable
arg_dict = {"m": 3 * Variable("nx"), "n": 2 * Variable("ny") + 4}
space = isl.Set("[nx, ny, nz] -> { []: }").params().space
poly = isl.PwAff("[m, n] -> { [3 * m + 2 * n] : "
"m > 0 and n > 0; [7* m + 4*n] : m > 0 and n <= 0 }")
from loopy.isl_helpers import subst_into_pwaff
result = subst_into_pwaff(space, poly, arg_dict)
expected = isl.PwAff(
"[nx, ny, nz] -> { [(9nx + 4ny+8)] : nx > 0 and ny > -2;"
" [(21nx + 8ny+16)] : nx > 0 and ny <= -2 }")
assert result == expected
def iterate_closure(self):
ftp = self.ssh.open_sftp()
ftp.put('tmp/oc.txt', 'oc.txt')
ftp.close()
stdin, stdout, stderr = self.ssh.exec_command("./oc < tmp/oc.txt")
wynik = stdout.readlines()
tc = isl.Set(wynik[0])
return tc
def RemoveOtherSt(isl_BL, dane,sym_exvars):
constr = ""
for i in range(0,len(dane['st'])):
constr = constr + " v = "+ str(dane['st'][i])
if(i < len(dane['st'])-1):
constr = constr + " || "
CL = "{["
for i in range(0, len(sym_exvars)):
CL = CL + "x" + str(i) + ","
CL = CL + "v] : " + constr + "}"
CL = isl.Set(CL)
isl_BL = isl_BL.intersect(CL)
return isl_BL
def test_pickling():
instances = [
isl.Aff("[n] -> { [(-1 - floor((-n)/4))] }"),
isl.PwAff("[n] -> { [(0)] : n <= 4 and n >= 1; "
"[(-1 + n - floor((3n)/4))] : n >= 5 }"),
isl.BasicSet("[n] -> {[i,j,k]: i<=j + k and (exists m: m=j+k) "
"and n mod 5 = 17}"),
isl.Set("[n] -> {[i,j,k]: (i<=j + k and (exists m: m=j+k)) or (k=j)}")
]
from pickle import dumps, loads
for inst in instances:
inst2 = loads(dumps(inst))
assert inst.space == inst2.space
assert inst.is_equal(inst2)
def codegen(self, sched):
bld = isl.AstBuild.from_context(isl.Set("{:}"))
mp = isl.Map.from_domain_and_range(sched, sched)
mp = isl.Map.identity(mp.get_space())
mp = isl.Map.from_domain(sched)
ast = bld.ast_from_schedule(mp)
ptr = isl.Printer.to_str(isl.DEFAULT_CONTEXT)
ptr = ptr.set_output_format(isl.format.C)
ptr.flush()
ptr = ptr.print_ast_node(ast)
# Restore uninterpreted functions...
iters = sched.split('[')[1].split(']')[0].replace(' ', '').replace(
'0', 'z').split(',')
code = self.restoreUFs(ptr.get_str(), iters)
return code
def getIS(plik, rel, dane):
global_size = rel.dim(isl.dim_type.in_)
#UDS = rel.domain().subtract(rel.range()).coalesce()
#UDD = rel.range().subtract(rel.domain()).coalesce()
DOM_RAN = rel.range().union(rel.domain()).coalesce()
cl = clanpy.ClanPy()
cl.loop_path = plik
cl.Load()
cl.RunCandl()
cl.DepAnalysis()
IS = DOM_RAN
for i in range(0, len(cl.statements)):
IS_ = isl.Set(cl.statements[i].domain_map).coalesce()
set_size = IS_.dim(isl.dim_type.set)
for j in range(set_size, global_size - 1):
IS_ = IS_.insert_dims(isl.dim_type.set, j, 1)
IS_ = IS_.set_dim_name(isl.dim_type.set, j, 'i' + str(j))
c = isl.Constraint.eq_from_names(
IS_.get_space(), {
IS_.get_dim_name(isl.dim_type.set, j): -1,
1: -1
})
IS_ = IS_.add_constraint(c).coalesce()
set_size = IS_.dim(isl.dim_type.set)
IS_ = IS_.insert_dims(isl.dim_type.set, set_size, 1)
IS_ = IS_.set_dim_name(isl.dim_type.set, set_size, "v")
c = isl.Constraint.eq_from_names(IS_.get_space(), {
"v": -1,
1: int(dane[i])
})
IS_ = IS_.add_constraint(c).coalesce()
if i == 0:
IS = IS_
else:
IS = IS.union(IS_).coalesce()
return IS
def build_ast(self):
#astbld = isl.AstBuild.from_context( \
# isl.BasicSet("[C, R]->{: R>=1 and C>=1}", self.ctx))
parts = []
for plist in self.poly_parts.values():
parts.extend(plist)
# TODO figure out a way to create the correct parameter context
# since the parameters for all the parts may not be the same
astbld = isl.AstBuild.from_context(parts[0].sched.params())
#astbld = astbld.set_options(isl.UnionMap("{ }"))
sched_map = None
opt_map = None
for part in parts:
if sched_map is None:
# initial map
sched_map = isl.UnionMap.from_map(part.sched)
else:
part_map = isl.UnionMap.from_map(part.sched)
sched_map = sched_map.union(part_map)
srange = part.sched.range()
unroll_union_set = \
isl.UnionSet.from_set(isl.Set("{:}", self.ctx))
dom_union_set = \
isl.UnionSet.universe(isl.UnionSet.from_set(srange))
if opt_map is None:
opt_map = isl.UnionMap.from_domain_and_range(dom_union_set, \
unroll_union_set)
else:
opt_map = opt_map.union( \
isl.UnionMap.from_domain_and_range( \
dom_union_set, unroll_union_set) )
astbld = astbld.set_options(opt_map)
# All parts in the group will have the same schedule dimension
# using the first part as the canonical one
num_ids = parts[0].sched.dim(isl._isl.dim_type.out)
ids = isl.IdList.alloc(self.ctx, num_ids)
for i in range(0, num_ids):
sched_name = parts[0].sched.get_dim_name(isl._isl.dim_type.out, i)
id_ = isl.Id.alloc(self.ctx, sched_name, None)
ids = ids.add(id_)
astbld = astbld.set_iterators(ids)
self.polyast.append(astbld.ast_from_schedule(sched_map))
def test_codegen():
# courtesy of Marek Pałkowski
def isl_ast_codegen(S):
b = isl.AstBuild.from_context(isl.Set("{:}"))
m = isl.Map.from_domain_and_range(S, S)
m = isl.Map.identity(m.get_space())
m = isl.Map.from_domain(S)
ast = b.ast_from_schedule(m)
p = isl.Printer.to_str(isl.DEFAULT_CONTEXT)
p = p.set_output_format(isl.format.C)
p.flush()
p = p.print_ast_node(ast)
return p.get_str()
s = isl.Set("[n,m] -> { [i,j] : 0 <= i <= n and i <= j <= m }")
print(isl_ast_codegen(s))
def test_subst_into_pwqpolynomial():
from pymbolic.primitives import Variable
arg_dict = {
"m": 3 * Variable("nx"),
"n": 3 * Variable("ny"),
"nx": Variable("nx"),
"ny": Variable("ny"),
"nz": Variable("nz")
}
space = isl.Set("[nx, ny, nz] -> { []: }").space
poly = isl.PwQPolynomial("[m, n] -> { (256 * m + 256 * m * n) : "
"m > 0 and n > 0; 256 * m : m > 0 and n <= 0 }")
from loopy.isl_helpers import subst_into_pwqpolynomial
result = subst_into_pwqpolynomial(space, poly, arg_dict)
expected_pwqpoly = isl.PwQPolynomial(
"[nx, ny, nz] -> {"
"(768 * nx + 2304 * nx * ny) : nx > 0 and ny > 0;"
"768 * nx : nx > 0 and ny <= 0 }")
assert (result - expected_pwqpoly).is_zero()
def get_RCYCLE(rel_simple, orig):
#rel_simple = isl.Map("[n] -> {[i,j] -> [i',j'] : 1 <= i <= n && 1 <= j <= n && 1 <= i' <= n && 1 <= j' <= n}")
rplus = rel_simple.transitive_closure()[0].coalesce()
inp = []
outp = []
symb = []
n = rel_simple.dim(isl.dim_type.in_)
for i in range(0, n):
inp.append("i" + str(i))
outp.append("o" + str(i))
symb.append("s" + str(i))
rlex = "{[" + ",".join(inp) + "] -> [" + ",".join(
outp) + "] : " + tiling_v3.CreateLex(outp, inp) + "}"
rlex = isl.Map(rlex)
invert_rel = rel_simple.fixed_power_val(-1).coalesce()
r_out = rlex.intersect(rplus.intersect(invert_rel)).coalesce()
print 'R_CYCLE'
print r_out
if orig == 1:
print "Oryginal TILES"
print '#nowa prosta implementacja R_CYCLE'
S = "[" + ",".join(symb) + "] -> {[" + ",".join(symb) + "]}"
S = isl.Set(S)
R_CYCLE2 = S.apply(rplus).intersect(S).coalesce()
print R_CYCLE2
return r_out
def hull(self, S):
text_file = open('tmp/_rel.txt', 'w')
text_file.write('R := ' + str(S) + ';poly R;')
text_file.close()
ftp = self.ssh.open_sftp()
ftp.put('tmp/_rel.txt', '_rel.txt')
ftp.close()
stdin, stdout, stderr = self.ssh.exec_command("barvinok/iscc < _rel.txt")
wynik = stdout.readlines()
#print wynik
relp = isl.Set(wynik[0])
return relp
def test_schedule():
schedule = isl.Map("{S[t,i,j] -> [t,i,j]: 0 < t < 20 and 0 < i < j < 100}")
accesses = isl.Map("{S[t,i,j] -> bar[t%2, i+1, j-1]}")
context = isl.Set("{:}")
build = isl.AstBuild.from_context(context)
def callback(node, build):
schedulemap = build.get_schedule()
accessmap = accesses.apply_domain(schedulemap)
aff = isl.PwMultiAff.from_map(isl.Map.from_union_map(accessmap))
access = build.call_from_pw_multi_aff(aff)
return isl.AstNode.alloc_user(access)
build, callback_handle = build.set_at_each_domain(callback)
ast = build.ast_from_schedule(schedule)
def cb_print_user(printer, options, node):
print("Callback user called")
printer = printer.print_str("Callback user")
return printer
def cb_print_for(printer, options, node):
print("Callback for called")
printer = printer.print_str("Callback For")
return printer
opts = isl.AstPrintOptions.alloc(isl.DEFAULT_CONTEXT)
opts, cb_print_user_handle = opts.set_print_user(cb_print_user)
opts, cb_print_for_handle = opts.set_print_for(cb_print_for)
printer = isl.Printer.to_str(isl.DEFAULT_CONTEXT)
printer = printer.set_output_format(isl.format.C)
printer.print_str("// Start\n")
printer = ast.print_(printer, opts)
printer.print_str("// End")
print(printer.get_str())
def data_1():
program = vec_add()
partitioners_A = dist.partition(program['A'], [0], [4], [16], "row")
partitioners_B = dist.partition(program['B'], [0], [4], [16], "row")
partitioners_C = dist.partition(program['C'], [0], [4], [16], "row")
str_schedule = "{Send_A[p0, i1]->[0, p0, i1]; Send_B[p0, i1]->[1, p0, i1]; Receive_A[p0, i1]->[2, p0, i1]; Receive_B[p0, i1]->[3, p0, i1]; S0[i]->[4, 0, i]}"
context = isl.Set("[r0]->{:}")
return {
'S0_dom': program['S0_dom'],
'A': program['A'],
'B': program['B'],
'C': program['C'],
'Access_A': program['Access_A'],
'Access_B': program['Access_B'],
'Access_C': program['Access_C'],
'pr_partitioner_A': partitioners_A['pr'],
'ps_partitioner_A': partitioners_A['ps'],
'pr_partitioner_B': partitioners_B['pr'],
'ps_partitioner_B': partitioners_B['ps'],
'pr_partitioner_C': partitioners_C['pr'],
'ps_partitioner_C': partitioners_C['ps'],
'str_schedule': str_schedule,
'context': context
}
def data_3():
program = mat_mul_2D()
partitioners_A = dist.partition(program['A'], [0], [3], [12], "row")
partitioners_B = dist.partition(program['B'], [0], [3], [12], "row")
partitioners_C = dist.partition(program['C'], [0], [3], [12], "row")
str_schedule = "{Send_A[p0, i1, i2]->[0, p0, i1, i2]; Send_B[p0, i1, i2]->[1, p0, i1, i2]; Receive_A[p0, i1, i2]->[2, p0, i1, i2]; Receive_B[p0, i1, i2]->[3, p0, i1, i2]; S0[i, j, k]->[4, 0, i, j]}"
context = isl.Set("[r0, r1]->{:}")
return {
'S0_dom': program['S0_dom'],
'A': program['A'],
'B': program['B'],
'C': program['C'],
'Access_A': program['Access_A'],
'Access_B': program['Access_B'],
'Access_C': program['Access_C'],
'pr_partitioner_A': partitioners_A['pr'],
'ps_partitioner_A': partitioners_A['ps'],
'pr_partitioner_B': partitioners_B['pr'],
'ps_partitioner_B': partitioners_B['ps'],
'pr_partitioner_C': partitioners_C['pr'],
'ps_partitioner_C': partitioners_C['ps'],
'str_schedule': str_schedule,
'context': context
}
