Compile and stash results locally, if possible.

.gitignore

@@ -13,3 +13,4 @@ setuptools*egg-info
 setuptools.pth
 siteconf.py
 doc/html
+*__pycache__

copperhead/compiler/binarygenerator.py

@@ -78,6 +78,9 @@ def prepare_cuda_compilation(M):
     M.toolchains = (host_toolchain, nvcc_toolchain)
     M.codepy_module = device_module
     M.code = (str(host_module.generate()), str(device_module.generate()))
+    M.kwargs = dict(host_kwargs=dict(cache_dir=M.code_dir),
+                    nvcc_kwargs=dict(cache_dir=M.code_dir),
+                    debug=M.verbose)
     return []
 
 def prepare_host_compilation(M):
@@ -105,7 +108,8 @@ def prepare_host_compilation(M):
     from ..runtime import host_toolchain
     M.toolchains = (host_toolchain,)
     M.code = (str(host_module.generate()),)
-
+    M.kwargs = dict(cache_dir=M.code_dir,
+                    debug=M.verbose)
     return []
 
 def make_binary(M):
@@ -115,8 +119,9 @@ def make_binary(M):
     code = M.code
     codepy_module = M.codepy_module
     toolchains = M.toolchains
+    kwargs = M.kwargs
     try:
-        module = codepy_module.compile(*toolchains, debug=M.verbose)
+        module = codepy_module.compile(*toolchains, **kwargs)
     except Exception as e:
         for m in code:
             print m

copperhead/compiler/passes.py

@@ -247,6 +247,7 @@ def compile(source,
     M.time = opts.pop('time', False)
     M.tag = tag
     M.verbose = opts.pop('verbose', False)
+    M.code_dir = opts['code_dir']
     return run_compilation(target, source, M)
 
 

copperhead/runtime/cufunction.py

@@ -20,6 +20,8 @@
 from __future__ import absolute_import
 
 import inspect
+import tempfile
+import os.path
 from ..compiler import pyast, typeinference
 from . import places
 
@@ -44,6 +46,8 @@ def __init__(self, fn):
         # Parse and cache the Copperhead AST for this function
         stmts = pyast.statement_from_text(self.get_source())
         self.syntax_tree = stmts
+        # Establish code directory
+        self.code_dir = self.get_code_dir()
         self.cache = {}
         self.code = {}
 
@@ -105,3 +109,21 @@ def infer_type(self):
     def get_code(self):
         return self.code
 
+    def get_code_dir(self):
+        source_dir, source_file = os.path.split(inspect.getsourcefile(self.fn))
+        candidate = os.path.join(source_dir, '__pycache__', source_file, self.__name__)
+        if os.path.exists(candidate):
+            return candidate
+        try:
+            os.makedirs(candidate)
+            return candidate
+        except OSError:
+            #Can't create a directory where the source file lives
+            #Let's put it in tempdir
+            candidate = os.path.join(tempfile.gettempdir(),
+                                     'copperhead-cache-uid%s' % os.getuid(),
+                                     source_file, self.__name__)
+            if os.path.exists(candidate):
+                return candidate
+            os.makedirs(candidate)    
+            return candidate

copperhead/runtime/driver.py

@@ -124,6 +124,7 @@ def execute(tag, cufn, *v, **k):
                                 globals=cufn.get_globals(),
                                 input_types={name : cu_types},
                                 tag=tag,
+                                code_dir=cufn.code_dir,
                                 **k)
     #Store the binary and the compilation result
     cufn.cache[signature] = compiled_fn