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 }