added cudaize.py from svn repo

1 files changed, 1047 insertions, 0 deletions

diff --git a/examples/cuda-chill/cudaize.py b/examples/cuda-chill/cudaize.py
new file mode 100755
index 0000000..ffef009
--- /dev/null
+++ b/examples/cuda-chill/cudaize.py
@@ -0,0 +1,1047 @@
+#! /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 )
+