Limit compiler cache interface to getTarget and addModule

Current implementation of the interface, used via
_loadFromCompilerCache, runs loadForSymbol for a given link name and
then returns two dicts representing everything the cache touched during
this load process. Maintaining this interface makes the partial-load
refactor difficult, and muddies the converter layers/cache relationship.
Here we alter the API so that we can ask the cache for
a TypedCallTarget, and add modules, and that's it. This means getting
rid of _loadFromCompilerCache, and associated registers for tracking
what's being converted. Also means passing the cache down to the
native_ast_to_llvm layer.

Author: Augustus Lonergan

typed_python/compiler/compiler_cache.py

@@ -62,25 +62,28 @@ def __init__(self, cacheDir):
             if len(moduleHash) == 40:
                 self.loadNameManifestFromStoredModuleByHash(moduleHash)
 
+        self.targetsLoaded = {}
+
     def hasSymbol(self, linkName):
         return linkName in self.nameToModuleHash
 
+    def getTarget(self, linkName):
+        assert self.hasSymbol(linkName)
+
+        self.loadForSymbol(linkName)
+
+        return self.targetsLoaded[linkName]
+
     def markModuleHashInvalid(self, hashstr):
         with open(os.path.join(self.cacheDir, hashstr, "marked_invalid"), "w"):
             pass
 
     def loadForSymbol(self, linkName):
         moduleHash = self.nameToModuleHash[linkName]
 
-        nameToTypedCallTarget = {}
-        nameToNativeFunctionType = {}
-
-        if not self.loadModuleByHash(moduleHash, nameToTypedCallTarget, nameToNativeFunctionType):
-            return None
-
-        return nameToTypedCallTarget, nameToNativeFunctionType
+        self.loadModuleByHash(moduleHash)
 
-    def loadModuleByHash(self, moduleHash, nameToTypedCallTarget, nameToNativeFunctionType):
+    def loadModuleByHash(self, moduleHash):
         """Load a module by name.
 
         As we load, place all the newly imported typed call targets into
@@ -114,11 +117,7 @@ def loadModuleByHash(self, moduleHash, nameToTypedCallTarget, nameToNativeFuncti
 
         # load the submodules first
         for submodule in submodules:
-            if not self.loadModuleByHash(
-                submodule,
-                nameToTypedCallTarget,
-                nameToNativeFunctionType
-            ):
+            if not self.loadModuleByHash(submodule):
                 return False
 
         modulePath = os.path.join(targetDir, "module.so")
@@ -131,8 +130,7 @@ def loadModuleByHash(self, moduleHash, nameToTypedCallTarget, nameToNativeFuncti
 
         self.loadedModules[moduleHash] = loaded
 
-        nameToTypedCallTarget.update(callTargets)
-        nameToNativeFunctionType.update(functionNameToNativeType)
+        self.targetsLoaded.update(callTargets)
 
         return True
 

typed_python/compiler/llvm_compiler.py

@@ -84,18 +84,14 @@ def create_execution_engine(inlineThreshold):
 
 
 class Compiler:
-    def __init__(self, inlineThreshold):
+    def __init__(self, inlineThreshold, compilerCache):
         self.engine, self.module_pass_manager = create_execution_engine(inlineThreshold)
-        self.converter = native_ast_to_llvm.Converter()
+        self.converter = native_ast_to_llvm.Converter(compilerCache)
         self.functions_by_name = {}
         self.inlineThreshold = inlineThreshold
         self.verbose = False
         self.optimize = True
 
-    def markExternal(self, functionNameToType):
-        """Provide type signatures for a set of external functions."""
-        self.converter.markExternal(functionNameToType)
-
     def mark_converter_verbose(self):
         self.converter.verbose = True
 

typed_python/compiler/native_ast_to_llvm.py

@@ -501,14 +501,13 @@ def __init__(self,
                  module,
                  globalDefinitions,
                  globalDefinitionLlvmValues,
-                 function,
                  converter,
                  builder,
                  arg_assignments,
                  output_type,
-                 external_function_references
+                 external_function_references,
+                 compilerCache,
                  ):
-        self.function = function
 
         # dict from name to GlobalVariableDefinition
         self.globalDefinitions = globalDefinitions
@@ -522,6 +521,7 @@ def __init__(self,
         self.external_function_references = external_function_references
         self.tags_initialized = {}
         self.stack_slots = {}
+        self.compilerCache = compilerCache
 
     def tags_as(self, new_tags):
         class scoper():
@@ -648,7 +648,24 @@ def namedCallTargetToLLVM(self, target):
                         llvmlite.ir.Function(self.module, func_type, target.name)
 
             func = self.external_function_references[target.name]
-        elif target.name in self.converter._externallyDefinedFunctionTypes:
+        elif target.name in self.converter._function_definitions:
+            func = self.converter._functions_by_name[target.name]
+
+            if func.module is not self.module:
+                # first, see if we'd like to inline this module
+                if (
+                    self.converter.totalFunctionComplexity(target.name) < CROSS_MODULE_INLINE_COMPLEXITY
+                ):
+                    func = self.converter.repeatFunctionInModule(target.name, self.module)
+                else:
+                    if target.name not in self.external_function_references:
+                        self.external_function_references[target.name] = \
+                            llvmlite.ir.Function(self.module, func.function_type, func.name)
+
+                    func = self.external_function_references[target.name]
+        else:
+            # TODO: decide whether to inline based on something in the compiler cache
+            assert self.compilerCache is not None and self.compilerCache.hasSymbol(target.name)
             # this function is defined in a shared object that we've loaded from a prior
             # invocation
             if target.name not in self.external_function_references:
@@ -665,22 +682,6 @@ def namedCallTargetToLLVM(self, target):
                 )
 
             func = self.external_function_references[target.name]
-        else:
-            func = self.converter._functions_by_name[target.name]
-
-            if func.module is not self.module:
-                # first, see if we'd like to inline this module
-                if (
-                    self.converter.totalFunctionComplexity(target.name) < CROSS_MODULE_INLINE_COMPLEXITY
-                    and self.converter.canBeInlined(target.name)
-                ):
-                    func = self.converter.repeatFunctionInModule(target.name, self.module)
-                else:
-                    if target.name not in self.external_function_references:
-                        self.external_function_references[target.name] = \
-                            llvmlite.ir.Function(self.module, func.function_type, func.name)
-
-                    func = self.external_function_references[target.name]
 
         return TypedLLVMValue(
             func,
@@ -1484,16 +1485,12 @@ def define(fname, output, inputs, vararg=False):
 
 
 class Converter:
-    def __init__(self):
+    def __init__(self, compilerCache):
         object.__init__(self)
         self._modules = {}
         self._functions_by_name = {}
         self._function_definitions = {}
 
-        # a map from function name to function type for functions that
-        # are defined in external shared objects and linked in to this one.
-        self._externallyDefinedFunctionTypes = {}
-
         # total number of instructions in each function, by name
         self._function_complexity = {}
 
@@ -1502,12 +1499,7 @@ def __init__(self):
         self._printAllNativeCalls = os.getenv("TP_COMPILER_LOG_NATIVE_CALLS")
         self.verbose = False
 
-    def markExternal(self, functionNameToType):
-        """Provide type signatures for a set of external functions."""
-        self._externallyDefinedFunctionTypes.update(functionNameToType)
-
-    def canBeInlined(self, name):
-        return name not in self._externallyDefinedFunctionTypes
+        self.compilerCache = compilerCache
 
     def totalFunctionComplexity(self, name):
         """Return the total number of instructions contained in a function.
@@ -1621,19 +1613,19 @@ def add_functions(self, names_to_definitions):
                         TypedLLVMValue(func.args[i], definition.args[i][1])
 
                 block = func.append_basic_block('entry')
-                builder = llvmlite.ir.IRBuilder(block)
+                builder = llvmlite.ir.IRBuilder(block)  # this shares state with func
 
                 try:
                     func_converter = FunctionConverter(
                         module,
                         globalDefinitions,
                         globalDefinitionsLlvmValues,
-                        func,
                         self,
                         builder,
                         arg_assignments,
                         definition.output_type,
-                        external_function_references
+                        external_function_references,
+                        self.compilerCache,
                     )
 
                     func_converter.setup()