Partially load modules from compiler cache, handling possible race condition #440
Conversation
This file contains 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
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. Also ensure that the new pickle protocol support works with 'local names' (e.g. dotted method names).
wllgrnt
force-pushed
the
will-compiler-cache-partial-load-multi-module
branch
4 times, most recently
from
d77f679
to
12d4b42
Compare
added 2 commits
March 2, 2023 14:14
Previous iterations of the cache assumed a one-one-one function name to module mapping, however it's possible to end up with many modules which contain the same function (e.g due to a race condition when using multiple processes, but other scenarios could exist in the future). This commit separates the func_name (the id for the function) with the link_name (the unique id for a given function in a given module). This distinction is not exposed outside the cache - when asked for a target the cache chooses which version to return (currently just the first one it sees).
During the compilation of one Entrypointed function it's possible to import a module which calls a second Entrypointed function. This breaks our model of the compilation process and could cause deadlocks, so instead throw an ImportError.
wllgrnt
force-pushed
the
will-compiler-cache-partial-load-multi-module
branch
from
12d4b42
to
e2d754a
Compare
6 tasks
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
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.
Motivation and Context
See #414 for motivation behind commits 65b622c, f0747ba, 12e35a8.
These commits introduced an issue where if two processes working in parallel generated the same function in different cache modules, our assumptions about the module -> function mapping would break and the functions would not be properly linked. (Previously this would be dealt with by marking one of the modules invalid). Commit ffd7492 handles this by maintaining a function name and a (realized name / link name / instance name), and using the latter internally.
Approach
Key approach here was ensuring that the concept of a link name did not leak outside the cache - cache users should not need to have any notion of which modules a given function is in.
How Has This Been Tested?
We use a MockDirectory class (written by @guslonergan ) to generate versions of the cache with multiple modules containing the same function, approximating the state of the cache following a race.
Types of changes
Checklist: