Lazy tls #64
Merged
Lazy tls #64
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
Copying an idea from mimalloc, initialise the TLS variable to a global allocator that doesn't own any memory and then lazily check when we hit a slow path (which we always do when using the global allocator, because it doesn't own any memory) if we are the global allocator and replace it. There is a slight complication compared to mimalloc's version of this idea. Snmalloc collects outgoing messages and it's possible for the first operation in a thread to be a free of memory allocated by a different thread. We address this by initialising the queues with a size value indicating that they are full and then do the lazy check when about to insert a message that would make a queue full. This will then trigger lazy creation of an allocator. Global initialisation doesn't work for the fake allocator, so skip most of its constructor.
By caching the result of the first call to ThreadAlloc::get(), we were always hitting a code path that should be hit once per thread in normal operation.
We were passing an argument less than 4K to the MAP_ALIGNED macro, which caused an undefined shift. The compiler helpfully propagated the undef values back to earlier in the code and gave us some exciting nonsense.
sylvanc
previously approved these changes
Jul 5, 2019
Most compilers are happy if you say always-inline but they can't. GCC will complain. Here, we have two mutually recursive functions that are marked as always inline. In an optimised build, one is inlined into the other and then becomes a tail-recursive function that should inline the tail call. Inlining the tail call can be done by simply jumping to the start of the function and so everything is fine. In a debug build, the second transform doesn't happen and so we're left with a call to an always-inline function.
mjp41
previously approved these changes
Jul 5, 2019
| size_t sz = sizeclass_to_size(sizeclass); | ||
| if ((remote.size + sz) < REMOTE_CACHE) | ||
| { | ||
| stats().remote_free(sizeclass); |
There was a problem hiding this comment.
Add assert that we are not fake at this point!
There was a problem hiding this comment.
Perhaps put something similar in other places where we don't expect to see the fake allocator.
sylvanc
previously approved these changes
Jul 5, 2019
This is needed because in some configurations the constructor for the global placeholder is not called before the first allocation (i.e. when other globals call the allocator in their constructor) and so we ended up following a null pointer.
mjp41
previously approved these changes
Jul 5, 2019
Fixes an issue where the global placeholder allocator was being released.
mjp41
approved these changes
Jul 8, 2019
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.
Lazily initialise the TLS pointer on slow paths, so that we can avoid a check that it's initialised on the fast paths. We now statically set the TLS pointer to the address of a global allocator, which does not own any memory. When we try to allocate from it, we hit a slow path and there we check if it's actually the global allocator (in which case we allocate a real allocator and store a pointer to it in TLS).
This trims one branch from the fast path in
malloc.