cmake build

1 files changed, 1834 insertions, 0 deletions

diff --git a/chill/src/chillmodule.cc b/chill/src/chillmodule.cc
new file mode 100644
index 0000000..fbeb477
--- /dev/null
+++ b/chill/src/chillmodule.cc
@@ -0,0 +1,1834 @@
+
+// chill interface to python
+
+#include "chilldebug.h"
+
+#ifdef CUDACHILL
+
+#include "rose.h"                              // ?? 
+#include "loop_cuda_rose.hh"
+#include "ir_rose.hh"
+#include "ir_cudarose.hh"
+
+#include <vector>
+
+#else
+
+#include "chill_run_util.hh"
+
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <omega.h>
+#include "loop.hh"
+#include "ir_code.hh"
+#ifdef BUILD_ROSE
+#include "ir_rose.hh"
+#elif BUILD_SUIF
+#include "ir_suif.hh"
+#endif
+
+#endif
+
+#include "chillmodule.hh"
+
+// TODO 
+#undef _POSIX_C_SOURCE
+#undef _XOPEN_SOURCE
+#include <Python.h>
+
+using namespace omega;
+
+// -- Cuda CHiLL global variables --
+#ifdef CUDACHILL
+
+extern LoopCuda *myloop;
+extern IR_Code  *ir_code;
+extern std::vector<IR_Control *> ir_controls;
+extern std::vector<int> loops;
+
+#else
+
+extern Loop *myloop;
+extern IR_Code *ir_code;
+extern bool is_interactive;
+extern bool repl_stop;
+
+std::string procedure_name;
+std::string source_filename;
+
+int loop_start_num;
+int loop_end_num;
+
+extern std::vector<IR_Control *> ir_controls;
+extern std::vector<int> loops;
+
+#endif
+
+// ----------------------- //
+// CHiLL support functions //
+// ----------------------- //
+#ifndef CUDACHILL
+// not sure yet if this actually needs to be exposed to the python interface
+// these four functions are here to maintain similarity to the Lua interface
+int get_loop_num_start() {
+  return loop_start_num;
+}
+
+int get_loop_num_end() {
+  return loop_end_num;
+}
+
+static void set_loop_num_start(int start_num) {
+  loop_start_num = start_num;
+}
+
+static void set_loop_num_end(int end_num) {
+  loop_end_num = end_num;
+}
+
+// TODO: finalize_loop(int,int) and init_loop(int,int) are identical to thier Lua counterparts.
+// consider integrating them
+
+void finalize_loop(int loop_num_start, int loop_num_end) {
+  if (loop_num_start == loop_num_end) {
+    ir_code->ReplaceCode(ir_controls[loops[loop_num_start]], myloop->getCode());
+    ir_controls[loops[loop_num_start]] = NULL;
+  }
+  else {
+    std::vector<IR_Control *> parm;
+    for (int i = loops[loop_num_start]; i <= loops[loop_num_end]; i++)
+      parm.push_back(ir_controls[i]);
+    IR_Block *block = ir_code->MergeNeighboringControlStructures(parm);
+    ir_code->ReplaceCode(block, myloop->getCode());
+    for (int i = loops[loop_num_start]; i <= loops[loop_num_end]; i++) {
+      delete ir_controls[i];
+      ir_controls[i] = NULL;
+    }
+  }
+  delete myloop;
+}
+void finalize_loop() {
+  int loop_num_start = get_loop_num_start();
+  int loop_num_end = get_loop_num_end();
+  finalize_loop(loop_num_start, loop_num_end);
+}
+static void init_loop(int loop_num_start, int loop_num_end) {
+  if (source_filename.empty()) {
+    fprintf(stderr, "source file not set when initializing the loop");
+    if (!is_interactive)
+      exit(2);
+  }
+  else {
+    if (ir_code == NULL) {
+      #ifdef BUILD_ROSE  
+      if (procedure_name.empty())
+        procedure_name = "main";
+      #elif BUILD_SUIF   
+      if (procedure_number == -1)
+        procedure_number = 0;   
+      #endif
+        
+      #ifdef BUILD_ROSE
+      ir_code = new IR_roseCode(source_filename.c_str(), procedure_name.c_str());
+      #elif BUILD_SUIF
+      ir_code = new IR_suifCode(source_filename.c_str(), procedure_name.c_str());
+      #endif
+          
+      IR_Block *block = ir_code->GetCode();
+      ir_controls = ir_code->FindOneLevelControlStructure(block);
+      for (int i = 0; i < ir_controls.size(); i++) {
+        if (ir_controls[i]->type() == IR_CONTROL_LOOP)
+          loops.push_back(i);
+      }
+      delete block;
+    }
+    if (myloop != NULL && myloop->isInitialized()) {
+       finalize_loop();
+    }
+  }
+  set_loop_num_start(loop_num_start);
+  set_loop_num_end(loop_num_end);
+  if (loop_num_end < loop_num_start) {
+    fprintf(stderr, "the last loop must be after the start loop");
+    if (!is_interactive)
+      exit(2);
+  }              
+  if (loop_num_end >= loops.size()) {
+    fprintf(stderr, "loop %d does not exist", loop_num_end);
+    if (!is_interactive)
+      exit(2);
+  }
+  std::vector<IR_Control *> parm;
+  for (int i = loops[loop_num_start]; i <= loops[loop_num_end]; i++) {
+    if (ir_controls[i] == NULL) {
+      fprintf(stderr, "loop has already been processed");
+      if (!is_interactive)
+        exit(2);
+    }
+    parm.push_back(ir_controls[i]);
+  }
+  IR_Block *block = ir_code->MergeNeighboringControlStructures(parm);
+  myloop = new Loop(block);
+  delete block;  
+  //if (is_interactive) printf("%s ", PROMPT_STRING);
+}
+#endif
+
+// ----------------------- //
+// Python support funcions //
+// ----------------------- //
+
+// -- CHiLL support -- //
+static void strict_arg_num(PyObject* args, int arg_num, const char* fname = NULL) {
+  int arg_given = PyTuple_Size(args);
+  char msg[128];
+  if(arg_num != arg_given) {
+    if(fname)
+      sprintf(msg, "%s: expected %i arguments, was given %i.", fname, arg_num, arg_given);
+    else
+      sprintf(msg, "Expected %i argumets, was given %i.", arg_num, arg_given);
+    throw std::runtime_error(msg);
+  }
+}
+
+static int strict_arg_range(PyObject* args, int arg_min, int arg_max, const char* fname = NULL) {
+  int arg_given = PyTuple_Size(args);
+  char msg[128];
+  if(arg_given < arg_min || arg_given > arg_max) {
+    if(fname)
+      sprintf(msg, "%s: expected %i to %i arguments, was given %i.", fname, arg_min, arg_max, arg_given);
+    else
+      sprintf(msg, "Expected %i to %i, argumets, was given %i.", arg_min, arg_max, arg_given);
+    throw std::runtime_error(msg);
+  }
+  return arg_given;
+}
+
+static int intArg(PyObject* args, int index, int dval = 0) {
+  if(PyTuple_Size(args) <= index)
+    return dval; 
+  int ival;
+  PyObject *item = PyTuple_GetItem(args, index); 
+  Py_INCREF(item);
+  if (PyInt_Check(item)) ival = PyInt_AsLong(item);
+  else {
+    fprintf(stderr, "argument at index %i is not an int\n", index);
+    exit(-1);
+  }
+  return ival;
+}
+
+static std::string strArg(PyObject* args, int index, const char* dval = NULL) {
+  if(PyTuple_Size(args) <= index)
+    return dval;
+  std::string strval;
+  PyObject *item = PyTuple_GetItem(args, index); 
+  Py_INCREF(item);
+  if (PyString_Check(item)) strval = strdup(PyString_AsString(item));
+  else {
+    fprintf(stderr, "argument at index %i is not an string\n", index);
+    exit(-1);
+  }
+  return strval;
+}
+
+static bool boolArg(PyObject* args, int index, bool dval = false) {
+  if(PyTuple_Size(args) <= index)
+    return dval;
+  bool bval;
+  PyObject* item = PyTuple_GetItem(args, index);
+  Py_INCREF(item);
+  return (bool)PyObject_IsTrue(item);
+}
+
+static bool tostringintmapvector(PyObject* args, int index, std::vector<std::map<std::string,int> >& vec) {
+  if(PyTuple_Size(args) <= index)
+    return false;
+  PyObject* seq = PyTuple_GetItem(args, index);
+  //TODO: Typecheck
+  int seq_len = PyList_Size(seq);
+  for(int i = 0; i < seq_len; i++) {
+    std::map<std::string,int> map;
+    PyObject* dict = PyList_GetItem(seq, i);
+    PyObject* keys = PyDict_Keys(dict);
+    //TODO: Typecheck
+    int dict_len = PyList_Size(keys);
+    for(int j = 0; j < dict_len; j++) {
+      PyObject* key = PyList_GetItem(keys, j);
+      PyObject* value = PyDict_GetItem(dict, key);
+      std::string str_key = strdup(PyString_AsString(key));
+      int int_value = PyInt_AsLong(value);
+      map[str_key] = int_value;
+    }
+    vec.push_back(map);
+  }
+  return true;
+}
+
+static bool tointvector(PyObject* seq, std::vector<int>& vec) {
+  //TODO: Typecheck
+  int seq_len = PyList_Size(seq);
+  for(int i = 0; i < seq_len; i++) {
+    PyObject* item = PyList_GetItem(seq, i);
+    vec.push_back(PyInt_AsLong(item));
+  }
+  return true;
+}
+
+static bool tointvector(PyObject* args, int index, std::vector<int>& vec) {
+  if(PyTuple_Size(args) <= index)
+    return false;
+  PyObject* seq = PyTuple_GetItem(args, index);
+  return tointvector(seq, vec);
+}
+
+static bool tointset(PyObject* args, int index, std::set<int>& set) {
+  if(PyTuple_Size(args) <= index)
+    return false;
+  PyObject* seq = PyTuple_GetItem(args, index);
+  //TODO: Typecheck
+  int seq_len = PyList_Size(seq);
+  for(int i = 0; i < seq_len; i++) {
+    PyObject* item = PyList_GetItem(seq, i);
+    set.insert(PyInt_AsLong(item));
+  }
+  return true;
+}
+static bool tointmatrix(PyObject* args, int index, std::vector<std::vector<int> >& mat) {
+  if(PyTuple_Size(args) <= index)
+    return false;
+  PyObject* seq_one = PyTuple_GetItem(args, index);
+  int seq_one_len = PyList_Size(seq_one);
+  for(int i = 0; i < seq_one_len; i++) {
+    std::vector<int> vec;
+    PyObject* seq_two = PyList_GetItem(seq_one, i);
+    int seq_two_len = PyList_Size(seq_two);
+    for(int j = 0; j < seq_two_len; j++) {
+      PyObject* item = PyList_GetItem(seq_two, j);
+      vec.push_back(PyInt_AsLong(item));
+    }
+    mat.push_back(vec);
+  }
+  return true;
+}
+
+#ifdef CUDACHILL
+// ------------------------------ //
+// Cuda CHiLL interface functions //
+// ------------------------------ //
+
+static PyObject *
+chill_print_code(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("\nC print_code() PY\n"); 
+  
+  myloop->printCode();
+  
+  Py_RETURN_NONE;  // return Py_BuildValue( "" );
+  
+}
+
+static PyObject *
+chill_print_ri(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("\nC chill_print_ri() called from python\n"); 
+  myloop->printRuntimeInfo();
+  DEBUG_PRINT("\n");
+  Py_RETURN_NONE;  // return Py_BuildValue( "" );
+}
+
+static PyObject *
+chill_print_idx(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("\nC chill_print_idx() called from python\n"); 
+  myloop->printIndexes();
+  DEBUG_PRINT("\n");
+  Py_RETURN_NONE;  // return Py_BuildValue( "" );
+}
+
+static PyObject *
+chill_print_dep(PyObject *self, PyObject *args)
+{
+  DEBUG_PRINT("\nC chill_print_dep()\n"); 
+  std::cout << myloop->dep;
+  Py_RETURN_NONE;  // return Py_BuildValue( "" );
+}
+
+static PyObject *
+chill_print_space(PyObject *self, PyObject *args)
+{
+  DEBUG_PRINT("\nC chill_print_space()\n"); 
+  for (int i = 0; i < myloop->stmt.size(); i++) {
+    DEBUG_PRINT("s%d: ", i+1);
+    Relation r;
+    if (!myloop->stmt[i].xform.is_null())
+      r = Composition(copy(myloop->stmt[i].xform), copy(myloop->stmt[i].IS));
+    else
+      r = copy(myloop->stmt[i].IS);
+    r.simplify(2, 4);
+    r.print();
+  }
+  Py_RETURN_NONE;  // return Py_BuildValue( "" );
+}
+
+static PyObject *
+chill_num_statements(PyObject *self, PyObject *args)  
+{
+  //DEBUG_PRINT("\nC chill_num_statements() called from python\n"); 
+  int num = myloop->stmt.size();
+  //DEBUG_PRINT("C num_statement() = %d\n", num); 
+  return Py_BuildValue( "i", num ); // BEWARE "d" is DOUBLE, not int
+}  
+
+static PyObject *
+chill_does_var_exist( PyObject *self, PyObject *args)
+{
+  DEBUG_PRINT("\nC chill_does_var_exist()\n"); 
+  int yesno = 0;
+  // TODO if (myloop->symbolExists(symName)) yesno = 1;
+  DEBUG_PRINT("*** chill_does_var_exist *** UNIMPLEMENTED\n"); 
+  return Py_BuildValue( "i", yesno); // there seems to be no boolean type
+}
+
+
+static PyObject *
+chill_add_sync(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("\nC chill_add_sync()  *UNTESTED*\n"); 
+  int sstmt = -123;
+  //   char index_name[180];
+  static char Buffer[1024];
+  static char *index_name = &Buffer[0]; 
+  
+  if (!PyArg_ParseTuple(args, "is", &sstmt, &index_name)){
+    fprintf(stderr, "chill_add_sync, can't parse statement number and name passed from python\n");
+    exit(-1);
+  }
+  
+  DEBUG_PRINT("chill_add_sync, statement %d   index_name '%s'\n", 
+              sstmt, index_name);
+  std::string idxName( index_name); // ?? 
+  myloop->addSync(sstmt, idxName);
+  
+  Py_RETURN_NONE;  // return Py_BuildValue( "" );
+}
+
+static PyObject *
+chill_rename_index(PyObject *self, PyObject *args)
+{
+  DEBUG_PRINT("\nC chill_rename_index() called from python\n"); 
+  int sstmt;
+  //char oldname[80], newname[80];
+  static char old[1024], newn[1024];
+  
+  static char *oldname = &old[0], *newname=&newn[0];
+  
+  if (!PyArg_ParseTuple(args, "iss", &sstmt, &oldname, &newname)){
+    fprintf(stderr, "chill_rename_index, can't parse statement number and names passed from python\n");
+    exit(-1);
+  }
+  
+  //DEBUG_PRINT("chill_rename_index, statement %d   oldname '%s'   newname '%s'\n", 
+  //sstmt, oldname, newname);
+  
+  std::string idxName(oldname);
+  std::string newName(newname); 
+  
+  //DEBUG_PRINT("calling myloop->renameIndex( %d, %s, %s )\n", 
+  //sstmt, idxName.c_str(), newName.c_str()); 
+  
+  myloop->renameIndex(sstmt, idxName, newName);
+  
+  //DEBUG_PRINT("after myloop->renameIndex()\n");  
+  
+  Py_RETURN_NONE;  // return Py_BuildValue( "" );
+}
+
+
+
+//THIS NEEDS TO MOVE
+
+
+
+static PyObject *
+chill_permute_v2(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("C       permute_v2()\n"); 
+  //int tot = sizeof(args);
+  //int things = tot / sizeof(PyObject *);
+  //DEBUG_PRINT("tot %d bytes, %d things\n", tot, things);   
+  
+  int sstmt = -123;
+  PyObject *pyObj;
+  
+  //if (!PyArg_ParseTuple( args, "iO", &sstmt, &pyObj)) {
+  //if (!PyArg_ParseTuple( args, "i", &sstmt)) {
+  if (!PyArg_ParseTuple( args, "O", &pyObj)) { // everything on a single tuple
+    fprintf(stderr, "failed to parse tuple\n");
+    exit(-1);
+  }
+  Py_XINCREF(pyObj);
+  
+  // the ONLY arg is a tuple. figure out how big it is 
+  int tupleSize = PyTuple_Size(pyObj);
+  //DEBUG_PRINT("%d things in order tuple\n", tupleSize); 
+  
+  // first has to be the statement number
+  PyObject *tupleItem = PyTuple_GetItem(pyObj, 0); 
+  Py_XINCREF(tupleItem);
+  if (PyInt_Check( tupleItem )) sstmt = PyInt_AsLong( tupleItem );
+  else {
+    fflush(stdout);
+    fprintf(stderr, "first tuple item in chill_permute_v2 is not an int?\n");
+    exit(-1);
+  }
+  
+  //DEBUG_PRINT("stmt %d\n", sstmt);
+  
+  char **strings;
+  std::vector<std::string> order;
+  std::string *cppstrptr;
+  std::string cppstr;
+  
+  strings = (char **) malloc( sizeof(char *) * tupleSize ) ; // too big
+  for (int i=1; i<tupleSize; i++) {
+    tupleItem = PyTuple_GetItem(pyObj, i);
+    Py_XINCREF(tupleItem);
+    int im1 = i-1;  // offset needed for the actual string vector
+    if (PyString_Check( tupleItem))  {
+      strings[im1] = strdup(PyString_AsString(tupleItem));
+      //DEBUG_PRINT("item %d = '%s'\n", i, strings[im1]);
+      //cppstrptr = new std::string( strings[im1] );
+      //order.push_back(  &(new std::string( strings[im1] )));
+      //order.push_back(  &cppstrptr );
+      
+      cppstr = strings[im1];
+      order.push_back(  cppstr );
+    }
+    else {
+      fprintf(stderr, "later parameter was not a string?\n");
+      exit(-1);
+    }
+    
+  }
+  
+  myloop->permute_cuda(sstmt,order);
+  //DEBUG_PRINT("returned from permute_cuda()\n"); 
+  Py_RETURN_NONE;  // return Py_BuildValue( "" );
+}
+
+
+static PyObject *
+chill_tile_v2_3arg( PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("in chillmodule.cc, chill_tile_v2_3arg()\n"); 
+  
+  int sstmt, level, tile_size, outer_level;
+  //char index_name[80], control_name[80];
+  static char *index_name, *control_name;
+  int tiling_method;
+  
+  if (!PyArg_ParseTuple(args, "iii", &sstmt, &level, &outer_level)) {
+    fprintf(stderr,"chill_tile_v2, can't parse parameters passed from python\n");
+    exit(-1);
+  }
+  
+  // 3 parameter version 
+  //DEBUG_PRINT("chill_tile_v2( %d %d %d)   (3 parameter version) \n", 
+  //sstmt,level,outer_level);  
+  myloop->tile_cuda(sstmt,level,outer_level);
+  //DEBUG_PRINT("chill_tile_v2 3 parameter version returning normally\n"); 
+  Py_RETURN_NONE; 
+}
+
+
+static PyObject *
+chill_tile_v2_7arg( PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("in chillmodule.cc, chill_tile_v2_7arg()\n"); 
+  
+  int sstmt, level, tile_size, outer_level;
+  //char index_name[80], control_name[80];
+  static char iname[1024], cname[1024];
+  static char *index_name = &iname[0], *control_name=&cname[0];
+  int tiling_method;
+  
+  if (!PyArg_ParseTuple(args, "iiiissi", 
+                        &sstmt, &level, &tile_size, &outer_level, 
+                        &index_name, &control_name, &tiling_method)){
+    fprintf(stderr, "chill_tile_v2_7arg, can't parse parameters passed from python\n");
+    exit(-1);
+  }
+  
+  //DEBUG_PRINT("7 parameter version was called?\n"); 
+  
+  // 7 parameter version was called 
+  //DEBUG_PRINT("tile_v2( %d, %d, %d, %d ... )\n", 
+  // sstmt, level, tile_size, outer_level);
+  
+  //DEBUG_PRINT("tile_v2( %d, %d, %d, %d, %s, %s, %d)\n", 
+  //sstmt,level,tile_size,outer_level,index_name, control_name, tiling_method);
+  
+  TilingMethodType method = StridedTile;    
+  if (tiling_method == 0)  method = StridedTile;
+  else if (tiling_method == 1) method = CountedTile;
+  else fprintf(stderr, "ERROR: tile_v2 illegal tiling method, using StridedTile\n");
+  
+  //DEBUG_PRINT("outer level %d\n", outer_level);  
+  //DEBUG_PRINT("calling myloop->tile_cuda( %d, %d, %d, %d, %s, %s, method)\n", 
+  // sstmt, level, tile_size, outer_level, index_name, control_name); 
+  
+  // BUH   level+1?
+  myloop->tile_cuda(sstmt, level, tile_size, outer_level, index_name, control_name, method); 
+  Py_RETURN_NONE; 
+}
+
+
+static PyObject *
+chill_cur_indices(PyObject *self, PyObject *args)
+{
+  int stmt_num = -123; 
+  if (!PyArg_ParseTuple(args, "i", &stmt_num)){
+    fprintf(stderr, "chill_cur_indides, can't parse statement number passed from python\n");
+    exit(-1);
+  }
+  //DEBUG_PRINT("cur_indices( %d )\n", stmt_num);  
+  
+  char formatstring[1024];
+  for (int i=0; i<1024; i++) formatstring[i] = '\0';
+  
+  int num = myloop->idxNames[stmt_num].size();
+  for(int i=0; i<num; i++){
+    //DEBUG_PRINT("myloop->idxNames[%d] index %d = '%s'\n", 
+    //stmt_num, i, myloop->idxNames[stmt_num][i].c_str()); 
+    
+    // backwards, works because all entries are the same  
+    //sprintf(formatstring, "i %s", formatstring); 
+    strcat( formatstring, "s ");
+    // put this in a list or something to pass back to python
+  }
+  
+  int l = strlen(formatstring);
+  if (l > 0) formatstring[l-1] = '\0';
+  
+  //DEBUG_PRINT("%d current indices, format string '%s'\n\n",num,formatstring);  
+  //DEBUG_PRINT("%d current indices\n\n",  num);  
+  
+  //return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),myloop->idxNames[stmt_num][1].c_str() );
+  
+  // I don't know a clean way to do this. 
+  if (num == 2) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                     myloop->idxNames[stmt_num][1].c_str());
+  if (num == 3) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                     myloop->idxNames[stmt_num][1].c_str(),
+                                     myloop->idxNames[stmt_num][2].c_str());  
+  if (num == 4) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                     myloop->idxNames[stmt_num][1].c_str(),
+                                     myloop->idxNames[stmt_num][2].c_str(),
+                                     myloop->idxNames[stmt_num][3].c_str()); 
+  if (num == 5) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                     myloop->idxNames[stmt_num][1].c_str(),
+                                     myloop->idxNames[stmt_num][2].c_str(),
+                                     myloop->idxNames[stmt_num][3].c_str(),
+                                     myloop->idxNames[stmt_num][4].c_str()); 
+  if (num == 6) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                     myloop->idxNames[stmt_num][1].c_str(),
+                                     myloop->idxNames[stmt_num][2].c_str(),
+                                     myloop->idxNames[stmt_num][3].c_str(),
+                                     myloop->idxNames[stmt_num][4].c_str(),
+                                     myloop->idxNames[stmt_num][5].c_str()); 
+  if (num == 7) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                     myloop->idxNames[stmt_num][1].c_str(),
+                                     myloop->idxNames[stmt_num][2].c_str(),
+                                     myloop->idxNames[stmt_num][3].c_str(),
+                                     myloop->idxNames[stmt_num][4].c_str(),
+                                     myloop->idxNames[stmt_num][5].c_str(),
+                                     myloop->idxNames[stmt_num][6].c_str()); 
+  if (num == 8) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                     myloop->idxNames[stmt_num][1].c_str(),
+                                     myloop->idxNames[stmt_num][2].c_str(),
+                                     myloop->idxNames[stmt_num][3].c_str(),
+                                     myloop->idxNames[stmt_num][4].c_str(),
+                                     myloop->idxNames[stmt_num][5].c_str(),
+                                     myloop->idxNames[stmt_num][6].c_str(),
+                                     myloop->idxNames[stmt_num][7].c_str()); 
+  if (num == 9) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                     myloop->idxNames[stmt_num][1].c_str(),
+                                     myloop->idxNames[stmt_num][2].c_str(),
+                                     myloop->idxNames[stmt_num][3].c_str(),
+                                     myloop->idxNames[stmt_num][4].c_str(),
+                                     myloop->idxNames[stmt_num][5].c_str(),
+                                     myloop->idxNames[stmt_num][6].c_str(),
+                                     myloop->idxNames[stmt_num][7].c_str(),
+                                     myloop->idxNames[stmt_num][8].c_str()); 
+  if (num == 10) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                      myloop->idxNames[stmt_num][1].c_str(),
+                                      myloop->idxNames[stmt_num][2].c_str(),
+                                      myloop->idxNames[stmt_num][3].c_str(),
+                                      myloop->idxNames[stmt_num][4].c_str(),
+                                      myloop->idxNames[stmt_num][5].c_str(),
+                                      myloop->idxNames[stmt_num][6].c_str(),
+                                      myloop->idxNames[stmt_num][7].c_str(),
+                                      myloop->idxNames[stmt_num][8].c_str(),
+                                      myloop->idxNames[stmt_num][9].c_str()); 
+  if (num == 11) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                      myloop->idxNames[stmt_num][1].c_str(),
+                                      myloop->idxNames[stmt_num][2].c_str(),
+                                      myloop->idxNames[stmt_num][3].c_str(),
+                                      myloop->idxNames[stmt_num][4].c_str(),
+                                      myloop->idxNames[stmt_num][5].c_str(),
+                                      myloop->idxNames[stmt_num][6].c_str(),
+                                      myloop->idxNames[stmt_num][7].c_str(),
+                                      myloop->idxNames[stmt_num][8].c_str(),
+                                      myloop->idxNames[stmt_num][9].c_str(),
+                                      myloop->idxNames[stmt_num][10].c_str()); 
+  if (num == 12) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                      myloop->idxNames[stmt_num][1].c_str(),
+                                      myloop->idxNames[stmt_num][2].c_str(),
+                                      myloop->idxNames[stmt_num][3].c_str(),
+                                      myloop->idxNames[stmt_num][4].c_str(),
+                                      myloop->idxNames[stmt_num][5].c_str(),
+                                      myloop->idxNames[stmt_num][6].c_str(),
+                                      myloop->idxNames[stmt_num][7].c_str(),
+                                      myloop->idxNames[stmt_num][8].c_str(),
+                                      myloop->idxNames[stmt_num][9].c_str(),
+                                      myloop->idxNames[stmt_num][10].c_str(),
+                                      myloop->idxNames[stmt_num][11].c_str()); 
+  if (num == 13) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                      myloop->idxNames[stmt_num][1].c_str(),
+                                      myloop->idxNames[stmt_num][2].c_str(),
+                                      myloop->idxNames[stmt_num][3].c_str(),
+                                      myloop->idxNames[stmt_num][4].c_str(),
+                                      myloop->idxNames[stmt_num][5].c_str(),
+                                      myloop->idxNames[stmt_num][6].c_str(),
+                                      myloop->idxNames[stmt_num][7].c_str(),
+                                      myloop->idxNames[stmt_num][8].c_str(),
+                                      myloop->idxNames[stmt_num][9].c_str(),
+                                      myloop->idxNames[stmt_num][10].c_str(),
+                                      myloop->idxNames[stmt_num][11].c_str(),
+                                      myloop->idxNames[stmt_num][12].c_str()); 
+  if (num == 14) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                      myloop->idxNames[stmt_num][1].c_str(),
+                                      myloop->idxNames[stmt_num][2].c_str(),
+                                      myloop->idxNames[stmt_num][3].c_str(),
+                                      myloop->idxNames[stmt_num][4].c_str(),
+                                      myloop->idxNames[stmt_num][5].c_str(),
+                                      myloop->idxNames[stmt_num][6].c_str(),
+                                      myloop->idxNames[stmt_num][7].c_str(),
+                                      myloop->idxNames[stmt_num][8].c_str(),
+                                      myloop->idxNames[stmt_num][9].c_str(),
+                                      myloop->idxNames[stmt_num][10].c_str(),
+                                      myloop->idxNames[stmt_num][11].c_str(),
+                                      myloop->idxNames[stmt_num][12].c_str(),
+                                      myloop->idxNames[stmt_num][13].c_str()); 
+  if (num == 15) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                      myloop->idxNames[stmt_num][1].c_str(),
+                                      myloop->idxNames[stmt_num][2].c_str(),
+                                      myloop->idxNames[stmt_num][3].c_str(),
+                                      myloop->idxNames[stmt_num][4].c_str(),
+                                      myloop->idxNames[stmt_num][5].c_str(),
+                                      myloop->idxNames[stmt_num][6].c_str(),
+                                      myloop->idxNames[stmt_num][7].c_str(),
+                                      myloop->idxNames[stmt_num][8].c_str(),
+                                      myloop->idxNames[stmt_num][9].c_str(),
+                                      myloop->idxNames[stmt_num][10].c_str(),
+                                      myloop->idxNames[stmt_num][11].c_str(),
+                                      myloop->idxNames[stmt_num][12].c_str(),
+                                      myloop->idxNames[stmt_num][13].c_str(),
+                                      myloop->idxNames[stmt_num][14].c_str()); 
+  if (num == 16) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                      myloop->idxNames[stmt_num][1].c_str(),
+                                      myloop->idxNames[stmt_num][2].c_str(),
+                                      myloop->idxNames[stmt_num][3].c_str(),
+                                      myloop->idxNames[stmt_num][4].c_str(),
+                                      myloop->idxNames[stmt_num][5].c_str(),
+                                      myloop->idxNames[stmt_num][6].c_str(),
+                                      myloop->idxNames[stmt_num][7].c_str(),
+                                      myloop->idxNames[stmt_num][8].c_str(),
+                                      myloop->idxNames[stmt_num][9].c_str(),
+                                      myloop->idxNames[stmt_num][10].c_str(),
+                                      myloop->idxNames[stmt_num][11].c_str(),
+                                      myloop->idxNames[stmt_num][12].c_str(),
+                                      myloop->idxNames[stmt_num][13].c_str(),
+                                      myloop->idxNames[stmt_num][14].c_str(),
+                                      myloop->idxNames[stmt_num][15].c_str()); 
+  if (num == 17) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                      myloop->idxNames[stmt_num][1].c_str(),
+                                      myloop->idxNames[stmt_num][2].c_str(),
+                                      myloop->idxNames[stmt_num][3].c_str(),
+                                      myloop->idxNames[stmt_num][4].c_str(),
+                                      myloop->idxNames[stmt_num][5].c_str(),
+                                      myloop->idxNames[stmt_num][6].c_str(),
+                                      myloop->idxNames[stmt_num][7].c_str(),
+                                      myloop->idxNames[stmt_num][8].c_str(),
+                                      myloop->idxNames[stmt_num][9].c_str(),
+                                      myloop->idxNames[stmt_num][10].c_str(),
+                                      myloop->idxNames[stmt_num][11].c_str(),
+                                      myloop->idxNames[stmt_num][12].c_str(),
+                                      myloop->idxNames[stmt_num][13].c_str(),
+                                      myloop->idxNames[stmt_num][14].c_str(),
+                                      myloop->idxNames[stmt_num][15].c_str(),
+                                      myloop->idxNames[stmt_num][16].c_str()); 
+  if (num == 18) return Py_BuildValue(formatstring, myloop->idxNames[stmt_num][0].c_str(),
+                                      myloop->idxNames[stmt_num][1].c_str(),
+                                      myloop->idxNames[stmt_num][2].c_str(),
+                                      myloop->idxNames[stmt_num][3].c_str(),
+                                      myloop->idxNames[stmt_num][4].c_str(),
+                                      myloop->idxNames[stmt_num][5].c_str(),
+                                      myloop->idxNames[stmt_num][6].c_str(),
+                                      myloop->idxNames[stmt_num][7].c_str(),
+                                      myloop->idxNames[stmt_num][8].c_str(),
+                                      myloop->idxNames[stmt_num][9].c_str(),
+                                      myloop->idxNames[stmt_num][10].c_str(),
+                                      myloop->idxNames[stmt_num][11].c_str(),
+                                      myloop->idxNames[stmt_num][12].c_str(),
+                                      myloop->idxNames[stmt_num][13].c_str(),
+                                      myloop->idxNames[stmt_num][14].c_str(),
+                                      myloop->idxNames[stmt_num][15].c_str(),
+                                      myloop->idxNames[stmt_num][16].c_str(),
+                                      myloop->idxNames[stmt_num][17].c_str()); 
+  
+  fprintf(stderr, "going to die horribly,  num=%d\n", num); 
+}
+
+
+static PyObject *
+chill_block_indices(PyObject *self, PyObject *args) {
+  
+  // I'm unsure what the legal states are here
+  // is it always "bx", or  ("bx" and "by") ?
+  int howmany = 0;
+  char *loopnames[2]; 
+  if (myloop->cu_bx > 1) {
+    loopnames[howmany] = strdup("bx");
+    howmany++;
+  }
+  if (myloop->cu_by > 1) {
+    loopnames[howmany] = strdup("by");
+    howmany++;
+  }
+  
+  if (howmany == 0) return Py_BuildValue("()");
+  if (howmany == 1) return Py_BuildValue("(s)", loopnames[0]);
+  if (howmany == 2) return Py_BuildValue("(ss)", loopnames[0], loopnames[1]);
+  fprintf(stderr, "chill_block_indices(), gonna die, howmany == %d", howmany);
+  exit(666);
+  
+  Py_RETURN_NONE;
+}
+
+static PyObject *
+chill_thread_indices(PyObject *self, PyObject *args) {
+  
+  // I'm unsure what the legal states are here
+  // is it always "tx", or  ("tx" and "ty") or ("tx" and "ty" and "tz") ?
+  int howmany = 0;
+  char *loopnames[3];
+  if (myloop->cu_tx > 1) {
+    loopnames[howmany++] = strdup("tx");
+  }
+  if (myloop->cu_ty > 1) {
+    loopnames[howmany++] = strdup("ty");
+  }
+  if (myloop->cu_tz > 1) {
+    loopnames[howmany++] = strdup("tz");
+  }
+  
+  if (howmany == 0) return Py_BuildValue("()");
+  if (howmany == 1) return Py_BuildValue("(s)",   
+                                         loopnames[0]);
+  if (howmany == 2) return Py_BuildValue("(ss)",  
+                                         loopnames[0], 
+                                         loopnames[1]);
+  if (howmany == 3) return Py_BuildValue("(sss)", 
+                                         loopnames[0],
+                                         loopnames[1],
+                                         loopnames[2]);
+  
+  fprintf(stderr, "chill_thread_indices(), gonna die, howmany == %d", howmany);
+  exit(999);
+}
+
+
+
+
+
+static PyObject *
+block_dims(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("block_dims() returning %d %d\n", myloop->cu_bx, myloop->cu_by);
+  Py_BuildValue( "i i", myloop->cu_bx, myloop->cu_by);
+}
+
+
+static PyObject *
+thread_dims(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("thread_dims() returning %d %d %d\n", 
+  //myloop->cu_tx, myloop->cu_ty, myloop->cu_tz);
+  
+  Py_BuildValue( "i i i", myloop->cu_tx, myloop->cu_ty, myloop->cu_tz);
+}
+
+
+static PyObject *
+chill_hard_loop_bounds(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("hard_loop_bounds("); 
+  int sstmt, level;  // input parameters
+  int upper, lower;  // output
+  
+  if (!PyArg_ParseTuple(args, "ii", &sstmt, &level)){
+    fprintf(stderr, "hard_loop_bounds, ");
+    fprintf(stderr, "can't parse statement numbers passed from python\n");
+    exit(-1);
+  }
+  //DEBUG_PRINT(" %d, %d )\n", sstmt, level); 
+  
+  myloop->extractCudaUB(sstmt, level, upper, lower); 
+  
+  //DEBUG_PRINT("lower %d  upper %d\n", lower, upper);
+  
+  Py_BuildValue( "i i", lower, upper);
+}
+
+
+static PyObject *
+chill_datacopy9(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("\n\n\n*****  datacopy_v2()  9ARGS\n"); 
+  
+  int sstmt;
+  int level;
+  std::string cppstr;
+  std::string array_name;
+  std::vector<std::string> new_idxs;
+  bool allow_extra_read;
+  int fastest_changing_dimension;
+  int padding_stride;
+  int padding_alignment;
+  bool cuda_shared; 
+  
+  PyObject     *pyObj;
+
+  if (!PyArg_ParseTuple( args, "O", &pyObj)) { // everything on a single tuple
+    
+    fprintf(stderr, "failed to parse tuple\n");
+    exit(-1);
+  }
+  Py_XINCREF( pyObj );
+  
+  //if (PyList_Check(pyObj))  fprintf(stderr, "it's a list\n");
+  //if (PyTuple_Check(pyObj)) fprintf(stderr, "it's a tuple\n");
+  
+  
+  
+  // the ONLY arg is a tuple. figure out how big it is 
+  int tupleSize = PyTuple_Size(pyObj);
+  //DEBUG_PRINT("%d things in object tuple\n", tupleSize); 
+  
+  // first has to be the statement number
+  PyObject *tupleItem1 = PyTuple_GetItem(pyObj, 0); 
+  Py_INCREF(tupleItem1);
+  if (PyInt_Check( tupleItem1)) sstmt = PyInt_AsLong( tupleItem1 );
+  else {
+    fprintf(stderr, "second tuple item in chill_datacopy9 is not an int?\n");
+    exit(-1);
+  }
+  //DEBUG_PRINT("stmt %d\n", sstmt);
+  
+  PyObject *tupleItem2 = PyTuple_GetItem(pyObj, 1);  // second item is level
+  Py_INCREF(tupleItem2);
+  if (PyInt_Check( tupleItem2 )) level = PyInt_AsLong( tupleItem2);
+  else {
+    fprintf(stderr, "second tuple item in chill_datacopy9 is not an int?\n");
+    exit(-1);
+  }
+  //DEBUG_PRINT("level %d\n", level );
+  
+  // third item is array name 
+  PyObject *tupleItem3 = PyTuple_GetItem(pyObj, 2);  
+  Py_INCREF(tupleItem3);
+  array_name = strdup(PyString_AsString(tupleItem3)); 
+  //DEBUG_PRINT("array name '%s'\n", array_name.c_str()); 
+  
+  
+  // integer number of indices  
+  PyObject *tupleItem4 = PyTuple_GetItem(pyObj, 3); 
+  Py_INCREF(tupleItem4);  
+  int numindex= PyInt_AsLong( tupleItem4 );
+  //DEBUG_PRINT("%d indices\n", numindex); 
+  
+  
+  PyObject *tupleItemTEMP;
+  for (int i=0; i<numindex; i++)  {
+    tupleItemTEMP = PyTuple_GetItem(pyObj, 4+i);
+    Py_INCREF(tupleItemTEMP);
+    cppstr = strdup(PyString_AsString(tupleItemTEMP)); 
+    new_idxs.push_back( cppstr );
+    //DEBUG_PRINT("%s\n", cppstr.c_str());
+  }
+  
+  PyObject *tupleItem5 = PyTuple_GetItem(pyObj, 4+numindex);
+  Py_INCREF(tupleItem5);
+  allow_extra_read = PyInt_AsLong( tupleItem5 );
+  
+  PyObject *tupleItem6 = PyTuple_GetItem(pyObj, 5+numindex);
+  Py_INCREF(tupleItem6);
+  fastest_changing_dimension = PyInt_AsLong( tupleItem6 );
+  
+  PyObject *tupleItem7 = PyTuple_GetItem(pyObj, 6+numindex);
+  Py_INCREF(tupleItem7);
+  padding_stride = PyInt_AsLong( tupleItem7 );
+  
+  PyObject *tupleItem8 = PyTuple_GetItem(pyObj, 7+numindex);
+  Py_INCREF(tupleItem8);
+  padding_alignment = PyInt_AsLong( tupleItem8 );
+  
+  PyObject *tupleItem9 = PyTuple_GetItem(pyObj, 8+numindex);
+  Py_INCREF(tupleItem9);
+  cuda_shared = PyInt_AsLong( tupleItem9 );
+  
+  
+  //DEBUG_PRINT("calling myloop->datacopy_cuda()\n");      
+  
+  // corruption happenes in here??? 
+  myloop->datacopy_cuda(sstmt, level, array_name, new_idxs,
+                        allow_extra_read, fastest_changing_dimension,
+                        padding_stride, padding_alignment, cuda_shared);
+  
+  DEBUG_PRINT("before attempt (after actual datacopy)\n"); 
+  //myloop->printCode(); // attempt to debug 
+  DEBUG_PRINT("back from attempt\n"); 
+  
+  //DEBUG_PRINT("datacopy_9args returning\n"); 
+  
+  Py_RETURN_NONE;  
+}
+
+
+
+
+
+static PyObject *
+chill_datacopy_privatized(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("C datacopy_privatized\n"); 
+  PyObject *pyObj;
+  if (!PyArg_ParseTuple( args, "O", &pyObj)) { // everything on a single tuple
+    fprintf(stderr, "failed to parse tuple\n");
+    exit(-1);
+  }
+  
+  PyObject *tupleItem = PyTuple_GetItem(pyObj, 0); //  statement number
+  Py_XINCREF(tupleItem);
+  int sstmt = PyInt_AsLong( tupleItem );
+  
+  tupleItem = PyTuple_GetItem(pyObj, 1);  // start_loop
+  Py_XINCREF(tupleItem);
+  std::string start_loop = strdup(PyString_AsString(tupleItem));
+  int level = myloop->findCurLevel(sstmt, start_loop);
+  
+  
+  tupleItem = PyTuple_GetItem(pyObj, 2);  // array_name
+  Py_XINCREF(tupleItem);
+  std::string array_name = strdup(PyString_AsString(tupleItem));
+  
+  // things to hold constant  - first a count, then the things
+  tupleItem = PyTuple_GetItem(pyObj, 3);  // how many things in the array
+  Py_XINCREF(tupleItem);
+  int howmany = PyInt_AsLong( tupleItem );
+  
+  //DEBUG_PRINT("%d things to hold constant: ", howmany);
+  std::vector<std::string> holdconstant;
+  std::string cppstr;
+  
+  for (int i=0; i<howmany; i++) {
+    tupleItem = PyTuple_GetItem(pyObj, 4+i);
+    Py_XINCREF(tupleItem);
+    cppstr = strdup(PyString_AsString(tupleItem));
+    holdconstant.push_back( cppstr );   // add at end
+  }
+  
+  std::vector<int> privatized_levels(howmany);  
+  for(int i=0; i<howmany; i++) { 
+    privatized_levels[i] = myloop->findCurLevel(sstmt, holdconstant[i]);
+    //DEBUG_PRINT("privatized_levels[ %d ] = %d\n", i, privatized_levels[i] );
+  }
+  
+  bool allow_extra_read = false;
+  int fastest_changing_dimension = -1; 
+  int padding_stride = 1;
+  int padding_alignment = 1;
+  bool cuda_shared = false;
+  
+  
+  myloop->datacopy_privatized_cuda(sstmt, level, array_name, privatized_levels,
+                                   allow_extra_read, fastest_changing_dimension,
+                                   padding_stride, padding_alignment, 
+                                   cuda_shared);
+  
+  
+  Py_RETURN_NONE;
+}
+
+
+
+
+
+
+static PyObject *
+chill_unroll(PyObject *self, PyObject *args)
+{
+  int sstmt, level, unroll_amount;
+  
+  if (!PyArg_ParseTuple(args, "iii", &sstmt, &level, &unroll_amount)) {
+    fprintf(stderr, "chill_unroll, can't parse parameters passed from python\n");
+    exit(-1);
+  }
+  
+  //DEBUG_PRINT("chill_unroll( %d, %d, %d)\n", sstmt, level, unroll_amount );
+  bool does_expand = myloop->unroll_cuda(sstmt,level,unroll_amount);
+  
+  // TODO return the boolean?
+  Py_RETURN_NONE;
+}
+
+
+
+
+static PyObject *
+chill_cudaize_v2(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("cudaize_v2\n"); 
+  PyObject *pyObj;
+  if (!PyArg_ParseTuple( args, "O", &pyObj)) { // everything on a single tuple
+    fprintf(stderr, "failed to parse tuple\n");
+    exit(-1);
+  }
+  
+  // the ONLY arg is a tuple. figure out how big it is 
+  int tupleSize = PyTuple_Size(pyObj);
+  //DEBUG_PRINT("%d things in tuple\n", tupleSize); 
+  
+  PyObject *tupleItem = PyTuple_GetItem(pyObj, 0);  //the kernel name
+  Py_XINCREF(tupleItem);
+  std::string kernel_name = strdup(PyString_AsString(tupleItem)); 
+  
+  std::map<std::string, int> array_sizes;
+  tupleItem = PyTuple_GetItem(pyObj, 1); // number of array sizes
+  Py_XINCREF(tupleItem);
+  int numarraysizes = PyInt_AsLong( tupleItem );
+  
+  std::string cppstr;
+  int offset = 2;
+  for (int i=0; i<numarraysizes; i++) {
+    tupleItem = PyTuple_GetItem(pyObj, offset++);
+    Py_XINCREF(tupleItem);
+    cppstr = strdup(PyString_AsString(tupleItem));
+    tupleItem = PyTuple_GetItem(pyObj, offset++); // integer size
+    int siz = PyInt_AsLong( tupleItem );
+    
+    //DEBUG_PRINT("arraysize for %s = %d\n", cppstr.c_str(), siz); 
+    array_sizes.insert( std::make_pair( cppstr, siz )); 
+  }
+  
+  
+  std::vector<std::string> blockIdxs;
+  tupleItem = PyTuple_GetItem(pyObj, offset++); // integer number of blocks
+  Py_XINCREF(tupleItem);
+  int numblocks = PyInt_AsLong( tupleItem );
+  //DEBUG_PRINT("%d blocks\n", numblocks);
+  for (int i=0; i<numblocks; i++)  {
+    tupleItem = PyTuple_GetItem(pyObj, offset++);
+    cppstr = strdup(PyString_AsString(tupleItem));
+    blockIdxs.push_back( cppstr );
+    //DEBUG_PRINT("%s\n", cppstr.c_str());
+  }
+  
+  std::vector<std::string> threadIdxs;
+  tupleItem = PyTuple_GetItem(pyObj, offset++); // integer number of threads
+  Py_XINCREF(tupleItem);
+  int numthreads= PyInt_AsLong( tupleItem );
+  //DEBUG_PRINT("%d threads\n", numthreads);
+  for (int i=0; i<numthreads; i++)  {
+    tupleItem = PyTuple_GetItem(pyObj, offset++);
+    Py_XINCREF(tupleItem);
+    cppstr = strdup(PyString_AsString(tupleItem));
+    threadIdxs.push_back( cppstr );
+    //DEBUG_PRINT("%s\n", cppstr.c_str());
+  }
+  
+  
+  myloop->cudaize_v2(kernel_name, array_sizes, blockIdxs, threadIdxs);
+  
+  Py_RETURN_NONE;  // return Py_BuildValue( "" );
+}
+
+
+
+static PyObject *get_loop_num()  { 
+  // TODO get_loop_num()     it's a global value?
+  fprintf(stderr, "get_loop_num()  UNIMPLEMENTED\n");
+  exit(-1);
+}
+
+
+
+
+static PyObject *
+chill_copy_to_texture(PyObject *self, PyObject *args)
+{
+  //DEBUG_PRINT("C copy_to_texture() called from python \n"); 
+  const char *array_name;
+  if (!PyArg_ParseTuple(args, "s", &array_name)){
+    fprintf(stderr, "chill_copy_to_texture can't parse array name\n");
+    exit(-1);
+  }
+  //DEBUG_PRINT("array name = %s\n", array_name);
+  myloop->copy_to_texture(array_name);
+  
+  Py_RETURN_NONE; 
+}
+
+
+
+
+
+
+
+static PyObject *
+chill_init(PyObject *self, PyObject *args)
+{
+  DEBUG_PRINT("C chill_init() called from python as read_IR()\n");
+  DEBUG_PRINT("C init( ");  
+  const char *filename;
+  const char *procname;
+  if (!PyArg_ParseTuple(args, "ss", &filename, &procname)){
+    fprintf(stderr, "umwut? can't parse file name and procedure name?\n");
+    exit(-1);
+  }
+  
+  int loop_num = 0;
+  
+  DEBUG_PRINT("%s, 0, 0 )\n", filename);  
+  
+  DEBUG_PRINT("GETTING IR CODE in chill_init() in chillmodule.cc\n");
+  DEBUG_PRINT("ir_code = new IR_cudaroseCode(%s, %s);\n",filename, procname);
+  ir_code = new IR_cudaroseCode(filename, procname); //this produces 15000 lines of output 
+  fflush(stdout); 
+  
+  
+  
+  
+  //protonu--here goes my initializations
+  //A lot of this code was lifted from Chun's parser.yy
+  //the plan is now to create the LoopCuda object directly
+  IR_Block *block = ir_code->GetCode();
+  DEBUG_PRINT("ir_code->FindOneLevelControlStructure(block); chillmodule.cc\n"); 
+  ir_controls = ir_code->FindOneLevelControlStructure(block);
+  
+  int loop_count = 0;
+  for (int i = 0; i < ir_controls.size(); i++) {
+    if (ir_controls[i]->type() == IR_CONTROL_LOOP) {
+      loops.push_back(i);
+      loop_count++;
+    }
+  }
+  delete block;
+  
+  
+  std::vector<IR_Control *> parm;
+  for(int j = 0; j < loop_count; j++)
+    parm.push_back(ir_controls[loops[j]]);
+  
+  
+  DEBUG_PRINT("block = ir_code->MergeNeighboringControlStructures(parm);\n"); 
+  block = ir_code->MergeNeighboringControlStructures(parm);
+  
+  //DEBUG_PRINT("myloop = new LoopCuda(block, loop_num); in chillmodule.cc\n"); 
+  myloop = new LoopCuda(block, loop_num);
+  fflush(stdout); DEBUG_PRINT("back\n"); 
+  delete block;
+  
+  //end-protonu
+  
+  fflush(stdout);
+  DEBUG_PRINT("myloop->original();\n"); 
+  myloop->original();
+  fflush(stdout);
+  DEBUG_PRINT("myloop->useIdxNames=true;\n"); 
+  myloop->useIdxNames=true;//Use idxName in code_gen
+  //register_v2(L);
+  
+  fflush(stdout);
+  DEBUG_PRINT("chill_init DONE\n"); 
+  Py_RETURN_NONE;  // return Py_BuildValue( "" );
+  
+}
+
+#else
+// ------------------------- //
+// CHiLL interface functions //
+// ------------------------- //
+
+static PyObject* chill_source(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 1, "source");
+  source_filename = strArg(args, 0);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_procedure(PyObject* self, PyObject* args) {
+  if(!procedure_name.empty()) {
+    fprintf(stderr, "only one procedure can be handled in a script");
+    if(!is_interactive)
+      exit(2);
+  }
+  procedure_name = strArg(args, 0);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_loop(PyObject* self, PyObject* args) {
+  // loop (n)
+  // loop (n:m)
+  
+  int nargs = PyTuple_Size(args);
+  int start_num;
+  int end_num;
+  if(nargs == 1) {
+    start_num = intArg(args, 0);
+    end_num = start_num;
+  }
+  else if(nargs == 2) {
+    start_num = intArg(args, 0);
+    end_num = intArg(args, 1);
+  }
+  else {
+    fprintf(stderr, "loop takes one or two arguments");
+    if(!is_interactive)
+      exit(2);
+  }
+  set_loop_num_start(start_num);
+  set_loop_num_end(end_num);
+  init_loop(start_num, end_num);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_print_code(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 0, "print_code");
+  myloop->printCode();
+  printf("\n");
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_print_dep(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 0, "print_dep");
+  myloop->printDependenceGraph();
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_print_space(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 0, "print_space");
+  myloop->printIterationSpace();
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_exit(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 0, "exit");
+  repl_stop = true;
+  Py_RETURN_NONE;
+}
+
+static void add_known(std::string cond_expr) {
+  int num_dim = myloop->known.n_set();
+  std::vector<std::map<std::string, int> >* cond;
+  cond = parse_relation_vector(cond_expr.c_str());
+  
+  Relation rel(num_dim);
+  F_And *f_root = rel.add_and();
+  for (int j = 0; j < cond->size(); j++) {
+    GEQ_Handle h = f_root->add_GEQ();
+    for (std::map<std::string, int>::iterator it = (*cond)[j].begin(); it != (*cond)[j].end(); it++) {
+      try {
+        int dim = from_string<int>(it->first);
+        if (dim == 0)
+          h.update_const(it->second);
+        else
+          throw std::invalid_argument("only symbolic variables are allowed in known condition");
+      }
+      catch (std::ios::failure e) {
+        Free_Var_Decl *g = NULL;
+        for (unsigned i = 0; i < myloop->freevar.size(); i++) {
+          std::string name = myloop->freevar[i]->base_name();
+          if (name == it->first) {
+            g = myloop->freevar[i];
+            break;
+          }
+        }
+        if (g == NULL)
+          throw std::invalid_argument("symbolic variable " + it->first + " not found");
+        else
+          h.update_coef(rel.get_local(g), it->second);
+      }
+    }
+  }
+  myloop->addKnown(rel);
+}
+
+static PyObject* chill_known(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 1, "known");
+  if (PyList_Check(PyTuple_GetItem(args, 0))) {
+    PyObject* list = PyTuple_GetItem(args, 0);
+    for (int i = 0; i < PyList_Size(list); i++) {
+      add_known(std::string(PyString_AsString(PyList_GetItem(list, i))));
+    }
+  }
+  else {
+    add_known(strArg(args, 0));
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_remove_dep(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 0, "remove_dep");
+  int from = intArg(args, 0);
+  int to = intArg(args, 1);
+  myloop->removeDependence(from, to);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_original(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 0, "original");
+  myloop->original();
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_permute(PyObject* self, PyObject* args) {
+  int nargs = strict_arg_range(args, 1, 3, "permute");
+  if((nargs < 1) || (nargs > 3))
+    throw std::runtime_error("incorrect number of arguments in permute");
+  if(nargs == 1) {
+    // premute ( vector )
+     std::vector<int> pi;
+    if(!tointvector(args, 0, pi))
+      throw std::runtime_error("first arg in permute(pi) must be an int vector");
+    myloop->permute(pi);
+  }
+  else if (nargs == 2) {
+    // permute ( set, vector )
+    std::set<int> active;
+    std::vector<int> pi;
+    if(!tointset(args, 0, active))
+      throw std::runtime_error("the first argument in permute(active, pi) must be an int set");
+    if(!tointvector(args, 1, pi))
+      throw std::runtime_error("the second argument in permute(active, pi) must be an int vector");
+     myloop->permute(active, pi);
+  }
+  else if (nargs == 3) {
+    int stmt_num = intArg(args, 1);
+    int level = intArg(args, 2);
+    std::vector<int> pi;
+    if(!tointvector(args, 3, pi))
+      throw std::runtime_error("the third argument in permute(stmt_num, level, pi) must be an int vector");
+    myloop->permute(stmt_num, level, pi);
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_pragma(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 3, "pragma");
+  int stmt_num = intArg(args, 1);
+  int level = intArg(args, 1);
+  std::string pragmaText = strArg(args, 2);
+  myloop->pragma(stmt_num, level, pragmaText);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_prefetch(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 3, "prefetch");
+  int stmt_num = intArg(args, 0);
+  int level = intArg(args, 1);
+  std::string prefetchText = strArg(args, 2);
+  int hint = intArg(args, 3);
+  myloop->prefetch(stmt_num, level, prefetchText, hint);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_tile(PyObject* self, PyObject* args) {
+  int nargs = strict_arg_range(args, 3, 7, "tile");
+  int stmt_num = intArg(args, 0);
+  int level = intArg(args, 1);
+  int tile_size = intArg(args, 2);
+  if(nargs == 3) {
+    myloop->tile(stmt_num, level, tile_size);
+  }
+  else if(nargs >= 4) {
+    int outer_level = intArg(args, 3);
+    if(nargs >= 5) {
+      TilingMethodType method = StridedTile;
+      int imethod = intArg(args, 4, 2); //< don't know if a default value is needed
+      // check method input against expected values
+      if (imethod == 0)
+        method = StridedTile;
+      else if (imethod == 1)
+        method = CountedTile;
+      else
+        throw std::runtime_error("5th argument must be either strided or counted");
+      if(nargs >= 6) {
+        int alignment_offset = intArg(args, 5);
+        if(nargs == 7) {
+          int alignment_multiple = intArg(args, 6, 1);
+          myloop->tile(stmt_num, level, tile_size, outer_level, method, alignment_offset, alignment_multiple);
+        }
+        if(nargs == 6)
+          myloop->tile(stmt_num, level, tile_size, outer_level, method, alignment_offset);
+      }
+      if(nargs == 5)
+        myloop->tile(stmt_num, level, tile_size, outer_level, method);
+    }
+  if(nargs == 4)
+    myloop->tile(stmt_num, level, tile_size, outer_level);
+  }
+  Py_RETURN_NONE;
+}
+
+static void chill_datacopy_vec(PyObject* args) {
+  // Overload 1: bool datacopy(
+  //    const std::vector<std::pair<int, std::vector<int> > > &array_ref_nums,
+  //    int level,
+  //    bool allow_extra_read = false,
+  //    int fastest_changing_dimension = -1,
+  //    int padding_stride = 1,
+  //    int padding_alignment = 4,
+  //    int memory_type = 0);
+  std::vector<std::pair<int, std::vector<int> > > array_ref_nums;
+  // expect list(tuple(int,list(int)))
+  // or dict(int,list(int))
+  if(PyList_CheckExact(PyTuple_GetItem(args, 0))) {
+    PyObject* list = PyTuple_GetItem(args, 0);
+    for(int i = 0; i < PyList_Size(list); i ++) {
+      PyObject* tup = PyList_GetItem(list, i);
+      int index = PyLong_AsLong(PyTuple_GetItem(tup, 0));
+      std::vector<int> vec;
+      tointvector(PyTuple_GetItem(tup, 1), vec);
+      array_ref_nums.push_back(std::pair<int, std::vector<int> >(index, vec));
+    }
+  }
+  else if(PyList_CheckExact(PyTuple_GetItem(args, 0))) {
+    PyObject* dict = PyTuple_GetItem(args, 0);
+    PyObject* klist = PyDict_Keys(dict);
+    for(int ki = 0; ki < PyList_Size(klist); ki++) {
+      PyObject* index = PyList_GetItem(klist, ki);
+      std::vector<int> vec;
+      tointvector(PyDict_GetItem(dict,index), vec);
+      array_ref_nums.push_back(std::pair<int, std::vector<int> >(PyLong_AsLong(index), vec));
+    }
+    Py_DECREF(klist);
+  }
+  else {
+    //TODO: this should never happen
+  }
+  int level = intArg(args, 1);
+  bool allow_extra_read = boolArg(args, 2, false);
+  int fastest_changing_dimension = intArg(args, 3, -1);
+  int padding_stride = intArg(args, 4, 1);
+  int padding_alignment = intArg(args, 5, 4);
+  int memory_type = intArg(args, 6, 0);
+  myloop->datacopy(array_ref_nums, level, allow_extra_read, fastest_changing_dimension, padding_stride, padding_alignment, memory_type);
+}
+
+static void chill_datacopy_int(PyObject* args) {
+  int stmt_num = intArg(args, 0);
+  int level = intArg(args, 1);
+  std::string array_name = strArg(args,2,0);
+  bool allow_extra_read = boolArg(args,3,false);
+  int fastest_changing_dimension = intArg(args, 4, -1);
+  int padding_stride = intArg(args, 5, 1);
+  int padding_alignment = intArg(args, 6, 4);
+  int memory_type = intArg(args, 7, 0);
+  myloop->datacopy(stmt_num, level, array_name, allow_extra_read, fastest_changing_dimension, padding_stride, padding_alignment, memory_type);
+}
+
+static PyObject* chill_datacopy(PyObject* self, PyObject* args) {
+  // Overload 2: bool datacopy(int stmt_num, int level, const std::string &array_name, bool allow_extra_read = false, int fastest_changing_dimension = -1, int padding_stride = 1, int padding_alignment = 4, int memory_type = 0);
+  int nargs = strict_arg_range(args, 3, 7, "datacopy");
+  if(PyList_CheckExact(PyTuple_GetItem(args,0)) || PyDict_CheckExact(PyTuple_GetItem(args, 0))) {
+    chill_datacopy_vec(args);
+  }
+  else {
+    chill_datacopy_int(args);
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_datacopy_privatized(PyObject* self, PyObject* args) {
+  //  bool datacopy_privatized(int stmt_num, int level, const std::string &array_name, const std::vector<int> &privatized_levels, bool allow_extra_read = false, int fastest_changing_dimension = -1, int padding_stride = 1, int padding_alignment = 1, int memory_type = 0);
+  int nargs = strict_arg_range(args, 4, 9, "datacopy_privatized");
+  int stmt_num = intArg(args, 0);
+  int level = intArg(args, 1);
+  std::string array_name = strArg(args, 2);
+  std::vector<int> privatized_levels;
+  tointvector(args, 3, privatized_levels);
+  bool allow_extra_read = boolArg(args, 4, false);
+  int fastest_changing_dimension = intArg(args, 5, -1);
+  int padding_stride = intArg(args, 6, 1);
+  int padding_alignment = intArg(args, 7, 1);
+  int memory_type = intArg(args, 8);
+  myloop->datacopy_privatized(stmt_num, level, array_name, privatized_levels, allow_extra_read, fastest_changing_dimension, padding_stride, padding_alignment, memory_type);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_unroll(PyObject* self, PyObject* args) {
+  int nargs = strict_arg_range(args, 3, 4, "unroll");
+  //std::set<int> unroll(int stmt_num, int level, int unroll_amount, std::vector< std::vector<std::string> >idxNames= std::vector< std::vector<std::string> >(), int cleanup_split_level = 0);
+  int stmt_num = intArg(args, 0);
+  int level = intArg(args, 1);
+  int unroll_amount = intArg(args, 2);
+  std::vector< std::vector<std::string> > idxNames = std::vector< std::vector<std::string> >();
+  int cleanup_split_level = intArg(args, 3);
+  myloop->unroll(stmt_num, level, unroll_amount, idxNames, cleanup_split_level);
+  Py_RETURN_NONE;
+}
+  
+static PyObject* chill_unroll_extra(PyObject* self, PyObject* args) {
+  int nargs = strict_arg_range(args, 3, 4, "unroll_extra");
+  int stmt_num = intArg(args, 0);
+  int level = intArg(args, 1);
+  int unroll_amount = intArg(args, 2);
+  int cleanup_split_level = intArg(args, 3, 0);
+  myloop->unroll_extra(stmt_num, level, unroll_amount, cleanup_split_level); 
+  Py_RETURN_NONE;
+}
+  
+static PyObject* chill_split(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 3, "split");
+  int stmt_num = intArg(args, 0);
+  int level = intArg(args, 1);
+  int num_dim = myloop->stmt[stmt_num].xform.n_out();
+  
+  std::vector<std::map<std::string, int> >* cond;
+  std::string cond_expr = strArg(args, 2);
+  cond = parse_relation_vector(cond_expr.c_str());
+  
+  Relation rel((num_dim-1)/2);
+  F_And *f_root = rel.add_and();
+  for (int j = 0; j < cond->size(); j++) {
+    GEQ_Handle h = f_root->add_GEQ();
+    for (std::map<std::string, int>::iterator it = (*cond)[j].begin(); it != (*cond)[j].end(); it++) {
+      try {
+        int dim = from_string<int>(it->first);
+        if (dim == 0)
+          h.update_const(it->second);
+        else {
+          if (dim > (num_dim-1)/2)
+            throw std::invalid_argument("invalid loop level " + to_string(dim) + " in split condition");
+          h.update_coef(rel.set_var(dim), it->second);
+        }
+      }
+      catch (std::ios::failure e) {
+        Free_Var_Decl *g = NULL;
+        for (unsigned i = 0; i < myloop->freevar.size(); i++) {
+          std::string name = myloop->freevar[i]->base_name();
+          if (name == it->first) {
+            g = myloop->freevar[i];
+            break;
+          }
+        }
+        if (g == NULL)
+          throw std::invalid_argument("unrecognized variable " + to_string(it->first.c_str()));
+        h.update_coef(rel.get_local(g), it->second);
+      }
+    }
+  }
+  myloop->split(stmt_num,level,rel);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_nonsingular(PyObject* self, PyObject* args) {
+  std::vector< std::vector<int> > mat;
+  tointmatrix(args, 0, mat);
+  myloop->nonsingular(mat);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_skew(PyObject* self, PyObject* args) {
+  std::set<int> stmt_nums;
+  std::vector<int> skew_amounts;
+  int level = intArg(args, 1);
+  tointset(args, 0, stmt_nums);
+  tointvector(args, 2, skew_amounts);
+  myloop->skew(stmt_nums, level, skew_amounts);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_scale(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 3);
+  std::set<int> stmt_nums;
+  int level = intArg(args, 1);
+  int scale_amount = intArg(args, 2);
+  tointset(args, 0, stmt_nums);
+  myloop->scale(stmt_nums, level, scale_amount);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_reverse(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 2);
+  std::set<int> stmt_nums;
+  int level = intArg(args, 1);
+  tointset(args, 0, stmt_nums);
+  myloop->reverse(stmt_nums, level);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_shift(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 3);
+  std::set<int> stmt_nums;
+  int level = intArg(args, 1);
+  int shift_amount = intArg(args, 2);
+  tointset(args, 0, stmt_nums);
+  myloop->shift(stmt_nums, level, shift_amount);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_shift_to(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 3);
+  int stmt_num = intArg(args, 0);
+  int level = intArg(args, 1);
+  int absolute_pos = intArg(args, 2);
+  myloop->shift_to(stmt_num, level, absolute_pos);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_peel(PyObject* self, PyObject* args) {
+  strict_arg_range(args, 2, 3);
+  int stmt_num = intArg(args, 0);
+  int level = intArg(args, 1);
+  int amount = intArg(args, 2);
+  myloop->peel(stmt_num, level, amount);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_fuse(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 2);
+  std::set<int> stmt_nums;
+  int level = intArg(args, 1);
+  tointset(args, 0, stmt_nums);
+  myloop->fuse(stmt_nums, level);
+  Py_RETURN_NONE;
+}
+
+static PyObject* chill_distribute(PyObject* self, PyObject* args) {
+  strict_arg_num(args, 2);
+  std::set<int> stmts;
+  int level = intArg(args, 1);
+  tointset(args, 0, stmts);
+  myloop->distribute(stmts, level);
+  Py_RETURN_NONE;
+}
+
+static PyObject *
+chill_num_statements(PyObject *self, PyObject *args)  
+{
+  //DEBUG_PRINT("\nC chill_num_statements() called from python\n"); 
+  int num = myloop->stmt.size();
+  //DEBUG_PRINT("C num_statement() = %d\n", num); 
+  return Py_BuildValue( "i", num ); // BEWARE "d" is DOUBLE, not int
+}
+#endif
+
+#ifdef CUDACHILL
+static PyMethodDef ChillMethods[] = { 
+  
+  // python name            C routine              parameter passing         comment
+  {"print_code",          chill_print_code,          METH_VARARGS,    "print the code at this point"},
+  {"print_ri",            chill_print_ri  ,          METH_VARARGS,    "print Runtime Info          "},
+  {"print_idx",           chill_print_idx ,          METH_VARARGS,    "print indices               "},
+  {"print_dep",           chill_print_dep ,          METH_VARARGS,    "print dep, dependecies?"},
+  {"print_space",         chill_print_space,         METH_VARARGS,    "print something or other "},
+  {"add_sync",            chill_add_sync,            METH_VARARGS,    "add sync, whatever that is"},
+  {"rename_index",        chill_rename_index,        METH_VARARGS,    "rename a loop index"},
+  {"permute",             chill_permute,             METH_VARARGS,    "change the order of loops?"},
+  {"tile3",               chill_tile_v2_3arg,        METH_VARARGS,    "something to do with tile"},
+  {"tile7",               chill_tile_v2_7arg,        METH_VARARGS,    "something to do with tile"},
+  {"thread_dims",         thread_dims,               METH_VARARGS,    "tx, ty, tz "},
+  {"block_dims",          block_dims,                METH_VARARGS,    "bx, by"},
+  {"thread_indices",      chill_thread_indices,      METH_VARARGS,    "bx, by"},
+  {"block_indices",       chill_block_indices,       METH_VARARGS,    "bx, by"},
+  {"hard_loop_bounds",    chill_hard_loop_bounds,    METH_VARARGS,    "lower, upper"},
+  {"unroll",              chill_unroll,              METH_VARARGS,    "unroll a loop"},
+  {"cudaize",             chill_cudaize_v2,          METH_VARARGS,    "dunno"},
+  {"datacopy_privatized", chill_datacopy_privatized, METH_VARARGS,    "dunno"},
+  
+  {"datacopy_9arg",       chill_datacopy9,           METH_VARARGS,    "datacopy with 9 arguments"},
+  {"copy_to_texture",     chill_copy_to_texture,     METH_VARARGS,    "copy to texture mem"},
+  {"read_IR",             chill_init,                METH_VARARGS,    "read an Intermediate Representation file"}, 
+  {"cur_indices",         chill_cur_indices,         METH_VARARGS,    "currently active indices"},
+  {"num_statements",      chill_num_statements,      METH_VARARGS,    "number of statements in ... something"},
+  {NULL, NULL, 0, NULL}        /* Sentinel */
+  
+  //{"copy_to_constant",    chill_copy_to_constant,    METH_VARARGS,  "copy to constant mem"},
+  
+};
+#else
+static PyMethodDef ChillMethods[] = { 
+  
+  //python name           C routine                  parameter passing comment
+  {"source",              chill_source,                    METH_VARARGS,     "set source file for chill script"},
+  {"procedure",           chill_procedure,                 METH_VARARGS,     "set the name of the procedure"},
+  {"loop",                chill_loop,                      METH_VARARGS,     "indicate which loop to optimize"},
+  {"print_code",          chill_print_code,                METH_VARARGS,     "print generated code"},
+  {"print_dep",           chill_print_dep,                 METH_VARARGS,     "print the dependencies graph"},
+  {"print_space",         chill_print_space,               METH_VARARGS,     "print space"},
+  {"exit",                chill_exit,                      METH_VARARGS,     "exit the interactive consule"},
+  {"known",               chill_known,                     METH_VARARGS,     "knwon"},
+  {"remove_dep",          chill_remove_dep,                METH_VARARGS,     "remove dependency i suppose"},
+  {"original",            chill_original,                  METH_VARARGS,     "original"},
+  {"permute",             chill_permute,                   METH_VARARGS,     "permute"},
+  {"pragma",              chill_pragma,                    METH_VARARGS,     "pragma"},
+  {"prefetch",            chill_prefetch,                  METH_VARARGS,     "prefetch"},
+  {"tile",                chill_tile,                      METH_VARARGS,     "tile"},
+  {"datacopy",            chill_datacopy,                  METH_VARARGS,     "datacopy"},
+  {"datacopy_privitized", chill_datacopy_privatized,       METH_VARARGS,     "datacopy_privatized"},
+  {"unroll",              chill_unroll,                    METH_VARARGS,     "unroll"},
+  {"unroll_extra",        chill_unroll_extra,              METH_VARARGS,     "unroll_extra"},
+  {"split",               chill_split,                     METH_VARARGS,     "split"},
+  {"nonsingular",         chill_nonsingular,               METH_VARARGS,     "nonsingular"},
+  {"skew",                chill_skew,                      METH_VARARGS,     "skew"},
+  {"scale",               chill_scale,                     METH_VARARGS,     "scale"},
+  {"reverse",             chill_reverse,                   METH_VARARGS,     "reverse"},
+  {"shift",               chill_shift,                     METH_VARARGS,     "shift"},
+  {"shift_to",            chill_shift_to,                  METH_VARARGS,     "shift_to"},
+  {"peel",                chill_peel,                      METH_VARARGS,     "peel"},
+  {"fuse",                chill_fuse,                      METH_VARARGS,     "fuse"},
+  {"distribute",          chill_distribute,                METH_VARARGS,     "distribute"},
+  {"num_statements",      chill_num_statements,            METH_VARARGS,     "number of statements in the current loop"},
+  {NULL, NULL, 0, NULL}
+};
+#endif
+
+static void register_globals(PyObject* m) {
+  // Preset globals
+  PyModule_AddStringConstant(m, "VERSION", CHILL_BUILD_VERSION);
+  PyModule_AddStringConstant(m, "dest", "C");
+  PyModule_AddStringConstant(m, "C", "C");
+  // Tile method
+  PyModule_AddIntConstant(m, "strided", 0);
+  PyModule_AddIntConstant(m, "counted", 1);
+  // Memory mode
+  PyModule_AddIntConstant(m, "global", 0);
+  PyModule_AddIntConstant(m, "shared", 1);
+  PyModule_AddIntConstant(m, "textured", 2);
+  // Bool flags
+  PyModule_AddIntConstant(m, "sync", 1);
+} 
+
+PyMODINIT_FUNC
+initchill(void)    // pass C methods to python 
+{
+  DEBUG_PRINT("in C, initchill() to set up C methods to be called from python\n");
+  PyObject* m = Py_InitModule("chill", ChillMethods);
+  register_globals(m);
+}