Prune the graph of inflight functions to not include the ones we don't need#438
Open
wllgrnt wants to merge 7 commits intowill-compiler-cache-partial-load-multi-modulefrom
Open
Prune the graph of inflight functions to not include the ones we don't need#438wllgrnt wants to merge 7 commits intowill-compiler-cache-partial-load-multi-modulefrom
wllgrnt wants to merge 7 commits intowill-compiler-cache-partial-load-multi-modulefrom
Conversation
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.
Previously we would always attempt to link and validate all global variables when loading a module from the cache. This caused linking errors, or validation errors, or deserialization errors, and meant we needed the mark_invalid mechanism for handling modules with outdated global variables. Here we add double-serialised global variables, and only deserialize,link&validate the subset required for the function required (and its dependencies). This requires the cache to store a function and global_var dependency graph. Also add utility methods for GlobalVariableDefinition.
Pickle supports a protocol where __reduce__returns a string giving the global name. Implementing this behaviour lets us serialize numpy ufuncs. Also adjust installInflightFunctions to handle new load behaviour, fix an instability caused by not leaving LoadedModule objects in memory, and adjust alternative test.
…(e.g. dotted method names).
…t need. When we first call a python function 'f' with a specific set of arguments, we may not know its return type the first time we try to convert it. To ensure we have a stable typing graph, we repeatedly update the active functions in our graph until the type graph is stable. This can lead to many copies of the same function, or even multiple signatures of the same function, only one of which we'll use. This change prunes those away before we submit them to the LLVM layer.
wllgrnt
force-pushed
the
brax-prune-compiler-graph
branch
from
706f894 to
4843289
Compare
wllgrnt
changed the base branch from
dev
to
will-compiler-cache-partial-load-multi-module
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
3 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
(by @braxtonmckee)
Motivation and Context
When we first call a python function 'f' with a specific set of arguments, we may not know its return type the first time we try to convert it. To ensure we have a stable typing graph, we repeatedly update the active functions in our graph until the type graph is stable.
This can lead to many copies of the same function, or even multiple signatures of the same function, only one of which we'll use.
This change prunes those away before we submit them to the LLVM layer.
How Has This Been Tested?
Running
test_dispatch_to_function_overloadwithTP_COMPILER_VERBOSE=1with and without this commit causes 13 functions to be converted rather than 17, with a slight speedup.Types of changes
Checklist: