v0.2.1

24 files changed, 0 insertions, 2849 deletions

diff --git a/test-chill/test-cases/examples/cuda-chill/cp.c b/test-chill/test-cases/examples/cuda-chill/cp.c
deleted file mode 100644
index 837d7a6..0000000
--- a/test-chill/test-cases/examples/cuda-chill/cp.c
+++ /dev/null
@@ -1,29 +0,0 @@
-#define N 1
-
-#define VOLSIZEY 512
-#define VOLSIZEX 512
-#define VOLSIZEZ 1
-#define ATOMCOUNT 4000
-#define GRIDSPACING 0.1
-#define zDim 0
-
-extern float sqrtf(float);
-
-void cenergy_cpu(float atoms[ATOMCOUNT*4],float *energy,float z)
-{
-int i,j,n;float dx,dy,dz; 
-   
-    for (j=0; j<VOLSIZEY; j++) {
-        for (i=0; i<VOLSIZEX; i++) {
-            	  for (n=0;n<ATOMCOUNT;n+=4) {
-				dx = (GRIDSPACING * i) - atoms[n];
-				dy = (GRIDSPACING * j) - atoms[n+1];
-				dz = z - atoms[n+2];
-        		        energy[(j*VOLSIZEX + i)+VOLSIZEX*VOLSIZEY*zDim] += atoms[n+3]/sqrtf( (dx*dx) + (dy*dy)+ (dz*dz) ) ;
-            }
-              
-
-        }
-    }
-}
-
diff --git a/test-chill/test-cases/examples/cuda-chill/cp.lua b/test-chill/test-cases/examples/cuda-chill/cp.lua
deleted file mode 100644
index 1ef2264..0000000
--- a/test-chill/test-cases/examples/cuda-chill/cp.lua
+++ /dev/null
@@ -1,46 +0,0 @@
---CUBLAS 2 MM Multiply
-
---This function form intializes "CUDAIZE v2" versus "CUDAIZE v1" if you
---call init() and use global variables to specify procedure and loop
-
---Second parameter is procedure # and third is loop #
-init("cp.c", "cenergy_cpu", 0) 
-
-dofile("cudaize.lua") --defines custom tile_by_index, copy_to_registers,
-                     --copy_to_shared methods
-V=512
-N=4000
-N=1
-
-Tj=32
-Ti=16
-Tii=16
-Tjj=16
-
---normalize_index("j")
---normalize_index("i")
-print_code()
-normalize_index("n")
--- TILE COMMANDS ZEROOOOOOOOOOO:3
---permute(0,{"i","j","n"})
---tile_by_index({"i","j"},{Ti,Tj},{l1_control="ii",l2_control="jj"},{"ii","jj","i","j","n"})--CU=-1
-tile_by_index({"j","i"},{Tj,Ti},{l1_control="jj",l2_control="ii"},{"jj","ii","j","i","n"})--CU=-1
---tile_by_index({"n"},{Tn},{l1_control="nn"},{"jj","ii","nn","j","i","n"})--CU=-1
-
---tile_by_index({"j","i"},{Tjjj,Tiii},{l1_control="jjj",l2_control="iii"},{"jj","ii","nn","jjj","j","iii","i","n"})--CU=3
---tile_by_index({"i","j"},{Tii,Tjj},{l1_control="iii",l2_control="jjj"},{"ii","jj","i","iii","j","jjj","n"})--CU=3
---tile_by_index({"j"}, {Tn}, {l1_control="j",l1_tile="jjj"}, {"ii", "jj", "nn","jjj","j","i","n"})
---tile_by_index({"i"}, {Tii}, {l1_control="iii",l1_tile="i"}, {"ii", "jj", "iii","i","j","n"})
-print_code()
-cudaize("kernel_GPU",{atoms=N*4,energy=V*V*1},{block={"jj","ii"}, thread={"j","i"}})--CU=3
---cudaize("kernel_GPU",{atoms=N*4,energy=V*V*1},{block={"ii","jj"}, thread={"i","j"}})--CU=3
-print_code()
-copy_to_shared("tx","atoms",-16)
-copy_to_registers("tx","energy")
---copy_to_texture("atoms")
---unroll_to_depth(1)
---unroll(0,9,0)
---unroll(0,5,0)
-
---unroll(0,8,256)
-print_code()
diff --git a/test-chill/test-cases/examples/cuda-chill/cudaize.lua b/test-chill/test-cases/examples/cuda-chill/cudaize.lua
deleted file mode 100644
index 7359cca..0000000
--- a/test-chill/test-cases/examples/cuda-chill/cudaize.lua
+++ /dev/null
@@ -1,1004 +0,0 @@
-
--- THIS IS CUDAIZE.LUA
-
-function table.contains_key(table, key)
-   for k in pairs(table) do
-      if k == key then
-         return true
-      end
-   end
-   return false
-end
-
-function valid_indices(stmt, indices)
-   --print( "valid_indices() lua calling C cur_indices")
-   --io.flush()
-   cur = cur_indices(stmt) 
-   --print("Cur indices "..list_to_string(cur))
-   for idx in pairs(indices) do
-      if not table.contains_key(cur,idx) then
-         return false
-      end
-   end
-   return true
-end
-
-function next_clean_level(cur_idxs,level)
-   --print("next_clean_level( ..., "..level.." )")
-   --print(string.format("indices_at_each_level %s ",list_to_string(cur_idxs) ))
-   
-   --print("loop to "..#cur_idxs)
-   for i=level+1,#cur_idxs do
-      --print("Checking level "..i.." = '"..cur_idxs[i].."'")
-      if (# cur_idxs[i] > 0) then
-         --print("Good enough"..(# cur_idxs[i]))
-         --print("returning "..i)
-         return i
-      end
-   end
-   return -1 --sentinal that there were no non-dummy indices left
-end
-
-function build_order(final_order, tile_idx_names, ctrl_idx_names, tile_idx_map, cur_level)
-   order = {}
-   --print("\nbuild_order()")
-   --print("build_order(): final_order = ( "..list_to_string(final_order).." )")
-   --print("build_order(): ctrl_idx_names = ("..list_to_string(ctrl_idx_names).." )")
-   --print("cur_level "..cur_level.."")
-   --io.flush()
-   
-   for i,k in ipairs(final_order) do
-      skip = false
-      cur = final_order[i]
-      --print("\ncur "..cur.." = final_order["..i.."] = "..final_order[i].."  ")
-      --control loops below our current level should not be in the current order
-      for j=cur_level+2,# ctrl_idx_names do
-         --print("j "..j.." final_order["..i.."] = "..final_order[i].."  ")
-         if ctrl_idx_names[j] == final_order[i] then
-            skip = true
-            --print("SKIP "..final_order[i].."  ")
-            --io.flush()
-         end
-      end
-      --possibly substitute tile indices ifn necessar
-      if table.contains_key(tile_idx_map,final_order[i]) then
-         approved_sub = false
-         sub_string = tile_idx_map[final_order[i]]
-         for j=cur_level+2,# tile_idx_names do
-            if tile_idx_names[j] == sub_string then
-               approved_sub = true
-            end
-         end
-         if approved_sub then
-            cur = sub_string
-         end
-      end
-      if not skip then
-         table.insert(order,cur)
-      end
-   end
-   return order
-end
-
-function list_to_string(str_list)
-   --Helpful debug output
-   l = ""
-   for i,str in ipairs(str_list) do
-      if i > 1 then
-         l = l .. ", " .. str
-      else
-         l = str
-      end
-   end
-   return l
-end
-
-
-function find_cur_level(stmt,idx)
-   --Search cur_indices for a idx at stmt
-   cur = cur_indices(stmt)
-   --print(string.format("find_cur_level(stmt %d, idx %s)  Cur indices %s", stmt, idx, list_to_string(cur)))
-   for i,cidx in ipairs(cur) do
-      if cidx == idx then
-         --print(string.format("found it at index %d", i))
-         return i
-      end
-   end
-   error("Unable to find "..idx.." in current list of indices")
-end
-
-
-function chk_cur_level(stmt,idx)
-   --Search cur_indices for a idx at stmt
-   cur = cur_indices(stmt)
-   for i,cidx in ipairs(cur) do
-      if cidx == idx then
-         return i
-      end
-   end
-   return -1
-end
-
-
-function find_offset(cur_order, tile, control)
-   --print("Looking for tile '"..tile.."' and control '"..control.."' in ( "..list_to_string(cur_order)..", )")
-   idx1 = -1
-   idx2 = -1
-   for i,cur in ipairs(cur_order) do
-      if(cur == tile) then
-         idx1 = i
-      end
-      if(cur == control) then
-         idx2 = i
-      end
-   end
-   if(idx1 < 0) then
-      error("Unable to find tile " .. tile .. " in current list of indices")
-   end
-   if(idx2 < 0) then
-      error("Unable to find control " .. control .. " in current list of indices")
-   end
-   --print("found at level " .. idx2 .. " and " .. idx1)
-   if(idx2 < idx1) then
-      return idx2-idx1+1
-   else
-      return idx2-idx1
-   end
-end
-
-function tile_by_index(tile_indices, sizes, index_names, final_order, tile_method)
-   --print "STARTING TILE BY INDEX"
-   --io.flush()
-   stmt = 0 --assume stmt 0
-   cur = cur_indices(stmt)
-   --print("Cur indices "..list_to_string(cur))
-   if not valid_indices(stmt,tile_indices) then
-      error('One of the indices in the first parameter were not '..
-            'found in the current set of indices.')
-   end
-   if not tile_method then tile_method = counted end
-   tile_idx_names = {}
-   for i,s in ipairs(tile_indices) do tile_idx_names[i]=s end --shallow copy
-   --print("tile_index_names: ['"..list_to_string(tile_indices).."']")
-   
-   --print("index_names:  ") 
-   --for k,v in pairs(index_names) do print(k,v) end
-   
-   --io.flush()
-   
-   ctrl_idx_names = {}
-   tile_idx_map = {}
-   for k,v in pairs(index_names) do
-      valid = false
-      if(string.sub(k,1,1) == "l") then
-         if string.sub(k,-8) == "_control" then
-            i = tonumber(string.sub(k,2,-9))
-            if i and i >= 1 and i <= (# tile_indices) then
-               ctrl_idx_names[i] = v
-               --print(string.format("Handling control %s for loop level %d",v,i))
-               --print("control "..k.."   name  "..v.." ")
-               valid = true
-            end
-         elseif string.sub(k,-5) == "_tile" then
-            i = tonumber(string.sub(k,2,-6))
-            if i and i >= 1 and i <= (# tile_indices) then
-               --print(string.format("tile %s -> %s",tile_indices[i], v))
-               tile_idx_names[i] = v
-               tile_idx_map[v] = tile_indices[i]
-               --print(string.format("tile %s -> %s",tile_indices[i], v))
-               valid = true
-            end
-         end
-      end
-      if not valid then error(string.format("%s is not a proper key for specifying "..
-                                            "tile or control loop indices\n", k)) end
-   end
-   
-   --filter out control indices (and do name substitution of unprocessed tile indices) for a given level
-   cur_order = build_order(final_order, tile_indices, ctrl_idx_names, tile_idx_map, -1)
-   permute(stmt, cur_order)
-   
-   for i,cur_idx in ipairs(tile_indices) do
-      --print(string.format("i %d  cur_idx %s calling build order ********", i-1, cur_idx))
-      cur_order = build_order(final_order, tile_indices, ctrl_idx_names, tile_idx_map, i-1)
-      --Find a 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)
-      offset = find_offset(cur_order, tile_idx_names[i], ctrl_idx_names[i])
-      --print(string.format("offset %d", offset))
-      
-      if (offset <= 0) then
-         --print(string.format("[offset<=0]1tile(%d, %d, %d, %d, %s, %s, %s)",stmt, level, sizes[i], level+offset, tile_idx_names[i], ctrl_idx_names[i], tile_method)) 
-         tile(stmt, level, sizes[i], level+offset, tile_idx_names[i], ctrl_idx_names[i], tile_method)
-      else
-         --print(string.format("2tile(%d, %d, %d, %d, %s, %s, %s)", stmt, level, sizes[i], level, tile_idx_names[i], ctrl_idx_names[i], tile_method))
-         tile(stmt, level, sizes[i], level, tile_idx_names[i], ctrl_idx_names[i], tile_method);--regular level
-         --flip tile and control loop
-         --print(string.format("3tile(%d, %d, %d)",stmt, level+1, level+1))
-         tile(stmt, level+1, level+1);
-         --print(string.format("4tile(%d, %d, %d)",stmt, level+1, level))
-         tile(stmt, level+1, level);
-         --print(string.format("\n[offset>0]tile(%d, %d, %d, %d,%s,%s,%s)",stmt, level, sizes[i], level, tile_idx_names[i], ctrl_idx_names[i], tile_method)) 
-	 --print_code()
-         
-      end
-      
-      --Do permutation based on cur_order
-      --print "permute based on build order calling build_order()"
-      --print "cur_order = build_order(final_order, tile_indices, ctrl_idx_names, tile_idx_map, i-1)"
-      cur_order = build_order(final_order, tile_indices, ctrl_idx_names, tile_idx_map, i-1)
-      --print "permute(stmt, cur_order);"
-      permute(stmt, cur_order);
-      --print "\nafter permute(), code is:"
-      --print_code()
-   end
-   --print "ENDING TILE BY INDEX"
-   --print_code()
-end
-
-function normalize_index(index)
-   stmt = 0 --assume stmt 0cur = cur_indices(stmt)
-   --print("Cur indices "..list_to_string(cur))
-   l = find_cur_level(stmt, index)
-   tile(stmt, l, l)
-   --print(string.format("\n[Normalize]tile(%d, %d, %d)",stmt, l,l)) 
-end
-
-function is_in_indices(stmt, idx)
-   cur = cur_indices(stmt)
-   for i=0,#cur,1 do
-      if(cur[i]==idx) then
-         return true
-      end
-   end
-   return false
-   
-end
-
-
-function copy_to_registers(start_loop, array_name)
-   
-   --print("\n\n****** starting copy to registers")
-   io.flush()
-
-   stmt = 0 --assume stmt 0
-   
-   -- [Malik] first we make sure that tx and ty are consecutive loops in the 2D thread setup, otherwise all levels for subsequent operations are messed up. Start logic.
-   cur = cur_indices(stmt)
-   table_Size = table.getn(cur)
-   
-   --print(string.format("Cur indices %s,",list_to_string(cur)))
-   --print(string.format("The table size is %d", table_Size))
-   --table.foreach(cur, print)
-   --print_code()
-   
-   level_tx = -1
-   level_ty = -1
-   if is_in_indices(stmt,"tx") then level_tx = find_cur_level(stmt,"tx") end
-   if is_in_indices(stmt,"ty") then level_ty = find_cur_level(stmt,"ty") end
-   --print(string.format("level_tx %d  level_ty %d", level_tx, level_ty))
-   
-   ty_lookup_idx = "" 
-   org_level_ty = level_ty
-   
-   --if(cur[level_tx+1]~=nil and cur[level_tx+1]~="") then ty_lookup = ty_lookup+1 end
-   if(cur[level_ty+1]~=nil and cur[level_ty+1]~="") then 
-      --print(string.format("IF  cur[%d] = %s", level_ty+1, cur[level_ty+1]))
-      ty_lookup_idx = cur[level_ty+1] 
-   else
-      --if cur[level_ty]  ~= nil then print(string.format("ELSE ty_lookup_idx = cur[%d] = %s", level_ty, cur[level_ty])) --   TODO 
-      --else print "ELSE (dangerous)" end
-      ty_lookup_idx = cur[level_ty]  -- may assign nil !?
-   end
-   --if ty_lookup_idx ~= nil then print(string.format("ty_lookup_idx '%s'", ty_lookup_idx))  --  TODO 
-   --else print "ty_lookup_idx is NIL"
-   --end
-   
-   if level_ty > 0 then
-      --print(string.format("\ntile3(%d,%d,%d)",stmt,level_ty,level_tx+1))
-      tile(stmt,level_ty,level_tx+1) 
-   end
-   --print_code()
-   
-   --print("\ntylookup is %d",ty_lookup)
-   --exit(0)
-   --
-   cur = cur_indices(stmt)
-   table_Size = table.getn(cur)
-   --print(string.format("Cur indices %s,",list_to_string(cur)))
-   --print("The table size is "..table.getn(cur))
-   --table.foreach(cur, print)
-   
-   if is_in_indices(stmt,"tx") then   level_tx = find_cur_level(stmt,"tx") end
-   if ty_lookup_idx then
-      if is_in_indices(stmt,ty_lookup_idx) then level_ty = find_cur_level(stmt,ty_lookup_idx) end
-   end
-   
-   ty_lookup = 1
-   idx_flag = -1
-   -- find the level of the next valid index after ty+1
-   --print(string.format("\nlevel_ty %d", level_ty))
-   if level_ty > 0 then
-      --print(string.format("table_Size %d", table_Size))
-      for num= level_ty+ty_lookup,table_Size do
-         --print(string.format("num=%d   cur[num] = '%s'",num, cur[num]))
-         if(cur[num] ~= "") then
-            idx_flag = find_cur_level(stmt,cur[num])
-            --print (string.format("idx_flag = %d", idx_flag))
-            break
-         end
-      end
-   end
-   
-   --print(string.format("\n(first) I am checking all indexes after ty+1 %s",idx_flag))
-   --print_code()
-   --print ""
-   
-   how_many_levels = 1
-   startat = idx_flag + 1
-   if startat == 0 then startat = 1 end  -- avoid attempt to examine an illegal array offset
-   --print(string.format("idx_flag = %d   I will check levels starting with %d", idx_flag, idx_flag+1))
-   
-   for ch_lev = startat,table_Size,1 do    -- was for ch_lev = idx_flag+1,table_Size,1 do
-      --print(string.format("ch_lev %d", ch_lev))
-      if(cur[ch_lev] ~= nil and cur[ch_lev] ~= "") then
-         --print(string.format("cur[%d] = '%s'", ch_lev, cur[ch_lev])) 
-         how_many_levels = how_many_levels+1
-      end
-   end
-   --print("\nHow Many Levels",how_many_levels)
-   
-   -- change this all to reflect the real logic which is to normalize all loops inside the thread loops. 
-   if(how_many_levels <2) then
-      while( idx_flag >= 0) do
-         for num = level_ty+ty_lookup,(table_Size) do
-            --print(string.format("at top of loop, num is %d", num))
-            --print(string.format("num %d", num))
-            --print(string.format("cur[num] = '%s'", cur[num]))
-            if(cur[num] ~= "") then
-               idx=cur[num]
-               --print(string.format("idx '%s'", idx))
-               
-               curlev = find_cur_level(stmt,idx)
-               --print(string.format("curlev %d", curlev))
-               
-               --print_code()
-               --print(string.format("\n[COPYTOREG]tile(%d,%d,%d)",stmt,find_cur_level(stmt,idx),level_tx))
-               tile(stmt,find_cur_level(stmt,idx),find_cur_level(stmt,idx))
-               curlev = find_cur_level(stmt,idx)
-               --print(string.format("curlev %d", curlev))
-               tile(stmt,find_cur_level(stmt,idx),level_tx)
-               --print(string.format("hehe '%s'",cur[num]))
-               
-               cur = cur_indices(stmt)
-               --print("Cur indices INSIDE"..list_to_string(cur))
-               table_Size = table.getn(cur)
-               --print(string.format("Table Size is: %d",table_Size))
-               level_tx = find_cur_level(stmt,"tx")
-               --print(string.format("\n level TX is: %d",level_tx))
-               level_ty = find_cur_level(stmt,ty_lookup_idx)
-               --print(string.format("\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 num= level_ty+ty_lookup,table_Size do
-                  --print(string.format("num mucking num = %d", num))
-                  if(cur[num] ~= nil and cur[num] ~= "") then
-                     idx_flag = find_cur_level(stmt,cur[num])
-                     --print("\n(second) I am checking all indexes after ty+1 %s",cur[num])
-                     break
-                  end
-               end
-               --print(string.format("num mucked to %d     idx_flag = %d", num, idx_flag))
-               
-            end
-            --print(string.format("at bottom of loop, num is %d", num))
-         end
-      end
-   end
-   --print "done with levels"
-   
-   
-   
-   
-   --print "ARE WE SYNCED HERE?"
-   --print_code()
-   --print("\ntile(%d,%d,%d)",stmt,level_k,level_k)
-   --tile(stmt,level_k,level_k)
-   
-   -- [Malik] end logic
-   --print_code()
-   start_level = find_cur_level(stmt, start_loop)
-   --We should hold contant any block or tile loop
-   block_idxs = block_indices()
-   thread_idxs = thread_indices()
-   --print("\nblock indices are")
-   --table.foreach(block_idxs, print)
-   --print("\nthread indices are")
-   --table.foreach(thread_idxs, print)
-   --print(string.format("\nStart Level: %d",start_level))
-   
-   hold_constant = {}
-   --print("\n Now in Blocks")
-   for i,idx in ipairs(block_idxs) do
-      --print(string.format("\n Idx:%s : Level: %d",idx,find_cur_level(stmt,idx)))
-      if find_cur_level(stmt,idx) >= start_level then
-         table.insert(hold_constant, idx)
-         --print(string.format("\nJust inserted block %s in hold_constant",idx))
-      end
-   end
-   
-   
-   --print("\n Now in Threads")
-   for i,idx in ipairs(thread_idxs) do
-      --print(string.format("\n Idx:%s : Level: %d",idx,find_cur_level(stmt,idx)))
-      if find_cur_level(stmt,idx) >= start_level then
-         table.insert(hold_constant, idx)
-         --print(string.format("\nJust inserted thread %s in hold_constant",idx))
-      end
-   end
-   
-   --print "\nhold constant table is: "
-   --table.foreach(hold_constant, print)
-   
-   --print("\nbefore datacopy pvt")
-   old_num_stmts = num_statements()
-   --print_code()
-   --print(string.format("\n[DataCopy]datacopy_privatized(%d, %s, %s, vector having privatized levels)",stmt, start_loop, array_name)) 
-   --table.foreach(hold_constant, print)
-   datacopy_privatized(stmt, start_loop, array_name, hold_constant)
-   
-   --print(hold_constant)
-   new_num_stmts = num_statements()
-   --print("\nthe num of statements:%d\n",new_num_stmt)
-   --print_code()
-   --exit(0)
-   -- [Malik] normalize the copy loops created.
-   cur = cur_indices(old_num_stmts)
-   --print("Cur indices "..list_to_string(cur))
-   for cidx,i in ipairs(cur) do
-      if i ~= "tx" and i~="ty" and i~="bx" and i~="by" then
-         --tile(old_num_stmts,find_cur_level(old_num_stmts,i),find_cur_level(old_num_stmts,i))
-         --print("\nTILE OF REG: tile(%d,%d,%d)",old_num_stmts,find_cur_level(old_num_stmts,i),find_cur_level(old_num_stmts,i))
-      end
-   end
-   --print_code()
-   --print("\nthe num of statements OLD+1 :",(old_num_stmts+1))  
-
-
---[[ 
-   is this commented out? why yes, yes it is   block comment 
-   if( (old_num_stmts+1) <= new_num_stmts) then
-      cur = cur_indices(old_num_stmts+1)
-      --print("Cur indices+1 "..list_to_string(cur))
-      for cidx,i in ipairs(cur) do
-         if i ~= "tx" and i~="ty" and i~="bx" and i~="by" then
-            tile(old_num_stmts+1,find_cur_level(old_num_stmts+1,i),find_cur_level(old_num_stmts+1,i))
-	    --print("\nTILE OF REG: tile(%d,%d,%d)",old_num_stmts+1,find_cur_level(old_num_stmts+1,i),find_cur_level(old_num_stmts+1,i))
-         end
-      end
-   end
---]]
-
-
-   --Unroll to the last thread level
-   --for stmt=old_num_stmts,new_num_stmts-1 do
-   -- level = find_cur_level(stmt,thread_idxs[#thread_idxs])--get last thread level
-   --if level < #cur_indices(stmt) then
-   -- unroll(stmt,level+1,0)
-   --print(string.format("\n[Unroll]unroll(%d, %d, 0)",stmt, level+1)) 
-   ----print_code()
-   --end
-   --end
-   io.flush()
-   --print("****** ending copy to registers\n\n")
-   --io.flush()
-end
-
-function copy_to_shared(start_loop, array_name, alignment)
-   --print(string.format("\nstarting copy to shared(%s, %s, %d )",start_loop,array_name,alignment))
-   stmt = 0 --assume stmt 0
-   cur = cur_indices(stmt)
-   --print("Cur indices "..list_to_string(cur))
-   
-   start_level = find_cur_level(stmt, start_loop)
-   --print(string.format("start_level %d", start_level))
-   
-   old_num_stmts = num_statements()
-   --print(string.format("old_num_statements %d", old_num_stmts))
-   
-   --Now, we give it indices for up to two dimentions for copy loop
-   copy_loop_idxs = {"tmp1","tmp2"}
-   --print(string.format("\n[DataCopy]datacopy(%d, %d, %s, {\"tmp1\",\"tmp2\"},false,0,1,%d,true)",stmt, start_level, array_name, alignment)) 
-   datacopy(stmt, start_level, array_name, copy_loop_idxs, false, 0, 1, alignment,true)
-   
-   add_sync(stmt,start_loop)
-   new_num_stmts = 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(string.format("fairly CUBLAS2 specific, OLD %d  NEW %d",  old_num_stmts, new_num_stmts ))
-   
-   for stmt=old_num_stmts,new_num_stmts-1 do
-      --print(string.format("for stmt = %d", stmt))
-      was_no_error, level = pcall(find_cur_level, stmt, "tmp2")
-      
-      if was_no_error then 
-         --print_code() 
-         --print("\nCopy to shared: [If was no error]\n")
-         find_cur_level(stmt,"tmp2")
-         tile(stmt, level, level)
-         
-         lower,upper = hard_loop_bounds(stmt, level)
-         upper = upper + 1
-         --print(string.format("lower %d  upper %d", lower, upper))
-         
-         tx,ty = thread_dims()
-         --print("2-loop cleanup: lower, upper: "..lower..", "..upper..", tx: "..tx)
-         
-         level = find_cur_level(stmt,"tmp1")
-         --print(string.format("level %d", level))
-         
-         if tx == upper and ty == 1 then
-            --print(string.format("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")
-            --print(string.format("\n[Tile0]tile(%d, %d, 1, %d,%s,%s,counted)",stmt, second_level, level, "tx", "tx")) 
-            tile(stmt, second_level, 1, level, "tx", "tx", counted)
-         else
-            --print "DO need?"
-            --print_code()
-            if(ty == 1) then new_ctrl = "tmp3" else new_ctrl = "ty" end
-
-
---[[ Commenting out a block of Gabe's code in this control flow
-               -- level = find_cur_level(stmt,"tmp1")
-               tile(stmt, level, level)
-
-               lower,upper = hard_loop_bounds(stmt, level)
-               upper = upper + 1
-               --print_code()
-               --print("2-loop cleanup: lower, upper: "..lower..", "..upper..", tx: "..tx..", level: "..level)
-               if(math.ceil(upper/ty) > 1)then
-                  tile(stmt, level, math.ceil(upper/ty), level, "tmp", new_ctrl, counted)
-                  --print(string.format("\n[Tile1]tile(%d, %d, %f[%d,%d], %d,%s,%s,counted)",stmt, level,  math.ceil(upper/ty),upper,ty, level, "tmp", new_ctrl)) 
-               else
-                  tile(stmt, level, math.ceil(upper/ty), level, "ty", new_ctrl, counted)
-		  --print(string.format("\n[Tile1]tile(%d, %d, %f[%d,%d], %d,%s,%s,counted)",stmt, level,  math.ceil(upper/ty),upper,ty, level, "tx", new_ctrl))
-               end
-               
-               --print_code()    
-               -- [Malik] If here we have the loop upper bound > tx, then we should tile once more after the next tile, to carve out the correct tx. 
-               lower1,upper1 = hard_loop_bounds(stmt,level)
-               level1 = level
-               stmt1 = stmt
-               -- [Malik] Do the tile after the second level tile with if condition. Just to keep the original order, the tile is being pushed to the end. 
-               
-               --print("[Malik]-loop cleanup: lower1, upper1: "..lower1..", "..upper1..", tx: "..tx..", level:"..level1)
-
-               --print_code()
-               --level = find_cur_level(stmt,"tmp")
-               --tile(stmt,level,level)
-               --print_code() 
-               
-               --[Malik] if you are moving the loop above the level1, you need to update level1 with new position which would be level1+2 or second_level
-               if(level <= level1) then level1 = level1+2 end
- 	       --print(string.format("\n[Tile2]tile(%d, %d, 1, %d,%s,%s,counted)",stmt, second_level, level, "tx", "tx")) 
-               --print("\n----------------------------------")
-               --print_code()
-               --print("\n**********************************")
-               --print("[Malik]-loop cleanup: lower1, upper1: "..lower1..", "..upper1..", tx: "..tx..", level:"..level1)
-               -- [Malik] If the upper bound > tx, we do another tile to carve out the correct tx from a bigger loop. Else just normalize the bounds. 
-               if( upper1 > ty) then
-                  third_level = find_cur_level(stmt1,"tmp")
-                  --print("\n\n\n\t\t\t\tthirdlevel:"..third_level)
-                  tile(stmt1, third_level, ty, third_level, "ty", "tmp", counted)
-                  --print(string.format("\n[Tile3]tile(%d, %d, %d,%d,%s,%s,counted)",stmt1, third_level, ty,third_level, "ty", "tmp"))
-                  tile(stmt1,third_level+1,third_level+1)
-                  --print(string.format("\n[Tile3]tile(%d, %d, %d)",stmt1, third_level+1, third_level+1))
-                  tile(stmt1,third_level+1,third_level)
-                  --print(string.format("\n[Tile3]tile(%d, %d, %d)",stmt1, third_level+1, third_level))
-               else
-                  tile(stmt1,level1,level1)
-                  --print(string.format("\n[Tile3ELSE]tile(%d, %d, %d)",stmt1,level1,level1))
-               end
-               
-               --print("\nStarting tmp2\n");--print_code();
-               second_level = find_cur_level(stmt,"tmp2")
-               lower,upper = hard_loop_bounds(stmt,second_level)
-               level = second_level
-               --print("[Malik]-loop cleanup@tmp2: lower, upper: "..lower..", "..upper..", tx: "..tx..", level:"..level)
-               
-               if(math.ceil(upper/tx) > 1)then
-                  tile(stmt, second_level,math.ceil(upper/tx), level, "tmp", "tx", counted)
-                  --print(string.format("\n[Tile2]tile(%d, %d, %d,%d,%s,%s,counted)",stmt, second_level,math.ceil(upper/tx),second_level, "tmp", "tx"))
-               else
-                  tile(stmt, second_level,math.ceil(upper/tx), level, "tx", "tx", counted)
-                  --print(string.format("\n[Tile2]tile(%d, %d, %d,%d,%s,%s,counted)",stmt, second_level,math.ceil(upper/tx),second_level, "tx", "tx"))
-               end
-               --print_code()
-               lower2,upper2 = hard_loop_bounds(stmt,level)
-               level2 = level
-               stmt2 = stmt
-               --print("[Malik]-loop cleanup@tmp2: lower2, upper2: "..lower2..", "..upper2..", tx: "..tx..", level:"..level2)
-               -- now for the second level.
-               if( upper2 > tx) then
-                  forth_level = find_cur_level(stmt2,"tmp")
-                  --print("\n\n\n\t\t\t\tforthlevel:"..forth_level)
-                  --print_code()
-                  tile(stmt2, forth_level, 1, forth_level, "tx", "tmp", counted)
-                  --print(string.format("\n[Tile3B]tile(%d, %d, %d,%d,%s,%s,counted)",stmt2, forth_level, tx,forth_level, "ty", "tmp"))
-                  --print_code()
-                  --tile(stmt2,forth_level+1,forth_level+1)
-                  --print(string.format("\n[Tile3B]tile(%d, %d, %d)",stmt2, forth_level+1, forth_level+1))
-                  --tile(stmt2,forth_level+1,forth_level)
-                  --print(string.format("\n[Tile3B]tile(%d, %d, %d)",stmt2, forth_level+1, forth_level))
-               else
-                  new_level = find_cur_level(stmt2,"ty")
-                  tile(stmt2,level2,1,new_level,"tx","tx",counted)
-                  --print(string.format("\n[Tile3BELSE]tile(%d, %d, %d)",stmt2,level2,level2))
-                  tmp_level = find_cur_level(stmt2,"tmp")
-                  tile(stmt2,tmp_level,tmp_level)
-               end
-               
-               --print_code()
-               --print("\n----------------------------------")
---]]
-               
-               --print_code() 
-               --print("\nStarting tmp2\n");--print_code();
-               first_level = find_cur_level(stmt,"tmp1")
-               second_level = find_cur_level(stmt,"tmp2")
-               lower,upper = hard_loop_bounds(stmt,second_level)
-               
-               --print("[Malik]-loop cleanup@tmp2: lower, upper: "..lower..", "..upper..", tx: "..tx..",first level:"..first_level..",second_level:"..second_level)
-               
-               -- Move the fastest changing dimension loop to the outermost,identified by "tmp2" and to be identified as tx.
-               --print(string.format("\n[fastest]tile(%d, %d, %d,%d,%s,%s,counted)",stmt, second_level,1,first_level, "tx", "tx"))
-               tile(stmt,second_level,1,first_level,"tx","tx",counted)
-               --print_code()
-               
-               first_level = find_cur_level(stmt,"tmp1")
-               lower_1,upper_1 = hard_loop_bounds(stmt,first_level)
-               tx_level = find_cur_level(stmt,"tx")
-               lower_tx,upper_tx = hard_loop_bounds(stmt,tx_level)
-               --print(string.format("UL_1 %d %d     UL_tx %d %d", lower_1, upper_1, lower_tx, upper_tx))
-               
-               if(math.ceil(upper_tx/tx) > 1)then
-                  --print "ceil I say"
-                  --print(string.format("\n[Tile1]tile(%d, %d, %d,%d,%s,%s,counted)",stmt, tx_level,tx,tx_level, "tx", "tmp1"))
-                  tile(stmt,tx_level,tx,tx_level,"tx","tmp_tx",counted)
-                  --print_code()
-                  
-                  peat = find_cur_level(stmt,"tx")
-                  --print(string.format("\n[Tile1]tile(%d, %d, %d)",stmt, peat, peat))
-                  tile(stmt, peat, peat )  --find_cur_level(stmt,"tx"),find_cur_level(stmt,"tx"))
-                  --print_code()
-                  
-                  if (find_cur_level(stmt,"tx")>find_cur_level(stmt,"tmp_tx")) then
-                     --print(string.format("\nagain [Tile1]tile(%d, %d, %d)",stmt,find_cur_level(stmt,"tx"),find_cur_level(stmt,"tmp_tx")))
-                     tile(stmt,find_cur_level(stmt,"tx"),find_cur_level(stmt,"tmp_tx"))
-                     --print_code()
-                  end
-                  --else
-                  --tile(stmt, tx_level,1, tx_level, "tx", "tx", counted)
-                  --print(string.format("\n[Tile2]tile(%d, %d, %d,%d,%s,%s,counted)",stmt, tx_level,1,tx_level, "tx", "tx"))
-               end
-               --print_code()
-               --]]  -- this apparently is NOT the end of a block comment
-               
-               --print("\nStarting tmp1\n")
-               -- Handle the other slower changing dimension, the original outermost loop, now identified by "tmp1", to be identified as "ty".
-               tile(stmt,find_cur_level(stmt,"tmp1"),find_cur_level(stmt,"tmp1"))     
-               --print_code()  
-               
-               ty_level = find_cur_level(stmt,"tmp1")
-               lower_ty,upper_ty = hard_loop_bounds(stmt,ty_level)
-               
-               tx_level = find_cur_level(stmt,"tx")
-               lower_tx,upper_tx = hard_loop_bounds(stmt,tx_level)
-               --print("[Malik]-loop cleanup@tmp1: lowerty, upperty: "..lower_ty..", "..upper_ty..", ty: "..ty..",ty level:"..ty_level..",tx_level:"..tx_level..", stmt: "..stmt)
-               
-               --print "before ceil"
-               if(math.ceil(upper_ty/ty) > 1)then
-                  --print "CEIL IF"
-                  --print("\n Inside upper_ty/ty > 1\n");
-                  
-                  --print(string.format("\n[Tile2]tile(%d, %d, %d,%d,%s,%s,counted)",stmt, ty_level,ty,ty_level, "ty", "tmp_ty"))
-                  tile(stmt,ty_level,ty,ty_level,"ty","tmp_ty",counted)
-                  --print_code()
-                  
-                  --print(string.format("\n[Tile2-1]tile(%d, %d, %d)",stmt,find_cur_level(stmt  ,"ty"),find_cur_level(stmt,"ty")))
-                  tile(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"ty"))
-                  --print_code()
-                  
-                  -----------------------------------------------------------------------
-                  ----------------------------------------------------------------------
-                  cur_idxs = cur_indices(stmt)
-                  --print("\n cur indexes are "..list_to_string(cur_idxs))
-                  
-                  -- Putting ty before any tmp_tx   
-                  idx_flag = -1
-                  for num= 0,table.getn(cur_idxs) do
-                     if(cur[num] == "tmp_tx") then
-                        idx_flag = find_cur_level(stmt,cur[num])
-                        break
-                     end
-                  end
-                  --print(string.format("\n (1) so i have found out the value of idx flag as %d",idx_flag) )
-                  
-                  if(idx_flag >=0 ) then  
-                     if (find_cur_level(stmt,"ty")>find_cur_level(stmt,"tmp_ty")) then
-                        --print(string.format("\n[Tile2-2]tile(%d, %d, %d)",stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty")))
-                        tile(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty"))
-                        --print_code()
-                     end
-                  end
-                  
-                  -- Now Putting ty before any tmp_ty
-                  idx_flag = -1
-                  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(string.format("\n IF  so i have found out the value of idx flag as %d",idx_flag) )
-                  if(idx_flag >=0 ) then  
-                     --print "one more test"
-                     if ((find_cur_level(stmt,"ty")>find_cur_level(stmt,"tmp_ty"))) then
-                        --print(string.format("\n[Tile2-2]tile(%d, %d, %d)",stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty")))
-                        tile(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty"))
-                        --print_code()
-                     end
-                  end
-               else
-                  --print "CEIL ELSE"
-                  --cur_idxs = cur_indices(stmt)
-                  --print("\n Inside upper_ty/ty <= 1\n");
-                  
-                  --print(string.format("\n[Tile3]tile(%d, %d, %d,%d,%s,%s,counted)",stmt, ty_level,1,ty_level, "ty", "ty"))
-                  tile(stmt, ty_level,1, ty_level, "ty", "ty", counted)
-                  --print_code()
-                  
-                  --print(string.format("\n[Tile3-1]tile(%d, %d, %d)",stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tx")+1))
-                  tile(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tx")+1)
-                  --print_code()
-                  
-                  idx_flag = -1
-                  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
-                  end
-                  --print(string.format("\n ELSE so i have found out the value of idx flag as %d",idx_flag) )
-                  if(idx_flag >=0 ) then  
-                     if (find_cur_level(stmt,"ty")>find_cur_level(stmt,"tmp_ty")) then
-                        --print(string.format("tile( stmt %d, level ty %d, level ty %d",stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty"))) 
-                        tile(stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty"))
-                        --print(string.format("\n[Tile3-2]tile(%d, %d, %d)",stmt,find_cur_level(stmt,"ty"),find_cur_level(stmt,"tmp_ty")))
-                     end
-                  end
-               end
-               
-               --print_code()
-         end
-         
-         
-         --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")
-         tile(stmt, level, level)
-         
-         --print(string.format("\n[Tile]tile(%d, %d, %d)",stmt, level, level)) 
-         tx,ty = thread_dims()
-         lower,upper = hard_loop_bounds(stmt, level)
-         upper = upper+1 --upper bound given as <=, compare to dimensions tx which is <
-         --print("upper "..upper.." tx "..tx)
-         if upper == tx then
-            rename_index(stmt, "tmp1", "tx")
-         else
-            --print("upper is not tx")
-            --TODO: Don't know, maybe do some tileing etc
-            --print_code()
-            --print("upper "..upper.." tx "..tx.." stmt: "..stmt.." level: "..level)
-            tile(stmt, level,tx,level, "tx", "tmp_tx", counted)
-            --print_code()
-            
-            --print("stmt:"..stmt.." level+1: "..level+1)
-            --print("TILE 7")
-            tile(stmt, level+1,1,level+1,"tx", "tx",counted)
-            --print("TILE 3")
-            tile(stmt,level+1,level)
-            --print_code()
-            
-            if(ty > 1) then
-               --print_code()
-               --print("GOING IN")
-               lower,upper = hard_loop_bounds(stmt, level+1)
-               --print(string.format("ty %d  lower %d  upper %d", ty, lower, upper))
-               --upper=125
-               --print("NOW FOR Y: upper "..upper.." ty "..ty.." stmt: "..stmt.." level: "..(level+1).." bound:"..math.ceil(upper/ty))
-               tile(stmt, level+1,math.ceil(upper/ty),level+1, "tmp_ty", "ty", counted)
-               --tile(stmt, level+2,math.ceil(upper/ty),level+2, "tmp_ty", "ty", counted)
-            end
-            --print_code()
-            --rename_index(stmt, "tmp1", "tx")
-            --print("Warning: Need to implement some logic here to tile the single level shared copy loop to match thread dimensions")
-         end
-      end
-      --Always add sync
-      add_sync(stmt,start_loop)
-      
-   end
-   --print("ending copy to shared\n")
-   --print_code()
-end
-
-function unroll_to_depth(max_depth)
-   --print(string.format("\n\nunroll_to_depth(%d)", max_depth ))
-   --print "SYNC UP"
-   
-   cur = cur_indices(0)
-   thread_idxs = thread_indices()
-   guard_idx = thread_idxs[#thread_idxs]
-   
-   --print(string.format("cur    indices %s",list_to_string(cur)))
-   --print(string.format("thread indices %s",list_to_string(thread_idxs)))
-   --print(string.format("#thread_idxs = %d", #thread_idxs))
-   --print(string.format("guard_idx = %s", guard_idx))
-   
-   ---- HERE FIND OUT THE LOOPS WHICH ARE COMMON BETWEEN STATEMENTS   
-   common_loops = {}
-   comm_loops_cnt = 0
-   num_stmts = num_statements()
-   --print(string.format("num statements %d", num_stmts))
-   
-   for stmt=0,num_stmts-1 do
-      cur_idxs = cur_indices(stmt)
-      
-      --print(string.format("\nSTMT %d Current Indices: %s",stmt,list_to_string(cur_idxs)))
-      
-      if(chk_cur_level(stmt,"tx")>0) then
-         for ii=1,find_cur_level(stmt,"tx")-1 do    -- started at 0
-            --print(string.format("ii = %d", ii)) -- index starts at 1, what does index 0 do?
-            --if cur_idxs[ii] == nil then print "cur_idxs[i]] is NIL" 
-            --else print(string.format("cur_idxs[%d] = '%s'", ii, cur_idxs[ii])) -- index starts at 1, what does index 0 do?
-            --end
-            
-            if(cur_idxs[ii] ~= "bx" and cur_idxs[ii] ~= "by" and cur_idxs[ii] ~= nil and cur_idxs[ii] ~= "tx" and cur_idxs[ii] ~= "ty" and cur_idxs[ii] ~= "") then 
-               
-               --print(string.format("id %s is not in the list", cur_idxs[ii] ))
-               
-               for stmt1=stmt+1,num_stmts-1 do
-                  --print(string.format("\nii %d stmt1 is %d", ii, stmt1))          
-                  cur_idxs1 = cur_indices(stmt1)
-                  --print("\nstmt1 cur_idxs1 is "..list_to_string(cur_idxs1))   
-                  
-                  --print(string.format("cur level(%d, %s) = %d", stmt, "tx",  find_cur_level(stmt,"tx")))    
-                  
-                  endrange = find_cur_level(stmt,"tx")-1
-                  --print(string.format("for iii=1, %d do", endrange))
-                  
-                  for iii=1,find_cur_level(stmt,"tx")-1 do  -- started at 0
-                     --print(string.format("stmt %d   ii %d   iii %d ", stmt, ii, iii))
-                     --if(cur_idxs1[iii] ~= nil) then 
-                     --   print(string.format("stmt %d   ii %d   iii %d  cur_idxs1[%d] = '%s'", stmt, ii, iii, iii, cur_idxs1[iii]))  
-                     --else 
-                     --   print(string.format("stmt %d   ii %d   iii %d  cur_idxs1[%d] = NIL", stmt, ii, iii, iii))  
-                     --end
-                     
-                     if(cur_idxs1[iii] ~= "bx" and cur_idxs1[iii] ~= "by" and cur_idxs1[iii] ~= nil and cur_idxs1[iii] ~= "tx" and cur_idxs1[iii] ~= "ty" and cur_idxs1[iii] ~= "") then  
-                        if(cur_idxs[ii] == cur_idxs1[iii]) then
-                           --print("\nfound idx:"..cur_idxs[ii])
-			   --if(comm_loops_cnt == 0) then print "\n\n*** WARNING *** assigning to array index ZERO in Lua" end
-                           common_loops[comm_loops_cnt] = cur_idxs[ii]
-                           --print(string.format("cl[%d] = '%s'", comm_loops_cnt,   common_loops[comm_loops_cnt]))
-                           comm_loops_cnt = comm_loops_cnt + 1
-                        end
-                     end  
-                  end
-               end  
-            end
-         end
-      end
-   end
-   ----
-   --if(comm_loops_cnt>0) then 
-   --   print("\n COMM LOOPS :TOTAL "..comm_loops_cnt..", and are "..list_to_string(common_loops).." this loop :"..common_loops[0])
-   --else
-   --   print "UNROLL can't unroll any loops?"
-   --end
-   
-   
-   
-   
-   repeat
-      old_num_stmts = num_statements()
-      --print(string.format("old_num_statements %d", old_num_stmts))
-      
-      for stmt=0,old_num_stmts-1 do
-         cur_idxs = cur_indices(stmt)
-         --print(string.format("stmt %d    cur_idxs = %s", stmt, list_to_string(cur_idxs)))
-         if(#cur_idxs > 0) then 
-            gaurd_level = -1
-            if(chk_cur_level(stmt,guard_idx)>0) then
-               gaurd_level = find_cur_level(stmt,guard_idx)
-            end
-            --print(string.format("guard_level(sp) = %d", gaurd_level))
-            
-            if(gaurd_level>-1) then
-               level = next_clean_level(cur_idxs,gaurd_level)
-               --print(string.format("next clean level %d", level))
-               
-               --need to handle max_depth
-               num_unrolled = 0
-               level_unroll_comm = level
-               level_arr = {}
-               while level >= 0 do
-                  --print(string.format("while: level = %d", level))
-                  
-                  if num_unrolled == max_depth then break end
-                  --print("Unrolling "..stmt.." at level "..(level).." index ".. cur_idxs[gaurd_level+1])
-                  
-                  level_arr[num_unrolled] = level
-                  num_unrolled = num_unrolled + 1
-                  
-                  guard_level = find_cur_level(stmt,guard_idx)
-                  level = next_clean_level(cur_idxs,level+1)
-               end
-               --dies print("How many levels for unroll commands"..table.getn(level_arr).." which is "..level_arr[0].." and "..level_arr[#level_arr])
-               --if(table.getn(level_arr) ~= nil) then
-               
-               --print "OK, NOW WE UNROLL"
-               
-               if(level_unroll_comm >= 0)then
-                  for i = table.getn(level_arr),0,-1 do
-                     --print(string.format("\ni=%d", i))
-                     --print(string.format("[Unroll]unroll(%d, %d, 0)",stmt, level_arr[i]))     
-                     
-                     unroll(stmt,level_arr[i],0)
-                     --print("finished unroll]]\n")
-                     --print_code()
-                  end
-               end
-------
-            end    
---[[
-
-THERE WAS A BIG BLOCK OF COMMENTED OUT CODE HERE 
-
-
---]]
-------
-         end
-      end
-      new_num_stmts = num_statements()
-
-   until old_num_stmts == new_num_stmts
-
-end
-
-
diff --git a/test-chill/test-cases/examples/cuda-chill/cudaize.py b/test-chill/test-cases/examples/cuda-chill/cudaize.py
deleted file mode 100755
index ffef009..0000000
--- a/test-chill/test-cases/examples/cuda-chill/cudaize.py
+++ /dev/null
@@ -1,1047 +0,0 @@
-#! /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 )
-
diff --git a/test-chill/test-cases/examples/cuda-chill/mm.c b/test-chill/test-cases/examples/cuda-chill/mm.c
deleted file mode 100644
index 0efbeeb..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mm.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#define N 1024
-
-void normalMM(float c[N][N], float a[N][N], float b[N][N]) {
-  int i, j, k;
-
-  for (i = 0; i < N; i++)
-    for (j = 0; j < N; j++)
-      for (k = 0; k < N; k++)
-        c[j][i] = c[j][i] + a[k][i] * b[j][k];
-}
diff --git a/test-chill/test-cases/examples/cuda-chill/mm.lua b/test-chill/test-cases/examples/cuda-chill/mm.lua
deleted file mode 100644
index 5bde1b0..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mm.lua
+++ /dev/null
@@ -1,38 +0,0 @@
-init("mm.c", "normalMM", 0)
-dofile("cudaize.lua")
-N=1024
-Ti=128
-Tj=64
-Tk=16
-Tii=16
-Tjj=16
-
-
-
-
-N=1024
-
-
-
-
-
-
-
-
-
-
-
-
-
-tile_by_index({"i","j"},{Ti,Tj},{l1_control="ii",l2_control="jj"},{"ii","jj","i","j","k"})CU=1
-
-tile_by_index({"k"},{Tk},{l1_control="kk"},{"ii","jj","kk","i","j","k"})CU=3
-
-tile_by_index({"i","j"},{Tii,Tjj},{l1_control="iii",l2_control="jjj"},{"ii","jj","kk","i","iii","j","jjj","k"},1)CU=2
-
-cudaize("mm_GPU",{a=1048576,b=1048576,c=1048576},{block={"ii","jj"}, thread={"i","j"}})CU=2
-copy_to_shared("tx","a",-16)
-copy_to_shared("tx","b",-16)
-copy_to_registers("kk","c")
---print_code()
-unroll_to_depth(2)
diff --git a/test-chill/test-cases/examples/cuda-chill/mpeg4.c b/test-chill/test-cases/examples/cuda-chill/mpeg4.c
deleted file mode 100755
index 7f83bf7..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mpeg4.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#define N1 4096
-#define N2 4096
-#define WINDOW_SIZE 16
-
-void mpeg4_cpu(float result[N1][N2], float prev[N2+WINDOW_SIZE][N2+WINDOW_SIZE], float  curr[WINDOW_SIZE*WINDOW_SIZE])
-{
-	unsigned int i;
-	unsigned int j;
-	unsigned int k;
-	unsigned int l;
-
-	for ( i = 0; i < N1; ++i)    
-		for ( j = 0; j < N2; ++j) 
-                       for ( k = 0; k < WINDOW_SIZE; ++k) 
-				for ( l = 0; l < WINDOW_SIZE; ++l) 
-					result[i][j] += prev[i+k][j+l] * curr[k*WINDOW_SIZE+l];
-				
-			
-
-		
-	
-}
-
diff --git a/test-chill/test-cases/examples/cuda-chill/mpeg4.lua b/test-chill/test-cases/examples/cuda-chill/mpeg4.lua
deleted file mode 100644
index f025dc0..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mpeg4.lua
+++ /dev/null
@@ -1,45 +0,0 @@
---CUBLAS 2 MM Multiply
-
---This function form intializes "CUDAIZE v2" versus "CUDAIZE v1" if you
---call init() and use global variables to specify procedure and loop
-
---Second parameter is procedure # and third is loop #
-init("mpeg4.c", "mpeg4_cpu", 0) 
-
---dofile("cudaize.lua") --defines custom tile_by_index, copy_to_registers,copy_to_shared methods
-dofile("cudaize.lua") --defines custom tile_by_index, copy_to_registers,copy_to_shared methods
-
-N=4096
-M=4096
-W=16
-
---TI 4ust be <= M
---TJ must be <=TI
-Ti=32
-Tj=32
-Tii=16
-Tjj=16
-Tk=4
---permute(0,{"j","i","k","l"})
-tile_by_index({"i","j"},{Ti,Tj},{l1_control="ii",l2_control="jj"},{"ii","jj","i","j","k","l"})
---tile_by_index({"k","l"},{Tk*2,Tk*2},{l1_control="kk",l2_control="ll"},{"ii","jj","kk","ll","i","j","k","l"})
---print_code()
---tile_by_index({"k","l"},{Tk,Tk},{l1_control="kk",l2_control="ll"},{"ii","jj","i","j","kk","k","ll","l"})
-tile_by_index({"i","j"},{Tii,Tjj},{l1_control="iii",l2_control="jjj"},{"ii","jj","iii","i","jjj","j","k","l"})
---print_code()
---normalize_index("j")
---normalize_index("i")
---print_code()
-cudaize("kernel_GPU",{curr=W*W,prev=(N+W)*(M+W),result=N*M},{block={"ii","jj"}, thread={"i","j"}})
---print_code()
-copy_to_shared("iii","prev",16)
-
-copy_to_registers("jjj","result")
-
---print_code()
---copy_to_constant_no_tile("curr")
-unroll_to_depth(2)
-print_code()
-print_space()
-
-
diff --git a/test-chill/test-cases/examples/cuda-chill/mriq-fh.c b/test-chill/test-cases/examples/cuda-chill/mriq-fh.c
deleted file mode 100755
index 1e924b7..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mriq-fh.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#define X 32768
-#define K 256
-struct kValues {
-  float Kx;
-  float Ky;
-  float Kz;
-  float PhiMag;
-};
-extern float sin(float);
-extern float cos(float);
-
-void mriFH_cpu(float *rPhi,float *rRho,float *iRho, float *iPhi, float *rD, float *iD, float *kx, float *ky, float *kz, float *dx, float *dy, float *dz, float *rFHref, float *iFHref)
-{
-
-    	float rfh;
-	float ifh;
-	float exp;
-	float cArg;
-	float sArg;
-    	//float rRho[K];
-	//float iRho[K];
-        unsigned int k;
-	unsigned int x;
- 
-      
-    for (x = 0; x < X; ++x) {
-        for (k = 0; k < K; ++k) {
-            
-	       exp = 2 * 3.14159 * (kx[k]* dx[x] + ky[k]* dy[x] + kz[k]* dz[x]);
-	       cArg = cos(exp);
-	       sArg = sin(exp);
-            rFHref[x] += rRho[k]* cArg - iRho[k]* sArg;
-            iFHref[x] += iRho[k]*cArg + rRho[k]*sArg;
-        }
-         
-    }
-}
-
diff --git a/test-chill/test-cases/examples/cuda-chill/mriq-fh.lua b/test-chill/test-cases/examples/cuda-chill/mriq-fh.lua
deleted file mode 100755
index 3277bac..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mriq-fh.lua
+++ /dev/null
@@ -1,73 +0,0 @@
---CUBLAS 2 MM Multiply
-
---This function form intializes "CUDAIZE v2" versus "CUDAIZE v1" if you
---call init() and use global variables to specify procedure and loop
-
---Second parameter is procedure # and third is loop #
-init("mriq-fh.c", "mriFH_cpu", 0) 
-
-dofile("cudaize.lua") --defines custom tile_by_index, copy_to_registers,
-                      --copy_to_shared methods
-N=32768
-M=256
-Tx=256
-
-
-print_code()
---permute(0,{"j","i"})
---tile_by_index({"j","i"}, {TI,TJ}, {l1_control="jj", l2_control="ii"}, {"jj","ii", "j", "i"})
-tile_by_index({"x"},{Tx},{l1_control="xx"},{"xx","x","k"})
---tile_by_index({"x"},{16},{l1_control="xx1"},{"xx","x","xx1","k"})
---tile_by_index({"j"}, {TI}, {l1_control="jj"}, {"ii","jj", "j", "i"})
---tile_by_index({"i"}, {TI}, {l1_control="ii"}, {"ii", "i", "j"})
-print_code()
-
-normalize_index("x")
---normalize_index("i")
-print_code()
---tile_by_index({"i"}, {TI}, {l1_control="iii",l1_tile="i"}, {"ii","jj", "iii","j","i"})
---print_code()
---cudaize("Kernel_GPU", {x=N,y=N,z=N,Qr=N,Qi=N,kVals=M},{block={"jj"}, thread={"j"}})
-cudaize("kernel_GPU",{dx=N,dy=N,dz=N,iRho=M,kx=M,ky=M,kz=M,rFHref=N,iFHref=N,rRho=M},{block={"xx"}, thread={"x"}})
---copy_to_shared("tx","iRho",-16)
---copy_to_shared("tx","dz",1)
---copy_to_shared("tx","rRho",-16)
---copy_to_registers("tx","rFHref")
---copy_to_registers("tx","rRho")
---copy_to_registers("tx","iRho")
---copy_to_registers("tx","kx")
---copy_to_registers("tx","dx")
---copy_to_registers("tx","ky")
---copy_to_registers("tx","dy")
---copy_to_registers("tx","kz")
---copy_to_registers("tx","dz")
---copy_to_registers("tx","iFHref")
---copy_to_texture("rRho")
---copy_to_texture("kx")
---copy_to_texture("dx")
---copy_to_texture("ky")
---copy_to_texture("dy")
---copy_to_texture("kz")
---copy_to_texture("dz")
---copy_to_texture("iRho")
---print_code()--]]
---unroll(0,4,0)
---copy_to_constant_no_tile("kx")
---copy_to_constant_no_tile("ky")
---copy_to_constant_no_tile("kz")
---copy_to_constant_no_tile("rRho")
---copy_to_constant_no_tile("iRho")
-
---unroll_to_depth(1)
-print_code()
---[[
-copy_to_Texture("rRho")
-copy_to_Texture("kx")
-copy_to_Texture("dx")
-copy_to_Texture("ky")
-copy_to_Texture("dy")
-copy_to_Texture("kz")
-copy_to_Texture("dz")
-copy_to_Texture("iRho")
---unroll_to_depth(2)
---]]
diff --git a/test-chill/test-cases/examples/cuda-chill/mriq.c b/test-chill/test-cases/examples/cuda-chill/mriq.c
deleted file mode 100644
index ba4b87c..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mriq.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#define N 32768
-#define M 3072
-struct kValues {
-  float Kx;
-  float Ky;
-  float Kz;
-  float PhiMag;
-};
-extern float sinf(float);
-extern float cosf(float);
-
-void
-ComputeQCPU(int numK, int numX,struct kValues kVals[M],float x[N], float y[N], float z[N],float Qr[N], float Qi[N]) {
-  float expArg;
-  float cosArg;
-  float sinArg;
-  float phi;
-  int i;
-  int j;
-  numK = M;
-  numX = N;
-  for ( i = 0; i < M; i++) {
-    for ( j = 0; j < N; j++) {
-      expArg = 6.2831853071795864769252867665590058f * (kVals[i].Kx * x[j] +kVals[i].Ky * y[j] +kVals[i].Kz * z[j]);
-      cosArg = cosf(expArg);
-      sinArg = sinf(expArg);
-      phi = kVals[i].PhiMag;
-      Qr[j] += phi * cosArg;
-      Qi[j] += phi * sinArg;
-    }
-  }
-}
-  
diff --git a/test-chill/test-cases/examples/cuda-chill/mriq.lua b/test-chill/test-cases/examples/cuda-chill/mriq.lua
deleted file mode 100644
index 1170111..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mriq.lua
+++ /dev/null
@@ -1,55 +0,0 @@
---CUBLAS 2 MM Multiply
-
---This function form intializes "CUDAIZE v2" versus "CUDAIZE v1" if you
---call init() and use global variables to specify procedure and loop
-
---Second parameter is procedure # and third is loop #
-init("mriq.c", "ComputeQCPU", 0) 
-
-dofile("cudaize.lua") --defines custom tile_by_index, copy_to_registers,
-                      --copy_to_shared methods
-N=32768
-M=3072
-TI=128
-TJ=128
-
-permute(0,{"j","i"})
---tile_by_index({"j","i"}, {TI,TJ}, {l1_control="jj", l2_control="ii"}, {"jj","ii", "j", "i"})
-tile_by_index({"i"}, {TJ}, {l1_control="ii",l1_tile="i"}, {"ii", "j","i"})
-tile_by_index({"j"}, {TI}, {l1_control="jj"}, {"ii","jj", "j", "i"})
---tile_by_index({"i"}, {TI}, {l1_control="ii"}, {"ii", "i", "j"})
---print_code()
-
-normalize_index("j")
-normalize_index("i")
---print_code()
---tile_by_index({"i"}, {TI}, {l1_control="iii",l1_tile="i"}, {"ii","jj", "iii","j","i"})
---print_code()
-cudaize("Kernel_GPU", {x=N,y=N,z=N,Qr=N,Qi=N,kVals=M},{block={"jj"}, thread={"j"}})
-
-copy_to_shared("tx","kVals",1)
---copy_to_shared("tx","x",1)
---copy_to_shared("tx","y",1)
---copy_to_shared("tx","z",1)
-
---copy_to_texture("kVals")
---datacopy(0, 3, "kVals", {"tt","t"},false,0,1,-16,true)
---print_code()
---datacopy_privatized(0,"tx","kVals",{"tx"})
---copy_to_registers("tx","kVals")
-copy_to_registers("ii","x")
-copy_to_registers("ii","y")
-copy_to_registers("ii","z")
-copy_to_registers("ii","Qi")
-copy_to_registers("ii","Qr")
---[[datacopy_privatized(0,"tx","x",{"tx"})
-datacopy_privatized(0,"tx","y",{"tx"})
-datacopy_privatized(0,"tx","z",{"tx"})
-datacopy_privatized(0,"tx","Qi",{"tx"})
-datacopy_privatized(0,"tx","Qr",{"tx"})
-
-
-]]--
---unroll(0,5,64)
-print_code()
---unroll_to_depth(1) --won't unroll past thread/loop mapping, unrolls up to two loop levels
diff --git a/test-chill/test-cases/examples/cuda-chill/mv-shadow.c b/test-chill/test-cases/examples/cuda-chill/mv-shadow.c
deleted file mode 100644
index 582b187..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mv-shadow.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#define N 1024
-
-void normalMV(float c[N][N], float a[N], float b[N]) {
-  int i, j;
-
-  for (i = 0; i < N; i++)
-    for (j = 0; j < N; j++)
-      a[i] = a[i] + c[j][i] * b[j];
-}
diff --git a/test-chill/test-cases/examples/cuda-chill/mv-shadow.lua b/test-chill/test-cases/examples/cuda-chill/mv-shadow.lua
deleted file mode 100644
index 43e8491..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mv-shadow.lua
+++ /dev/null
@@ -1,65 +0,0 @@
-init("mv-shadow.c","normalMV",0)
-dofile("cudaize.lua") --defines custom tile_by_index, copy_to_registers,
-                      --copy_to_shared methods
-
-N=129
-TI=32
-TJ=64
-
-N=1024
-TI=16
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
---Tile the i and j loop, introducing "ii" as the control loop for the "i"
---tile, "k" for the control loop fo the "j" tile, with the final order
---of {"ii", "k", "i", "j"}
-tile_by_index({"i","j"}, {TI,TJ}, {l1_control="ii", l2_control="k"}, {"ii", "k", "i", "j"})
---tile_by_index({"i"}, {TI}, {l1_control="iii"}, {"ii", "k", "iii","i", "j"})
---tile_by_index({"j"}, {TI}, {l2_control="k"}, { "k", "i", "j"})
---tile_by_index({"i"}, {TI}, {l1_control="ii"}, {"ii", "i", "j"})
---print_code()
---Normalize indx will do a tile size of one over the loop level specified
---by the input index. This is useful to get a zero lower bound and hard
---upper bound on a loop instead of it being relative to previous loop
---levels.
---normalize_index("ii")
-normalize_index("i")
-print_code()
-
---Cudaize now determines the grid dimentions from the loops themselves
---(the upper bounds of the block and thread loops). It also renames the
---given block and thread loops's indexes to the approviate values from
---the set {"bx","by","tx","ty","tz"}. The second parameter specifies the
---size of the arrays to be copied in the CUDA scaffolding.
-cudaize("mv_GPU", {a=N, b=N, c=N*N}, {block={"ii"}, thread={"i"}})
---print_code()
-
---Does a datacopy, tile, and add_sync to get a shared memory copy
-
---copy_to_shared("tx", "b", 1)
---copy_to_shared("tx", "c", -16)
---print_code()
---copy_to_texture("b")
---copy_to_texture("c")
-copy_to_registers("k", "a")
---print_code()
-
-unroll_to_depth(1) --won't unroll past thread/loop mapping, unrolls up to two loop levels
---copy_to_texture("b")
---print_code()
---unroll(0,5,0)
---print_code()
diff --git a/test-chill/test-cases/examples/cuda-chill/mv.c b/test-chill/test-cases/examples/cuda-chill/mv.c
deleted file mode 100644
index 582b187..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mv.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#define N 1024
-
-void normalMV(float c[N][N], float a[N], float b[N]) {
-  int i, j;
-
-  for (i = 0; i < N; i++)
-    for (j = 0; j < N; j++)
-      a[i] = a[i] + c[j][i] * b[j];
-}
diff --git a/test-chill/test-cases/examples/cuda-chill/mv.lua b/test-chill/test-cases/examples/cuda-chill/mv.lua
deleted file mode 100644
index ca54501..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mv.lua
+++ /dev/null
@@ -1,65 +0,0 @@
-init("mv.c","normalMV",0)
-dofile("cudaize.lua") --defines custom tile_by_index, copy_to_registers,
-                      --copy_to_shared methods
-
-N=129
-TI=32
-TJ=64
-
-N=1024
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
---Tile the i and j loop, introducing "ii" as the control loop for the "i"
---tile, "k" for the control loop fo the "j" tile, with the final order
---of {"ii", "k", "i", "j"}
-tile_by_index({"i","j"}, {TI,TJ}, {l1_control="ii", l2_control="k"}, {"ii", "k", "i", "j"})
---tile_by_index({"i"}, {TI}, {l1_control="iii"}, {"ii", "k", "iii","i", "j"})
---tile_by_index({"j"}, {TI}, {l2_control="k"}, { "k", "i", "j"})
---tile_by_index({"i"}, {TI}, {l1_control="ii"}, {"ii", "i", "j"})
---print_code()
---Normalize indx will do a tile size of one over the loop level specified
---by the input index. This is useful to get a zero lower bound and hard
---upper bound on a loop instead of it being relative to previous loop
---levels.
---normalize_index("ii")
-normalize_index("i")
-print_code()
-
---Cudaize now determines the grid dimentions from the loops themselves
---(the upper bounds of the block and thread loops). It also renames the
---given block and thread loops's indexes to the approviate values from
---the set {"bx","by","tx","ty","tz"}. The second parameter specifies the
---size of the arrays to be copied in the CUDA scaffolding.
-cudaize("mv_GPU", {a=N, b=N, c=N*N}, {block={"ii"}, thread={"i"}})
-
---print_code()
-
---Does a datacopy, tile, and add_sync to get a shared memory copy
-
---copy_to_shared("tx", "b", 1)
---copy_to_shared("tx", "c", -16)
---print_code()
---copy_to_texture("b")
---copy_to_texture("c")
-copy_to_registers("k", "a")
---print_code()
-
-unroll_to_depth(1) --won't unroll past thread/loop mapping, unrolls up to two loop levels
---copy_to_texture("b")
---print_code()
---unroll(0,5,0)
---print_code()
diff --git a/test-chill/test-cases/examples/cuda-chill/mv_try.c b/test-chill/test-cases/examples/cuda-chill/mv_try.c
deleted file mode 100644
index 7781f3b..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mv_try.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#define N 4096
-
-void normalMV(int n, float c[N][N], float a[N], float b[N]) {
-  int i, j;
-
-  for (i = 0; i < n; i++)
-    for (j = 0; j < n; j++)
-      a[i] = a[i] + c[i][j] * b[j];
-}
diff --git a/test-chill/test-cases/examples/cuda-chill/mv_try.lua b/test-chill/test-cases/examples/cuda-chill/mv_try.lua
deleted file mode 100644
index db4d9ad..0000000
--- a/test-chill/test-cases/examples/cuda-chill/mv_try.lua
+++ /dev/null
@@ -1,14 +0,0 @@
-init("mv_try.c","normalMV",0)
-dofile("cudaize.lua") --defines custom tile_by_index, copy_to_registers,
-                      --copy_to_shared methods
-
-TI=96
-
-N=4096
-
-
-tile_by_index({"i"}, {TI}, {l1_control="ii"}, {"ii", "i", "j"})
-cudaize("mv_GPU", {a=N, b=N, c=N*N},
-        {block={"ii"}, thread={"i"}})
-
-print_code()
diff --git a/test-chill/test-cases/examples/cuda-chill/nbody.c b/test-chill/test-cases/examples/cuda-chill/nbody.c
deleted file mode 100644
index 57899b6..0000000
--- a/test-chill/test-cases/examples/cuda-chill/nbody.c
+++ /dev/null
@@ -1,66 +0,0 @@
-#define NBODIES 16384
-#define SOFTENINGSQUARED 0.01f
-#define DELTATIME 0.001f
-#define DAMPING 1.0f
-
-#define NBLOCKSY 1
-#define NBLOCKSX (NBODIES/NTHREADSX)
-#define NTHREADSY 1 
-#define NTHREADSX 64
-
-#define BLOCKSIZE 128
-
-#define SHARED 1
-#define TIMER 1
-#define VERIFY 1
-
-extern float sqrtf(float);
-
-void nbody_cpu(float* oldpos,float* oldpos1, float *newpos, float *oldvel, float *newvel, float *force)
-{
-    float r0,r1,r2;
-    float invDist, invDistCube, mass, invMass;
-    unsigned int i,j;
-    for(i = 0; i < NBODIES; ++i) {
-        //force[i*4  ] = 0;
-        //force[i*4+1] = 0;
-        //force[i*4+2] = 0;
-        //force[i*4+3] = 0;
-        for(j = 0; j < NBODIES; ++j) {
-	    r0 = oldpos[j*4]-oldpos1[i*4];
-	    r1 = oldpos[j*4+1]-oldpos1[i*4+1];
-	    r2 = oldpos[j*4+2]-oldpos1[i*4+2];
-
-	    invDist = 1.0/sqrtf(r0 * r0 + r1 * r1 + r2 * r2 + SOFTENINGSQUARED);
-	    invDistCube =  invDist * invDist * invDist;
-	    mass = oldpos1[i*4+3];
-
-	    force[i*4] = force[i*4] + r0 * mass * invDistCube;
-	    force[i*4+1] = force[i*4+1] + r1 * mass * invDistCube;
-	    force[i*4+2] = force[i*4+2] + r2 * mass * invDistCube;
-
-        }
-    }
-
-/*    for (i = 0; i < NBODIES; ++i) {
-        invMass = oldvel[4*i+3];
-
-        oldvel[4*i] += (force[4*i] * invMass) * DELTATIME * DAMPING;
-        oldvel[4*i+1] += (force[4*i+1] * invMass) * DELTATIME * DAMPING;
-        oldvel[4*i+2] += (force[4*i+2] * invMass) * DELTATIME * DAMPING;
-
-        oldpos[4*i] += oldvel[4*i] * DELTATIME;
-        oldpos[4*i+1] += oldvel[4*i+1] * DELTATIME;
-        oldpos[4*i+2] += oldvel[4*i+2] * DELTATIME;
-
-        newpos[4*i+0] = oldpos[4*i];
-        newpos[4*i+1] = oldpos[4*i+1];
-        newpos[4*i+2] = oldpos[4*i+2];
-        newpos[4*i+3] = oldpos[4*i+3];
-
-        newvel[4*i+0] = oldvel[4*i];
-        newvel[4*i+1] = oldvel[4*i+1];
-        newvel[4*i+2] = oldvel[4*i+2];
-        newvel[4*i+3] = oldvel[4*i+3];
-    }*/
-}
diff --git a/test-chill/test-cases/examples/cuda-chill/nbody.lua b/test-chill/test-cases/examples/cuda-chill/nbody.lua
deleted file mode 100644
index 08f88a9..0000000
--- a/test-chill/test-cases/examples/cuda-chill/nbody.lua
+++ /dev/null
@@ -1,53 +0,0 @@
---CUBLAS 2 MM Multiply
-
---This function form intializes "CUDAIZE v2" versus "CUDAIZE v1" if you
---call init() and use global variables to specify procedure and loop
-
---Second parameter is procedure # and third is loop #
-init("nbody.c", "nbody_cpu" , 0) 
-
-dofile("cudaize.lua") --defines custom tile_by_index, copy_to_registers,
-                     --copy_to_shared methods
-NBODIES=16384
-
-
---Tj=128 CHANGE FOR BEST..... BEST IS 64BLOCKS 128THREADS
---Ti=256
-Tj=64
-Ti=32
-Tjjj=1
-Tiii=1
-Tn=0.1
---normalize_index("j")
---
---print_code()
---normalize_index("n")
--- TILE COMMANDS ZEROOOOOOOOOOO:3
---tile_by_index({"i","j"},{Ti,Tj},{l1_control="ii",l2_control="jj"},{"ii","jj","i","j"})--CU=-1
-tile_by_index({"i"},{Ti},{l1_control="ii"},{"ii","i","j"})--CU=-1
---normalize_index("i")
---tile_by_index({"n"},{Tn},{l1_control="nn"},{"jj","ii","nn","j","i","n"})--CU=-1
-
---tile_by_index({"j","i"},{Tjjj,Tiii},{l1_control="jjj",l2_control="iii"},{"jj","ii","nn","jjj","j","iii","i","n"})--CU=3
---tile_by_index({"j"}, {Tn}, {l1_control="j",l1_tile="jjj"}, {"ii", "jj", "nn","jjj","j","i","n"})
---tile_by_index({"i"}, {Ti/2}, {l1_control="iii"}, {"ii","iii", "jj","i","j"})
---print_code()
-cudaize("kernel_GPU",{oldpos=4*NBODIES,oldpos1=4*NBODIES,oldvel=4*NBODIES,force=4*NBODIES,newpos=4*NBODIES,newvel=4*NBODIES},{block={"ii"}, thread={"i"}})--CU=3
-print_code()
---tile(0,6,6)
---copy_to_shared("tx","oldpos",-16)
---copy_to_registers("j","oldpos")
---copy_to_registers("j","oldpos1")
---copy_to_registers("j","force")
-
---copy_to_texture("oldpos")
---tile(1,3,3)
---tile(2,3,3)
-
-print_code()
---unroll_to_depth(1)
---
---tile(2,3,3)
---unroll(2,3,0)
---unroll(0,5,0)
---print_code()
diff --git a/test-chill/test-cases/examples/cuda-chill/tmv-shadow.c b/test-chill/test-cases/examples/cuda-chill/tmv-shadow.c
deleted file mode 100644
index cb9ea8d..0000000
--- a/test-chill/test-cases/examples/cuda-chill/tmv-shadow.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#define N 1024
-
-void normalMV(float c[N][N], float a[N], float b[N]) {
-  int i, j;
-
-  for (i = 0; i < N; i++)
-    for (j = 0; j < N; j++)
-      a[i] = a[i] + c[i][j] * b[j];
-}
diff --git a/test-chill/test-cases/examples/cuda-chill/tmv-shadow.lua b/test-chill/test-cases/examples/cuda-chill/tmv-shadow.lua
deleted file mode 100644
index 196b939..0000000
--- a/test-chill/test-cases/examples/cuda-chill/tmv-shadow.lua
+++ /dev/null
@@ -1,50 +0,0 @@
-init("tmv-shadow.c","normalMV",0)
-dofile("cudaize.lua") --defines custom tile_by_index, copy_to_registers,
-                      --copy_to_shared methods
-
-N=1024
---N= 8209
---N=129
-TI=64
-N=1024
-TI=32
---tile, "k" for the control loop for the "j" tile, with the final order
---of {"ii", "k", "i", "j"}
-tile_by_index({"i","j"}, {TI,TI}, {l1_control="ii", l2_control="k"}, {"ii", "k", "i", "j"})
---tile_by_index({"i"}, {TI}, {l1_control="ii"}, {"ii",  "i", "j"})
---print_code()
---tile_by_index({"i"}, {TI/32}, {l1_control="iii"}, {"ii", "k", "iii","i", "j"})
-
---print_code()
---Normalize indx will do a tile size of one over the loop level specified
---by the input index. This is useful to get a zero lower bound and hard
---upper bound on a loop instead of it being relative to previous loop
---levels.
---normalize_index("i")
---print_code()
-
---Cudaize now determines the grid dimentions from the loops themselves
---(the upper bounds of the block and thread loops). It also renames the
---given block and thread loops's indexes to the approviate values from
---the set {"bx","by","tx","ty","tz"}. The second parameter specifies the
---size of the arrays to be copied in the CUDA scaffolding.
-cudaize("tmv_GPU", {a=N, b=N, c=N*N},{block={"ii"}, thread={"i"}})
-
---print_code()
-
---Does a datacopy, tile, and add_sync to get a shared memory copy
-copy_to_shared("tx", "b", 1)
---copy_to_texture("b")
---print_code()
-
-copy_to_shared("tx", "c", -16)
---copy_to_texture("c")
---print_code()
-
-copy_to_registers("k", "a")
-print_code()
---unroll(0,5,0)
---unroll(0,4,0)
---unroll(2,4,16)
-unroll_to_depth(1)
---print_code()
diff --git a/test-chill/test-cases/examples/cuda-chill/tmv.c b/test-chill/test-cases/examples/cuda-chill/tmv.c
deleted file mode 100644
index cb9ea8d..0000000
--- a/test-chill/test-cases/examples/cuda-chill/tmv.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#define N 1024
-
-void normalMV(float c[N][N], float a[N], float b[N]) {
-  int i, j;
-
-  for (i = 0; i < N; i++)
-    for (j = 0; j < N; j++)
-      a[i] = a[i] + c[i][j] * b[j];
-}
diff --git a/test-chill/test-cases/examples/cuda-chill/tmv.lua b/test-chill/test-cases/examples/cuda-chill/tmv.lua
deleted file mode 100644
index 5071108..0000000
--- a/test-chill/test-cases/examples/cuda-chill/tmv.lua
+++ /dev/null
@@ -1,50 +0,0 @@
-init("tmv.c","normalMV",0)
-dofile("cudaize.lua") --defines custom tile_by_index, copy_to_registers,
-                      --copy_to_shared methods
-
-N=1024
---N= 8209
---N=129
-TI=64
-N=1024
-TI=32
---tile, "k" for the control loop for the "j" tile, with the final order
---of {"ii", "k", "i", "j"}
-tile_by_index({"i","j"}, {TI,TI}, {l1_control="ii", l2_control="k"}, {"ii", "k", "i", "j"})
---tile_by_index({"i"}, {TI}, {l1_control="ii"}, {"ii",  "i", "j"})
---print_code()
---tile_by_index({"i"}, {TI/32}, {l1_control="iii"}, {"ii", "k", "iii","i", "j"})
-
---print_code()
---Normalize indx will do a tile size of one over the loop level specified
---by the input index. This is useful to get a zero lower bound and hard
---upper bound on a loop instead of it being relative to previous loop
---levels.
---normalize_index("i")
---print_code()
-
---Cudaize now determines the grid dimentions from the loops themselves
---(the upper bounds of the block and thread loops). It also renames the
---given block and thread loops's indexes to the approviate values from
---the set {"bx","by","tx","ty","tz"}. The second parameter specifies the
---size of the arrays to be copied in the CUDA scaffolding.
-cudaize("tmv_GPU", {a=N, b=N, c=N*N},{block={"ii"}, thread={"i"}})
-
---print_code()
-
---Does a datacopy, tile, and add_sync to get a shared memory copy
-copy_to_shared("tx", "b", 1)
---copy_to_texture("b")
---print_code()
-
-copy_to_shared("tx", "c", -16)
---copy_to_texture("c")
---print_code()
-
-copy_to_registers("k", "a")
-print_code()
---unroll(0,5,0)
---unroll(0,4,0)
---unroll(2,4,16)
-unroll_to_depth(1)
---print_code()