#! /usr/bin/python # THIS IS CUDAIZE.PY import chill import sys import math strided = 0 counted = 1 def print_code(): chill.print_code() print "" sys.stdout.flush() def table_contains_key( table, key ): # use a dict for the 'table'? return table.has_key(key) # (key in table)? def print_array( arr ): # a useful function to mimic lua output for a in arr[:-1]: print "%s," % a, print "%s" % arr[-1] sys.stdout.flush() def valid_indices( statement, indices ): #print "valid_indices() python calling C cur_indices" #print statement cur = chill.cur_indices(statement) # calls C #print "python valid_indices(), cur = ", #print cur #print "indices = ", #print indices for index in indices: if not index in cur: return False return True def next_clean_level( indices_at_each_level, level): #print "next_clean_level( ..., %d )" % level #print "indices_at_each_level ", print_array( indices_at_each_level ) numlevels = len(indices_at_each_level) #print "loop to %d" % numlevels for i in range(level+1, numlevels+1): pythoni = i-1 # LUA index starts at 1 #print "Checking level %d = '%s'" % (i, indices_at_each_level[pythoni]) sys.stdout.flush() if len(indices_at_each_level[pythoni]) > 0: # LUA INDEX STARTS AT 1 #print "returning %d" % i return i # MATCH lua return value, LUA index starts at one return -1 # no non-dummy indices def build_order( final_order, tile_index_names, control_index_names, tile_index_map, current_level): order = [] #print "\nbuild_order()" #print "build_order(): final_order = (", count = 0 for f in final_order: #if count+1 == len(final_order): # print "%s )" % f #else: # print "%s," % f , count += 1 keys = control_index_names.keys() keys.sort() #if (2 == len(keys)): # print "build_order(): ctrl_idx_names = (%s, %s)" % (control_index_names[0], control_index_names[1]) #else: # print "build_order(): ctrl_idx_names = (%s" % control_index_names[0], # for k in keys[1:]: # print ", %s" % control_index_names[k], # print ")" #print control_index_names #print "cur_level %d" % current_level #print "tile index map: ", #print tile_index_map for i in range(len(final_order)): k = final_order[i] # not used? skip = False cur = final_order[i] # control loops below our current level should not be in the current order # skip = cur in control_index_names[current_level+2:] #print "\n%d control_index_names, " % len(control_index_names) #print control_index_names for j in range(current_level+1, len(control_index_names)): #print "comparing cur %s with cin[%d] %s" % ( cur, j, control_index_names[j]) if control_index_names[j] == cur: skip = True #print "SKIP %s " % cur # possibly substitute tile indices if necessary if tile_index_map.has_key(cur): approved_sub = False sub_string = tile_index_map[cur] #print "sub_string = ", #print sub_string # approved_sub = sub_string in tile_index_names[current_level+2:] for j in range(current_level+1, len(tile_index_names)): if tile_index_names[j] == sub_string: approved_sub = True if approved_sub: cur = sub_string if not skip: order.append( cur) #print "build_order() returning order (", #print order #for o in order: # print "%s," % o, #print ")" return order def find_cur_level( stmt, idx ): #print "find_cur_level(stmt %d, idx %s) Cur indices" % ( stmt, idx ), cur = chill.cur_indices(stmt) #for c in cur[:-1]: # print "%s," % c, #print "%s" % cur[ -1 ] index = 1 # lua starts indices at 1 !! for c in cur: if c == idx: #print "found it at index %d" % index #sys.stdout.flush() #print "in find_cur_level, returning ", #print index return index index += 1 #print "find_cur_level(), Unable to find index %s in" % idx, #print cur #print "in find_cur_level, returning -1" return -1 # special meaning "it's not there" def chk_cur_level( stmt, idx ): # search cur_indices for a ind at stmt cur = chill.cur_indices(stmt) if idx in cur: return 1 + cur.index(idx) # lua index starts at 1 ! return -1 def find_offset( cur_order, tile, control): #print "Looking for tile '%s' and control '%s' in (" % (tile, control), #print cur_order #for o in cur_order: # print "%s," % o, #print ")" idx1 = -1 idx2 = -1 if tile in cur_order: idx1 = 1 + cur_order.index(tile) # lua indexes from 1! else: print "find_offset(), unable to find tile %s in current list of indices" % tile sys.exit(-1) if control in cur_order: idx2 = 1 + cur_order.index(control) # lua indexes from 1! else: print "find_offset(), unable to find control %s in current list of indices" % control sys.exit(-1) #print "found at level %d and %d" % ( idx2, idx1 ) # this appears horrible if idx2 < idx1: return idx2-idx1+1 # bad ordering else: return idx2-idx1 def tile_by_index( tile_indices, sizes, index_names, final_order, tile_method): #print "STARTING TILE BY INDEX" #print "tile_by_index() tile_method ", #print tile_method #print "index_names: ", #print index_names stmt = 0 # assume statement 0 if not valid_indices( stmt, tile_indices): print "python tile_by_index() one or more of ", print tile_indices, print " is not valid" sys.exit(-1) if tile_method == None: #print "CREATING tile_method = 1" tile_method = 1 # "counted" tile_index_names = [] for ti in tile_indices: tile_index_names.append( ti ) # make a copy? #print "tile_index_names:", #print tile_index_names control_index_names = {} # a dictionary? tile_index_map = {} #print "index_names: " #print index_names for pair in index_names: valid = False control = pair[0] name = pair[1] #print "control %s name %s" % ( control, name ) if control[0] == "l" and control[1].isdigit(): if control.endswith("_control"): index = int(control[1: -8]) control_index_names[index-1] = name valid = True elif control.endswith("_tile"): index = int(control[1: -5]) #print "index %d" % index tile_index_names[index-1] = name # ?? tile_index_map[name] = tile_indices[index-1] valid = True if not valid: print "%s is not a proper key for specifying tile or control loop indices\n" % control #print "control_index_names = ", #print control_index_names #print "tile_index_names = ", #print tile_index_names #print "before call to build_order(), tile_index_map = ", #print tile_index_map # filter out control indices (and do name substitution of unprocessed tile indices) for a given level cur_order = build_order(final_order, tile_indices, control_index_names, tile_index_map, -1) #print "returned from build_order python\n\n" # print("permute("..stmt..", {"..list_to_string(cur_order).."})") #print "permute(%d, {" % stmt, #print "cur_order = ", #print cur_order, #print "})" cur_order.insert(0, stmt) #print cur_order chill.permute( tuple( cur_order)) #print "in cudaize.py, returned from C code chill.permute()\n" for i in range(len(tile_indices)): cur_idx = tile_indices[i] #print "i %d cur_idx %s calling build order ********" % (i, cur_idx) cur_order = build_order( final_order, tile_indices, control_index_names, tile_index_map, i) #print "cur_idx %s return from build order" % cur_idx # Find an offset between tile loop and control loop # 0 = control loop one level above tile loop # -1 = control loop two levels above tile loop # > 0 = tile loop above control loop # In the last case, we do two extra tile commands to get the control # above the tile and then rely on the final permute to handle the # rest level = find_cur_level(stmt,cur_idx) #print "level %d\n" % level offset = find_offset(cur_order, tile_index_names[i], control_index_names[i]) #print "offset %d" % offset if offset <= 0: #print "[offset<=0]1tile(%d, %d, %d, %d, %s, %s, %d)" % (stmt, level, sizes[i], level+offset, tile_index_names[i], control_index_names[i], tile_method ) chill.tile7( stmt, level, sizes[i], level+offset, tile_index_names[i], control_index_names[i], tile_method ) #print "in cudaize.py, returned from C code chill.tile7\n" else: #print "2tile(%d, %d, %d, %d, %s, %s, %d)" % (stmt, level, sizes[i], level+offset-1, tile_index_names[i], control_index_names[i], tile_method ) chill.tile7( stmt, level, sizes[i], level+offset-1, tile_index_names[i], control_index_names[i], tile_method ) # regular level # flip and tile control loop #print "3tile(%d, %d, %d)" % ( stmt, level+1, level+1) chill.tile3( stmt, level+1, level+1) #print "4tile(%d, %d, %d)" % ( stmt, level+1, level) chill.tile3( stmt, level+1, level) #print_code() # Do permutation based on cur_order #print("permute based on build order calling build_order()") cur_order = build_order(final_order, tile_indices, control_index_names, tile_index_map, i) #print("permute based on build order return from build_order()") # print("permute("..stmt..", {"..list_to_string(cur_order).."})") topermute = cur_order topermute.insert(0, stmt) chill.permute( tuple(topermute) ) #print "\nafter permute(), code is:" #print_code() def normalize_index( index ): #print "in cudaize.py, normalize_index( %s )" % index stmt = 0 # assume stmt 0 l = find_cur_level( stmt, index ) chill.tile3( stmt, l, l ) def is_in_indices( stmt, idx): cur = chill.cur_indices(stmt) return idx in cur def copy_to_registers( start_loop, array_name ): #print "\n\n****** starting copy to registers" #sys.stdout.flush() stmt = 0 # assume stmt 0 cur = chill.cur_indices(stmt) # calls C table_Size = len(cur) #print "Cur indices", #print_array(cur) #print "\nThe table size is %d" % table_Size #count=1 #for c in cur: # print "%d\t%s" % (count,c) # count += 1 #print_code() # would be much cleaner if not translating this code from lua! level_tx = -1 level_ty = -1 if is_in_indices(stmt,"tx"): level_tx = find_cur_level(stmt,"tx") if is_in_indices(stmt,"ty"): level_ty = find_cur_level(stmt,"ty") #print "level_tx %d level_ty %d" % ( level_tx, level_ty ) #sys.stdout.flush() ty_lookup_idx = "" org_level_ty = level_ty # UGLY logic. Lua index starts at 1, so all tests etc here are off by 1 from the lua code # level_ty initializes to -1 , which is not a valid index, and so there is added code to # make it not try to acccess offset -1. -1 IS a valid python array index # to top it off, the else below can assign a NIL to ty_lookup_idx! if level_ty != -1 and cur[level_ty] != "": #print "IF cur[%d] = %s" % ( level_ty, cur[level_ty] ) ty_lookup_idx = cur[level_ty] else: #print "ELSE ty_lookup_idx = cur[%d] = %s" % ( level_ty, cur[level_ty-1]) ty_lookup_idx = cur[level_ty-1] #print "ty_lookup_idx '%s'" % ty_lookup_idx if level_ty > -1: #print "\ntile3(%d,%d,%d)" % (stmt,level_ty,level_tx+1) chill.tile3(stmt,level_ty,level_tx+1) #print_code() cur = chill.cur_indices(stmt) # calls C table_Size = len(cur) #print "Cur indices ", #for c in cur: # print "%s," % c, #print "\nThe table size is %d" % len(cur) #count=1 #for c in cur: # print "%d\t%s" % (count,c) # count += 1 #sys.stdout.flush() if is_in_indices(stmt,"tx"): level_tx = find_cur_level(stmt,"tx") if ty_lookup_idx != "": # perhaps incorrect test if is_in_indices(stmt,ty_lookup_idx): level_ty = find_cur_level(stmt,ty_lookup_idx) ty_lookup = 1 idx_flag = -1 # find the level of the next valid index after ty+1 #print "\nlevel_ty %d" % level_ty if level_ty > -1: #print "table_Size %d" % table_Size for num in range(-1 + level_ty+ty_lookup,table_Size): # ?? off by one? #print "num=%d cur[num] = '%s'" % (num+1, cur[num]) # num+1 is lua index ???? sys.stdout.flush() if cur[num] != "": idx_flag = find_cur_level(stmt,cur[num]) #print "idx_flag = %d" % idx_flag break #print "\n(first) I am checking all indexes after ty+1 %s" % idx_flag #print_code() #print "" how_many_levels = 1 #print "idx_flag = %d I will check levels starting with %d" % (idx_flag, idx_flag+1) # lua arrays start at index 1. the next loop in lua starts at offset 0, since idx_flag can be -1 # thus the check for "not equal nil" in lua (bad idea) # python arrays start at 0, so will check for things that lua doesn't (?) startat = idx_flag + 1 if idx_flag == -1: startat = 1 # pretend we're lua for now. TODO: fix the logic for ch_lev in range(startat,table_Size+1): # logic may be wrong (off by one) #print "ch_lev %d" % ch_lev if ch_lev <= table_Size and cur[ch_lev-1] != "": #print "cur[%d] = '%s'" % ( ch_lev, cur[ch_lev-1] ) how_many_levels += 1 #print "\nHow Many Levels %d" % how_many_levels sys.stdout.flush() sys.stdout.flush() if how_many_levels< 2: while( idx_flag >= 0): for num in range(level_ty+ty_lookup,table_Size+1): #print "at top of loop, num is %d" % num #print "cur[num] = '%s'" % cur[num-1] if cur[num-1] != "": idx = cur[num-1] #print "idx '%s'" % idx sys.stdout.flush() curlev = find_cur_level(stmt,idx) #print "curlev %d" % curlev #print "\n[COPYTOREG]tile(%d,%d,%d)"%(stmt,curlev,level_tx) chill.tile3(stmt, curlev, curlev) curlev = find_cur_level(stmt,idx) #print "curlev %d" % curlev chill.tile3(stmt,curlev,level_tx) #print "hehe '%s'" % cur[num-1] cur = chill.cur_indices(stmt) #print "Cur indices INSIDE", #for c in cur: # print "%s," % c, table_Size = len(cur) #print "\nTable Size is: %d" % len(cur) level_tx = find_cur_level(stmt,"tx") #print "\n level TX is: %d" % level_tx level_ty = find_cur_level(stmt,ty_lookup_idx) #print "\n level TY is: %d" %level_ty idx_flag = -1 #print "idx_flag = -1" #- find the level of the next valid index after ty+1 #- the following was num, which conflicts with loop we're already in, and otherwise wasn't used (?) for num2 in range( -1 + level_ty+ty_lookup ,table_Size): # lua starts index at one #print "num mucking num = %d" % num2 if(cur[num2] != ""): #print "cur[%d] = '%s'" % ( num2, cur[num2] ) idx_flag = find_cur_level(stmt,cur[num2]) #print("\n(second) I am checking all indexes after ty+1 %s",cur[num2]) break #print "num mucked to %d idx_flag = %d" % (num, idx_flag) #print "at bottom of loop, num is %d" % num #print "done with levels" # this was a block comment ??? # for num in range(level_ty+1, table_Size+1): # print "num %d" % num # if cur[num-1] != "": # idx_flag = find_cur_level(stmt,cur[num-1]) ## ugly # print "idx_flag = %d" % idx_flag # change this all to reflect the real logic which is to normalize all loops inside the thread loops. # print "change this all ...\n" # print "level_ty+1 %d table_Size-1 %d idx_flag %d" %( level_ty+1, table_Size-1, idx_flag) # sys.stdout.flush() # sys.stdout.flush() # while level_ty+1 < (table_Size-1) and idx_flag >= 0: # print "*** level_ty %d" % level_ty # for num in range(level_ty+2,table_Size+1): # lua for includes second value # print "num %d cur[num] %s" % (num, cur[num]) # if cur[num] != "": # idx = cur[num] # print "idx='%s'" % idx # #print_code() #print "ARE WE SYNCED HERE?" #print_code() # [Malik] end logic start_level = find_cur_level(stmt, start_loop) # start_loop was passed parameter! # We should hold constant any block or tile loop block_idxs = chill.block_indices() thread_idxs = chill.thread_indices() #print"\nblock indices are" #for index, val in enumerate(block_idxs): # print "%d\t%s" % ( int(index)+1 , val ) #print"\nthread indices are" #for index, val in enumerate(thread_idxs): # print "%d\t%s" % ( int(index)+1 , val ) #print "\nStart Level: %d" % start_level hold_constant = [] #print("\n Now in Blocks") for idx in block_idxs: blocklevel = find_cur_level(stmt,idx) if blocklevel >= start_level: hold_constant.append(idx) #print "\nJust inserted block %s in hold_constant" %idx #print("\n Now in Threads") for idx in thread_idxs: blocklevel = find_cur_level(stmt,idx) if blocklevel >= start_level: hold_constant.append(idx) #print "\nJust inserted thread %s in hold_constant" %idx #print "\nhold constant table is: " #for index, val in enumerate(hold_constant): # print "%d\t%s" % ( int(index)+1 , val ) #print("\nbefore datacopy pvt") old_num_stmts = chill.num_statements() #sys.stdout.flush() #print "\n[DataCopy]datacopy_privatized(%d, %s, %s, " % (stmt, start_loop, array_name), #print hold_constant, #print ")" passtoC = [stmt, start_loop, array_name ] # a list passtoC.append( len(hold_constant ) ) for h in hold_constant: passtoC.append( h ) chill.datacopy_privatized( tuple( passtoC )) sys.stdout.flush() sys.stdout.flush() new_num_statements = chill.num_statements() #print "new num statements %d" % new_num_statements # Unroll to the last thread level # for stmt in range(old_num_statements, new_num_statements): # print "unrolling statement %d" % stmt # level = find_cur_level(stmt,thread_idxs[-1]) #get last thread level # print "level is %d" % level # idxs = chill.cur_indices(stmt) # if level < len(idxs): # chill.unroll(stmt,level+1,0) def copy_to_shared( start_loop, array_name, alignment ): #print "\nstarting copy to shared( %s, %s, %d)" % (start_loop, array_name, alignment ) #print "copy_to_shared( %s, %s, %d) in cudaize.py" % ( start_loop, array_name, alignment ) stmt = 0 # assume statement 0 cur = chill.cur_indices(stmt) #print "Cur indices ", #print_array( cur ) start_level = find_cur_level( stmt, start_loop ) #print "start_level %d" % start_level old_num_statements = chill.num_statements() #print "old_num_statements %d" % old_num_statements # Now, we give it indices for up to two dimensions for copy loop copy_loop_idxs = ["tmp1","tmp2"] #chill.datacopy_9arg(stmt, start_level, array_name, copy_loop_idxs, False, 0, 1, alignment,True) passtoC = [stmt, start_level, array_name] # a list passtoC.append( len(copy_loop_idxs)) for i in copy_loop_idxs: passtoC.append(i) passtoC.append( 0 ) # False passtoC.append( 0 ) passtoC.append( 1 ) passtoC.append( alignment ) passtoC.append( 1 ) # True #print "\n[DataCopy]datacopy( ", #print passtoC, #print ")" #if array_name == "b": # chill.cheat(1) #if array_name == "c": # chill.cheat(2) chill.datacopy_9arg( tuple( passtoC )) #print "back from datacopy_9arg\n\n\n" #sys.stdout.flush() #print "calling add_sync( %d, %s )" % ( stmt, start_loop ) chill.add_sync( stmt, start_loop ) #print "back from add_sync()\n\n" new_num_statements = chill.num_statements() # This is fairly CUBLAS2 specific, not sure how well it generalizes, # but for a 2D copy, what we want to do is "normalize" the first loop # "tmp1" then get its hard upper bound. We then want to tile it to # make the control loop of that tile "ty". We then tile "tmp2" with a # size of 1 and make it "tx". #print "fairly CUBLAS2 specific, OLD %d NEW %d" % ( old_num_statements, new_num_statements) sys.stdout.flush() sys.stdout.flush() for stmt in range(old_num_statements, new_num_statements): #print "for stmt = %d" % stmt level = find_cur_level( stmt, "tmp2") #print "FOUND CUR LEVEL? level '", #print level, #print "'" #print "in loop, stmt %d level %d" % ( stmt, level ) if level != -1: #print "\nCopy to shared: [If was no error]\n" find_cur_level(stmt,"tmp2") chill.tile3( stmt, level, level ) #print "hard_loop_bounds( %d, %d )" % (stmt, level) bounds = chill.hard_loop_bounds(stmt, level) lower = bounds[0] upper = 1+ bounds[1] #print "lower %d upper %d" % ( lower, upper ) dims = chill.thread_dims() #print "in cudaize.py copy_to_shared, dims =", #print dims tx = dims[0] ty = dims[1] #print "2-loop cleanup: lower, upper: %d, %d, tx: %d" % ( lower, upper, tx) level = find_cur_level(stmt,"tmp1") #print "level %d" % level if tx == upper and ty == 1: #print "tx = %d upper = %d ty = %d"% (tx, upper, ty) #print "Don't need" # Don't need an extra tile level, just move this loop up second_level = find_cur_level(stmt,"tmp2") chill.tile7(stmt, second_level, 1, level, "tx", "tx", counted) else: #print "DO need?" if ty == 1: new_ctrl = "tmp3" else: new_ctrl = "ty" # LOTS of commented out code here in cudaize.lua #print_code() #print "\nStarting tmp2\n" first_level = find_cur_level(stmt,"tmp1") second_level = find_cur_level(stmt,"tmp2") bounds = chill.hard_loop_bounds(stmt, second_level) lower = bounds[0] upper = 1 + bounds[1] # BROKEN? #print "[Malik]-loop cleanup@tmp2: lower, upper: %d, %d, tx: %d,first level:%d,second_level:%d" % ( lower, upper-1, tx, first_level, second_level) # Move the fastest changing dimension loop to the outermost,identified by "tmp2" and to be identified as tx. #print "\n[fastest]tile(%d, %d, %d,%d,%s,%s,counted)"%(stmt, second_level,1,first_level, "tx", "tx") chill.tile7(stmt, second_level,1,first_level,"tx","tx",counted) #print_code() first_level = find_cur_level(stmt,"tmp1") bounds = chill.hard_loop_bounds(stmt, first_level) lower_1 = bounds[0] upper_1 = 1 + bounds[1] tx_level = find_cur_level(stmt,"tx") bounds = chill.hard_loop_bounds(stmt,tx_level) lower_tx = bounds[0] upper_tx = 1+bounds[1] #print "UL_1 %d %d UL_tx %d %d" % ( lower_1, upper_1-1, lower_tx, upper_tx-1) if int(math.ceil( float(upper_tx)/float(tx))) > 1: #print "ceil I say" #print "\n[Tile1]tile(%d, %d, %d,%d,%s,%s,counted)" % (stmt, tx_level,tx,tx_level, "tx", "tmp1") chill.tile7(stmt,tx_level,tx,tx_level,"tx","tmp_tx",counted) #print_code() repeat = find_cur_level(stmt,"tx") #print "\n[Tile1]tile(%d, %d, %d)" % (stmt, repeat, repeat) chill.tile3(stmt, repeat, repeat) #find_cur_level(stmt,"tx"),find_cur_level(stmt,"tx")) #print_code() if find_cur_level(stmt,"tx")>find_cur_level(stmt,"tmp_tx"): #print "\nagain [Tile1]tile(%d, %d, %d)" % (stmt,find_cur_level(stmt,"tx"),find_cur_level(stmt,"tmp_tx")) chill.tile3(stmt,find_cur_level(stmt,"tx"),find_cur_level(stmt,"tmp_tx")) #print_code() #print_code() #print "\nStarting tmp1\n" # Handle the other slower changing dimension, the original outermost loop, now identified by "tmp1", to be identified as "ty". chill.tile3(stmt,find_cur_level(stmt,"tmp1"),find_cur_level(stmt,"tmp1")) #print_code() ty_level = find_cur_level(stmt,"tmp1") bounds = chill.hard_loop_bounds(stmt,ty_level) lower_ty = bounds[0] upper_ty = 1 + bounds[1] tx_level = find_cur_level(stmt,"tx") bounds = chill.hard_loop_bounds(stmt,tx_level) lower_tx = bounds[0] upper_tx = 1 + bounds[1] #print "[Malik]-loop cleanup@tmp1: lowerty, upperty: %d, %d, ty: %d,ty level:%d,tx_level:%d, stmt: %d" % ( lower_ty, upper_ty-1, ty, ty_level, tx_level, stmt) #print "before ceil" #sys.stdout.flush() if(math.ceil(float(upper_ty)/float(ty)) > 1): #print "CEIL IF" #print "\n Inside upper_ty/ty > 1\n" #print "\n[Tile2]tile(%d, %d, %d,%d,%s,%s,counted)"%(stmt, ty_level,ty,ty_level, "ty", "tmp_ty") chill.tile7(stmt,ty_level,ty,ty_level,"ty","tmp_ty",counted) #print_code() #print "\n[Tile2-1]tile(%d, %d, %d)"%(stmt,find_cur_level(stmt ,"ty"),find_cur_level(stmt,"ty")) chill.tile3(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"ty")) #print_code() cur_idxs = chill.cur_indices(stmt) #print "\n cur indexes are ", #print_array( cur_idxs) #sys.stdout.flush() # Putting ty before any tmp_tx idx_flag = -1 if "tmp_tx" in cur_idxs: idx_flag = 1 + cur_idxs.index("tmp_tx") # lua index starts at 1 #print "\n (1) so i have found out the value of idx flag as %d" % idx_flag #sys.stdout.flush() if idx_flag >= 0: if find_cur_level(stmt,"ty") > find_cur_level(stmt,"tmp_ty"): #print "\n[Tile2-2]tile(%d, %d, %d)"%(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty")) chill.tile3(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty")) #print_code() # Now Putting ty before any tmp_ty sys.stdout.flush() idx_flag = -1 if "tmp_ty" in cur_idxs: idx_flag = 1 + cur_idxs.index("tmp_ty") # lua index starts at 1 #print "\n IF so i have found out the value of idx flag as %d" % idx_flag #sys.stdout.flush() if idx_flag >= 0: #print "one more test" sys.stdout.flush() if find_cur_level(stmt,"ty")>find_cur_level(stmt,"tmp_ty"): #print "\n[Tile2-2]tile(%d, %d, %d)"%(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty")) #sys.stdout.flush() chill.tile3(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty")) #print_code() else: #print "CEIL ELSE" #print "\n[Tile3]tile(%d, %d, %d,%d,%s,%s,counted)" % (stmt, ty_level,1,ty_level, "ty", "ty") #sys.stdout.flush() chill.tile7( stmt, ty_level, 1, ty_level, "ty", "ty", counted ) #print_code() #print "\n[Tile3-1]tile(%d, %d, %d)"%(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tx")+1) sys.stdout.flush() chill.tile3(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tx")+1) #print_code() idx_flag = -1 # LUA code checks to see if cur_idxs exists? it is unused except in the other clause of this is #if(cur_idxs) then #print "CAN NEVER GET HERE? cur_idxs" #for num= 0,table.getn(cur_idxs) do #if(cur[num] == "tmp_ty") then #idx_flag = find_cur_level(stmt,cur[num]) #break #end #end print "\n ELSE so i have found out the value of idx flag as %d" % idx_flag if idx_flag >= 0: # can't happen print "tile( stmt %d, level ty %d, level ty %d" % ( stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty")) #chill.tile3(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty")) #print "\n\n *** at bottom of if in copy to shared, " #print_code() #print "end of if" else: # copy to shared only created one level, not two, so we use a different approach (MV & TMV) #print "\nCopy to shared: [If was error]\n" level = find_cur_level(stmt,"tmp1") chill.tile3(stmt, level, level) dims = chill.thread_dims() #print dims tx = dims[0] ty = dims[1] bounds = chill.hard_loop_bounds(stmt, level) lower = bounds[0] upper = bounds[1] #print "bounds lower %d upper %d" % (lower, upper) upper = upper+1 # upper bound given as <=, compare to dimensions tx which is < if upper == tx: #print "upper == tx" chill.rename_index( stmt, "tmp1", "tx") else: #print "upper is not tx" #print "upper %d tx %d stmt: %d level: %d" % ( upper, tx, stmt, level) chill.tile7( stmt, level, tx, level, "tx", "tmp_tx", counted) #print_code() #print "stmt:%d level+1: %d" % ( stmt, level+1) #print("TILE 7") chill.tile7( stmt, level+1,1,level+1,"tx", "tx",counted) #print("TILE 3") chill.tile3( stmt, level+1, level) #print_code() if ty > 1: #print "GOING IN" bounds = chill.hard_loop_bounds(stmt, level+1) lower = bounds[0] upper = bounds[1] #print "ty %d lower %d upper %d" % ( ty, lower, upper ) floatdiv = float(upper)/float(ty) bound = int(math.ceil(float(upper)/float(ty))) #print "NOW FOR Y: upper %d ty %d stmt: %d level: %d bound: %d" % ( upper, ty, stmt, level+1, bound) chill.tile7(stmt, level+1, bound, level+1, "tmp_ty", "ty", counted) # Always add sync chill.add_sync( stmt, start_loop ) #print "ending copy to shared\n" #sys.stdout.flush() #print_code() def unroll_to_depth( max_depth ): print "\n\nunroll_to_depth(%d)" % max_depth print "SYNC UP" sys.stdout.flush() cur = chill.cur_indices(0) thread_idxs = chill.thread_indices() guard_idx = thread_idxs[-1] # last one print "cur indices", print_array(cur) print "thread indices", print_array(thread_idxs) print "guard_idx = %s" % guard_idx #print "thread_idxs = ", #print thread_idxs guard_idx = thread_idxs[-1] #print "guard_idx = %s" % guard_idx # HERE FIND OUT THE LOOPS WHICH ARE COMMON BETWEEN STATEMENTS common_loops = [] comm_loops_cnt = 0 num_stmts = chill.num_statements() print "num statements %d" % num_stmts for stmt in range(num_stmts): sys.stdout.flush() print "\nSTMT %d" % stmt, cur_idxs = chill.cur_indices(stmt) print "Current Indices:", for c in cur_idxs[:-1]: print "%s," % c, print "%s" % cur_idxs[-1] # last one sys.stdout.flush() #print_code() if chk_cur_level(stmt, "tx") > 0: for ii in range(find_cur_level(stmt,"tx")-1): print "ii = %d\ncur_idxs[%d] = '%s'" % (ii+1, ii+1, cur_idxs[ii]) # print to match lua id = cur_idxs[ii] if id not in ["bx", "by", "", "tx", "ty"]: print "id %s is not in the list" % id for stmt1 in range(stmt+1, num_stmts): print "\nii %d stmt1 is %d" % (ii+1, stmt1) # print to match lua cur_idxs1 = chill.cur_indices(stmt1) print "\nstmt1 cur_idxs1 is ", for ind in cur_idxs1[:-1]: print "%s," % ind, print "%s" % cur_idxs1[-1] print "cur level(%d, %s) = %d" % (stmt, "tx", find_cur_level(stmt,"tx") ) sys.stdout.flush() endrange = find_cur_level(stmt,"tx")-1 print "for iii=1, %d do" % endrange sys.stdout.flush() for iii in range(endrange): # off by one? TODO print "stmt %d ii %d iii %d\n" % (stmt, ii+1, iii+1), sys.stdout.flush() if iii >= len(cur_idxs1): print "stmt %d ii %d iii %d cur_idxs1[%d] = NIL" % (stmt, ii+1, iii+1, iii+1, ) # print to match lua else: print "stmt %d ii %d iii %d cur_idxs1[%d] = '%s'" % (stmt, ii+1, iii+1, iii+1, cur_idxs1[iii]) # print to match lua sys.stdout.flush() # this will still probably die if iii < len(cur_idxs1) and [iii] not in ["bx", "by", "tx", "ty", ""]: if cur_idxs[ii] == cur_idxs1[iii]: print "\nfound idx:%s" % cur_idxs[ii] common_loops.append(cur_idxs[ii]) print "cl[%d] = '%s'" % ( comm_loops_cnt, cur_idxs[ii] ) comm_loops_cnt = len(common_loops) if len(common_loops) > 0: print "\n COMM LOOPS :TOTAL %d, and are " % comm_loops_cnt, print common_loops, print " this loop : %s" % common_loops[0] else: print "UNROLL can't unroll any loops?" while True: # break at bottom of loop (repeat in lua) old_num_statements = chill.num_statements() print "old_num_statements %d" % old_num_statements for stmt in range(old_num_statements): cur_idxs = chill.cur_indices(stmt) print "stmt %d cur_idxs =" % stmt, index = 0 for i in cur_idxs: index +=1 if index == len(cur_idxs): print "%s" %i else: print "%s," % i, if len(cur_idxs) > 0: guard_level = -1 if chk_cur_level(stmt, guard_idx) > 0: guard_level = find_cur_level(stmt,guard_idx) print "guard_level(sp) = %d" % guard_level if guard_level > -1: level = next_clean_level(cur_idxs,guard_level) print "next clean level %d" % level #print "looking at %d" % stmt #print "comparing %d and %d in" % (guard_level, level), #index = 0 #for i in cur_idxs: #index +=1 #if index == len(cur_idxs): # print "%s" %i #else: # print "%s," % i, # need to handle max_depth num_unrolled = 0 level_unroll_comm = level level_arr = [] #print "before while, level = %d" % level while level >= 0: print "while: level = %d" % level if num_unrolled == max_depth: break print "Unrolling %d at level %d index %s" % ( stmt, level, cur_idxs[guard_level]) # ??? level_arr.append(level) guard_level = find_cur_level(stmt,guard_idx) level = next_clean_level(cur_idxs,level+1) print "OK, NOW WE UNROLL" if level_unroll_comm >= 0: level_arr.reverse() for i,lev in enumerate(level_arr): print "\ni=%d" % i print "[Unroll]unroll(%d, %d, 0)" % (stmt, lev) chill.unroll(stmt, lev, 0) new_num_statements = chill.num_statements() if old_num_statements == new_num_statements: break # exit infinite loop # all other calls to C have a routine in this file (?) def unroll( statement, level, unroll_amount ): chill.unroll( statement, level, unroll_amount )