def on_kernel(self, kernel_id): last_kernel = self.last_kernel self.last_kernel = kernel_id if not self.acc.is_empty(): if last_kernel is not None: self.kernels[last_kernel].finish = True domain = self.acc self.acc = isl.UnionSet("{ }", self.ctx.isl_context) writes = assign_map.intersect_domain(domain).range() writes = list({ s.get_tuple_name() for s in to_sets(writes) }) reads = use_map.intersect_domain(domain).range() reads = list({ s.get_tuple_name() for s in to_sets(reads) }) for v in reads: self.cpu_access(v, write=False) for v in writes: self.cpu_access(v, write=True) kernel = self.kernels[kernel_id] for v in kernel.reads: self.gpu_acccess(v, kernel_id, write=False) for v in kernel.writes: self.gpu_acccess(v, kernel_id, write=True)
def test_union_casts(): # https://github.com/inducer/islpy/issues/29 s1 = isl.UnionSet("{[0]}") s2 = isl.BasicSet("{[1]}") s2.union(s1) # works fine s1.union(s2) # does not work
def __init__(self, ctx, assign_map, use_map, arrays, domains, kernels): self.ctx = ctx self.assign_map = assign_map self.use_map = use_map self.arrays = arrays self.domains = domains self.kernels = kernels self.last_kernel = None self.acc = isl.UnionSet("{ }", ctx.isl_context)
def test_sched_constraints_set_validity(): domain = isl.UnionSet("[n] -> { A[i] : 0 <= i < n; B[i] : 0 <= i < n }") validity = isl.UnionMap("[n] -> { A[i] -> B[i] : 0 <= i < n }") sc = isl.ScheduleConstraints.on_domain(domain) sc = sc.set_validity(validity) validity2 = sc.get_validity() print(validity) print(validity2) assert str(validity) == str(validity2)
def tile(plik, block, permute, output_file="", L="0", SIMPLIFY="False", perfect_mode=False, parallel_option=False, rplus_mode='', cpus=2): print '' print colored('/\__ _\ /\ == \ /\ __ \ /\ ___\ /\ __ \ ', 'green') print colored('\/_/\ \/ \ \ __< \ \ __ \ \ \ \____ \ \ \/\ \ ', 'green') print colored(' \ \_\ \ \_\ \_\ \ \_\ \_\ \ \_____\ \ \_____\ ', 'green') print colored(' \/_/ \/_/ /_/ \/_/\/_/ \/_____/ \/_____/ ', 'green') print '' print ' An Automatic Parallelizer and Optimizer' print 'based on the ' + colored('TRA', 'green') + 'nsitive ' + colored( 'C', 'green') + 'l' + colored('O', 'green') + 'sure of dependence graphs' print ' traco.sourceforge.net ' print '' print 'TIME SPACE TILING Module' LPetit = "tmp/tmp_petit" + L + ".t" BLOCK = block.split(',') BLOCK2 = BLOCK for i in range(len(BLOCK), 10): BLOCK.append(BLOCK[len(BLOCK) - 1]) linestring = open(plik, 'r').read() lines = linestring.split('\n') petit_loop = convert_loop.convert_loop(lines) file = open(LPetit, 'w') imperf = 0 endloop = 0 startloop = 0 for line in petit_loop: #sprawdz przy okazji jaka petla idealnie czy nie if 'for' in line and not 'endfor' in line: if startloop == 2: imperf = 1 startloop = 1 else: if startloop == 1: startloop = 2 if 'endfor' in line: endloop = 1 if endloop == 1 and 'endfor' not in line and not line.isspace( ) and line != '': imperf = 1 file.write(line + '\n') file.close() start = time.time() loop = Dependence.Kernel_Loop(LPetit, 1) loop.Load_Deps() loop.Load_instrukcje() loop.PreprocessPet() loop.Get_Arrays() end = time.time() elapsed = end - start print "Dependence analysis: time taken: ", elapsed, "seconds." print colored('R', 'green') print loop.isl_rel isl_symb = loop.Deps[0].Relation.get_var_names(isl.dim_type.param) symb_prefix = '' if len(isl_symb) > 0: symb_prefix = '[' + ','.join(isl_symb) + '] -> ' cl = clanpy.ClanPy() cl.loop_path = plik cl.Load() arr = map(int, loop.dane) arr = sorted(list(set(arr))) for i in range(0, len(cl.statements)): cl.statements[i].petit_line = arr[i] cl.statements[i].bounds = tiling_v5.GetBounds( petit_loop, cl.statements[i].petit_line, BLOCK2, 0) print cl.statements[i].scatering for i in range(0, len(cl.statements)): cl.statements[i].domainpet = isl.Set( symb_prefix + ' { S' + str(cl.statements[i].petit_line) + '[' + ','.join(cl.statements[i].original_iterators) + '] : ' + cl.statements[i].domain + '}') #print cl.statements[i].domainpet IS = isl.UnionSet(str(cl.statements[0].domainpet)) for i in range(1, len(cl.statements)): IS = IS.union(cl.statements[i].domainpet) IS = IS.coalesce() print colored('IS', 'green') print IS #isl schedule text = 'R:= ' + str(loop.isl_rel) + '; IS := ' + str( IS) + '; schedule IS respecting R minimizing R;' print colored('ISL output', 'green') sched_dump = iscc.iscc_communicate(text) print sched_dump lines = sched_dump.split('\n') sched_maps = sched_parser.parse(lines, cl, symb_prefix) print colored('ISL schedules', 'green') for m in sched_maps: print m SCHED = isl.UnionMap(str(sched_maps[0])) for i in range(1, len(sched_maps)): SCHED = SCHED.union(sched_maps[i]) SCHED = SCHED.coalesce() #SCHED = isl.UnionMap('[N] -> { S27[i, j] -> [-i + j, 2,j] : N > 0 and 0 <= i <= -2 + N and i < j < N; S20[i, j, k] -> [-i + j, 0,0,1,k] : N > 0 and 0 <= i <= -2 + N and 2 + i <= j < N and i < k < j; S23[i, j, k] -> [-i + j, 0,k,2, j] : N > 0 and 0 <= i <= -2 + N and 2 + i <= j < N and i < k <= -2 + j; S26[i, j] -> [-i + j, 1,j] : N > 0 and 0 <= i <= -2 + N and i < j < N; S16[i, j, k, m] -> [-i + j, 0,k, 0,m] : N > 0 and 0 <= i <= -2 + N and 2 + i <= j < N and i < k <= -2 + j and k < m <= -3 - i + j + k and m < j }') #SCHED = isl.UnionMap('[n, loop] -> { S12[l, i, k] -> [l,i,k] : n >= 2 and loop > 0 and 0 < l <= loop and 0 < i < n and 0 <= k < i }') print colored('SCHED', 'green') print SCHED #print colored('deltas R', 'green') # SPACE # wykryj liczbe na razie globalnie islR = Scatter(loop.isl_rel, cl, True) D = loop.isl_rel.deltas() spaces_num = sys.maxint for i in range(0, len(cl.statements)): depth = len(cl.statements[i].original_iterators) nums = 0 for j in range(0, depth): direct = ' < ' print cl.statements[i].bounds[j]['step'] # decrementation if cl.statements[i].bounds[j]['step'] == '-1': direct = ' > ' TEST = '{ S' + str(cl.statements[i].petit_line) + '[' + ','.join( cl.statements[i].original_iterators) + '] : ' + cl.statements[ i].original_iterators[j] + direct + ' 0 }' print TEST TEST = isl.Set(TEST) TEST = D.intersect(TEST) if (TEST.is_empty()): nums = nums + 1 else: break # sa ujemne # print nums if (nums < spaces_num): spaces_num = nums print colored('SPACES NUMBER', 'green') print spaces_num if spaces_num == 0 or 1 == 1: print 'No spaces or manually input calculated number' spaces_num = int(raw_input()) # vars vars = [] sym_exvars = [] for st in cl.statements: if (len(st.original_iterators) == loop.maxl): vars = st.original_iterators break for v in vars: sym_exvars.append(v * 2) ################################## SPACES = {} space = '' for st in cl.statements: tmpspaces = [] for i in range(0, spaces_num): space = st.domainpet space = space.insert_dims(isl.dim_type.param, 0, 1) space = space.set_dim_name(isl.dim_type.param, 0, sym_exvars[i]) space = str(space) space = space.replace( '}', MakesSpaceConstr(st, vars, sym_exvars, isl_symb, BLOCK, i)) print space space = isl.Set(space) tmpspaces.append(space) #print space SPACES["S" + str(st.petit_line)] = tmpspaces ################################## #experimental Rk if False: print "==============================================" spaceunion = None for s in SPACES: print s tmpspace = None for ss in SPACES[s]: if tmpspace is None: tmpspace = isl.UnionSet(str(ss)) else: tmpspace = tmpspace.union(ss).coalesce() if spaceunion is None: spaceunion = tmpspace else: spaceunion = spaceunion.union(tmpspace).coalesce() if (1 == 0): print "Experimental Rk" print "SPACE" print spaceunion print "new R" R = loop.isl_rel.from_domain_and_range(spaceunion, spaceunion).coalesce() print R #Rk = R.power() #print "Rk" print Rk print "==============================================" ################################### sched_maps_i = sched_maps #SCHED_1 SCHED_2 TIMES = [] if (spaces_num < cl.maxdim): print colored("SCHED_1:=SCHED^-1", 'green') for i in range(0, len(sched_maps_i)): sched_maps_i[i] = sched_maps_i[i].fixed_power_val(-1).coalesce() print sched_maps_i[i] #if i == 3: # sched_maps_i[i] = isl.Map('[N] -> {[i0, 0] -> S20[i, j = i0 + i]: N > 0 and 0 <= i <= -2 + N and i0=1}') TIMES.append(sched_maps_i[i]) tmp = '' if ("i0" in str(TIMES[i])): TIMES[i] = TIMES[i].insert_dims(isl.dim_type.param, 0, 1) TIMES[i] = TIMES[i].set_dim_name(isl.dim_type.param, 0, 'c') TIMES[i] = TIMES[i].insert_dims(isl.dim_type.param, 0, 1) TIMES[i] = TIMES[i].set_dim_name(isl.dim_type.param, 0, 'i0') tmp = str(TIMES[i]) if 'i1' in tmp: v = 'i1' else: v = 'i0' tmp = tmp.replace('}', " && " + str(BLOCK[spaces_num]) + "c<=" + v + "<=" + str(BLOCK[spaces_num]) + "*(c+1)-1 && i0=i0' }") # podmien na bloki else: tmp = str(TIMES[i]) TIMES[i] = isl.Map(tmp).range() print colored("TIMEi", 'green') for s in TIMES: print s print colored("TIME", 'green') else: print colored("TIME: all distance vectors elements are positive", 'green') for i in range(0, len(sched_maps_i)): TIMES.append(sched_maps_i[i].subtract( sched_maps_i[i]).complement().domain().coalesce()) ######################################### TIMES experimental code TIME = isl.UnionSet(str(TIMES[i])) for i in range(1, len(TIMES)): TIME = TIME.union(TIMES[i]) TIME = TIME.coalesce() print TIME ######################################### TILES = [] for i in range(0, len(TIMES)): TILES.append(TIMES[i]) for j in range(0, spaces_num): TILES[i] = TILES[i].intersect( SPACES['S' + str(cl.statements[i].petit_line)][j]).coalesce() TILE = isl.UnionSet(str(TILES[0])) for i in range(1, len(TILES)): TILE = TILE.union(TILES[i]) TILE = TILE.coalesce() print colored("TILE", 'green') print TILE print "Making MAP %%%" ########################################### # MAKE MAP TILE = str(TILE).split('->')[1] # j=i-i0 crazy thing #################################################### wstawia oryginalne iteratory, dodaje rownania i scattering strTILE = TILE.split(';') for st in cl.statements: s = 'S' + str(st.petit_line) for i in range(0, len(strTILE)): if s in strTILE[i]: res = re.findall(r'S\d+\[[^\]]+', strTILE[i]) a = st.scatering b = st.original_iterators[:] for k in range(0, st.getDim()): if st.bounds[k]['step'] == '-1': b[k] = '-' + b[k] if (len(a) < cl.maxdim + 1): for k in range(len(a), cl.maxdim + 1): #wyrownaj zerami a.append(u'0') if (len(b) < cl.maxdim): for k in range(len(b), cl.maxdim): #wyrownaj zerami b.append(u'0') c = a + b #scatter c[::2] = a c[1::2] = b strTILE[i] = strTILE[i].replace(res[0], s + '[' + ','.join(c)) res = res[0].split('[')[1].replace(' ', '').split(',') for r in res: if '=' in r: strTILE[i] = strTILE[i].replace( ':', ': ' + r + ' and ') break else: continue TILE = ';'.join(strTILE) print TILE ##################################################### arr = [] arr.append('t') timet = [] if spaces_num == 0: timet.append('0') for i in range(0, spaces_num): arr.append(sym_exvars[i]) timet.append(sym_exvars[i]) arr.append('i0') arr.append('c,') arr = ','.join(arr) TILE = TILE.replace('[', '[' + arr) timet = ' t = ' + '+'.join(timet) if (spaces_num >= cl.maxdim): # dodatnie wektory timet += ' and c = 0 and i0 = 0 ' TILE = symb_prefix + TILE.replace(':', ':' + timet + ' and ') for st in cl.statements: s = 'S' + str(st.petit_line) TILE = TILE.replace( s, s + '[' + ','.join(st.original_iterators) + '] -> ') print colored("MAP", 'green') print TILE print 'MAP in ISL' print isl.UnionMap(TILE).coalesce() #loop_x = iscc.iscc_communicate("L :=" + str(TILE) + "; codegen L;") #print loop_x print colored("ISL AST", 'green') loop_x = iscc.isl_ast_codegen_map(isl.UnionMap(TILE)) print loop_x # ************************************************************************** lines = loop_x.split('\n') # *********** post processing **************** print colored("POSTPROCESSING", 'green') loop_str = [] for line in lines: if line.endswith(');'): tab = imperf_tile.get_tab(line) line = line.replace(' ', '') line = line[:-2] line = line[1:] line = line.split('(') petit_st = line[0].replace('S', '') line = line[1] arr = line.split(',') s = '' for i in range(0, len(cl.statements)): # TODO if petit_st has 'c' get all statements make if from petit_line and insert to s, solution for loop over st if 'c' in petit_st: combo_st = '{' for j in range(0, len(cl.statements)): combo_st += '\n' + tab combo_st += 'if( ' + petit_st + ' == ' + str(cl.statements[j].petit_line) + ' ) ' + \ cl.statements[j].body s = combo_st + '\n' + tab + '}' elif cl.statements[i].petit_line == int( petit_st): # st.petit_line s = cl.statements[i].body for i in range( 0, len(vars) ): # todo oryginal iterators for loops with mixed indexes if (i + 1 > len(arr)): continue subt = arr[i] if (('+' in subt) or ('-' in subt)): subt = '(' + subt + ')' s = re.sub(r'\b' + vars[i] + r'\b', subt, s) loop_str.append(tab + s) else: line = line.replace('for (int', 'for(') loop_str.append(line) # *********** post processing end **************** if (1 == 1): for line in loop_str: if 'for( c1 ' in line and spaces_num < cl.maxdim: print imperf_tile.get_tab(line) + colored( '#pragma omp parallel for', 'green') print line # VALIDITY # Lex_Neg2:=[N]->{ [i0, i1]: (i0=0 and i1=0 ) or i0<0 or i0=0 and i1<0 }; # VALIDITY SCHED2 = Scatter(SCHED, cl, False) L = 2 * cl.maxdim + 1 lexvar = ["i%d" % i for i in range(0, L)] lexneg = '{[' + ','.join(lexvar) + '] : (' for i in range(0, L): lexneg += lexvar[i] + '=0' + ' and ' lexneg += '1=1) or ' for i in range(0, L): lexneg += lexvar[i] + ' < 0 and ' for j in range(0, i): lexneg += lexvar[j] + ' = 0 and ' lexneg += ' 1 = 1 or ' lexneg += ' 1 = 0 }' lexneg = isl.Set(lexneg) C = (SCHED2.fixed_power_val(-1).apply_range(islR)).apply_range(SCHED2) P = C.deltas().intersect(lexneg).coalesce() if P.is_empty(): print colored('VALIDATION OK', 'green') else: print colored('VALIDATION FAILED !!', 'red') print colored('lexneg', 'yellow') print lexneg print colored('C = (SCHED^-1(R))(SCHED)', 'yellow') print C print colored('P = C.deltas()', 'yellow') print C.deltas() print colored('P*C', 'yellow') print P for d in loop.Deps: del d.Relation
# for(i=1; i<=N; i++) # for(j=0; j<=N; j++) # S1[i,j]: Z[i,j] = f(Z[i-1,j]); # # | # v # # for(j=0; j<=N; j++) # for(i=1; i<=N; i++) # S1[i,j]: Z[i,j] = f(Z[i-1,j]); # import islpy as isl import common ### fill in the original iteration space (domain)---set of stmt instances I = isl.UnionSet("[N] -> { ... }") ### fill in the original schedule---relation mapping stmts to time Sini = isl.UnionMap("[N] -> { ... }").intersect_domain(I) print("Initial Schedule:") print(Sini) ### fill in the write/read access relations---mapping stmts to read/written array elements Write = isl.UnionMap("[N] -> { ... }").intersect_domain(I) Read = isl.UnionMap("[N] -> { ... }").intersect_domain(I) Dep = common.mkDepGraph(Sini, Read, Write) print("Dependency graph is:") print(Dep) ### Most Importantly: fill in the new schedule representing the loop
def test_union_map(): d = isl.UnionSet("[start, num] -> {S[i,j] : start <= i,j < start + num}") s = isl.UnionMap("{S[i,j] -> [i,j]}").intersect_domain(d) aw = isl.UnionMap("{S[i,j] -> B[1024 i + j]}") aw.compute_flow(aw, aw, s)
# for(j=0; j<=N; j++) # S2: X[j] = g(Y[j]) # | # V # for(p=0; p<=N; p++) { # S1: Y[p] = Z[N-p]; # S2: X[p] = Y[p]; # } # A[i] == A[0,i] # B[i] == A[1,i] # C[i] == A[2,i] import islpy as isl import common I = isl.UnionSet("[N] -> {S1[i]: 0<=i<=N; S2[j]: 0<=j<=N}") Sini = isl.UnionMap( "[N] -> {S1[i] -> [1,i]; S2[j] -> [2,j]}").intersect_domain(I) print("Initial Schedule:") print(Sini) Write = isl.UnionMap( "[N] -> {S1[i] -> Y[N-i]; S2[j] -> X[j]}").intersect_domain(I) Read = isl.UnionMap( "[N] -> {S1[i] -> Z[i]; S2[j] -> Y[j]}").intersect_domain(I) Dep = common.mkDepGraph(Sini, Read, Write) print("Dependency graph is:") print(Dep) Snew = isl.UnionMap( "[N] -> {S1[p] -> [N-p,1]; S2[j] -> [j,2]}").intersect_domain(I)
### # for(p=1; p<=N; p++) # S1: Y[p] = f(Z[p]); # S2: X[p] = g(Y[p+1]) # | # V # for(i=1; i<=N; i++) # S1: Y[i] = f(Z[i]); # # for(j=1; j<=N; j++) # S2: X[j] = g(Y[j+1]) import islpy as isl import common I = isl.UnionSet("[N] -> {S1[p]: 1<=p<=N; S2[p]: 1<=p<=N}") Sini0 = isl.UnionMap("[N] -> { S1[p] -> [p,1]; S2[p] -> [p,2] }") Sini = Sini0.intersect_domain(I) print("Initial Schedule:") print(Sini) Write = isl.UnionMap("[N] -> {S1[p] -> Y[p]; S2[p] -> X[p]}").intersect_domain( I) Read = isl.UnionMap( "[N] -> {S1[p] -> Z[p]; S2[p] -> Y[p+1]}").intersect_domain(I) Dep = common.mkDepGraph(Sini, Read, Write) print("Dependency graph is:") print(Dep) Snew = isl.UnionMap( "[N] -> {S1[i] -> [1,i]; S2[j] -> [2,j]}").intersect_domain(I)
cmd += 'IND := Domain - LDR;' cmd += 'print "IND";' cmd += 'print IND;' ####################################################################### # RESULT TO ISLPY output = loop_x = iscc.iscc_communicate(cmd) output = output.split('\n') schedule = output[1] ld = output[3] rel = output[11] ind = output[13] ld = isl.UnionSet(ld) ind = isl.UnionSet(ind) schedule = isl.UnionMap(schedule) strrel = rel rel = isl.UnionMap(rel) print rel print schedule ######################################################################## rels = strrel.split(';') prefix = re.findall(r'[^{]*{', rels[0])[0] maps = [] for q in rels:
# } # | # Change of variables: p <- i+j, q <- j # | # V # for(int p=2; p < 2*N-1; p++) { # int up_bd = ((p+2)/2) + (p%2); # for(int q=max(1,p-N+1); q<min(up_bd,N); q++) { # S1: X[p-q][q] = X[p-q-1][q] + X[p-q][q-1]; # } # } import islpy as isl import common I = isl.UnionSet("[N] -> {S1[i,j]: 1<=i<N and 1<=j<min(i+2, N)}") Sini0 = isl.UnionMap("[N] -> { S1[i,j] -> [i,j] }") Sini = Sini0.intersect_domain(I) print("Initial Schedule:") print(Sini) print(I) Write = isl.UnionMap("[N] -> {S1[i,j] -> X[i,j]}").intersect_domain(I) Read = isl.UnionMap( "[N] -> {S1[i,j] -> X[i-1,j]; S1[i,j] -> X[i,j-1]}").intersect_domain(I) Dep = common.mkDepGraph(Sini, Read, Write) print("Dependency graph is:") print(Dep) #Inew = isl.UnionSet("[N] -> {S1[p,q]: 2<=p<2*N-1 and max(1,p-N+1)<=q<min((p+2)/2 + (p mod 2), N)}") Snew = isl.UnionMap("[N] -> {S1[x,q] -> [x+q,q]}").intersect_domain(I)
def NewTileGen(block_set, sym_exvars, vars, _SYM, symb, p_symb, par_tiling, rel, schedule, instrukcje): block_set = "BL := " + block_set[0] + ";" #print block_set R = "R := [" R = R + _SYM # dodaj zmienne symb ilorazow if (par_tiling): for i in range(0, len(sym_exvars)): R = R + " fff" + str(i) + "," R = R[:-1] + "] -> {[" for s in vars: R = R + s + "," R = R + "v] -> [" for s in sym_exvars: R = R + s + "," for s in vars: R = R + s + "," R = R + "v] : " if (par_tiling): for i in range(0, len(sym_exvars)): R = R + " " + sym_exvars[i] + "<= fff" + str(i) + " and " R = R + " true };" isl_BL = isl.Set(str(block_set).replace("BL := ", "")) isl_R = isl.Map(str(R).replace("R := ", "")) isl_BL = isl_BL.apply(isl_R).coalesce() isl_BL1 = isl_BL.project_out(isl._isl.dim_type.param, 0, len(sym_exvars)).coalesce() BL = iscc_communicate(block_set + R + "BL := R(BL);BL;") with open("tmp/barv_tiling.txt", "a") as myfile: myfile.write(block_set + R + "BL := R(BL);BL;") # usun symexvars z symb BL = BL.split("->") z = "[" for s in symb: z = z + s + "," for s in p_symb: z = z + s + "," if (par_tiling): for i in range(0, len(sym_exvars)): z = z + " fff" + str(i) + "," if (z != "["): z = z[:-1] z = z + "] -> " # poprawka gdyby za ii jj wejdzie stala pat = "\[" + "\w+,\s*" * len(vars) regex = re.compile(pat) tmp = "[" for s in sym_exvars: tmp = tmp + s + ", " BB = re.sub(pat, tmp, BL[1]) BL = "BL1 := " + z + BB + ";" if 0 == 1: Setii = iscc_communicate(BL + "BL1;") print Setii start = time.time() loop = iscc_communicate(BL + "codegen BL1;") islSet = isl.UnionSet(str(z + BB)) codegen_ultra.codegen(islSet, instrukcje, len(sym_exvars), vars, sym_exvars) #sys.exit() with open("tmp/barv_tiling.txt", "a") as myfile: myfile.write(BL + "codegen BL1;") end = time.time() elapsed = end - start print "Time taken: ", elapsed, "seconds." loops = [] loops.append(loop) if (schedule == 0): return loops else: ##### OBLICZANIE REPR TILE nloop = "" srepr = "" with open('sources_of_slices.txt') as f: content = f.readlines() srepr = content[0] tmp = "" for s in sym_exvars: tmp = tmp + s + "," srepr = srepr.replace("{ [", "{ [" + tmp) srepr = srepr.replace("{[", "{ [" + tmp) Rel_Z = "R := {[" for i in range(0, 2 * len(sym_exvars)): Rel_Z = Rel_Z + "i" + str(i) + "," Rel_Z = Rel_Z + "m] -> [" for i in range(0, len(sym_exvars)): Rel_Z = Rel_Z + "i" + str(i) + "," Rel_Z = Rel_Z[:-1] + "] };" output = iscc_communicate( BL + "Srepr := " + srepr + ";" + Rel_Z + "B := BL1 * Srepr;card B;print \"###\";codegen R(B);").split( '"###"') srepr_loop = output[1] ile = output[0] fs = 0 if ("{ 1 :" in ile): fs = 1 # --------- tmp = BL[:-1].replace("BL1 := ", "") rs = tmp + "->" + tmp + ";" #rs = iscc_communicate(tmp + "->" + tmp + ";") I = "I :={[" for i in range(0, len(sym_exvars)): I = I + "i" + str(i) + "," I = I[:-1] + "] -> [" for i in range(0, len(sym_exvars)): I = I + "i" + str(i) + "," I = I[:-1] + "]};" start = time.time() rpaczka = iscc_communicate('R:=' + rel + ';Rst := R^+;Rst;' + I + 'Rst+I;') rpaczka = rpaczka.split('\n') rplus = rpaczka[0] rstar = rpaczka[1] #rstar = iscc_communicate('R:=' + rel + ';'+I+'R^+ + I;') end = time.time() elapsed = end - start print "Time taken: ", elapsed, "seconds." tmp = "" tmp2 = "" for s in sym_exvars: tmp = tmp + s + "," tmp2 = tmp2 + s + "'," rplus = rplus.replace("{ [", "{ [" + tmp) rplus = rplus.replace("-> [", "-> [" + tmp2) rplus = rplus.replace("; [", "; [" + tmp) rstar = rstar.replace("{ [", "{ [" + tmp) rstar = rstar.replace("-> [", "-> [" + tmp2) rstar = rstar.replace("; [", "; [" + tmp) rt_red = rel rt_red = rt_red.replace("{ [", "{ [" + tmp) rt_red = rt_red.replace("-> [", "-> [" + tmp2) rt_red = rt_red.replace("; [", "; [" + tmp) sym_tmp = [] rlex = "RLEX := {[" for s in sym_exvars: rlex = rlex + s + "," sym_tmp.append(s + "'") rlex = rlex[:-1] + '] -> [' for s in sym_exvars: rlex = rlex + s + "'," rlex = rlex[:-1] + '] : ' rlex = rlex + CreateLex(sym_tmp, sym_exvars, len(sym_exvars)) + "};" rs = iscc_communicate( "RS := " + rs + "Rplus := " + rstar + ";RS*Rplus;", 0) #rp = iscc_communicate("RS := " + rs + ";Rplus := " + rplus + ";RS*Rplus;", 0) rt_red = iscc_communicate( "RS:= " + rs + ";RTRED := " + rt_red + ";RS*RTRED;", 0) rs = iscc_communicate(rs + ";", 1).split('\n')[0] rs = RelationExists(rs, len(sym_exvars), symb) srepr_loop = srepr_loop.split('\n') for i in range(0, len(srepr_loop)): if "for" in srepr_loop[i]: srepr_loop.insert(i, "#pragma omp parallel for") break st_reg = re.compile('\s*\(.*\);') vecs = [] taby = [] for line in srepr_loop: if (st_reg.match(line)): vecs.append(s1_to_vec(line, len(vecs))) taby.append(correct.whites(line)) #R_T = iscc_communicate("RS := " + rs + ";RS;") cmd = "RT :=" + rs + ";" for i in range(0, len(vecs)): cmd = cmd + vecs[i] + "codegen RT(S" + str(i) + ');print "###";' cmd = iscc_communicate(cmd) cmd = cmd.split('"###"') new_loop = [] i = 0 for line in srepr_loop: if (st_reg.match(line)): petla = cmd[i].split('\n') for s in petla: new_loop.append(taby[i] + s) i = i + 1 else: new_loop.append(line) #print new_loop nloop = "" for line in new_loop: if line != '': nloop = nloop + line + "\n" nloop = nloop[:-1] loops.append(nloop) #fs = 1 if (fs == 1): UDS = iscc_communicate('R := ' + rel + ";dom R - ran R;") tmp = "{ [" for s in sym_exvars: tmp = tmp + s + "," UDS = UDS.replace("{ [", tmp) UDS = UDS.replace("; [", tmp) tuds = iscc_communicate(BL + 'UDS := ' + UDS + ';' + Rel_Z + 'R(BL1*UDS);') rt_red = iscc_communicate(rt_red + ";", 1).split('\n')[0] rt_red = RelationExists(rt_red, len(sym_exvars), symb) rk = iscc_communicate(rlex + 'RT_RED := ' + rt_red + "*RLEX;pow RT_RED;") #rk = iscc_communicate('RT_RED := ' + rt_red + ";"+I+"Z := RT_RED-I;pow Z;") rk = RepairRk(rk, 1) #S(k) = Rk (TILE_UDS) - R_T+ compose Rk (TILE_UDS) cmd_sk = rlex + I + "Rk := " + rk + ";TUDS :=" + tuds + ";" + 'RT_RED := ' + rt_red + "*RLEX;RP :=RT_RED^+;Sk := Rk(TUDS) - RP(Rk(TUDS));Sk;" #cmd_sk = I + "Rk := " + rk +";TUDS :=" + tuds + ";" + "RP :=" + rp +"-I;Sk := Rk(TUDS) - RP(Rk(TUDS));Sk;" sk = iscc_communicate(cmd_sk) reg = re.compile("^[^{]+") tmp = "[" for s in symb: tmp = tmp + s + "," tmp = tmp[:-1] + "] -> " sk = reg.sub(tmp, sk) sk = sk.replace("{ [", "{ [k,") sk = sk.replace("; [", "; [k,") #print sk tudsk = tuds.replace("{ [", "{ [0,") tudsk = tudsk.replace("; [", "; [0,") fsloop = iscc_communicate("Sk := " + sk + ";TUDS := " + tudsk + ";Sk := Sk + TUDS; codegen Sk;") #usun k z symb i dodaj na poczatek krotek loops.append(fsloop) return loops