def tile(plik, block):
EXP_CODE = True
TilCompl = Complex()
BLOCK = block.split(',')
par_tiling = False
for i in range(len(BLOCK), 10):
BLOCK.append(BLOCK[len(BLOCK) - 1])
if (not BLOCK[0].isdigit()):
par_tiling = True
#EXP_CODE = False # nie ma wsparcia na razie dla gen. poszerzonego zbioru dla spar. tilingu, petle zewn. generowane sa z strings
linestring = open(plik, 'r').read()
lines = linestring.split('\n')
petit_loop = convert_loop.convert_loop(lines)
file = open("tmp/tmp_petit.t", 'w')
for line in petit_loop:
file.write(line + '\n')
file.close()
#zapisz zaleznosci
cmd = gen.path_petit + " tmp/tmp_petit.t > tmp/deps.txt"
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
process.wait()
#prywatyzacja
priv_stuff = priv_engine.PrivEng("tmp/deps.txt")
lines = linestring.split('\n')
stuff = []
for line in lines:
if 'for' in line:
stuff.append(functions.Loop(line))
if (DEBUG):
print stuff
start = time.time()
if (schedule_mode == 1):
flag = 0
else:
flag = 1
#pobierz relacje zaleznosci
if (os.path.exists('rel.txt')):
with open('rel.txt', 'r') as content_file:
dane = content_file.read()
else:
if (len(priv_stuff[1]) > 0 and
(priv_stuff[2] == 1 or False)): # jest par czyli mozna tiling
dane = gen.RelPrint_WithPriv("tmp/tmp_petit.t", priv_stuff[1])
else:
dane = gen.RelPrint("tmp/tmp_petit.t", flag)
output = process.stdout.read()
end = time.time()
elapsed = end - start
print "Time taken: ", elapsed, "seconds."
dane = dane.split("#")
rel = dane[0]
rel2 = rel
dane.remove(rel)
dane = list(set(dane))
# -------------------------------------------------------
# script for barvinok
# gdy nie ma zaleznosci
# problemy do rozwiazania
# zmienne symboliczne nie wiadomo skad wziasc
# numery instrukcji
nodeps = 0
if (rel == ''):
nodeps = 1
rel = "{["
for i in range(0, len(stuff)):
rel = rel + "i" + str(i) + ","
rel = rel + "v] -> ["
for i in range(0, len(stuff)):
rel = rel + "i" + str(i) + "',"
rel = rel + "v'] : false }"
loop_tools.MakeLDPetit("tmp/tmp_petit.t", "tmp/tmp_ld_petit.t")
dane = gen.RelPrint("tmp/tmp_ld_petit.t", 1)
dane = dane.split("#")
rel2 = dane[0]
dane.remove(rel2)
dane = list(set(dane))
for s in dane:
if "UNKNOWN" in s:
dane.remove(s)
# ISL ================================================================
#isl_rel = isl.Map(str(rel))
#isl_relclosure = isl_rel.transitive_closure()[0].coalesce()
#isl_symb = isl_rel.get_var_names(isl.dim_type.param)
#TilCompl.symb = isl_symb
#print dane
combo = loop_tools.ReadStatementNests("tmp/tmp_petit.t", dane)
instrukcje = combo[0]
nest_loop = combo[1]
if len(instrukcje) == 0:
print 'blad - brak instrukcji'
sys.exit()
# wczytaj wszystkie
# eksperymentalnie kasowanie innych poziomow
stuff_reduced = stuff[:] #osobna kopia
do_kas = []
for i in range(1, max(nest_loop) + 1):
dups = duplicates(nest_loop, i)
for s in dups:
if s != min(dups):
do_kas.append(s)
for item in do_kas:
stuff_reduced[item] = '!'
for i in range(0, stuff_reduced.count('!')):
stuff_reduced.remove('!') # remove
# -------------------------------
file = open("tmp/barv_tiling.txt", 'w')
file.write('R:=' + rel + ';\n')
if (DEBUG):
file.write('print "R";')
file.write('R;')
file.write('Rstar:= R^+;')
if (DEBUG):
file.write('print "Rstar";')
file.write('Rstar;')
find_symb = re.compile("^[^(\]|\{)]*\]")
if (rel2 == rel):
tmp = re.findall(find_symb, rel)
else:
tmp = re.findall(find_symb, rel2)
symb = []
if (len(tmp) > 0):
symb = tmp[0]
symb = symb.replace("[", "")
symb = symb.replace("]", "")
symb = symb.replace(" ", "")
symb = symb.split(",")
vars = [] # i
exvars = [] # ii'
sym_exvars = [] # ii
varsprim = [] # i'
par_vars = [] # iib
p_vars = [] #iib bez plusa lb
p_symb = []
# moze warto do iloczynu dodac lb a do floor N - lb
# do testowania +'+'+s['lb']
i = 0
for s in stuff_reduced:
vars.append(s['var'])
sym_exvars.append(s['var'] * 2)
exvars.append(s['var'] * 2 + "'")
varsprim.append(s['var'] + "'")
if par_tiling:
par_vars.append(s['var'] * 2 + 'b' + '+' + s['lb'])
p_vars.append(s['var'] * 2 + 'b')
else:
par_vars.append(s['var'] * 2 + "*" + BLOCK[i] + '+' + s['lb'])
i = i + 1
_SYM = ""
for s in sym_exvars:
_SYM = _SYM + s + ","
for i in range(len(vars), 10):
BLOCK.pop()
if (par_tiling):
for s in p_vars:
_SYM = _SYM + s + ","
p_symb.append(s)
for s in set(BLOCK): #remove duplicates
_SYM = _SYM + s + ","
p_symb.append(s)
for s in symb:
_SYM = _SYM + s + ","
#imperf
#lexarrays = imperf_tile.get_array(instrukcje, sym_exvars, stuff_reduced, symb, _SYM[:-1], BLOCK)
#print lexarrays
isl_Bij = ""
for i in range(0, len(instrukcje)):
Bij = MakeBij(_SYM, vars, sym_exvars, par_vars, stuff, BLOCK,
instrukcje[i])
isl_Bij_temp = isl.Set(str(Bij).replace("_Bij := ", ""))
#print isl_Bij
file.write(Bij)
if (i == 0):
file.write('Bij := _Bij;')
isl_Bij = isl_Bij_temp
else:
file.write('Bij := Bij + _Bij;')
isl_Bij = isl_Bij.union(isl_Bij_temp).coalesce()
#print isl_Bij
if (DEBUG):
file.write('print "Bij";')
file.write('Bij;')
for i in range(0, len(instrukcje)):
BLGT = MakeBLTandBGT_v2(_SYM, vars, sym_exvars, par_vars, varsprim,
exvars, stuff, BLOCK, instrukcje[i])
file.write(BLGT[0])
file.write(BLGT[1])
if (i == 0):
file.write('BLT := _BLT;')
file.write('BGT := _BGT;')
else:
file.write('BLT := BLT + _BLT;')
file.write('BGT := BGT + _BGT;')
#file.write(BLGT[0])
if (DEBUG):
file.write('print "BLT";')
file.write('BLT;')
#file.write(BLGT[1])
if (DEBUG):
file.write('print "BGT";')
file.write('BGT;')
file.write('X:= Rstar(BGT);')
file.write('BCUR:=Bij - X;')
if (DEBUG):
file.write('print "BCUR";')
file.write('BPREV:= Rstar(BCUR) * BLT;')
if (DEBUG):
file.write('print "BPREV";')
file.write('BPREV;')
file.write('BLOCK:= BCUR + BPREV;')
if (DEBUG):
file.write('print "BLOCK";')
file.write('BLOCK;')
file.write('print "$#$";')
file.write('BLOCK;')
file.write('print "$$$#$$$";')
if (schedule_mode):
file.write('codegen BLOCK;')
#file.write('BLOCK;')
file.close()
# -------------------------------------------------------
cmd = barv_script + " < tmp/barv_tiling.txt"
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
process.wait()
output = process.stdout.read()
end = time.time()
elapsed = end - start
print "Time taken: ", elapsed, "seconds."
if (DEBUG):
print output
lines = output.split("\n")
if (DEBUG):
for i in range(0, lines.index('"$#$"') + 1):
lines.pop(0)
block_set = []
for i in range(0, lines.index('"$$$#$$$"') + 1):
block_set.append(lines.pop(0))
block_set.pop()
lines = filter(lambda x: x != '', lines)
#dodaj s1 do petli
loop = postprocess_loop(lines)
bl_2half = loop
#eksperymentalnie
if (EXP_CODE):
loops = iscc.NewTileGen(block_set, sym_exvars, vars, _SYM, symb,
p_symb, par_tiling, rel, schedule_mode,
instrukcje)
loop_x = loops[0]
loop_x = postprocess_loop(loop_x.split('\n'))
loop = loop_x
#zmienne
v = ""
for s in stuff_reduced:
v = v + s['var'] + ","
v = v + "v"
text_file = open("names_info.txt", "w")
text_file.write(v)
text_file.close()
#print block_set # tu mozna rozszerzyc
#pseudokod
text_file = open("pseudocode.txt", "w")
text_file.write(loop)
text_file.close()
#przywroc instrukcje
if (EXP_CODE):
gen.ParsePrint2("tmp/tmp_petit.t", len(sym_exvars))
else:
gen.ParsePrint("tmp/tmp_petit.t")
filePaths = glob.glob(plik)
for filePath in filePaths:
base = os.path.basename(filePath)
nazwa = os.path.splitext(base)[0] + "_tiling" + os.path.splitext(
base)[1]
# usun puste linie i kopiuj
file = open("out_pseudocode.txt", 'r')
lines = file.readlines()
# oryginalny z elsami
lines_block = lines[:]
if par_tiling and not EXP_CODE:
for i in range(0, len(sym_exvars)):
lines.insert(
0, 'register int ' + sym_exvars[i] + 'b=' + sym_exvars[i] +
"*" + BLOCK[i] + ";\n")
if par_tiling and EXP_CODE:
for i in range(0, len(sym_exvars)):
lines[i] = lines[i].replace(
'\n',
'') + '{ register int ' + sym_exvars[i] + 'b=c' + str(
i) + '*' + BLOCK[i] + ";\n"
lines.append("}\n")
file.close()
#eksperymentalnie
if (not EXP_CODE):
for i in range(0, len(sym_exvars)):
# lines.insert(i, "for(int "+sym_exvars[i]+"="+stuff[i]['lb']+"; "+sym_exvars[i]+"<="+stuff[i]['ub']+"; "+sym_exvars[i]+"+="+str(BLOCK[i])+"){\n")
lines.insert(
i, "for(int " + sym_exvars[i] + "=0; " + sym_exvars[i] +
"<=floord(" + stuff[i]['ub'] + "-" + stuff[i]['lb'] + "," +
str(BLOCK[i]) + "); " + sym_exvars[i] + "++){\n")
lines.append("}\n")
else:
if par_tiling:
# do rozwiazania
for i in range(0, len(sym_exvars)):
lines.insert(
i, "int fff" + str(i) + "=floord(" + stuff[i]['ub'] +
"-" + stuff[i]['lb'] + "," + str(BLOCK[i]) + ");\n")
lines = filter(lambda a: a != '\n', lines)
if nodeps == 1:
lines.insert(0, "#pragma omp parallel\n")
file = open("out_pseudocode.txt", 'w')
lines = file.writelines(lines)
file.close()
shutil.copyfile("out_pseudocode.txt", nazwa)
if (len(loops) == 2):
tiling_schedule.slice_tiling(loops[1], bl_2half, sym_exvars)
if (len(loops) == 3): #fs
tiling_schedule.slice_tiling(loops[2], bl_2half, sym_exvars, 1)
def tile(plik, block):
BLOCK = block.split(',')
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("tmp/tmp_petit.t", 'w')
for line in petit_loop:
file.write(line + '\n')
file.close()
lines = linestring.split('\n')
stuff = []
for line in lines:
if 'for' in line:
stuff.append(functions.Loop(line));
if(DEBUG):
print stuff
#pobierz relacje zaleznosci
dane = gen.RelPrint("tmp/tmp_petit.t")
dane = dane.split("#")
rel = dane[0]
rel2 = rel
dane.remove(rel)
dane = list(set(dane))
# -------------------------------------------------------
# script for barvinok
# gdy nie ma zaleznosci
# problemy do rozwiazania
# zmienne symboliczne nie wiadomo skad wziasc
# numery instrukcji
if(rel == ''):
rel = "{["
for i in range(0,len(stuff)):
rel = rel + "i" + str(i) + ","
rel = rel + "v] -> ["
for i in range(0,len(stuff)):
rel = rel + "i" + str(i) + "',"
rel = rel + "v'] : false }"
loop_tools.MakeLDPetit("tmp/tmp_petit.t", "tmp/tmp_ld_petit.t")
dane = gen.RelPrint("tmp/tmp_ld_petit.t")
dane = dane.split("#")
rel2 = dane[0]
dane.remove(rel2)
dane = list(set(dane))
print dane
instrukcje = loop_tools.ReadStatementNests("tmp/tmp_petit.t", dane)
#print instrukcje
file = open("tmp/barv_tiling.txt", 'w')
file.write('R:=' + rel + ';\n')
if(DEBUG):
file.write('print "R";')
file.write('R;')
file.write('Rstar:= R^+;');
if(DEBUG):
file.write('print "Rstar";')
file.write('Rstar;')
find_symb = re.compile("^[^(\]|\{)]*\]");
if(rel2 == rel):
tmp = re.findall(find_symb, rel)
else:
tmp = re.findall(find_symb, rel2)
symb = []
if(len(tmp) > 0):
symb = tmp[0]
symb = symb.replace("[", "");
symb = symb.replace("]", "");
symb = symb.replace(" ", "");
symb = symb.split(",");
vars = [] # i
exvars = [] # ii'
sym_exvars = [] # ii
varsprim = [] # i'
for s in stuff:
vars.append(s['var']);
sym_exvars.append(s['var']*2);
exvars.append(s['var']*2+"'");
varsprim.append(s['var']+"'");
_SYM = ""
# for s in sym_exvars:
# _SYM = _SYM + s + ","
for s in symb:
_SYM = _SYM + s + ","
for i in range(0, len(instrukcje)):
Bij = MakeBij(_SYM, vars, sym_exvars, stuff, BLOCK, instrukcje[i])
file.write(Bij)
if(i==0):
file.write('Bij := _Bij;')
else:
file.write('Bij := Bij + _Bij;')
if(DEBUG):
file.write('print "Bij";')
file.write('Bij;')
for i in range(0, len(instrukcje)):
BLGT = MakeBLTandBGT(_SYM, vars, sym_exvars, varsprim, exvars, stuff, BLOCK, instrukcje[i])
file.write(BLGT[0])
file.write(BLGT[1])
if(i==0):
file.write('BLT := _BLT;')
file.write('BGT := _BGT;')
else:
file.write('BLT := BLT + _BLT;')
file.write('BGT := BGT + _BGT;')
#file.write(BLGT[0])
if(DEBUG):
file.write('print "BLT";')
file.write('BLT;')
#file.write(BLGT[1])
if(DEBUG):
file.write('print "BGT";')
file.write('BGT;')
file.write('X:= Rstar(BGT);')
file.write('BCUR:=Bij - X;')
if(DEBUG):
file.write('print "BCUR";')
file.write('BPREV:= Rstar(BCUR) * BLT;')
if(DEBUG):
file.write('print "BPREV";')
file.write('BPREV;')
file.write('BLOCK:= BCUR + BPREV;')
if(DEBUG):
file.write('print "BLOCK";')
file.write('BLOCK;')
file.write('print "$#$";')
file.write('codegen BLOCK;')
file.close()
# -------------------------------------------------------
cmd = barv_script + " --isl-no-tile-scale-tile-loops < tmp/barv_tiling.txt "
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
process.wait()
output = process.stdout.read()
#file = open("tmp/barv_tiling2.txt", 'w')
#file.write('BLOCK:=' + output + ';\n')
#file.write('codegen BLOCK;\n')
#file.close()
#cmd = barv_script + " < tmp/barv_tiling2.txt --isl-no-coalesce-bounded-wrapping"
#process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
#process.wait()
#output = process.stdout.read()
if(DEBUG):
print output
lines = output.split("\n")
if(DEBUG):
for i in range(0,lines.index('"$#$"')+1):
lines.pop(0);
lines = filter(lambda x:x!='',lines)
#dodaj s1 do petli
loop = ""
for i in range(0,len(lines)):
tmp = lines[i]
pattern = re.compile("^\W*\(")
if pattern.match(tmp):
tmp = tmp.replace("(", "s1(")
tmp = tmp.replace(", ", ",")
loop = loop + tmp
# if(i < len(lines)-1):
loop = loop + "\n"
#zmienne
v = ""
for s in stuff:
v = v + s['var'] + ","
v = v + "v"
text_file = open("names_info.txt", "w")
text_file.write(v)
text_file.close()
#pseudokod
text_file = open("pseudocode.txt", "w")
text_file.write(loop)
text_file.close()
#przywroc instrukcje
gen.ParsePrint("tmp/tmp_petit.t")
filePaths = glob.glob(plik)
for filePath in filePaths:
base = os.path.basename(filePath)
nazwa = os.path.splitext(base)[0] + "_tiling" + os.path.splitext(base)[1]
# usun puste linie i kopiuj
file = open("out_pseudocode.txt", 'r')
lines = file.readlines()
file.close()
# for i in range(0, len(sym_exvars)):
# lines.insert(i, "for(int "+sym_exvars[i]+"="+stuff[i]['lb']+"; "+sym_exvars[i]+"<="+stuff[i]['ub']+"; "+sym_exvars[i]+"+="+str(BLOCK[i])+"){\n")
# lines.insert(i, "for(int "+sym_exvars[i]+"=0; "+sym_exvars[i]+"<=floord("+stuff[i]['ub']+","+str(BLOCK[i])+"); "+sym_exvars[i]+"++){\n")
# lines.append("}\n")
lines = filter (lambda a: a != '\n',lines)
file = open("out_pseudocode.txt", 'w')
lines = file.writelines(lines)
file.close()
shutil.copyfile("out_pseudocode.txt", nazwa)
def GenerateSCC(j, permute):
gr = DepGraph(j)
z = mutual_accessibility(gr)
z_sorted = []
for zz in z:
z_sorted.append(zz)
komp = []
for zz in z_sorted:
if not z[zz] in komp:
komp.append(z[zz])
# SCC POLICZONE
komp2 = komp[:]
for i in (0, len(komp)):
for item in komp:
for stam in item:
for item2 in komp:
if item != item2:
for stam2 in item2:
if gr.has_edge((stam,stam2)):
a = komp2.index(item2)
b = komp2.index(item)
if(a < b): #zamien miejscami
komp2[b], komp2[a] = komp2[a], komp2[b]
rel = gen.RelPrint("tmp/petit_loop_"+str(j)+".t", 1)
dane = gr.nodes()
paczka = loop_tools.ReadStatementNests("tmp/petit_loop_"+str(j)+".t", dane)
combo = paczka[0]
instrukcje = combo
granice = paczka[2]
max_nest = 0
for c in combo:
if c['nest'] > max_nest:
max_nest = c['nest']
pattern = re.compile("\n#.*$")
rel = pattern.sub("", rel)
pattern = re.compile("{.*\->")
t = str(re.findall(pattern, rel)[0])
t = t.replace(" ", "")
t = t.replace("->", "")
t = t + " : true};"
# loop fuse to do in future and permutation too
if(False):
komp3 = []
for komponent in komp2:
con = 0
if komp3 == []:
komp3.append(komponent)
item = komponent
else:
for node in komponent:
for node2 in item:
if gr.has_edge((node2, node)):
con = 1
if(con == 1):
komp3.append(komponent)
item = komponent
else:
for node in komponent:
item.append(node)
loop_fuse = False
if(loop_fuse):
komp2 = komp3
params = ""
if("] -> {" in rel):
params = re.findall(".*\] -> \{", rel)[0].replace("{", "")
zbiory = []
for komponent in komp2:
warunek = "("
for line in komponent:
if warunek != "(":
warunek = warunek + "or"
warunek = warunek + " v=" + line + " "
warunek = warunek + ") and true"
zbior = t.replace("true", warunek)
zbiory.append(zbior)
file = open("tmp/barv_scc.txt", 'w')
if(1 == 1):
file.write('R:=' + rel + ';\n')
file.write('S:= dom R + ran R;')
i = 0
for zbior in zbiory:
file.write('S'+str(i)+':=' + zbior)
file.write('S'+str(i)+':= S * S'+str(i)+';')
file.write('codegen S'+str(i)+';')
i = i + 1
i = 0
permutate_list = []
for komponent in komp2:
set = params+"{["
ll = find_instr(komponent, instrukcje) # jesli komponent bedzie z loop fusion to trzeba wybrac najbardziej zagn. instrukcje
vars = instrukcje[ll]['vars']
#for q in range(0, max_nest+1):
# set = set + "i" + str(q) + ","
set = set + ','.join(vars) + ",v ] : "
#set = set[:-1] + "] : "
for line in komponent:
path = []
for item in combo:
for z in item['st']:
if int(line) == int(z):
path = item['path']
for q in range(0, len(vars)):
if(q < len(path)):
set = set + granice[path[q]]['lb'] + " <= "+ vars[q] +" <= " + granice[path[q]]['ub'] + " and "
#set = set + granice[path[q]]['lb'] + " <= i" + str(q) + " <= " + granice[path[q]]['ub'] + " and "
else:
set = set + " " + vars[q] + " = -1 and "
set = set + " v = " + line +" and true or "
set = set + " false}; "
if(1==0): #permute
# tylko zaleznosci z scc TODO
rel = imperf_tile.PermuteBlock("tmp/deps" + str(j) + ".txt", set, instrukcje[ll], params, len(instrukcje[ll]['vars']), permutate_list)
set = isl.Set(str(set))
# relacja identity - nie rob nic
if(rel.is_equal(rel.identity(rel.get_space()))):
permutate_list.pop()
else:
set = set.apply(rel)
set_size = set.dim(isl.dim_type.set)
set = set.insert_dims(isl.dim_type.set, set_size-1, max_nest+1-set_size)
tmp_set = '{[' + ','.join(instrukcje[ll]['vars']) +',-1' * (max_nest - len(instrukcje[ll]['vars'])) + ',v]}'
set = set.intersect(isl.Set(tmp_set)).coalesce()
set = 'S'+str(i)+':=' + str(set) + ";"
print set
file.write(set)
file.write('codegen S'+str(i)+';')
i = i + 1
file.close();
cmd = barv_script + " < tmp/barv_scc.txt"
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
process.wait()
output = process.stdout.read()
#dodaj s1 do petli
'''lines = output.split("\n")
lines = filter(lambda x:x!='',lines)
loop = ""
for i in range(0,len(lines)):
tmp = lines[i]
pattern = re.compile("^\W*\(")
if pattern.match(tmp):
tmp = tmp.replace("(", "s1(")
tmp = tmp.replace(", ", ",")
loop = loop + tmp
# if(i < len(lines)-1):
loop = loop + "\n"
linestring = open("tmp/petit_loop_"+str(j)+".t", 'r').read()
petit_lines = linestring.split('\n')
lines = loop.split("\n")
debug = False
loop = ""
for line in lines:
if("s1(" in line):
pattern = re.compile(",[^,]+\)")
st = pattern.findall(line)[0].replace(",", "").replace(")", "")
if(not st.isdigit()):
print "== ERROR =="
sys.exit()
numb_st = int(st)
st = petit_lines[int(st)-1]
st = st.replace(",", "][")
# nawiasy powinny byc zmienione jesli poprzedzaja je znaki
# alfanumeryczne, inaczej to nawiasy nie od tablic
st = re.sub("\s*\(", "(", st)
st = re.sub("\s*\)", ")", st)
st = re.sub(r'(?<=[a-zA-Z0-9_])\(', '[', st)
st = re.sub(r'(?<=[a-zA-Z0-9_])\)', ']', st)
# szukaj wektora
for item in combo:
if numb_st in item['st']:
vec = item['vars']
if debug:
loop = loop + get_tab(line) + "// " + ",".join(item['vars']) + "\n"
break
# nowy wektor
vec_new = line.replace("s1(", "").replace(");", "").replace(" ", "").split(",")[:-1]
if debug:
loop = loop + get_tab(line) + "// " + ",".join(vec_new) + "\n"
st2 = st
for i in range(0, len(vec)):
st2 = re.sub('\\b'+vec[i]+'\\b', vec_new[i], st2)
if debug:
loop = loop + get_tab(line) + "// " + st + ";\n"
loop = loop + get_tab(line) + st2 + ";\n"
else:
loop = loop + line.replace('int ', '') + "\n"
#do poprawy - za duzo operacji na plikach przerobic korekte
'''
loop = tiling_v3.postprocess_loop(output.split('\n'))
lines = loop.split('\n')
loop = imperf_tile.RestoreStatements(lines, "tmp/petit_loop_"+str(j)+".t", dane, 0, 0, permutate_list)
text_file = open("loop_scc.c", "w")
text_file.write(loop)
text_file.close()
loop = ""
for line in correct.Korekta("loop_scc.c"):
loop = loop + line + "\n"
text_file = open("loop_scc.c", "w")
text_file.write(loop)
text_file.close()
# dopisz do instrukcji wektory zmiennych indeksowych petli
# uzyskaj tabulacje
# zastap instrukcje
# nadaj format C
if(1==0):
linestring = open("tmp/C_loop_"+str(j)+".c", 'r').read()
lines = linestring.split('\n')
lines = linestring.split('\n')
stuff = []
for line in lines:
if 'for' in line:
stuff.append(functions.Loop(line));
v = ""
for s in stuff:
v = v + s['var'] + ","
v = v + "v"
text_file = open("names_info.txt", "w")
text_file.write(v)
text_file.close()
text_file = open("pseudocode.txt", "w")
text_file.write(loop)
text_file.close()
gen.ParsePrint("tmp/petit_loop_"+str(j)+".t")
shutil.copyfile("out_pseudocode.txt", "tmp/C_loop_scc"+str(j)+".c")
def tile(plik, block):
EXP_CODE = True
BLOCK = block.split(',')
par_tiling = False
for i in range(len(BLOCK),10):
BLOCK.append(BLOCK[len(BLOCK)-1])
if(not BLOCK[0].isdigit()):
par_tiling = True
#EXP_CODE = False # nie ma wsparcia na razie dla gen. poszerzonego zbioru dla spar. tilingu, petle zewn. generowane sa z strings
linestring = open(plik, 'r').read()
lines = linestring.split('\n')
petit_loop = convert_loop.convert_loop(lines)
file = open("tmp/tmp_petit.t", 'w')
for line in petit_loop:
file.write(line + '\n')
file.close()
#zapisz zaleznosci
cmd = gen.path_petit + " tmp/tmp_petit.t > tmp/deps.txt"
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
process.wait()
#prywatyzacja
priv_stuff = priv_engine.PrivEng("tmp/deps.txt")
lines = linestring.split('\n')
stuff = []
for line in lines:
if 'for' in line:
stuff.append(functions.Loop(line));
start = time.time()
if(schedule_mode==1):
flag = 0
else:
flag = 1
#pobierz relacje zaleznosci
if(os.path.exists('rel.txt')):
with open('rel.txt', 'r') as content_file:
dane = content_file.read()
else:
if(len(priv_stuff[1]) > 0 and (priv_stuff[2] == 1 or False)): # jest par czyli mozna tiling
dane = gen.RelPrint_WithPriv("tmp/tmp_petit.t", priv_stuff[1])
else:
dane = gen.RelPrint("tmp/tmp_petit.t", flag)
output = process.stdout.read()
end = time.time()
elapsed = end - start
if(DEBUG):
print "Time taken: ", elapsed, "seconds."
dane = dane.split("#")
rel = dane[0]
rel2 = rel
dane.remove(rel)
dane = list(set(dane))
if(DEBUG):
print rel
# -------------------------------------------------------
# script for barvinok
# gdy nie ma zaleznosci
# problemy do rozwiazania
# zmienne symboliczne nie wiadomo skad wziasc
# numery instrukcji
nodeps=0
if(rel == ''):
nodeps=1
rel = "{["
for i in range(0,len(stuff)):
rel = rel + "i" + str(i) + ","
rel = rel + "v] -> ["
for i in range(0,len(stuff)):
rel = rel + "i" + str(i) + "',"
rel = rel + "v'] : false }"
loop_tools.MakeLDPetit("tmp/tmp_petit.t", "tmp/tmp_ld_petit.t")
dane = gen.RelPrint("tmp/tmp_ld_petit.t",1)
dane = dane.split("#")
rel2 = dane[0]
dane.remove(rel2)
dane = list(set(dane))
for s in dane:
if "UNKNOWN" in s:
dane.remove(s)
combo = loop_tools.ReadStatementNests("tmp/tmp_petit.t", dane)
instrukcje = combo[0]
nest_loop = combo[1]
if len(instrukcje)==0:
print 'blad - brak instrukcji'
sys.exit()
# wczytaj wszystkie
# eksperymentalnie kasowanie innych poziomow
stuff_reduced = stuff[:] #osobna kopia
do_kas = []
for i in range(1, max(nest_loop)+1):
dups = duplicates(nest_loop, i)
for s in dups:
if s != min(dups):
do_kas.append(s)
for item in do_kas:
stuff_reduced[item] = '!'
for i in range(0,stuff_reduced.count('!')):
stuff_reduced.remove('!') # remove
# -------------------------------
#find_symb = re.compile("^[^(\]|\{)]*\]");
#if(rel2 == rel):
# tmp = re.findall(find_symb, rel)
#else:
# tmp = re.findall(find_symb, rel2)
isl_rel = isl.Map(str(rel))
isl_relclosure = isl_rel.transitive_closure()[0].coalesce()
isl_relplus = isl_relclosure
#ident = "{["
#for i in range(0, len(stuff_reduced)+1):
# ident = ident + "i" + str(i) + ","
#ident = ident[:-1] + "] -> ["
#for i in range(0, len(stuff_reduced)+1):
# ident = ident + "i" + str(i) + ","
#ident = ident[:-1] +"]}"
#isl_ident = isl.Map(ident)
isl_ident = isl_rel.identity(isl_rel.get_space())
isl_relclosure = isl_relclosure.union(isl_ident).coalesce() # R* = R+ u I
#LATEX
isl_relclosure.print_(sys.stdout,0, 5)
isl_symb = isl_rel.get_var_names(isl.dim_type.param)
symb = isl_symb
#if(len(tmp) > 0):
# symb = tmp[0]
# symb = symb.replace("[", "");
# symb = symb.replace("]", "");
# symb = symb.replace(" ", "");
# symb = symb.split(",");
vars = [] # i
exvars = [] # ii'
sym_exvars = [] # ii
varsprim = [] # i'
par_vars = [] # iib
p_vars = [] #iib bez plusa lb
p_symb = []
prev_vars = []
# moze warto do iloczynu dodac lb a do floor N - lb
# do testowania +'+'+s['lb']
i = 0
for s in stuff_reduced:
vars.append(s['var']);
sym_exvars.append(s['var']*2);
exvars.append(s['var']*2+"'");
varsprim.append(s['var']+"'");
if par_tiling:
par_vars.append(s['var']*2+'b'+'+'+s['lb'])
p_vars.append(s['var']*2+'b')
else:
par_vars.append(s['var']*2 + "*" + BLOCK[i]+'+'+s['lb'])
# na uzytel nieidealnie zagniezdzonych
prev_vars.append("(" + s['var']*2 + "-1)*" + BLOCK[i]+'+'+s['lb'])
i = i+1
_SYM = ""
for s in sym_exvars:
_SYM = _SYM + s + ","
for i in range(len(vars),10):
BLOCK.pop()
if(par_tiling):
for s in p_vars:
_SYM = _SYM + s + ","
p_symb.append(s)
for s in set(BLOCK): #remove duplicates
_SYM = _SYM + s + ","
p_symb.append(s)
for s in symb:
_SYM = _SYM + s + ","
isl_TILE = []
isl_TILE_LT = []
isl_TILE_GT = []
isl_TILE1 = []
isl_TILE2 = []
isl_TILEprim = []
isl_TILEunion = ""
isl_TILE_prev = []
isl_TILE_nextcol = []
isl_TILE_LT_prev = []
isl_TILE_GT_prev = []
isl_IT = []
isl_REST_new = []
for i in range(0, len(instrukcje)):
iti = isl.Set(imperf_tile.GetIT(instrukcje, stuff_reduced, _SYM, vars, sym_exvars, BLOCK, i))
isl_IT.append(iti)
# utworz Bij_PREV czyli podmien w par_vars jeden wymiar na prev_vars
# i unionem wszystkie polacz
for i in range(0, len(instrukcje)):
for j in range(0, instrukcje[i]["nest"]):
tmp_par_vars = []
for k in range(0, len(par_vars)):
if(j==k):
tmp_par_vars.append(prev_vars[k])
else:
tmp_par_vars.append(par_vars[k])
S = MakeBij(_SYM, vars, sym_exvars, tmp_par_vars, stuff, BLOCK, instrukcje[i])
S = isl.Set(str(S).replace("_Bij := ", ""))
if(len(isl_TILE_prev) <= i):
isl_TILE_prev.append(S)
isl_TILE_nextcol.append(S)
else:
isl_TILE_prev[i] = isl_TILE_prev[i].union(S).coalesce()
if(DEBUG):
for i in range(0, len(isl_TILE_prev)):
print "LT'_" + str(i)
print isl_TILE_prev[i]
for i in range(0, len(instrukcje)):
Bij = MakeBij(_SYM, vars, sym_exvars, par_vars, stuff, BLOCK, instrukcje[i])
if(DEBUG):
print "TILE" + str(i)
print Bij
isl_TILE.append(isl.Set(str(Bij).replace("_Bij := ", "")))
if(i==0):
isl_TILEunion = isl_TILE[i]
else:
isl_TILEunion = isl_TILEunion.union(isl_TILE[i])
global maxl
maxl = 0
for item in instrukcje:
if item['max_loop'] > maxl:
maxl = item['max_loop']
SET_II = "[" + _SYM[:-1] + "] -> {[" + ",".join(vars) + ",v] : "
for i in range(0, len(sym_exvars)):
SET_II = SET_II + sym_exvars[i] + " >= 0 and " + par_vars[i] + " <= " + stuff[i]['ub'] + " and "
SET_II = SET_II+ "1=1 }"
print SET_II
isl_SETii = isl.Set(SET_II)
if(DEBUG):
print isl_SETii
for i in range(0, len(instrukcje)):
Bij = MakeBij(_SYM, vars, sym_exvars, par_vars, stuff, BLOCK, instrukcje[i])
if(DEBUG):
print "======"
bltc=0 # czy juz liczono blt
bgtc=0 # -- || -- bgt
for j in range(0, len(instrukcje)):
BLGT = MakeBLTandBGT_v2(_SYM, vars, sym_exvars, par_vars, varsprim, exvars, stuff, BLOCK, instrukcje[j], instrukcje[i]) # porownaj zagniezdzenia instrukcji
isltmp = isl.Set(str(BLGT[0]).replace("_BLT := ", ""))
if(bltc==0):
isl_TILE_LT.append(isltmp)
bltc=1
else:
isl_TILE_LT[i] = isl_TILE_LT[i].union(isltmp).coalesce()
isltmp = isl.Set(str(BLGT[1]).replace("_BGT := ", ""))
if(bgtc==0):
isl_TILE_GT.append(isltmp)
bgtc=1
else:
isl_TILE_GT[i] = isl_TILE_GT[i].union(isltmp).coalesce()
if(DEBUG):
print "TILE_LT" + str(i)
print isl_TILE_LT[i]
print "TILE_GT" + str(i)
print isl_TILE_GT[i]
X = isl_TILE_GT[i].apply(isl_relclosure).coalesce()
if(DEBUG):
print "R*(TILE_GT" + str(i) + ")"
print X
isl_BCUR = isl_TILE[i].subtract(X).coalesce()
isl_TILE1.append(isl_BCUR)
if(DEBUG):
print "TILE1_" + str(i)
print isl_TILE1[i]
C = isl_TILE[i].apply(isl_relplus).coalesce()
if(DEBUG2):
print "(R*(TILEi)"
print C
C = C.intersect(isl_TILE_LT[i]).coalesce()
C = C.intersect(isl_IT[i]).coalesce()
A = isl_TILE_LT[i].apply(isl_relplus).coalesce()
A = A.intersect(isl_TILE_prev[i]).coalesce()
#A = isl_TILE_prev[i]
A = A.subtract(Project(isl_TILE1[i].union(C), sym_exvars)).coalesce()
#A = A.subtract(Project(C, sym_exvars)).coalesce()
if(DEBUG2):
print "(R+(LTi) intersect LT'i) - instrukcje [ belong to C and TILE1i ]"
print A
print "TILE2 (z wczesniejszym union C)"
A = A.union(C).coalesce()
#dla ladniejszego zapisu
A = A.intersect(isl_SETii).coalesce()
#A = isl_TILE_prev[i]
if(DEBUG2):
print A
#print "=============== s" + str(i)
# print isl_TILE1[i]
Z = isl_TILE[i].subtract(isl_TILE1[i])
Z = Project(Z, sym_exvars)
Z = Z.intersect(isl_TILE_prev[i].intersect(isl_SETii)).coalesce()
#print Z
Z = Z.subtract(Project(C, sym_exvars)).coalesce()
# A = LT'i intersect ( wszystkie punkty R*(TILE_GTi - ISi))
Z1 = isl_TILE_GT[i].subtract(isl_IT[i])
print "===="
#print Z1.apply(isl_relclosure)
#print isl_TILE1[i]
#Z = Project(Z1.apply(isl_relclosure), sym_exvars)
#print Z
#Z = Z.intersect(isl_TILE_prev[i]).intersect(isl_SETii)
A = Z.union(C)
isl_REST_new.append(isl_TILE[i].subtract(Project(A.union(isl_TILE1[i]), sym_exvars)).coalesce())
#print isl_REST_new[i]
isl_TILE2.append(A)
#isl_TILE2.append(A.intersect(isl_TILE_LT[i]).coalesce())
if(DEBUG):
print "TILE2_" + str(i)
print isl_TILE2[i]
isl_TILEprim.append(isl_TILE2[i].union(isl_BCUR).coalesce())
if(DEBUG):
print isl_SETii
isl_TILEprim[i] = isl_TILEprim[i].intersect(isl_SETii)
if(DEBUG):
print "TILEprim_" + str(i)
print isl_TILEprim[i]
iR = isl_REST_new[1]
for i in range(1, len(isl_REST_new)):
iR = iR.union(isl_REST_new[i]).coalesce()
iR = iR.apply(isl_relclosure)
iR = Project(iR, sym_exvars)
iT = isl_TILEprim[1]
for i in range(1, len(isl_REST_new)):
iT = iT.union(isl_TILEprim[i]).coalesce()
iT = Project(iT, sym_exvars)
print iT.intersect(iR).coalesce()
sys.exit()
if(DEBUG):
print "============================================================================="
for i in range(0, len(instrukcje)):
for ii in range(0,2):
constr = ""
if i == 1:
ubjj = 2
else:
ubjj = 1
for jj in range(0,ubjj):
if ubjj > 1:
constr = " && jj = " + str(jj)
bset = isl.BasicSet("[ii,jj] -> {[x, y,z] : ii = "+str(ii)+constr+"}")
#print "TILE_LT" + str(i)
#print "ii=" + str(ii) + ",jj=" + str(jj)
#print isl_TILE_LT[i].intersect(bset).coalesce()
#print "TILE_GT" + str(i)
#print "ii=" + str(ii) + ",jj=" + str(jj)
#print isl_TILE_GT[i].intersect(bset).coalesce()
#file.write('BLOCK;')
file.close()
# -------------------------------------------------------
'''cmd = barv_script + " < tmp/barv_tiling.txt"
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
process.wait()
output = process.stdout.read()
end = time.time()
elapsed = end - start
print "Time taken: ", elapsed, "seconds."
lines = output.split("\n")
if(DEBUG):
for i in range(0,lines.index('"$#$"')+1):
lines.pop(0);
block_set = []
for i in range(0,lines.index('"$$$#$$$"')+1):
block_set.append(lines.pop(0));
block_set.pop();
lines = filter(lambda x:x!='',lines)
#dodaj s1 do petli
loop = postprocess_loop(lines)
bl_2half = loop'''
#eksperymentalnie
if(EXP_CODE):
loops = TileGen(sym_exvars, vars, _SYM, symb, p_symb, par_tiling, rel, schedule_mode, instrukcje, stuff_reduced, BLOCK, isl_TILEprim, varsprim, isl_IT, isl_REST_new)
loop_x = loops[0]
loop_x = postprocess_loop(loop_x.split('\n'))
loop = loop_x
#zmienne
v = ""
for s in stuff_reduced:
v = v + s['var'] + ","
v = v + "v"
text_file = open("names_info.txt", "w")
text_file.write(v)
text_file.close()
#print block_set # tu mozna rozszerzyc
#pseudokod
text_file = open("pseudocode.txt", "w")
text_file.write(loop)
text_file.close()
#przywroc instrukcje
if(EXP_CODE):
gen.ParsePrint2("tmp/tmp_petit.t", len(sym_exvars))
else:
gen.ParsePrint("tmp/tmp_petit.t")
filePaths = glob.glob(plik)
for filePath in filePaths:
base = os.path.basename(filePath)
nazwa = os.path.splitext(base)[0] + "_tiling" + os.path.splitext(base)[1]
# usun puste linie i kopiuj
file = open("out_pseudocode.txt", 'r')
lines = file.readlines()
# oryginalny z elsami
lines_block = lines[:]
if par_tiling and not EXP_CODE:
for i in range(0, len(sym_exvars)):
lines.insert(0,'register int ' + sym_exvars[i] + 'b=' + sym_exvars[i] + "*" +BLOCK[i] + ";\n")
if par_tiling and EXP_CODE:
for i in range(0, len(sym_exvars)):
lines[i] = lines[i].replace('\n', '') + '{ register int ' + sym_exvars[i] + 'b=c'+str(i)+'*' +BLOCK[i] + ";\n"
lines.append("}\n")
file.close()
#eksperymentalnie
if(not EXP_CODE):
for i in range(0, len(sym_exvars)):
# lines.insert(i, "for(int "+sym_exvars[i]+"="+stuff[i]['lb']+"; "+sym_exvars[i]+"<="+stuff[i]['ub']+"; "+sym_exvars[i]+"+="+str(BLOCK[i])+"){\n")
lines.insert(i, "for(int "+sym_exvars[i]+"=0; "+sym_exvars[i]+"<=floord("+stuff[i]['ub']+"-"+stuff[i]['lb']+","+str(BLOCK[i])+"); "+sym_exvars[i]+"++){\n")
lines.append("}\n")
else:
if par_tiling:
# do rozwiazania
for i in range(0, len(sym_exvars)):
lines.insert(i, "int fff"+str(i)+"=floord("+stuff[i]['ub']+"-"+stuff[i]['lb']+","+str(BLOCK[i])+");\n")
lines = filter (lambda a: a != '\n',lines)
if nodeps==1:
lines.insert(0, "#pragma omp parallel\n")
file = open("out_pseudocode.txt", 'w')
lines = file.writelines(lines)
file.close()
shutil.copyfile("out_pseudocode.txt", nazwa)
'''if(len(loops) == 2):
def tile(plik,
block,
permute,
output_file="",
L="0",
SIMPLIFY="False",
perfect_mode=False,
parallel_option=False,
rplus_file=''):
SIMPLIFY = False
DEBUG = True
schedule_mode = parallel_option
#print "********** another version **************"
LPetit = "tmp/tmp_petit" + L + ".t"
LDeps = "tmp/deps" + L + ".txt"
# strong perfect
if (DEBUG):
if perfect_mode:
print 'Perfectly nested loop mode: enabled'
simpl_ub = False
BLOCK = block.split(',')
par_tiling = False
for i in range(len(BLOCK), 10):
BLOCK.append(BLOCK[len(BLOCK) - 1])
if (not BLOCK[1].isdigit()):
par_tiling = True
linestring = open(plik, 'r').read()
lines = linestring.split('\n')
if simpl_ub:
petit_loop = convert_loop.convert_loop(lines, BLOCK)
else:
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()
cmd = gen.path_petit + " " + LPetit + " > " + LDeps
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
process.wait()
lines = linestring.split('\n')
stuff = []
for_level = 0
for line in lines:
if 'endfor' in line:
for_level = for_level - 1
else:
if 'for' in line:
if simpl_ub:
stuff.append(functions.Loop(line, BLOCK[for_level]))
else:
stuff.append(functions.Loop(line))
for_level = for_level + 1
# na podstawie stuff zbuduj tablice inkrementacji i dekremnatacji poziomu
#if(schedule_mode == 0):
# flag = 1
#else:
flag = 1
# Proba prywatyzacji zmiennych w instrukcjach w gniazdach
priv_stuff = priv_engine.PrivEng(LDeps)
priv_box = 1
if (imperf == 0):
priv_box = 1
dane = []
sts = imperf_tile.Get_ST(LPetit, dane)
dane = dane + sts
combo = loop_tools.ReadStatementNests(LPetit, dane)
instrukcje = combo[0]
for pp in priv_stuff[3]:
for i in instrukcje:
a = set(i['st'])
b = set(pp[1])
if (a & b) and (
b -
a): # nie wszystkie instrukcje skalara sa w gniezdzie
priv_box = 0
# ==========
# jesli zmienne prywatne sa w obrebie jednego S1 to mozna
start = time.time()
if ((imperf == 0 and priv_box == 0)):
dane = gen.RelPrint(LPetit, flag)
else:
if (len(priv_stuff[1]) > 0):
dane = gen.RelPrint_WithPriv(LPetit, priv_stuff[1])
else:
dane = gen.RelPrint(LPetit, flag)
output = process.stdout.read()
end = time.time()
elapsed = end - start
print "Dependence analysis: time taken: ", elapsed, "seconds."
if (DEBUG):
print dane
dane = dane.split("#")
rel = dane[0]
rel2 = rel
print rel
dane.remove(rel)
dane = list(set(dane))
if (DEBUG):
print rel
# Create LD
Dependence.Create_LD_petit(L, petit_loop)
# -------------------------------------------------------
# script for barvinok
# gdy nie ma zaleznosci
# problemy do rozwiazania
# zmienne symboliczne nie wiadomo skad wziasc
# numery instrukcji
nodeps = 0
if (rel == ''):
nodeps = 1
LD_inp = "tmp/LD_petit_loop_" + L + ".t"
dane2 = gen.RelPrint(LD_inp, 1)
dane2 = dane2.split("#")
rel2 = dane2[0]
try:
isl_rel2 = isl.Map(str(rel2))
isl_symb = isl_rel2.get_var_names(isl.dim_type.param)
symb = isl_symb
except:
print "Internal error."
sys.exit()
rel = "[" + ",".join(symb) + "] -> {["
for i in range(0, len(stuff)):
rel = rel + "i" + str(i) + ","
rel = rel + "v] -> ["
for i in range(0, len(stuff)):
rel = rel + "i" + str(i) + "',"
rel = rel + "v'] : false }"
#loop_tools.MakeLDPetit("tmp/tmp_petit.t", "tmp/tmp_ld_petit.t")
#dane2.remove(rel2)
#dane2 = list(set(dane2))
#for i in range(0, len(dane2)):
# dane2[i] = str(int(dane2[i]) - 1)
for s in dane:
if "UNKNOWN" in s:
dane.remove(s)
# dodaj dane bez relacji
sts = imperf_tile.Get_ST(LPetit, dane)
dane = dane + sts
combo = loop_tools.ReadStatementNests(LPetit, dane)
instrukcje = combo[0]
nest_loop = combo[1]
if len(instrukcje) == 0:
print 'blad - brak instrukcji'
sys.exit()
# wczytaj wszystkie
# eksperymentalnie kasowanie innych poziomow
stuff_reduced = stuff[:] #osobna kopia
do_kas = []
for i in range(1, max(nest_loop) + 1):
dups = duplicates(nest_loop, i)
for s in dups:
if s != min(dups):
do_kas.append(s)
for item in do_kas:
stuff_reduced[item] = '!'
for i in range(0, stuff_reduced.count('!')):
stuff_reduced.remove('!') # remove
# -------------------------------
global maxl
maxl = 0
for item in instrukcje:
if item['max_loop'] > maxl:
maxl = item['max_loop']
start = time.time()
tmp_st = []
if (perfect_mode):
firstst = str(instrukcje[0]['st'][0])
#print rel
rel = re.sub(r"v = \d+", "v = " + firstst, rel)
rel = re.sub(r"v' = \d+", "v' = " + firstst, rel)
#print rel
tmp_st = instrukcje[0]['st']
instrukcje[0]['st'] = [instrukcje[0]['st'][0]]
#print instrukcje[0]['st']
# wywal reszte zapisz gdzies tablice
# exit(1)
# strong perfect mode
isl_rel = isl.Map(str(rel))
isl_ident = isl_rel.identity(isl_rel.get_space())
# k6 only
#print isl_rel
#rel_plus = isl_rel.transitive_closure()[0]
#isl_rel = isl_rel.subtract(rel_plus.apply_range(isl_rel))
#rel = isl.Map(str("{[i,j,v]->[i,j',v]}"))
#isl_rel = isl_rel.subtract(rel)
#print isl_rel
#exit(0)
# -------------
if (perfect_mode):
if (DEBUG):
print "Removing internal dependences for perfect nested loop"
isl_rel = isl_rel.subtract(isl_ident)
if (DEBUG):
print isl_rel
z = isl_rel.dim(isl.dim_type.out)
zz = maxl - z + 1
if (zz > 0):
if (DEBUG):
print "Error. Dimensions of dependencies are not equal to an amount of loop nests"
print "Relations will be extended."
isl_rel = isl_rel.insert_dims(isl.dim_type.in_, z - 1, zz)
isl_rel = isl_rel.insert_dims(isl.dim_type.out, z - 1, zz)
# jesli ktorys z blokow ma 1 wywal te zaleznosci
# w slicgu mozna tak jesli zewn petla tylko zapisuje zmienne prywatne
if (BLOCK[0] == '1' and schedule_mode == 0):
z = isl_rel.dim(isl.dim_type.out)
rtmp = "{["
for i in range(0, z):
rtmp = rtmp + "i" + str(i) + ","
rtmp = rtmp[:-1] + "] -> ["
for i in range(0, z):
rtmp = rtmp + "o" + str(i) + ","
rtmp = rtmp[:-1] + "] : i0 = o0 };"
rtmp = isl.Map(rtmp)
isl_rel = isl_rel.intersect(rtmp).coalesce()
# lata na petle ktore nie ma w relacjach
#if maxl > isl_rel:
start = time.time()
if (DEBUG):
print '!!!!!!!!!!'
# **************************************************************************
exact_rplus = '-1'
islrp = False
isl_relclosure = isl_rel
if (rplus_file != ''):
with open(rplus_file, "r") as myfile:
data = myfile.read().replace('\n', '')
isl_relclosure = isl.Map(str(data))
else:
if islrp:
isl_relclosure = isl_rel.transitive_closure()
exact_rplus = isl_relclosure[1]
isl_relclosure = isl_relclosure[0]
else:
isl_relclosure = relation_util.oc_IterateClosure(isl_rel)
exact_rplus = True
isl_relplus = isl_relclosure
end = time.time()
elapsed = end - start
print "Transitive closure: time taken: ", elapsed, "seconds."
isl_ident = isl_rel.identity(isl_rel.get_space())
if (DEBUG):
print 'R+'
print isl_relclosure
#isl_relclosure = rpp
print "!! exact_rplus " + str(exact_rplus)
isl_relclosure = isl_relclosure.union(isl_ident).coalesce() # R* = R+ u I
if (_debug_):
if (DEBUG):
print "R*"
print isl_relclosure
print exact_rplus
# **************************************************************************
isl_symb = isl_rel.get_var_names(isl.dim_type.param)
symb = isl_symb
end = time.time()
if (DEBUG):
print end - start
vars = [] # i
exvars = [] # ii'
sym_exvars = [] # ii
varsprim = [] # i'
par_vars = [] # iib
p_vars = [] #iib bez plusa lb
p_symb = []
im_par_vars = []
# moze warto do iloczynu dodac lb a do floor N - lb
# do testowania +'+'+s['lb']
i = 0
for s in stuff_reduced:
vars.append(s['var'])
sym_exvars.append(s['var'] * 2)
exvars.append(s['var'] * 2 + "'")
varsprim.append(s['var'] + "'")
if par_tiling:
par_vars.append(s['var'] * 2 + 'b' + '+' + s['lb'])
p_vars.append(s['var'] * 2 + 'b')
else:
par_vars.append(s['var'] * 2 + "*" + BLOCK[i] + '+' + s['lb'])
i = i + 1
# codegen.calculate_position(1, instrukcje, len(sym_exvars))
for s in stuff:
if s['var'] in vars:
i = vars.index(s['var'])
if par_tiling:
im_par_vars.append(s['var'] * 2 + 'b' + '+' + s['lb'])
else:
im_par_vars.append(s['var'] * 2 + "*" + BLOCK[i] + '+' +
s['lb'])
_SYM = ""
for s in sym_exvars:
_SYM = _SYM + s + ","
for i in range(len(vars), 10):
BLOCK.pop()
if (par_tiling):
for s in p_vars:
_SYM = _SYM + s + ","
p_symb.append(s)
for s in set(BLOCK): #remove duplicates
_SYM = _SYM + s + ","
p_symb.append(s)
for s in symb:
_SYM = _SYM + s + ","
# wektory same 0 - mozesz dac parallel
# prywatyzuj calosc, tam gdzie zapis seq, same 0 to parallel bloki (tylko odczyt)
par_tiled = 0
delta = isl_rel.deltas()
chkc = isl.Set("{[0," + ",".join(vars) + "]}")
delta = delta.subtract(chkc)
if (delta.is_empty()):
par_tiled = 1
if (DEBUG):
print "Parallel tiling detected."
########################################################################
cl = clanpy.ClanPy()
cl.loop_path = plik
cl.Load()
cl.RunCandl()
j = 0
if (len(cl.statements) > 0):
for i in range(0, len(instrukcje)):
instrukcje[i]['scatter'] = cl.statements[j].scatering[:]
j = j + len(instrukcje[i]['st'])
Rapply = GetRapply(vars, sym_exvars, _SYM)
isl_TILE = []
isl_TILE_LT = []
isl_TILE_GT = []
isl_TILE1 = []
isl_TILE2 = []
isl_TILEprim = []
isl_TILEbis = []
isl_TILEorig = []
permutate_list = []
permutate_maps = []
FFF_lines = []
FFF_idx = []
FFF_headers = []
FFF_headers_idx = []
for i in range(0, len(instrukcje)):
Bij = MakeBij(_SYM, vars, sym_exvars, im_par_vars, stuff, BLOCK,
instrukcje[i], par_tiling)
print Bij
print "oooooooooooooooooooooooooooooooooooooooooooooooooooo"
isl_TILE.append(isl.Set(str(Bij).replace("_Bij := ", "")))
if (DEBUG):
print 'T --------------------------------------------'
print stuff
print isl_TILE[i]
# oblicz II_SET
if (False):
if (len(symb) > 0):
ii_set = '[' + ','.join(symb) + '] -> '
else:
ii_set = ''
ii_set = ii_set + '{[' + ','.join(sym_exvars) + '] : '
for l in range(0, len(sym_exvars)):
ii_set = ii_set + sym_exvars[l] + ' >= 0 and '
ii_set = ii_set + BLOCK[l] + '*' + sym_exvars[
l] + ' + ' + stuff[l]['lb'] + ' <= ' + stuff[l][
'ub'] + ' and '
ii_set = ii_set + ' 1=1}'
if (DEBUG):
print ii_set
ii_set = isl.Set(ii_set)
if (DEBUG):
print 'II_SET ' + str(ii_set)
print 'CARD II_SET ' + test_isl.StringToCard(str(ii_set))
# ------------------------------
bltc = 0 # czy juz liczono blt
bgtc = 0 # -- || -- bgt
for j in range(0, len(instrukcje)):
BLGT = MakeBLTandBGT_v2(
_SYM, vars, sym_exvars, im_par_vars, varsprim, exvars, stuff,
BLOCK, instrukcje[j], instrukcje[i],
par_tiling) # porownaj zagniezdzenia instrukcji
if (DEBUG):
print '-------LT ----------'
print BLGT[0]
print '-------GT ----------'
print BLGT[1]
print BLGT[0]
isltmp = isl.Set(str(BLGT[0]).replace("_BLT := ", ""))
if (bltc == 0):
print isltmp
sys.exit(0)
isl_TILE_LT.append(isltmp)
bltc = 1
else:
isl_TILE_LT[i] = isl_TILE_LT[i].union(isltmp).coalesce()
isltmp = isl.Set(str(BLGT[1]).replace("_BGT := ", ""))
if (bgtc == 0):
isl_TILE_GT.append(isltmp)
bgtc = 1
else:
isl_TILE_GT[i] = isl_TILE_GT[i].union(isltmp).coalesce()
if (DEBUG):
print "s" + str(i)
print "LT"
print isl_TILE_LT[i]
print "GT"
print isl_TILE_GT[i]
X = isl_TILE_GT[i].apply(isl_relclosure).coalesce()
isl_BCUR = isl_TILE[i].subtract(X).coalesce()
isl_TILE1.append(isl_BCUR)
if (DEBUG):
print '---------bcur-----'
print isl_BCUR.apply(isl_relclosure)
isl_BPREV = isl_BCUR.apply(isl_relclosure).intersect(
isl_TILE_LT[i]).coalesce()
isl_BPREV = isl_BPREV.subtract(
X).coalesce() # changed according to ACM TOPLAS reviewer
if (DEBUG):
print isl_BPREV
print '---'
isl_TILE2.append(isl_BPREV)
#isl_TILEprim.append(isl_TILE1[i])
isl_TILEprim.append(isl_TILE1[i].union(isl_TILE2[i]).coalesce())
#poprawka intersect z IS - EKSPERYMENTALNA !!!!
IS = getIS(plik, isl_rel, dane)
DOMRAN = isl_rel.domain().union(isl_rel.range()).coalesce()
INDDD = IS.subtract(DOMRAN).coalesce()
if (DEBUG):
print '----------'
print INDDD
print IS
#print IS
# sys.exit(0)
#isl_TILEprim[i] = isl_TILEprim[i].intersect(IS).coalesce()
#for ll in range(0,i):
# isl_TILEprim[i] = isl_TILEprim[i].subtract(isl_TILEprim[ll]).coalesce()
#############################
print '^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^'
#isl_TILEprim.append(isl_TILE[i])
# print isl_TILEprim[0]
isl_TILEbis.append(
Project(isl_TILEprim[i].apply(Rapply).coalesce(),
sym_exvars).coalesce())
isl_TILEorig.append(
Project(isl_TILE[i].apply(Rapply).coalesce(),
sym_exvars).coalesce())
############################################################################
if (par_tiling):
idx_bylo = []
if (len(symb) > 0):
S = "[" + ",".join(symb) + ","
else:
S = "["
S1 = "{[" + ",".join(sym_exvars) + "," + ",".join(vars) + ",v] :"
for j in range(0, len(instrukcje[i]['path'])):
idx = str(instrukcje[i]['path'][j])
liniabb = " = floord(" + stuff[instrukcje[i]['path'][j]][
'ub'] + "-" + stuff[instrukcje[i]['path']
[j]]['lb'] + " ," + BLOCK[j] + ");"
if 1 == 1 or liniabb not in FFF_headers: # always true,
FFF_headers.append(liniabb)
FFF_headers_idx.append(idx)
linia = "int fff" + idx + liniabb
linia = linia.replace("floord( ", "floord(")
FFF_lines.append(linia)
else:
idx = FFF_headers_idx[FFF_headers.index(liniabb)]
if str({'id': idx, 'j': j}) not in FFF_idx:
FFF_idx.append({'id': idx, 'j': j})
if idx not in idx_bylo:
S = S + "fff" + idx + ","
idx_bylo.append(idx)
S1 = S1 + " " + sym_exvars[j] + "<= fff" + idx + " and "
S = S[:-1] + "] -> " + S1 + " true }"
if (DEBUG):
print S
S = isl.Set(S)
isl_TILEbis[i] = isl_TILEbis[i].intersect(S).coalesce()
#########################################################################
if (permute):
RP = imperf_tile.PermuteBlock(LDeps,
isl_TILEprim[i], instrukcje[i], symb,
len(sym_exvars), permutate_list)
if (isinstance(RP, isl.Map)):
print "Permutation experimental enabled:"
permutate_maps.append(RP)
isl_TILEprim[i] = isl_TILEprim[i].apply(RP)
#print isl_TILEprim[i]
if (_debug_):
if (DEBUG):
print "TILE"
print isl_TILE[i]
print "TILE_LT"
print isl_TILE_LT[i]
print "TILE_GT"
print isl_TILE_GT[i]
print "TILE_ITR (TILE1)"
print isl_TILE1[i]
print "TVLD_LT (TILE2)"
print isl_TILE2[i]
print "TILE_VLD (TILE')"
print isl_TILEprim[i]
# print "card"
# print test_isl.StringToCard(str(isl_TILEprim[i]))
print "TILE_VLD_ext (TILE'')"
print isl_TILEbis[i]
# correct upper bounds for simpl_ub
if simpl_ub:
cor_set = ''
if (len(symb) > 0):
cor_set = '[' + ','.join(symb) + '] -> '
else:
cor_set = ''
cor_set = cor_set + '{[' + ','.join(sym_exvars) + ',' + ','.join(
vars) + ',' + 'v] : '
for j in range(0, len(instrukcje[i]['path'])):
cor_set = cor_set + vars[j] + " <= " + stuff[
instrukcje[i]['path'][j]]['ub'] + " - " + BLOCK[j] + " && "
cor_set = cor_set + "("
for v in instrukcje[i]['st']:
cor_set = cor_set + " v = " + str(v) + " or"
cor_set = cor_set[:-2] + ")}"
cor_set = isl.Set(cor_set)
#print cor_set
#sys.exit(0)
isl_TILEbis[i] = isl_TILEbis[i].intersect(cor_set).coalesce()
isl_TILEorig[i] = isl_TILEorig[i].intersect(cor_set).coalesce()
if (SIMPLIFY):
isl_TILEbis[i] = imperf_tile.SimplifySlice(isl_TILEbis[i])
#print "TILE''" + "dla s" + str(i) + "\n" + str(isl_TILEbis[i])
#eksepeymentalnie dodaj pozycje do tilebis jesli wiele gniazd na roznych poziomach
Extend = False
if (imperf == 1):
Extend = True
#Extend = MultiNest(instrukcje)
#Extend = True
#print imperf
#vis3dimperf.imperf_vis(isl_TILEbis, isl_rel)
_rap = GetRapply4(vars, sym_exvars, _SYM, instrukcje, 0)
print _rap
#vis.Vis(isl_TILEbis[0], stuff, cl.deps, isl.Set(cl.statements[0].domain_map), True)
#sys.exit(0)
# zne takie jak z ale bez ext
if (Extend):
z = isl_TILEbis[0].apply(_rap)
zne = isl_TILEbis[0]
else:
z = isl_TILEbis[0]
for j in range(1, len(isl_TILEbis)):
_rap = GetRapply4(vars, sym_exvars, _SYM, instrukcje, j)
print _rap
if (DEBUG):
print _rap
if (Extend):
z = z.union(isl_TILEbis[j].apply(_rap))
zne = zne.union(isl_TILEbis[j])
else:
z = z.union(isl_TILEbis[j])
if (not Extend):
zne = z
print z
# -----------------------------------------------------------------
_rap = GetRapply4(vars, sym_exvars, _SYM, instrukcje, 0)
if (Extend):
zorig = isl_TILEorig[0].apply(_rap)
else:
zorig = isl_TILEorig[0]
for j in range(1, len(isl_TILEorig)):
_rap = GetRapply4(vars, sym_exvars, _SYM, instrukcje, j)
if (Extend):
zorig = zorig.union(isl_TILEorig[j].apply(_rap))
else:
zorig = zorig.union(isl_TILEorig[j])
zorig = zorig.coalesce()
# ---------------------------------------------------------------
z = z.coalesce()
z = z.remove_redundancies()
z = z.detect_equalities()
# z = imperf_tile.SimplifySlice(z)
#calculate II_SET
ii_SET = z.remove_dims(isl.dim_type.set,
int(isl_TILEbis[i].dim(isl.dim_type.set) / 2),
int(isl_TILEbis[i].dim(isl.dim_type.set) /
2)).coalesce()
if (_debug_):
print "II_SET"
print ii_SET
step = 0
if Extend:
step = 1
nazwa = ""
nazwapar = ""
filePaths = glob.glob(plik)
if (output_file != ""):
nazwa = output_file
nazwapar = output_file
else:
for filePath in filePaths:
base = os.path.basename(filePath)
nazwa = os.path.splitext(base)[0] + "_tiling" + os.path.splitext(
base)[1]
nazwapar = os.path.splitext(
base)[0] + "_partiling" + os.path.splitext(base)[1]
if (perfect_mode):
if (DEBUG):
print z
chang = str(tmp_st[0]) + "]"
if (DEBUG):
print chang
for i in range(1, len(tmp_st)):
zz = str(z).replace(chang, str(tmp_st[i]) + "]")
zz = isl.Set(zz)
z = z.union(zz).coalesce()
instrukcje[0]['st'] = tmp_st # correct statements
#z1 = isl.Set('[n,b] -> {[i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13] : n+2 = 2*b && b > 2 && n > 8 }')
# z1 = isl.Set('[n,b] -> {[i3,i4,i5,i6,i9,i10,i11,i12,i13] : n+2 = 2*b && b > 2 && n > 8 }')
#z = z.intersect(z1)
if (not schedule_mode or par_tiled):
print "Cloog start..."
start = time.time()
isl_ast = False
barv = 1
if (barv == 1):
if (isl_ast):
loop_x = iscc.isl_ast_codegen(z)
else:
loop_x = iscc.iscc_communicate("L :=" + str(z) +
"; codegen L;")
else: #cloog
#loop_x = codegen.tile_gen_short(vars, sym_exvars, symb,z,instrukcje, Extend)
with open('loopx', "r") as myfile:
loop_x = myfile.read()
#loop_x = iscc.oc_communicate(z)
#loop_x = codegen.tile_gen(vars, sym_exvars, symb, isl_TILEbis, instrukcje, "", [], stuff)
end = time.time()
elapsed = end - start
print "Code generation: time taken: ", elapsed, "seconds."
########################################################################
loop_x = postprocess_loop(loop_x.split('\n'))
loop = loop_x
lines = loop.split('\n')
loop = imperf_tile.RestoreStatements(lines, LPetit, dane, maxl, step,
permutate_list)
if par_tiled:
loop = "#pragma omp parallel for\n" + loop
for i in range(0, 5):
if (loop[-1] == '\n'):
loop = loop[:-1]
loop = loop + "\n"
new_gen = True
if (not new_gen):
gen.ParsePrint2("tmp/tmp_petit.t", len(sym_exvars))
if (new_gen):
text_file = open(nazwa, "w")
text_file.write(loop)
text_file.close()
if par_tiling:
lines = FFF_lines + correct.Korekta(nazwa)
for i in range(0, len(lines)):
if "for" in lines[i] and "fff" in lines[i]:
reg = re.compile("\=.*")
linia = reg.sub("", lines[i])
reg = re.compile(".*\(")
cc = reg.sub("", linia)
cc = cc.replace(" ", "")
for FF_item in FFF_idx:
if "fff" + FF_item['id'] in lines[i]:
lines[i] = lines[i] + "\n" + correct.whites(
lines[i]) + " register int " + sym_exvars[
FF_item['j']] + "b = " + BLOCK[
FF_item['j']] + "*" + cc + ";"
break
lines[i] = lines[i] + "\n"
text_file = open(nazwa, "w")
text_file.writelines(lines)
text_file.close()
if schedule_mode:
text_file = open(nazwapar, "w")
text_file.writelines(lines)
text_file.close()
if (output_file != ""):
return ""
if (not schedule_mode and 1 == 0):
rtile = tiling_schedule.get_RTILE(z, sym_exvars, isl_rel,
Extend)
print "RTILE:"
print rtile
tiling_schedule.get_RCYCLE(rtile, 0)
rtileorig = tiling_schedule.get_RTILE(zorig, sym_exvars,
isl_rel, Extend)
print "RTILE_ORIG:"
print rtileorig
tiling_schedule.get_RCYCLE(rtileorig, 1)
# =====================================================================================================================
# PARALLEL PARALLEL PARALLEL PARALLEL PARALLEL PARALLEL PARALLEL PARALLEL PARALLEL PARALLEL PARALLEL PARALLEL PARALLEL
Dodatek = [
LPetit, dane, maxl, step, nazwapar, permutate_list, permutate_maps
]
par_tiled = 0
if (DEBUG):
print '!!!!'
print zorig
if (schedule_mode and par_tiled != 1):
if (False):
tiling_schedule.tile_par(isl_TILEprim, isl_TILEbis, sym_exvars,
symb, isl_rel, isl_relplus,
isl_relclosure)
else:
# Rk
#tiling_schedule.tile_par3(z, sym_exvars, isl_rel, isl_relplus, isl_relclosure, Extend, _rap, Dodatek,SIMPLIFY, ii_SET)
# fsnew
rtile = tiling_schedule.get_RTILE(zne, sym_exvars, isl_rel, False)
#rtileplus = rtile.transitive_closure()
rapp = _rap
rapp = rapp.remove_dims(isl._isl.dim_type.in_, 0, len(sym_exvars))
rapp = rapp.remove_dims(isl._isl.dim_type.out, 0,
len(sym_exvars) * 2)
if not Extend:
z = z.apply(_rap)
fsnew_tiletry.fs_new(isl_rel, isl_relplus, rtile, LPetit, dane,
plik, SIMPLIFY, rapp, exact_rplus, z,
sym_exvars, maxl, step, isl_TILEprim, vars)
# przelec po blokach znajdz relacje jak nie ma to parallel
def convert_loop(input_loop, block=[]):
# input_loop = []
output_loop = []
endl = []
def_lines = []
def_lines.append('builtin integer myfun()')
for_level = 0 #ktora petla for zagniezdzona
# input_loop.append("for(i=1; i<=100; i++){")
# input_loop.append(" a1_1[i][i] = 11;")
# input_loop.append("}")
varsn = []
funcs = []
nest = 0
odst = 0
#dodaj klamry do brakujacych for
curly = []
for i in range(0,len(input_loop)):
line = input_loop[i]
line = line.replace("\t", "")
line = line.replace(" ", "")
line = line.replace("elseif", " else if")
line = line.replace("int", "")
# usun komentarze
pattern = re.compile("//.*$")
line = pattern.sub("", line)
# zmien zmienna out
pattern = re.compile("\\bout\\b")
line = pattern.sub("out1", line)
if(len(block) > 0):
stuff = functions.Loop(line, block[for_level])
else:
stuff = functions.Loop(line)
ifek = functions.If_Statement(line)
if(stuff != 0):
for_level = for_level + 1
if(stuff != 0 or ifek != ""):
if "{" in line:
nest = 1
else:
nest = 0
for j in range(i+1,len(input_loop)):
line2 = input_loop[j]
if line2.isspace():
continue
if "{" in line2:
nest = nest + 1
if "}" in line2:
nest = nest - 1
if "for" in line2:
continue
if nest == 0:
if ifek != "" and not 'else' in input_loop[j+1]:
#input_loop[j] = "endif"
curly.append([j, "endif"])
else:
if(stuff != 0):
curly.append([j, "endfor"])
for_level = for_level - 1
#input_loop[j] = "endfor"
break
curly = sorted(curly, key=lambda curly: curly[0], reverse=True)
for c in curly:
input_loop.insert(c[0]+1, c[1])
for line in input_loop:
if "pragma" in line:
continue
nest = 0
line = line.replace("\t", "")
line = line.replace(" ", "")
line = line.replace("elseif", " else if")
line = line.replace("int", "")
pattern = re.compile("//.*$")
line = pattern.sub("", line)
pattern = re.compile("\\bout\\b")
line = pattern.sub("out1", line)
if(len(block) > 0):
stuff = functions.Loop(line, block[for_level])
else:
stuff = functions.Loop(line)
if(stuff != 0):
output_loop.append(stuff["new_loop"])
# endl.append("endfor")
ifek = functions.If_Statement(line)
if(ifek != ""):
output_loop.append(ifek)
varsn = functions.CollectVars(varsn, line)
pattern = re.compile("\W*(\}|\{)\W*")
if(ifek == "" and stuff == 0 and (not pattern.match(line))):
pattern = re.compile("\w+\(");
items = pattern.findall(line)
for item in items:
z = item.replace("(", "")
if (z == "max" or z == "MAX" or z == "min" or z == "MIN"): # petit je zna
continue
if not (z in funcs): # no reduncancy
funcs.append(z)
output_loop.append(functions.ConvertSt(line))
#print funcs
#sys.exit(0)
for f in funcs:
def_lines.append('builtin integer ' + f +'()')
if f in varsn:
varsn.remove(f) # remove variable witch is a fun()
for _var in varsn:
dim_var =functions._DIM(_var)
if dim_var >= 0:
defv = functions.MakeDef(_var, dim_var)
def_lines.append(defv)
# for line in def_lines:
# print line
# for line in output_loop:
# print line
# for line in endl:
# print line
return def_lines + output_loop #+ endl
def CorrectLoop(_file):
linestring = open(_file, 'r').read()
lines = linestring.split('\n')
z1 = re.compile("\W*if\W*\(")
z2 = re.compile("\)\W*{")
z3 = re.compile("\W*for\W*\(")
z4 = re.compile(" ")
box = [] # tu przechowane sa warunki
i=0
while(i<len(lines)):
line = lines[i]
if(z1.match(line)): #ify
# if
tmp = line
tmp = z1.sub("", line)
tmp = z2.sub("", tmp)
tmp = z4.sub("", tmp)
box_item = { 'con' : tmp, 'from' : i, "to" : find_bracelet(i, lines), "if" : 1}
box.append(box_item)
if(z3.match(line)): #fory
stuff = functions.Loop(line.replace(' ', ''))
if(stuff==0):
return -1
constraint = stuff['var'] + " >= " + str(stuff["lb"]) + " && " + stuff["var"] + " <= " + str(stuff["ub"])
constraint = z4.sub("", constraint)
box_item = { 'con' : constraint, 'from' : i, "to" : find_bracelet(i, lines), "if" : 0}
box.append(box_item)
i = i + 1
rem_lines = []
for item in box:
if(item['if'] == 1):
tmp = item['con']
tmp_items = tmp.split("&&")
for item2 in box:
if(item2['from'] != item['from']):
if(item2['from'] <= item['from'] and item2['to'] >= item['to']):
tmp2 = item2['con']
tmp2_items = tmp2.split("&&")
x = []
for element in tmp_items:
if element not in tmp2_items:
x.append(element)
tmp_items = x
if(tmp_items == []):
rem_lines.append(item['from'])
rem_lines.append(item['to'])
new_loop = []
i=0
while(i<len(lines)):
if not (i in rem_lines):
if(lines[i] != '' and lines[i].strip() != ''):
new_loop.append(lines[i] + "\n")
i = i + 1
file= open(_file, 'w')
file.writelines(new_loop)
file.close()
