NFC: Reduce presence of "template <typename AddressSpaceView>"

[vitalybuka]

Summary

Goal is to make it more clear which parts of code rely on AddressSpaceView.

Also we this way we can remove some static_asserts which check that
CombinedAllocator instantiated with compatible types. Now
CombinedAllocator controls type by itself.

[vitalybuka]

fixes

[vitalybuka]

removed type duplicate

[delcypher]

If we're going to go down this road we really need to land https://reviews.llvm.org/D56964 first. That fixes additional behaviour of the allocators.

[delcypher]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_bytemap.h

80

This looks wrong. In the out-of-process case where we've copied over a FlatByteMap from the target process map2 is pointing to memory that isn't valid in our local address space. Here it looks like you're actually dereferencing invalid memory (map2[idx % kSize2]) and then taking a reference to it.

Perhaps this is okay. I think it might be the implicit conversion of map2[idx %kSize2] to an rvalue that actually triggers the dereference normally. This might not be happening here (I hope the code isn't taking a reference to a temporary r-value), but I am incredibly suspicious of this code.

[vitalybuka]

In D57279#1372464, @delcypher wrote:

If we're going to go down this road we really need to land https://reviews.llvm.org/D56964 first. That fixes additional behaviour of the allocators.

Sure, I'd like to land this patch as NFC. I don't mind if D56964 goes either before or after.
rebased D56964 is https://github.com/vitalybuka/llvm-project/commit/6eda6de4a4802bf3a830df270fe6dab279baf278
it required some manual interaction but very trivial.

compiler-rt/lib/sanitizer_common/sanitizer_allocator_bytemap.h

80

No, I just moved AddressSpaceView::Load out of the map, and return references here.
For random user this is still regular map. For allocator if we know that we are remote "copy" and we may need to fix-up reference with AddressSpaceView::Load
FlatByteMap does not need AddressSpaceView::Load but to make it general, I apply AddressSpaceView::Load even there.

Another option to add: const "u8* find(uptr) const {...}" where deference will be clearly out of the map, but I don't rely think references here are much worse here.

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary32.h

235

Here is a map access.
Maybe AddressSpaceView::LoadByRef could be useful, but I afraid that it will accept references to temps. So pointer only interface will not let to removes refs from map::operator[]

[vitalybuka]

rebase

[vitalybuka]

rebase

[vitalybuka]

rebase

[delcypher]

@vitalybuka Thanks for working on this.

Context for those new to the patch: We are looking at ways of converting a Allocator<LocalAddressSpaceView> into a Allocator<RemoteAddressSpaceView>. With the current design on master it is not safe to do a reinterpret_cast<>() because C++ doesn't guarantee that the two different types have the same data-layout or fields (AFAIK).

Over the weekend I investigated your first suggestion for fixing the reinterpret_cast problem for the allocators. I've updated my patch stack to use this new approach. Even though you're trying a different approach in this patch I thought it was important that I investigate other options. The key patches are...

• https://reviews.llvm.org/D57306 - This removes AddressSpaceView from primary allocators params data structures. The patch explains more but basically this is needed for the next patch. It fixes what I consider to be a design mistake on my part and cleans up the code considerably.
• https://reviews.llvm.org/D57307 - This add CopyFromTarget(...) static methods to all data types that take AddressSpaceView as a type parameter. It also adds a public templated type alias (ThisTASVT) that allows you to construct the RemoteAddressSpaceView counter-part from an existing type.
• https://reviews.llvm.org/D56207 - Updates the unit tests to use the new CopyFromTarget(...) and use ThisTASVT for type construction. Note that the test is significantly simpler now.

I'd encourage you take a look because I think what we might end up doing may be a hybrid between this patch and what I've done in the patches I listed above.

I've made a short pro/con list (from my perspective) for the two approaches. Hopefully this will encourage some discussion that will allow us to converge on a design.

This patch

This patch effectively tries to separate data and code. Data in a parent allocator class that is not templated over AddressSpaceView, and then the methods that depend on AddressSpaceView are in the child class. I'm guessing the hope is that recasting a AllocatorView<LocalAddressSpaceView> as a AllocatorView<RemoteAddressSpaceView> should work and be safe because all the data is in the parent class (the data layout doesn't depend on AddressSpaceView).

Pros

• Creating a AllocatorView<RemoteAddressSpaceView> from a AllocatorView<LocalAddressSpaceView> is a cheap operation because it's just a re-cast.
• There is a clear separation between what methods depend on AddressSpaceView in an allocator, and what does not depend on it. In fact this separation will also create compilation errors if you get it wrong (method is parent class tries to call a method that only exists in the child class).

Cons

• Restricts the design/behaviour of data structures contained within the allocator significantly. This design disallows fields of the allocator depending on AddressSpaceView (would require parent class taking AddressSpaceView as a template parameter which would break doing safe cheap casting). This is a very strong restriction because it means data structures inside the allocator cannot derefence pointers that point outside itself because the data structure has no access to AddressSpaceView.
• The previous point means we can (and do have) horrible layering violations. Now that data structures in the allocator cannot derefence pointers, it means the data structure's interface must return pointers (or references that we can take the address of) and that the caller must decide whether or not to use AddressSpaceView::Load(). This is a layering violation because it requires that the allocator knows how the data structure is implemented (does the pointer/reference returned point to the local address space or the remote address space?). A concrete example of this in this patch is ByteMap.
• The above problem is even worse if the used data-structure contains nested data-structures.

My CopyFromTarget(...) patch series.

Pros

• There is no restriction on what data structures that an allocator can use because they are allowed to take AddressSpaceView as a type parameter.
• There is no restriction on the design of nested data structures that use AddressSpaceView, other than that they implement CopyFromTarget(...) and use AddressSpaceView::Load(...).
• Because of the above point, data structures recursively using AddressSpaceView as a template parameter are supported (used in my patches).

Cons

• Creating a AllocatorView<RemoteAddressSpaceView> from a AllocatorView<LocalAddressSpaceView> is not cheap because we have to copy over all the fields (we might be able to improve this by using a constexpr() what checks if the data layout is the same).
• The above is a maintenance burden because we have to manually maintain code that enumerates the fields of types that depend on AddressSpaceView. Note, if we forget to copy a field that actually matters for allocator enumeration our tests should catch this.

Thoughts

I personally prefer my CopyFromTarget(...) patch series. Although I think what @vitalybuka has done in this patch is quite clever (the separation of code and data is quite aesthetically pleasing), I think this patch paints us into a design corner. The restrictions it places on what data structures can be used in allocators and how they can be implemented is a very serious concern of mine. I wanted the AddressSpaceView interface to be as unintrusive as possible but his patch feels like it places very intrusive design restrictions on the allocators. I would rather take the performance hit that CopyFromTarget(...) adds and the minor maintenance burden it adds so that we can continue to allow the Allocators to use whatever data structure they wish.

@kcc @eugenis @cryptoad I'd appreciate your input here because this is quite an important design decision.

[vitalybuka]

In D57279#1373276, @delcypher wrote:

@vitalybuka Thanks for working on this.

Context for those new to the patch: We are looking at ways of converting a Allocator<LocalAddressSpaceView> into a Allocator<RemoteAddressSpaceView>. With the current design on master it is not safe to do a reinterpret_cast<>() because C++ doesn't guarantee that the two different types have the same data-layout or fields (AFAIK).

Now you can reinterpret/memcpy at base class level.

Over the weekend I investigated your first suggestion for fixing the reinterpret_cast problem for the allocators. I've updated my patch stack to use this new approach. Even though you're trying a different approach in this patch I thought it was important that I investigate other options. The key patches are...

• https://reviews.llvm.org/D57306 - This removes AddressSpaceView from primary allocators params data structures. The patch explains more but basically this is needed for the next patch. It fixes what I consider to be a design mistake on my part and cleans up the code considerably.
• https://reviews.llvm.org/D57307 - This add CopyFromTarget(...) static methods to all data types that take AddressSpaceView as a type parameter. It also adds a public templated type alias (ThisTASVT) that allows you to construct the RemoteAddressSpaceView counter-part from an existing type.
• https://reviews.llvm.org/D56207 - Updates the unit tests to use the new CopyFromTarget(...) and use ThisTASVT for type construction. Note that the test is significantly simpler now.

I'd encourage you take a look because I think what we might end up doing may be a hybrid between this patch and what I've done in the patches I listed above.

I've made a short pro/con list (from my perspective) for the two approaches. Hopefully this will encourage some discussion that will allow us to converge on a design.

This patch

This patch effectively tries to separate data and code. Data in a parent allocator class that is not templated over AddressSpaceView, and then the methods that depend on AddressSpaceView are in the child class. I'm guessing the hope is that recasting a AllocatorView<LocalAddressSpaceView> as a AllocatorView<RemoteAddressSpaceView> should work and be safe because all the data is in the parent class (the data layout doesn't depend on AddressSpaceView).

Pros

• Creating a AllocatorView<RemoteAddressSpaceView> from a AllocatorView<LocalAddressSpaceView> is a cheap operation because it's just a re-cast.
• There is a clear separation between what methods depend on AddressSpaceView in an allocator, and what does not depend on it. In fact this separation will also create compilation errors if you get it wrong (method is parent class tries to call a method that only exists in the child class).

Cons

• Restricts the design/behaviour of data structures contained within the allocator significantly. This design disallows fields of the allocator depending on AddressSpaceView (would require parent class taking AddressSpaceView as a template parameter which would break doing safe cheap casting). This is a very strong restriction because it means data structures inside the allocator cannot derefence pointers that point outside itself because the data structure has no access to AddressSpaceView.

I rely hope we will try to avoid such fields with either design. So I don't think we need to optimize for this scenario.

• The previous point means we can (and do have) horrible layering violations. Now that data structures in the allocator cannot derefence pointers, it means the data structure's interface must return pointers (or references that we can take the address of) and that the caller must decide whether or not to use AddressSpaceView::Load(). This is a layering violation because it requires that the allocator knows how the data structure is implemented (does the pointer/reference returned point to the local address space or the remote address space?). A concrete example of this in this patch is ByteMap.

This one can be easily solved making SizeClassAllocator32->SizeClassAllocator32State a pure data structure without methods and
SizeClassAllocator32::WithView ->

class SizeClassAllocator32<AddressSpaceView> {
  // logic
  SizeClassAllocator32State state_;
}

or even better:

class SizeClassAllocator32<AddressSpaceView> {
  // logic
  SizeClassAllocator32State* state_;
}

This way remote part will be able to swap state pointers without need to copy/reinterprete anything.

Anyway all this hidden in implementation and simplify interface. These consts are "possible" future issues which will likely never bother us. AddressSpaceView noise is current issue.
I am against more complicate design for sake of avoiding possible but unlikely future issues.

• The above problem is even worse if the used data-structure contains nested data-structures.

My CopyFromTarget(...) patch series.

Pros

• There is no restriction on what data structures that an allocator can use because they are allowed to take AddressSpaceView as a type parameter.
• There is no restriction on the design of nested data structures that use AddressSpaceView, other than that they implement CopyFromTarget(...) and use AddressSpaceView::Load(...).
• Because of the above point, data structures recursively using AddressSpaceView as a template parameter are supported (used in my patches).

Cons

• Creating a AllocatorView<RemoteAddressSpaceView> from a AllocatorView<LocalAddressSpaceView> is not cheap because we have to copy over all the fields (we might be able to improve this by using a constexpr() what checks if the data layout is the same).
• The above is a maintenance burden because we have to manually maintain code that enumerates the fields of types that depend on AddressSpaceView. Note, if we forget to copy a field that actually matters for allocator enumeration our tests should catch this.

It adds even more complexity for readers.

Thoughts

I personally prefer my CopyFromTarget(...) patch series. Although I think what @vitalybuka has done in this patch is quite clever (the separation of code and data is quite aesthetically pleasing), I think this patch paints us into a design corner. The restrictions it places on what data structures can be used in allocators and how they can be implemented is a very serious concern of mine. I wanted the AddressSpaceView interface to be as unintrusive as possible but his patch feels like it places very intrusive design restrictions on the allocators. I would rather take the performance hit that CopyFromTarget(...) adds and the minor maintenance burden it adds so that we can continue to allow the Allocators to use whatever data structure they wish.

@kcc @eugenis @cryptoad I'd appreciate your input here because this is quite an important design decision.

[delcypher]

In D57279#1374260, @vitalybuka wrote:

In D57279#1373276, @delcypher wrote:

@vitalybuka Thanks for working on this.

Context for those new to the patch: We are looking at ways of converting a Allocator<LocalAddressSpaceView> into a Allocator<RemoteAddressSpaceView>. With the current design on master it is not safe to do a reinterpret_cast<>() because C++ doesn't guarantee that the two different types have the same data-layout or fields (AFAIK).

Now you can reinterpret/memcpy at base class level.

Okay. As long as we encapsulate that in a method similar to what I have in https://reviews.llvm.org/D57307

template <typename DstTy, typename SrcTy>
const SrcTy *CopyFromTarget(DstTy *dst, const SrcTy *src)

then I'm fine with that.

Over the weekend I investigated your first suggestion for fixing the reinterpret_cast problem for the allocators. I've updated my patch stack to use this new approach. Even though you're trying a different approach in this patch I thought it was important that I investigate other options. The key patches are...

• https://reviews.llvm.org/D57306 - This removes AddressSpaceView from primary allocators params data structures. The patch explains more but basically this is needed for the next patch. It fixes what I consider to be a design mistake on my part and cleans up the code considerably.
• https://reviews.llvm.org/D57307 - This add CopyFromTarget(...) static methods to all data types that take AddressSpaceView as a type parameter. It also adds a public templated type alias (ThisTASVT) that allows you to construct the RemoteAddressSpaceView counter-part from an existing type.
• https://reviews.llvm.org/D56207 - Updates the unit tests to use the new CopyFromTarget(...) and use ThisTASVT for type construction. Note that the test is significantly simpler now.

I'd encourage you take a look because I think what we might end up doing may be a hybrid between this patch and what I've done in the patches I listed above.

I've made a short pro/con list (from my perspective) for the two approaches. Hopefully this will encourage some discussion that will allow us to converge on a design.

This patch

This patch effectively tries to separate data and code. Data in a parent allocator class that is not templated over AddressSpaceView, and then the methods that depend on AddressSpaceView are in the child class. I'm guessing the hope is that recasting a AllocatorView<LocalAddressSpaceView> as a AllocatorView<RemoteAddressSpaceView> should work and be safe because all the data is in the parent class (the data layout doesn't depend on AddressSpaceView).

Pros

• Creating a AllocatorView<RemoteAddressSpaceView> from a AllocatorView<LocalAddressSpaceView> is a cheap operation because it's just a re-cast.
• There is a clear separation between what methods depend on AddressSpaceView in an allocator, and what does not depend on it. In fact this separation will also create compilation errors if you get it wrong (method is parent class tries to call a method that only exists in the child class).

Cons

• Restricts the design/behaviour of data structures contained within the allocator significantly. This design disallows fields of the allocator depending on AddressSpaceView (would require parent class taking AddressSpaceView as a template parameter which would break doing safe cheap casting). This is a very strong restriction because it means data structures inside the allocator cannot derefence pointers that point outside itself because the data structure has no access to AddressSpaceView.

I rely hope we will try to avoid such fields with either design. So I don't think we need to optimize for this scenario.

• The previous point means we can (and do have) horrible layering violations. Now that data structures in the allocator cannot derefence pointers, it means the data structure's interface must return pointers (or references that we can take the address of) and that the caller must decide whether or not to use AddressSpaceView::Load(). This is a layering violation because it requires that the allocator knows how the data structure is implemented (does the pointer/reference returned point to the local address space or the remote address space?). A concrete example of this in this patch is ByteMap.

This one can be easily solved making SizeClassAllocator32->SizeClassAllocator32State a pure data structure without methods and
SizeClassAllocator32::WithView ->

class SizeClassAllocator32<AddressSpaceView> {
  // logic
  SizeClassAllocator32State state_;
}

or even better:

class SizeClassAllocator32<AddressSpaceView> {
  // logic
  SizeClassAllocator32State* state_;
}

This way remote part will be able to swap state pointers without need to copy/reinterprete anything.

I was going to ask if the performance impact of this indirection matters. However given that Scudo now has its own independent code base I guess this matters a lot less.

Anyway all this hidden in implementation and simplify interface. These consts are "possible" future issues which will likely never bother us. AddressSpaceView noise is current issue.
I am against more complicate design for sake of avoiding possible but unlikely future issues.

Okay. I left this open for a week to see if anyone would respond and it seems that no one else has a differing opinion on this other than me. Given that I am not the code owner the only real way forward is for me to follow the approach in this patch.
Please allow me some time to try rebasing all my patches on top of this one so I can investigate how well it works. I will report back with my findings.

[vitalybuka]

sgtm

[vitalybuka]

Looking through my unfinished patches, and noticed this one.
I am curious if LocalAddressSpaceView stuff is in use, maybe it's abandoned and can be removed?
@delcypher @thetruestblue @rsundahl

[rsundahl]

I am curious if LocalAddressSpaceView stuff is in use, maybe it's abandoned and can be removed?

I'm not familiar with AddressSpaceView @vitalybuka but @yln or @kubamracek may have better perspective. Would applying this patch internally to see if we have explicit dependencies be useful? I can certainly do that as a black-box test, otherwise I'd have to dig in a bit to be of much help.

[vitalybuka]

In D57279#4386141, @rsundahl wrote:

I am curious if LocalAddressSpaceView stuff is in use, maybe it's abandoned and can be removed?

I'm not familiar with AddressSpaceView @vitalybuka but @yln or @kubamracek may have better perspective. Would applying this patch internally to see if we have explicit dependencies be useful? I can certainly do that as a black-box test, otherwise I'd have to dig in a bit to be of much help.

Applying the patch can be hard as it's outdated.

My question is "can we go further and remove AddressSpaceView completly?"

compiler-rt/lib/asan/asan_allocator.h

 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize  =  0x8000000000ULL;  // 500G
 typedef DefaultSizeClassMap SizeClassMap;
 # else
 const uptr kAllocatorSpace = 0x600000000000ULL;
 const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
 typedef DefaultSizeClassMap SizeClassMap;
 # endif
-template <typename AddressSpaceViewTy>
 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 0;
   typedef __asan::SizeClassMap SizeClassMap;
   typedef AsanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
-template <typename AddressSpaceView>
-using PrimaryAllocatorASVT = SizeClassAllocator64<AP64<AddressSpaceView>>;
-using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
+using PrimaryAllocator = SizeClassAllocator64<AP64>;
 #else  // Fallback to SizeClassAllocator32.
 static const uptr kRegionSizeLog = 20;
 static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
 # if SANITIZER_WORDSIZE == 32
-template <typename AddressSpaceView>
-using ByteMapASVT = FlatByteMap<kNumRegions, AddressSpaceView>;
+using ByteMap = FlatByteMap<kNumRegions>;
 # elif SANITIZER_WORDSIZE == 64
-template <typename AddressSpaceView>
-using ByteMapASVT =
-    TwoLevelByteMap<(kNumRegions >> 12), 1 << 12, AddressSpaceView>;
+using ByteMap = TwoLevelByteMap<(kNumRegions >> 12), 1 << 12>;
 # endif
 typedef CompactSizeClassMap SizeClassMap;
-template <typename AddressSpaceViewTy>
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = 16;
   typedef __asan::SizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = __asan::kRegionSizeLog;
-  using AddressSpaceView = AddressSpaceViewTy;
-  using ByteMap = __asan::ByteMapASVT<AddressSpaceView>;
+  using ByteMap = __asan::ByteMap;
   typedef AsanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
-template <typename AddressSpaceView>
-using PrimaryAllocatorASVT = SizeClassAllocator32<AP32<AddressSpaceView> >;
-using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
+using PrimaryAllocator = SizeClassAllocator32<AP32>;
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64
 
 static const uptr kNumberOfSizeClasses = SizeClassMap::kNumClasses;
-template <typename AddressSpaceView>
-using AllocatorCacheASVT =
-    SizeClassAllocatorLocalCache<PrimaryAllocatorASVT<AddressSpaceView>>;
-using AllocatorCache = AllocatorCacheASVT<LocalAddressSpaceView>;
+using AllocatorCache = SizeClassAllocatorLocalCache<PrimaryAllocator>;
+
+using SecondaryAllocator =
+    LargeMmapAllocator<AsanMapUnmapCallback, DefaultLargeMmapAllocatorPtrArray>;
 
-template <typename AddressSpaceView>
-using SecondaryAllocatorASVT =
-    LargeMmapAllocator<AsanMapUnmapCallback, DefaultLargeMmapAllocatorPtrArray,
-                       AddressSpaceView>;
 template <typename AddressSpaceView>
 using AsanAllocatorASVT =
-    CombinedAllocator<PrimaryAllocatorASVT<AddressSpaceView>,
-                      AllocatorCacheASVT<AddressSpaceView>,
-                      SecondaryAllocatorASVT<AddressSpaceView>,
+    CombinedAllocator<PrimaryAllocator, AllocatorCache, SecondaryAllocator,
                       AddressSpaceView>;
 using AsanAllocator = AsanAllocatorASVT<LocalAddressSpaceView>;
 
 struct AsanThreadLocalMallocStorage {
   uptr quarantine_cache[16];
   AllocatorCache allocator_cache;
   void CommitBack();
  private:

compiler-rt/lib/hwasan/hwasan_allocator.h

 
 static const uptr kMaxAllowedMallocSize = 2UL << 30;  // 2G
 
 struct AP64 {
   static const uptr kSpaceBeg = ~0ULL;
   static const uptr kSpaceSize = 0x2000000000ULL;
   static const uptr kMetadataSize = sizeof(Metadata);
   typedef __sanitizer::VeryDenseSizeClassMap SizeClassMap;
-  using AddressSpaceView = LocalAddressSpaceView;
   typedef HwasanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<HwasanMapUnmapCallback> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
                           SecondaryAllocator> Allocator;

compiler-rt/lib/lsan/lsan_allocator.h

 #endif
   u32 stack_trace_id;
 };
 
 #if defined(__mips64) || defined(__aarch64__) || defined(__i386__) || \
     defined(__arm__)
 static const uptr kRegionSizeLog = 20;
 static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
-template <typename AddressSpaceView>
-using ByteMapASVT =
-    TwoLevelByteMap<(kNumRegions >> 12), 1 << 12, AddressSpaceView>;
+using ByteMap = TwoLevelByteMap<(kNumRegions >> 12), 1 << 12>;
 
-template <typename AddressSpaceViewTy>
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = sizeof(ChunkMetadata);
   typedef __sanitizer::CompactSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = __lsan::kRegionSizeLog;
-  using AddressSpaceView = AddressSpaceViewTy;
-  using ByteMap = __lsan::ByteMapASVT<AddressSpaceView>;
+  using ByteMap = __lsan::ByteMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
-template <typename AddressSpaceView>
-using PrimaryAllocatorASVT = SizeClassAllocator32<AP32<AddressSpaceView>>;
-using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
+using PrimaryAllocator = SizeClassAllocator32<AP32>;
 #elif defined(__x86_64__) || defined(__powerpc64__)
 # if defined(__powerpc64__)
 const uptr kAllocatorSpace = 0xa0000000000ULL;
 const uptr kAllocatorSize  = 0x20000000000ULL;  // 2T.
 # else
 const uptr kAllocatorSpace = 0x600000000000ULL;
 const uptr kAllocatorSize  = 0x40000000000ULL;  // 4T.
 # endif
-template <typename AddressSpaceViewTy>
 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = sizeof(ChunkMetadata);
   typedef DefaultSizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
-template <typename AddressSpaceView>
-using PrimaryAllocatorASVT = SizeClassAllocator64<AP64<AddressSpaceView>>;
-using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
+using PrimaryAllocator = SizeClassAllocator64<AP64>;
 #endif
 
-template <typename AddressSpaceView>
-using AllocatorCacheASVT =
-    SizeClassAllocatorLocalCache<PrimaryAllocatorASVT<AddressSpaceView>>;
-using AllocatorCache = AllocatorCacheASVT<LocalAddressSpaceView>;
+using AllocatorCache = SizeClassAllocatorLocalCache<PrimaryAllocator>;
 
-template <typename AddressSpaceView>
-using SecondaryAllocatorASVT =
-    LargeMmapAllocator<NoOpMapUnmapCallback, DefaultLargeMmapAllocatorPtrArray,
-                       AddressSpaceView>;
+using SecondaryAllocator =
+    LargeMmapAllocator<NoOpMapUnmapCallback, DefaultLargeMmapAllocatorPtrArray>;
 
 template <typename AddressSpaceView>
-using AllocatorASVT =
-    CombinedAllocator<PrimaryAllocatorASVT<AddressSpaceView>,
-                      AllocatorCacheASVT<AddressSpaceView>,
-                      SecondaryAllocatorASVT<AddressSpaceView>,
-                      AddressSpaceView>;
+using AllocatorASVT = CombinedAllocator<PrimaryAllocator, AllocatorCache,
+                                        SecondaryAllocator, AddressSpaceView>;
 using Allocator = AllocatorASVT<LocalAddressSpaceView>;
 
 AllocatorCache *GetAllocatorCache();
 
 int lsan_posix_memalign(void **memptr, uptr alignment, uptr size,
                         const StackTrace &stack);
 void *lsan_aligned_alloc(uptr alignment, uptr size, const StackTrace &stack);
 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack);

compiler-rt/lib/msan/msan_allocator.cc

#if defined(__mips64)
   typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
 
   struct AP32 {
     static const uptr kSpaceBeg = 0;
     static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
     static const uptr kMetadataSize = sizeof(Metadata);
     typedef __sanitizer::CompactSizeClassMap SizeClassMap;
     static const uptr kRegionSizeLog = __msan::kRegionSizeLog;
-    using AddressSpaceView = LocalAddressSpaceView;
     using ByteMap = __msan::ByteMap;
     typedef MsanMapUnmapCallback MapUnmapCallback;
     static const uptr kFlags = 0;
   };
   typedef SizeClassAllocator32<AP32> PrimaryAllocator;
 #elif defined(__x86_64__)
 #if SANITIZER_NETBSD || \
     (SANITIZER_LINUX && !defined(MSAN_LINUX_X86_64_OLD_MAPPING))
   static const uptr kAllocatorSpace = 0x700000000000ULL;
 #else
   static const uptr kAllocatorSpace = 0x600000000000ULL;
 #endif
   static const uptr kMaxAllowedMallocSize = 8UL << 30;
 
   struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
     static const uptr kSpaceBeg = kAllocatorSpace;
     static const uptr kSpaceSize = 0x40000000000; // 4T.
     static const uptr kMetadataSize = sizeof(Metadata);
     typedef DefaultSizeClassMap SizeClassMap;
     typedef MsanMapUnmapCallback MapUnmapCallback;
     static const uptr kFlags = 0;
-    using AddressSpaceView = LocalAddressSpaceView;
   };
 
   typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 
 #elif defined(__powerpc64__)
   static const uptr kMaxAllowedMallocSize = 2UL << 30;  // 2G
 
   struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
     static const uptr kSpaceBeg = 0x300000000000;
     static const uptr kSpaceSize = 0x020000000000; // 2T.
     static const uptr kMetadataSize = sizeof(Metadata);
     typedef DefaultSizeClassMap SizeClassMap;
     typedef MsanMapUnmapCallback MapUnmapCallback;
     static const uptr kFlags = 0;
-    using AddressSpaceView = LocalAddressSpaceView;
   };
 
   typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 #elif defined(__aarch64__)
   static const uptr kMaxAllowedMallocSize = 2UL << 30;  // 2G
   static const uptr kRegionSizeLog = 20;
   static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
   typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
 
   struct AP32 {
     static const uptr kSpaceBeg = 0;
     static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
     static const uptr kMetadataSize = sizeof(Metadata);
     typedef __sanitizer::CompactSizeClassMap SizeClassMap;
     static const uptr kRegionSizeLog = __msan::kRegionSizeLog;
-    using AddressSpaceView = LocalAddressSpaceView;
     using ByteMap = __msan::ByteMap;
     typedef MsanMapUnmapCallback MapUnmapCallback;
     static const uptr kFlags = 0;
   };
   typedef SizeClassAllocator32<AP32> PrimaryAllocator;
 #endif
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<MsanMapUnmapCallback> SecondaryAllocator;

compiler-rt/lib/sanitizer_common/sanitizer_allocator_bytemap.h

 //===-- sanitizer_allocator_bytemap.h ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Part of the Sanitizer Allocator.
 //
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_ALLOCATOR_H
 #error This file must be included inside sanitizer_allocator.h
 #endif
 
 // Maps integers in rage [0, kSize) to u8 values.
-template <u64 kSize, typename AddressSpaceViewTy = LocalAddressSpaceView>
+template <u64 kSize>
 class FlatByteMap {
  public:
-  using AddressSpaceView = AddressSpaceViewTy;
   void Init() {
     internal_memset(map_, 0, sizeof(map_));
   }
 
   void set(uptr idx, u8 val) {
     CHECK_LT(idx, kSize);
     CHECK_EQ(0U, map_[idx]);
     map_[idx] = val;
   }
-  u8 operator[] (uptr idx) {
+  const u8 &operator[](uptr idx) const {
     CHECK_LT(idx, kSize);
     // FIXME: CHECK may be too expensive here.
     return map_[idx];
   }
+
  private:
   u8 map_[kSize];
 };
 
 // TwoLevelByteMap maps integers in range [0, kSize1*kSize2) to u8 values.
 // It is implemented as a two-dimensional array: array of kSize1 pointers
 // to kSize2-byte arrays. The secondary arrays are mmaped on demand.
 // Each value is initially zero and can be set to something else only once.
 // Setting and getting values from multiple threads is safe w/o extra locking.
 template <u64 kSize1, u64 kSize2,
-          typename AddressSpaceViewTy = LocalAddressSpaceView,
           class MapUnmapCallback = NoOpMapUnmapCallback>
 class TwoLevelByteMap {
  public:
-  using AddressSpaceView = AddressSpaceViewTy;
   void Init() {
     internal_memset(map1_, 0, sizeof(map1_));
     mu_.Init();
   }
 
   void TestOnlyUnmap() {
     for (uptr i = 0; i < kSize1; i++) {
       u8 *p = Get(i);
public:
 
   void set(uptr idx, u8 val) {
     CHECK_LT(idx, kSize1 * kSize2);
     u8 *map2 = GetOrCreate(idx / kSize2);
     CHECK_EQ(0U, map2[idx % kSize2]);
     map2[idx % kSize2] = val;
   }
 
-  u8 operator[] (uptr idx) const {
+  const u8 &operator[](uptr idx) const {
     CHECK_LT(idx, kSize1 * kSize2);
     u8 *map2 = Get(idx / kSize2);
-    if (!map2) return 0;
-    auto value_ptr = AddressSpaceView::Load(&map2[idx % kSize2]);
-    return *value_ptr;
+    if (!map2) {
+      static const u8 zero = 0;
+      return zero;
+    }
+    return map2[idx % kSize2];
   }
 
  private:
   u8 *Get(uptr idx) const {
     CHECK_LT(idx, kSize1);
     return reinterpret_cast<u8 *>(
         atomic_load(&map1_[idx], memory_order_acquire));
   }

compiler-rt/lib/sanitizer_common/sanitizer_allocator_combined.h

 // PrimaryAllocator is used via a local AllocatorCache.
 // SecondaryAllocator can allocate anything, but is not efficient.
 template <class PrimaryAllocator, class AllocatorCache,
           class SecondaryAllocator,
           typename AddressSpaceViewTy = LocalAddressSpaceView>  // NOLINT
 class CombinedAllocator {
  public:
   using AddressSpaceView = AddressSpaceViewTy;
-  static_assert(is_same<AddressSpaceView,
-                        typename PrimaryAllocator::AddressSpaceView>::value,
-                "PrimaryAllocator is using wrong AddressSpaceView");
-  static_assert(is_same<AddressSpaceView,
-                        typename SecondaryAllocator::AddressSpaceView>::value,
-                "SecondaryAllocator is using wrong AddressSpaceView");
+  using PrimaryAllocatorWithView =
+      typename PrimaryAllocator::template WithView<AddressSpaceView>;
+  using SecondaryAllocatorWithView =
+      typename SecondaryAllocator::template WithView<AddressSpaceView>;
 
   void InitLinkerInitialized(s32 release_to_os_interval_ms) {
     stats_.InitLinkerInitialized();
     primary_.Init(release_to_os_interval_ms);
     secondary_.InitLinkerInitialized();
   }
 
   void Init(s32 release_to_os_interval_ms) {
public:
   // Iterate over all existing chunks.
   // The allocator must be locked when calling this function.
   void ForEachChunk(ForEachChunkCallback callback, void *arg) {
     primary_.ForEachChunk(callback, arg);
     secondary_.ForEachChunk(callback, arg);
   }
 
  private:
-  PrimaryAllocator primary_;
-  SecondaryAllocator secondary_;
+  PrimaryAllocatorWithView primary_;
+  SecondaryAllocatorWithView secondary_;
+
   AllocatorGlobalStats stats_;
 };

compiler-rt/lib/sanitizer_common/sanitizer_allocator_internal.h

 typedef TwoLevelByteMap<(kInternalAllocatorNumRegions >> 12), 1 << 12> ByteMap;
 #endif
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = 0;
   typedef InternalSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = kInternalAllocatorRegionSizeLog;
-  using AddressSpaceView = LocalAddressSpaceView;
   using ByteMap = __sanitizer::ByteMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
 typedef SizeClassAllocator32<AP32> PrimaryInternalAllocator;
 
 typedef SizeClassAllocatorLocalCache<PrimaryInternalAllocator>
     InternalAllocatorCache;

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary32.h

enum {
     kRandomShuffleChunks = 1,
     kUseSeparateSizeClassForBatch = 2,
   };
 };
 
 template <class Params>
 class SizeClassAllocator32 {
  public:
-  using AddressSpaceView = typename Params::AddressSpaceView;
   static const uptr kSpaceBeg = Params::kSpaceBeg;
   static const u64 kSpaceSize = Params::kSpaceSize;
   static const uptr kMetadataSize = Params::kMetadataSize;
   typedef typename Params::SizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = Params::kRegionSizeLog;
   typedef typename Params::ByteMap ByteMap;
   typedef typename Params::MapUnmapCallback MapUnmapCallback;
 
-  static_assert(
-      is_same<typename ByteMap::AddressSpaceView, AddressSpaceView>::value,
-      "AddressSpaceView type mismatch");
-
   static const bool kRandomShuffleChunks = Params::kFlags &
       SizeClassAllocator32FlagMasks::kRandomShuffleChunks;
   static const bool kUseSeparateSizeClassForBatch = Params::kFlags &
       SizeClassAllocator32FlagMasks::kUseSeparateSizeClassForBatch;
 
   struct TransferBatch {
     static const uptr kMaxNumCached = SizeClassMap::kMaxNumCachedHint - 2;
     void SetFromArray(void *batch[], uptr count) {
void UnmapWithCallback(uptr beg, uptr size) {
     UnmapOrDie(reinterpret_cast<void *>(beg), size);
   }
 
   static bool CanAllocate(uptr size, uptr alignment) {
     return size <= SizeClassMap::kMaxSize &&
       alignment <= SizeClassMap::kMaxSize;
   }
 
-  void *GetMetaData(const void *p) {
-    CHECK(PointerIsMine(p));
-    uptr mem = reinterpret_cast<uptr>(p);
-    uptr beg = ComputeRegionBeg(mem);
-    uptr size = ClassIdToSize(GetSizeClass(p));
-    u32 offset = mem - beg;
-    uptr n = offset / (u32)size;  // 32-bit division
-    uptr meta = (beg + kRegionSize) - (n + 1) * kMetadataSize;
-    return reinterpret_cast<void*>(meta);
-  }
-
   NOINLINE TransferBatch *AllocateBatch(AllocatorStats *stat, AllocatorCache *c,
                                         uptr class_id) {
     DCHECK_LT(class_id, kNumClasses);
     SizeClassInfo *sci = GetSizeClassInfo(class_id);
     SpinMutexLock l(&sci->mutex);
     if (sci->free_list.empty()) {
       if (UNLIKELY(!PopulateFreeList(stat, c, sci, class_id)))
         return nullptr;
       DCHECK(!sci->free_list.empty());
     }
     TransferBatch *b = sci->free_list.front();
     sci->free_list.pop_front();
     return b;
   }
 
   NOINLINE void DeallocateBatch(AllocatorStats *stat, uptr class_id,
                                 TransferBatch *b) {
     DCHECK_LT(class_id, kNumClasses);
     CHECK_GT(b->Count(), 0);
     SizeClassInfo *sci = GetSizeClassInfo(class_id);
     SpinMutexLock l(&sci->mutex);
     sci->free_list.push_front(b);
   }
 
+  uptr ClassID(uptr size) { return SizeClassMap::ClassID(size); }
+
+  // ForceLock() and ForceUnlock() are needed to implement Darwin malloc zone
+  // introspection API.
+  void ForceLock() {
+    for (uptr i = 0; i < kNumClasses; i++) {
+      GetSizeClassInfo(i)->mutex.Lock();
+    }
+  }
+
+  void ForceUnlock() {
+    for (int i = kNumClasses - 1; i >= 0; i--) {
+      GetSizeClassInfo(i)->mutex.Unlock();
+    }
+  }
+
+  void PrintStats() {}
+
+  static uptr AdditionalSize() { return 0; }
+
+  typedef SizeClassMap SizeClassMapT;
+  static const uptr kNumClasses = SizeClassMap::kNumClasses;
+
+  template <typename AddressSpaceView>
+  class WithView : public SizeClassAllocator32 {
+   public:
+    uptr GetSizeClass(const void *p) {
+      return *AddressSpaceView::Load(
+          &possible_regions[ComputeRegionId(reinterpret_cast<uptr>(p))]);
+    }
+
     bool PointerIsMine(const void *p) {
       uptr mem = reinterpret_cast<uptr>(p);
       if (mem < kSpaceBeg || mem >= kSpaceBeg + kSpaceSize)
         return false;
-    return GetSizeClass(p) != 0;
-  }
-
-  uptr GetSizeClass(const void *p) {
-    return possible_regions[ComputeRegionId(reinterpret_cast<uptr>(p))];
+      return (GetSizeClass(p)) != 0;
     }
 
     void *GetBlockBegin(const void *p) {
       CHECK(PointerIsMine(p));
       uptr mem = reinterpret_cast<uptr>(p);
       uptr beg = ComputeRegionBeg(mem);
       uptr size = ClassIdToSize(GetSizeClass(p));
       u32 offset = mem - beg;
       u32 n = offset / (u32)size;  // 32-bit division
       uptr res = beg + (n * (u32)size);
-    return reinterpret_cast<void*>(res);
+      return reinterpret_cast<void *>(res);
     }
 
     uptr GetActuallyAllocatedSize(void *p) {
       CHECK(PointerIsMine(p));
       return ClassIdToSize(GetSizeClass(p));
     }
 
-  uptr ClassID(uptr size) { return SizeClassMap::ClassID(size); }
-
-  uptr TotalMemoryUsed() {
-    // No need to lock here.
-    uptr res = 0;
-    for (uptr i = 0; i < kNumPossibleRegions; i++)
-      if (possible_regions[i])
-        res += kRegionSize;
-    return res;
-  }
-
-  void TestOnlyUnmap() {
-    for (uptr i = 0; i < kNumPossibleRegions; i++)
-      if (possible_regions[i])
-        UnmapWithCallback((i * kRegionSize), kRegionSize);
-  }
-
-  // ForceLock() and ForceUnlock() are needed to implement Darwin malloc zone
-  // introspection API.
-  void ForceLock() {
-    for (uptr i = 0; i < kNumClasses; i++) {
-      GetSizeClassInfo(i)->mutex.Lock();
-    }
-  }
-
-  void ForceUnlock() {
-    for (int i = kNumClasses - 1; i >= 0; i--) {
-      GetSizeClassInfo(i)->mutex.Unlock();
-    }
+    void *GetMetaData(const void *p) {
+      CHECK(PointerIsMine(p));
+      uptr mem = reinterpret_cast<uptr>(p);
+      uptr beg = ComputeRegionBeg(mem);
+      uptr size = ClassIdToSize(GetSizeClass(p));
+      u32 offset = mem - beg;
+      uptr n = offset / (u32)size;  // 32-bit division
+      uptr meta = (beg + kRegionSize) - (n + 1) * kMetadataSize;
+      return reinterpret_cast<void *>(meta);
     }
 
     // Iterate over all existing chunks.
     // The allocator must be locked when calling this function.
     void ForEachChunk(ForEachChunkCallback callback, void *arg) {
       for (uptr region = 0; region < kNumPossibleRegions; region++)
-      if (possible_regions[region]) {
-        uptr chunk_size = ClassIdToSize(possible_regions[region]);
-        uptr max_chunks_in_region = kRegionSize / (chunk_size + kMetadataSize);
+        if (auto id = *AddressSpaceView::Load(&possible_regions[region])) {
+          uptr chunk_size = ClassIdToSize(id);
+          uptr max_chunks_in_region =
+              kRegionSize / (chunk_size + kMetadataSize);
           uptr region_beg = region * kRegionSize;
           for (uptr chunk = region_beg;
                chunk < region_beg + max_chunks_in_region * chunk_size;
                chunk += chunk_size) {
             // Too slow: CHECK_EQ((void *)chunk, GetBlockBegin((void *)chunk));
             callback(chunk, arg);
           }
         }
     }
 
-  void PrintStats() {}
-
-  static uptr AdditionalSize() { return 0; }
+    void TestOnlyUnmap() {
+      for (uptr i = 0; i < kNumPossibleRegions; i++)
+        if (*AddressSpaceView::Load(&possible_regions[i]))
+          UnmapWithCallback((i * kRegionSize), kRegionSize);
+    }
 
-  typedef SizeClassMap SizeClassMapT;
-  static const uptr kNumClasses = SizeClassMap::kNumClasses;
+    uptr TotalMemoryUsed() {
+      // No need to lock here.
+      uptr res = 0;
+      for (uptr i = 0; i < kNumPossibleRegions; i++)
+        if (*AddressSpaceView::Load(&possible_regions[i]))
+          res += kRegionSize;
+      return res;
+    }
+  };
 
  private:
   static const uptr kRegionSize = 1 << kRegionSizeLog;
   static const uptr kNumPossibleRegions = kSpaceSize / kRegionSize;
 
   struct ALIGNED(SANITIZER_CACHE_LINE_SIZE) SizeClassInfo {
     StaticSpinMutex mutex;
     IntrusiveList<TransferBatch> free_list;

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary64.h

struct SizeClassAllocator64FlagMasks {  //  Bit masks.
   enum {
     kRandomShuffleChunks = 1,
   };
 };
 
 template <class Params>
 class SizeClassAllocator64 {
  public:
-  using AddressSpaceView = typename Params::AddressSpaceView;
   static const uptr kSpaceBeg = Params::kSpaceBeg;
   static const uptr kSpaceSize = Params::kSpaceSize;
   static const uptr kMetadataSize = Params::kMetadataSize;
   typedef typename Params::SizeClassMap SizeClassMap;
   typedef typename Params::MapUnmapCallback MapUnmapCallback;
 
   static const bool kRandomShuffleChunks =
       Params::kFlags & SizeClassAllocator64FlagMasks::kRandomShuffleChunks;
public:
 
   uptr GetSizeClass(const void *p) {
     if (kUsingConstantSpaceBeg && (kSpaceBeg % kSpaceSize) == 0)
       return ((reinterpret_cast<uptr>(p)) / kRegionSize) % kNumClassesRounded;
     return ((reinterpret_cast<uptr>(p) - SpaceBeg()) / kRegionSize) %
            kNumClassesRounded;
   }
 
-  void *GetBlockBegin(const void *p) {
-    uptr class_id = GetSizeClass(p);
-    uptr size = ClassIdToSize(class_id);
-    if (!size) return nullptr;
-    uptr chunk_idx = GetChunkIdx((uptr)p, size);
-    uptr reg_beg = GetRegionBegin(p);
-    uptr beg = chunk_idx * size;
-    uptr next_beg = beg + size;
-    if (class_id >= kNumClasses) return nullptr;
-    const RegionInfo *region = AddressSpaceView::Load(GetRegionInfo(class_id));
-    if (region->mapped_user >= next_beg)
-      return reinterpret_cast<void*>(reg_beg + beg);
-    return nullptr;
-  }
-
   uptr GetActuallyAllocatedSize(void *p) {
     CHECK(PointerIsMine(p));
     return ClassIdToSize(GetSizeClass(p));
   }
 
   uptr ClassID(uptr size) { return SizeClassMap::ClassID(size); }
 
   void *GetMetaData(const void *p) {
public:
   }
 
   void ForceUnlock() {
     for (int i = (int)kNumClasses - 1; i >= 0; i--) {
       GetRegionInfo(i)->mutex.Unlock();
     }
   }
 
-  // Iterate over all existing chunks.
-  // The allocator must be locked when calling this function.
-  void ForEachChunk(ForEachChunkCallback callback, void *arg) {
-    for (uptr class_id = 1; class_id < kNumClasses; class_id++) {
-      RegionInfo *region = GetRegionInfo(class_id);
-      uptr chunk_size = ClassIdToSize(class_id);
-      uptr region_beg = SpaceBeg() + class_id * kRegionSize;
-      uptr region_allocated_user_size =
-          AddressSpaceView::Load(region)->allocated_user;
-      for (uptr chunk = region_beg;
-           chunk < region_beg + region_allocated_user_size;
-           chunk += chunk_size) {
-        // Too slow: CHECK_EQ((void *)chunk, GetBlockBegin((void *)chunk));
-        callback(chunk, arg);
-      }
-    }
-  }
-
   static uptr ClassIdToSize(uptr class_id) {
     return SizeClassMap::Size(class_id);
   }
 
   static uptr AdditionalSize() {
     return RoundUpTo(sizeof(RegionInfo) * kNumClassesRounded,
                      GetPageSizeCached());
   }
if (same_chunk_count_per_page) {
         prev_page_boundary = page_boundary;
 
         range_tracker.NextPage(counters.Get(i) == chunks_per_page);
       }
     }
     range_tracker.Done();
   }
 
+  template <typename AddressSpaceView>
+  class WithView : public SizeClassAllocator64 {
+   public:
+    // Iterate over all existing chunks.
+    // The allocator must be locked when calling this function.
+    void ForEachChunk(ForEachChunkCallback callback, void *arg) {
+      for (uptr class_id = 1; class_id < kNumClasses; class_id++) {
+        RegionInfo *region = GetRegionInfo(class_id);
+        uptr chunk_size = ClassIdToSize(class_id);
+        uptr region_beg = SpaceBeg() + class_id * kRegionSize;
+        uptr region_allocated_user_size =
+            AddressSpaceView::Load(region)->allocated_user;
+        for (uptr chunk = region_beg;
+             chunk < region_beg + region_allocated_user_size;
+             chunk += chunk_size) {
+          // Too slow: CHECK_EQ((void *)chunk, GetBlockBegin((void *)chunk));
+          callback(chunk, arg);
+        }
+      }
+    }
+
+    void *GetBlockBegin(const void *p) {
+      uptr class_id = GetSizeClass(p);
+      uptr size = ClassIdToSize(class_id);
+      if (!size)
+        return nullptr;
+      uptr chunk_idx = GetChunkIdx((uptr)p, size);
+      uptr reg_beg = GetRegionBegin(p);
+      uptr beg = chunk_idx * size;
+      uptr next_beg = beg + size;
+      if (class_id >= kNumClasses)
+        return nullptr;
+      const RegionInfo *region =
+          AddressSpaceView::Load(GetRegionInfo(class_id));
+      if (region->mapped_user >= next_beg)
+        return reinterpret_cast<void *>(reg_beg + beg);
+      return nullptr;
+    }
+  };
+
  private:
   friend class MemoryMapper;
 
   ReservedAddressRange address_range;
 
   static const uptr kRegionSize = kSpaceSize / kNumClassesRounded;
   // FreeArray is the array of free-d chunks (stored as 4-byte offsets).
   // In the worst case it may reguire kRegionSize/SizeClassMap::kMinSize

compiler-rt/lib/sanitizer_common/sanitizer_allocator_secondary.h

 #else
 typedef LargeMmapAllocatorPtrArrayDynamic DefaultLargeMmapAllocatorPtrArray;
 #endif
 
 // This class can (de)allocate only large chunks of memory using mmap/unmap.
 // The main purpose of this allocator is to cover large and rare allocation
 // sizes not covered by more efficient allocators (e.g. SizeClassAllocator64).
 template <class MapUnmapCallback = NoOpMapUnmapCallback,
-          class PtrArrayT = DefaultLargeMmapAllocatorPtrArray,
-          class AddressSpaceViewTy = LocalAddressSpaceView>
+          class PtrArrayT = DefaultLargeMmapAllocatorPtrArray>
 class LargeMmapAllocator {
  public:
-  using AddressSpaceView = AddressSpaceViewTy;
   void InitLinkerInitialized() {
     page_size_ = GetPageSizeCached();
     chunks_ = reinterpret_cast<Header**>(ptr_array_.Init());
   }
 
   void Init() {
     internal_memset(this, 0, sizeof(*this));
     InitLinkerInitialized();
uptr TotalMemoryUsed() {
     for (uptr i = 0; i < n_chunks_; i++) {
       Header *h = chunks_[i];
       CHECK_EQ(h->chunk_idx, i);
       res += RoundUpMapSize(h->size);
     }
     return res;
   }
 
-  bool PointerIsMine(const void *p) {
-    return GetBlockBegin(p) != nullptr;
-  }
-
   uptr GetActuallyAllocatedSize(void *p) {
     return RoundUpTo(GetHeader(p)->size, page_size_);
   }
 
   // At least page_size_/2 metadata bytes is available.
   void *GetMetaData(const void *p) {
     // Too slow: CHECK_EQ(p, GetBlockBegin(p));
     if (!IsAligned(reinterpret_cast<uptr>(p), page_size_)) {
       Printf("%s: bad pointer %p\n", SanitizerToolName, p);
       CHECK(IsAligned(reinterpret_cast<uptr>(p), page_size_));
     }
     return GetHeader(p) + 1;
   }
 
-  void *GetBlockBegin(const void *ptr) {
-    uptr p = reinterpret_cast<uptr>(ptr);
-    SpinMutexLock l(&mutex_);
-    uptr nearest_chunk = 0;
-    Header *const *chunks = AddressSpaceView::Load(chunks_, n_chunks_);
-    // Cache-friendly linear search.
-    for (uptr i = 0; i < n_chunks_; i++) {
-      uptr ch = reinterpret_cast<uptr>(chunks[i]);
-      if (p < ch) continue;  // p is at left to this chunk, skip it.
-      if (p - ch < p - nearest_chunk)
-        nearest_chunk = ch;
+  void PrintStats() {
+    Printf("Stats: LargeMmapAllocator: allocated %zd times, "
+           "remains %zd (%zd K) max %zd M; by size logs: ",
+           stats.n_allocs, stats.n_allocs - stats.n_frees,
+           stats.currently_allocated >> 10, stats.max_allocated >> 20);
+    for (uptr i = 0; i < ARRAY_SIZE(stats.by_size_log); i++) {
+      uptr c = stats.by_size_log[i];
+      if (!c) continue;
+      Printf("%zd:%zd; ", i, c);
     }
-    if (!nearest_chunk)
-      return nullptr;
-    const Header *h =
-        AddressSpaceView::Load(reinterpret_cast<Header *>(nearest_chunk));
-    Header *h_ptr = reinterpret_cast<Header *>(nearest_chunk);
-    CHECK_GE(nearest_chunk, h->map_beg);
-    CHECK_LT(nearest_chunk, h->map_beg + h->map_size);
-    CHECK_LE(nearest_chunk, p);
-    if (h->map_beg + h->map_size <= p)
-      return nullptr;
-    return GetUser(h_ptr);
+    Printf("\n");
   }
 
+  // ForceLock() and ForceUnlock() are needed to implement Darwin malloc zone
+  // introspection API.
+  void ForceLock() {
+    mutex_.Lock();
+  }
+
+  void ForceUnlock() {
+    mutex_.Unlock();
+  }
+
+  template <typename AddressSpaceView>
+  class WithView : public LargeMmapAllocator {
+   public:
+    bool PointerIsMine(const void *p) { return GetBlockBegin(p) != nullptr; }
+
     void EnsureSortedChunks() {
-    if (chunks_sorted_) return;
+      if (chunks_sorted_)
+        return;
       Header **chunks = AddressSpaceView::LoadWritable(chunks_, n_chunks_);
       Sort(reinterpret_cast<uptr *>(chunks), n_chunks_);
       for (uptr i = 0; i < n_chunks_; i++)
         AddressSpaceView::LoadWritable(chunks[i])->chunk_idx = i;
       chunks_sorted_ = true;
     }
 
     // This function does the same as GetBlockBegin, but is much faster.
     // Must be called with the allocator locked.
     void *GetBlockBeginFastLocked(void *ptr) {
       mutex_.CheckLocked();
       uptr p = reinterpret_cast<uptr>(ptr);
       uptr n = n_chunks_;
-    if (!n) return nullptr;
+      if (!n)
+        return nullptr;
       EnsureSortedChunks();
       Header *const *chunks = AddressSpaceView::Load(chunks_, n_chunks_);
       auto min_mmap_ = reinterpret_cast<uptr>(chunks[0]);
       auto max_mmap_ = reinterpret_cast<uptr>(chunks[n - 1]) +
                        AddressSpaceView::Load(chunks[n - 1])->map_size;
       if (p < min_mmap_ || p >= max_mmap_)
         return nullptr;
       uptr beg = 0, end = n - 1;
-    // This loop is a log(n) lower_bound. It does not check for the exact match
-    // to avoid expensive cache-thrashing loads.
+      // This loop is a log(n) lower_bound. It does not check for the exact
+      // match to avoid expensive cache-thrashing loads.
       while (end - beg >= 2) {
         uptr mid = (beg + end) / 2;  // Invariant: mid >= beg + 1
         if (p < reinterpret_cast<uptr>(chunks[mid]))
           end = mid - 1;  // We are not interested in chunks[mid].
         else
           beg = mid;  // chunks[mid] may still be what we want.
       }
 
       if (beg < end) {
         CHECK_EQ(beg + 1, end);
         // There are 2 chunks left, choose one.
         if (p >= reinterpret_cast<uptr>(chunks[end]))
           beg = end;
       }
 
       const Header *h = AddressSpaceView::Load(chunks[beg]);
       Header *h_ptr = chunks[beg];
       if (h->map_beg + h->map_size <= p || p < h->map_beg)
         return nullptr;
       return GetUser(h_ptr);
     }
 
-  void PrintStats() {
-    Printf("Stats: LargeMmapAllocator: allocated %zd times, "
-           "remains %zd (%zd K) max %zd M; by size logs: ",
-           stats.n_allocs, stats.n_allocs - stats.n_frees,
-           stats.currently_allocated >> 10, stats.max_allocated >> 20);
-    for (uptr i = 0; i < ARRAY_SIZE(stats.by_size_log); i++) {
-      uptr c = stats.by_size_log[i];
-      if (!c) continue;
-      Printf("%zd:%zd; ", i, c);
-    }
-    Printf("\n");
-  }
-
-  // ForceLock() and ForceUnlock() are needed to implement Darwin malloc zone
-  // introspection API.
-  void ForceLock() {
-    mutex_.Lock();
+    void *GetBlockBegin(const void *ptr) {
+      uptr p = reinterpret_cast<uptr>(ptr);
+      SpinMutexLock l(&mutex_);
+      uptr nearest_chunk = 0;
+      Header *const *chunks = AddressSpaceView::Load(chunks_, n_chunks_);
+      // Cache-friendly linear search.
+      for (uptr i = 0; i < n_chunks_; i++) {
+        uptr ch = reinterpret_cast<uptr>(chunks[i]);
+        if (p < ch)
+          continue;  // p is at left to this chunk, skip it.
+        if (p - ch < p - nearest_chunk)
+          nearest_chunk = ch;
       }
-
-  void ForceUnlock() {
-    mutex_.Unlock();
+      if (!nearest_chunk)
+        return nullptr;
+      const Header *h =
+          AddressSpaceView::Load(reinterpret_cast<Header *>(nearest_chunk));
+      Header *h_ptr = reinterpret_cast<Header *>(nearest_chunk);
+      CHECK_GE(nearest_chunk, h->map_beg);
+      CHECK_LT(nearest_chunk, h->map_beg + h->map_size);
+      CHECK_LE(nearest_chunk, p);
+      if (h->map_beg + h->map_size <= p)
+        return nullptr;
+      return GetUser(h_ptr);
     }
 
     // Iterate over all existing chunks.
     // The allocator must be locked when calling this function.
     void ForEachChunk(ForEachChunkCallback callback, void *arg) {
-    EnsureSortedChunks();  // Avoid doing the sort while iterating.
+      EnsureSortedChunks();  // Avoid doing the sort while
+                             // iterating.
       const Header *const *chunks = AddressSpaceView::Load(chunks_, n_chunks_);
       for (uptr i = 0; i < n_chunks_; i++) {
         const Header *t = chunks[i];
         callback(reinterpret_cast<uptr>(GetUser(t)), arg);
         // Consistency check: verify that the array did not change.
         CHECK_EQ(chunks[i], t);
         CHECK_EQ(AddressSpaceView::Load(chunks[i])->chunk_idx, i);
       }
     }
+  };
 
  private:
   struct Header {
     uptr map_beg;
     uptr map_size;
     uptr size;
     uptr chunk_idx;
   };

compiler-rt/lib/sanitizer_common/tests/sanitizer_allocator_test.cc

 typedef VeryCompactSizeClassMap SizeClassMap;
 #else
 static const uptr kAllocatorSpace = 0x700000000000ULL;
 static const uptr kAllocatorSize  = 0x010000000000ULL;  // 1T.
 static const u64 kAddressSpaceSize = 1ULL << 47;
 typedef DefaultSizeClassMap SizeClassMap;
 #endif
 
-template <typename AddressSpaceViewTy>
 struct AP64 {  // Allocator Params. Short name for shorter demangled names..
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 16;
   typedef ::SizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
-template <typename AddressSpaceViewTy>
 struct AP64Dyn {
   static const uptr kSpaceBeg = ~(uptr)0;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 16;
   typedef ::SizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
-template <typename AddressSpaceViewTy>
 struct AP64Compact {
   static const uptr kSpaceBeg = ~(uptr)0;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 16;
   typedef CompactSizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
-template <typename AddressSpaceViewTy>
 struct AP64VeryCompact {
   static const uptr kSpaceBeg = ~(uptr)0;
   static const uptr kSpaceSize = 1ULL << 37;
   static const uptr kMetadataSize = 16;
   typedef VeryCompactSizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
-template <typename AddressSpaceViewTy>
 struct AP64Dense {
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 16;
   typedef DenseSizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
-template <typename AddressSpaceView>
-using Allocator64ASVT = SizeClassAllocator64<AP64<AddressSpaceView>>;
-using Allocator64 = Allocator64ASVT<LocalAddressSpaceView>;
-
-template <typename AddressSpaceView>
-using Allocator64DynamicASVT = SizeClassAllocator64<AP64Dyn<AddressSpaceView>>;
-using Allocator64Dynamic = Allocator64DynamicASVT<LocalAddressSpaceView>;
-
-template <typename AddressSpaceView>
-using Allocator64CompactASVT =
-    SizeClassAllocator64<AP64Compact<AddressSpaceView>>;
-using Allocator64Compact = Allocator64CompactASVT<LocalAddressSpaceView>;
-
-template <typename AddressSpaceView>
-using Allocator64VeryCompactASVT =
-    SizeClassAllocator64<AP64VeryCompact<AddressSpaceView>>;
-using Allocator64VeryCompact =
-    Allocator64VeryCompactASVT<LocalAddressSpaceView>;
-
-template <typename AddressSpaceView>
-using Allocator64DenseASVT = SizeClassAllocator64<AP64Dense<AddressSpaceView>>;
-using Allocator64Dense = Allocator64DenseASVT<LocalAddressSpaceView>;
+using Allocator64 = SizeClassAllocator64<AP64>;
+using Allocator64Dynamic = SizeClassAllocator64<AP64Dyn>;
+using Allocator64Compact = SizeClassAllocator64<AP64Compact>;
+using Allocator64VeryCompact = SizeClassAllocator64<AP64VeryCompact>;
+using Allocator64Dense = SizeClassAllocator64<AP64Dense>;
 
 #elif defined(__mips64)
 static const u64 kAddressSpaceSize = 1ULL << 40;
 #elif defined(__aarch64__)
 static const u64 kAddressSpaceSize = 1ULL << 39;
 #elif defined(__s390x__)
 static const u64 kAddressSpaceSize = 1ULL << 53;
 #elif defined(__s390__)
 static const u64 kAddressSpaceSize = 1ULL << 31;
 #else
 static const u64 kAddressSpaceSize = 1ULL << 32;
 #endif
 
 static const uptr kRegionSizeLog = FIRST_32_SECOND_64(20, 24);
 static const uptr kFlatByteMapSize = kAddressSpaceSize >> kRegionSizeLog;
 
-template <typename AddressSpaceViewTy>
 struct AP32Compact {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = kAddressSpaceSize;
   static const uptr kMetadataSize = 16;
   typedef CompactSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = ::kRegionSizeLog;
-  using AddressSpaceView = AddressSpaceViewTy;
-  using ByteMap = FlatByteMap<kFlatByteMapSize, AddressSpaceView>;
+  using ByteMap = FlatByteMap<kFlatByteMapSize>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
-template <typename AddressSpaceView>
-using Allocator32CompactASVT =
-    SizeClassAllocator32<AP32Compact<AddressSpaceView>>;
-using Allocator32Compact = Allocator32CompactASVT<LocalAddressSpaceView>;
+using Allocator32Compact = SizeClassAllocator32<AP32Compact>;
 
 template <class SizeClassMap>
 void TestSizeClassMap() {
   typedef SizeClassMap SCMap;
   SCMap::Print();
   SCMap::Validate();
 }
 
+template <typename Allocator>
+using LocalAllocator =
+    typename Allocator::template WithView<LocalAddressSpaceView>;
+
 TEST(SanitizerCommon, DefaultSizeClassMap) {
   TestSizeClassMap<DefaultSizeClassMap>();
 }
 
 TEST(SanitizerCommon, CompactSizeClassMap) {
   TestSizeClassMap<CompactSizeClassMap>();
 }
 
 TEST(SanitizerCommon, VeryCompactSizeClassMap) {
   TestSizeClassMap<VeryCompactSizeClassMap>();
 }
 
 TEST(SanitizerCommon, InternalSizeClassMap) {
   TestSizeClassMap<InternalSizeClassMap>();
 }
 
 TEST(SanitizerCommon, DenseSizeClassMap) {
   TestSizeClassMap<VeryCompactSizeClassMap>();
 }
 
 template <class Allocator>
 void TestSizeClassAllocator() {
-  Allocator *a = new Allocator;
+  auto *a = new LocalAllocator<Allocator>;
   a->Init(kReleaseToOSIntervalNever);
   SizeClassAllocatorLocalCache<Allocator> cache;
   memset(&cache, 0, sizeof(cache));
   cache.Init(0);
 
   static const uptr sizes[] = {
     1, 16,  30, 40, 100, 1000, 10000,
     50000, 60000, 100000, 120000, 300000, 500000, 1000000, 2000000
for (uptr s = 0; s < ARRAY_SIZE(sizes); s++) {
         CHECK_EQ(x, a->GetBlockBegin(x));
         CHECK_EQ(x, a->GetBlockBegin(x + size - 1));
         CHECK(a->PointerIsMine(x));
         CHECK(a->PointerIsMine(x + size - 1));
         CHECK(a->PointerIsMine(x + size / 2));
         CHECK_GE(a->GetActuallyAllocatedSize(x), size);
         uptr class_id = a->GetSizeClass(x);
         CHECK_EQ(class_id, Allocator::SizeClassMapT::ClassID(size));
-        uptr *metadata = reinterpret_cast<uptr*>(a->GetMetaData(x));
+        uptr *metadata = reinterpret_cast<uptr *>(a->GetMetaData(x));
         metadata[0] = reinterpret_cast<uptr>(x) + 1;
         metadata[1] = 0xABCD;
       }
     }
     // Deallocate all.
     for (uptr i = 0; i < allocated.size(); i++) {
       void *x = allocated[i];
-      uptr *metadata = reinterpret_cast<uptr*>(a->GetMetaData(x));
+      uptr *metadata = reinterpret_cast<uptr *>(a->GetMetaData(x));
       CHECK_EQ(metadata[0], reinterpret_cast<uptr>(x) + 1);
       CHECK_EQ(metadata[1], 0xABCD);
       cache.Deallocate(a, a->GetSizeClass(x), x);
     }
     allocated.clear();
     uptr total_allocated = a->TotalMemoryUsed();
     if (last_total_allocated == 0)
       last_total_allocated = total_allocated;

 }
 #endif
 #endif
 
 TEST(SanitizerCommon, SizeClassAllocator32Compact) {
   TestSizeClassAllocator<Allocator32Compact>();
 }
 
-template <typename AddressSpaceViewTy>
 struct AP32SeparateBatches {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = kAddressSpaceSize;
   static const uptr kMetadataSize = 16;
   typedef DefaultSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = ::kRegionSizeLog;
-  using AddressSpaceView = AddressSpaceViewTy;
-  using ByteMap = FlatByteMap<kFlatByteMapSize, AddressSpaceView>;
+  using ByteMap = FlatByteMap<kFlatByteMapSize>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags =
       SizeClassAllocator32FlagMasks::kUseSeparateSizeClassForBatch;
 };
-template <typename AddressSpaceView>
-using Allocator32SeparateBatchesASVT =
-    SizeClassAllocator32<AP32SeparateBatches<AddressSpaceView>>;
-using Allocator32SeparateBatches =
-    Allocator32SeparateBatchesASVT<LocalAddressSpaceView>;
+using Allocator32SeparateBatches = SizeClassAllocator32<AP32SeparateBatches>;
 
 TEST(SanitizerCommon, SizeClassAllocator32SeparateBatches) {
   TestSizeClassAllocator<Allocator32SeparateBatches>();
 }
 
 template <class Allocator>
 void SizeClassAllocatorMetadataStress() {
-  Allocator *a = new Allocator;
+  auto *a = new LocalAllocator<Allocator>;
   a->Init(kReleaseToOSIntervalNever);
   SizeClassAllocatorLocalCache<Allocator> cache;
   memset(&cache, 0, sizeof(cache));
   cache.Init(0);
 
   const uptr kNumAllocs = 1 << 13;
   void *allocated[kNumAllocs];
   void *meta[kNumAllocs];

 #endif
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64
 TEST(SanitizerCommon, SizeClassAllocator32CompactMetadataStress) {
   SizeClassAllocatorMetadataStress<Allocator32Compact>();
 }
 
 template <class Allocator>
 void SizeClassAllocatorGetBlockBeginStress(u64 TotalSize) {
-  Allocator *a = new Allocator;
+  auto *a = new LocalAllocator<Allocator>;
   a->Init(kReleaseToOSIntervalNever);
   SizeClassAllocatorLocalCache<Allocator> cache;
   memset(&cache, 0, sizeof(cache));
   cache.Init(0);
 
   uptr max_size_class = Allocator::SizeClassMapT::kLargestClassID;
   uptr size = Allocator::SizeClassMapT::Size(max_size_class);
   // Make sure we correctly compute GetBlockBegin() w/o overflow.

 int TestMapUnmapCallback::map_count;
 int TestMapUnmapCallback::unmap_count;
 
 #if SANITIZER_CAN_USE_ALLOCATOR64
 // These tests can fail on Windows if memory is somewhat full and lit happens
 // to run them all at the same time. FIXME: Make them not flaky and reenable.
 #if !SANITIZER_WINDOWS
 
-template <typename AddressSpaceViewTy = LocalAddressSpaceView>
 struct AP64WithCallback {
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 16;
   typedef ::SizeClassMap SizeClassMap;
   typedef TestMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
 TEST(SanitizerCommon, SizeClassAllocator64MapUnmapCallback) {
   TestMapUnmapCallback::map_count = 0;
   TestMapUnmapCallback::unmap_count = 0;
-  typedef SizeClassAllocator64<AP64WithCallback<>> Allocator64WithCallBack;
-  Allocator64WithCallBack *a = new Allocator64WithCallBack;
+  typedef SizeClassAllocator64<AP64WithCallback> Allocator64WithCallBack;
+  auto *a = new LocalAllocator<Allocator64WithCallBack>;
   a->Init(kReleaseToOSIntervalNever);
   EXPECT_EQ(TestMapUnmapCallback::map_count, 1);  // Allocator state.
   SizeClassAllocatorLocalCache<Allocator64WithCallBack> cache;
   memset(&cache, 0, sizeof(cache));
   cache.Init(0);
   AllocatorStats stats;
   stats.Init();
   const size_t kNumChunks = 128;
   uint32_t chunks[kNumChunks];
   a->GetFromAllocator(&stats, 30, chunks, kNumChunks);
   // State + alloc + metadata + freearray.
   EXPECT_EQ(TestMapUnmapCallback::map_count, 4);
   a->TestOnlyUnmap();
   EXPECT_EQ(TestMapUnmapCallback::unmap_count, 1);  // The whole thing.
   delete a;
 }
 #endif
 #endif
 
-template <typename AddressSpaceViewTy = LocalAddressSpaceView>
 struct AP32WithCallback {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = kAddressSpaceSize;
   static const uptr kMetadataSize = 16;
   typedef CompactSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = ::kRegionSizeLog;
-  using AddressSpaceView = AddressSpaceViewTy;
-  using ByteMap = FlatByteMap<kFlatByteMapSize, AddressSpaceView>;
+  using ByteMap = FlatByteMap<kFlatByteMapSize>;
   typedef TestMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
 
 TEST(SanitizerCommon, SizeClassAllocator32MapUnmapCallback) {
   TestMapUnmapCallback::map_count = 0;
   TestMapUnmapCallback::unmap_count = 0;
-  typedef SizeClassAllocator32<AP32WithCallback<>> Allocator32WithCallBack;
-  Allocator32WithCallBack *a = new Allocator32WithCallBack;
+  typedef SizeClassAllocator32<AP32WithCallback> Allocator32WithCallBack;
+  auto *a = new LocalAllocator<Allocator32WithCallBack>;
   a->Init(kReleaseToOSIntervalNever);
   EXPECT_EQ(TestMapUnmapCallback::map_count, 0);
   SizeClassAllocatorLocalCache<Allocator32WithCallBack>  cache;
   memset(&cache, 0, sizeof(cache));
   cache.Init(0);
   AllocatorStats stats;
   stats.Init();
   a->AllocateBatch(&stats, &cache, 32);
   EXPECT_EQ(TestMapUnmapCallback::map_count, 1);
   a->TestOnlyUnmap();
   EXPECT_EQ(TestMapUnmapCallback::unmap_count, 1);
   delete a;
   // fprintf(stderr, "Map: %d Unmap: %d\n",
   //         TestMapUnmapCallback::map_count,
   //         TestMapUnmapCallback::unmap_count);
 }
 
 TEST(SanitizerCommon, LargeMmapAllocatorMapUnmapCallback) {
   TestMapUnmapCallback::map_count = 0;
   TestMapUnmapCallback::unmap_count = 0;
-  LargeMmapAllocator<TestMapUnmapCallback> a;
+  LocalAllocator<LargeMmapAllocator<TestMapUnmapCallback>> a;
   a.Init();
   AllocatorStats stats;
   stats.Init();
   void *x = a.Allocate(&stats, 1 << 20, 1);
   EXPECT_EQ(TestMapUnmapCallback::map_count, 1);
   a.Deallocate(&stats, x);
   EXPECT_EQ(TestMapUnmapCallback::unmap_count, 1);
 }
 
 // Don't test OOM conditions on Win64 because it causes other tests on the same
 // machine to OOM.
 #if SANITIZER_CAN_USE_ALLOCATOR64 && !SANITIZER_WINDOWS64 && !SANITIZER_ANDROID
 TEST(SanitizerCommon, SizeClassAllocator64Overflow) {
-  Allocator64 a;
+  LocalAllocator<Allocator64> a;
   a.Init(kReleaseToOSIntervalNever);
   SizeClassAllocatorLocalCache<Allocator64> cache;
   memset(&cache, 0, sizeof(cache));
   cache.Init(0);
   AllocatorStats stats;
   stats.Init();
 
   const size_t kNumChunks = 128;
   uint32_t chunks[kNumChunks];
   bool allocation_failed = false;
   for (int i = 0; i < 1000000; i++) {
     if (!a.GetFromAllocator(&stats, 52, chunks, kNumChunks)) {
       allocation_failed = true;
       break;
     }
   }
   EXPECT_EQ(allocation_failed, true);
 
   a.TestOnlyUnmap();
 }
 #endif
 
 TEST(SanitizerCommon, LargeMmapAllocator) {
-  LargeMmapAllocator<NoOpMapUnmapCallback> a;
+  LocalAllocator<LargeMmapAllocator<NoOpMapUnmapCallback>> a;
   a.Init();
   AllocatorStats stats;
   stats.Init();
 
   static const int kNumAllocs = 1000;
   char *allocated[kNumAllocs];
   static const uptr size = 4000;
   // Allocate some.
TEST(SanitizerCommon, LargeMmapAllocator) {
   }
   // Check that non left.
   CHECK_EQ(a.TotalMemoryUsed(), 0);
 
   // Allocate some more, also add metadata.
   for (int i = 0; i < kNumAllocs; i++) {
     char *x = (char *)a.Allocate(&stats, size, 1);
     CHECK_GE(a.GetActuallyAllocatedSize(x), size);
-    uptr *meta = reinterpret_cast<uptr*>(a.GetMetaData(x));
+    uptr *meta = reinterpret_cast<uptr *>(a.GetMetaData(x));
     *meta = i;
     allocated[i] = x;
   }
   for (int i = 0; i < kNumAllocs * kNumAllocs; i++) {
     char *p = allocated[i % kNumAllocs];
     CHECK(a.PointerIsMine(p));
     CHECK(a.PointerIsMine(p + 2000));
   }
   CHECK_GT(a.TotalMemoryUsed(), size * kNumAllocs);
   // Deallocate all in reverse order.
   for (int i = 0; i < kNumAllocs; i++) {
     int idx = kNumAllocs - i - 1;
     char *p = allocated[idx];
-    uptr *meta = reinterpret_cast<uptr*>(a.GetMetaData(p));
+    uptr *meta = reinterpret_cast<uptr *>(a.GetMetaData(p));
     CHECK_EQ(*meta, idx);
     CHECK(a.PointerIsMine(p));
     a.Deallocate(&stats, p);
   }
   CHECK_EQ(a.TotalMemoryUsed(), 0);
 
   // Test alignments. Test with 512MB alignment on x64 non-Windows machines.
   // Windows doesn't overcommit, and many machines do not have 51.2GB of swap.
TEST(SanitizerCommon, LargeMmapAllocator) {
   uptr page_size = GetPageSizeCached();
   char *p = (char *)a.Allocate(&stats, page_size, 1);
   CHECK_EQ(p, a.GetBlockBegin(p));
   CHECK_EQ(p, (char *)a.GetBlockBegin(p + page_size - 1));
   CHECK_NE(p, (char *)a.GetBlockBegin(p + page_size));
   a.Deallocate(&stats, p);
 }
 
-template
-<class PrimaryAllocator, class SecondaryAllocator, class AllocatorCache>
+template <class PrimaryAllocator, class SecondaryAllocator>
 void TestCombinedAllocator() {
-  typedef
-      CombinedAllocator<PrimaryAllocator, AllocatorCache, SecondaryAllocator>
-      Allocator;
-  Allocator *a = new Allocator;
+  using AllocatorCache = SizeClassAllocatorLocalCache<PrimaryAllocator>;
+  using Allocator =
+      CombinedAllocator<PrimaryAllocator, AllocatorCache, SecondaryAllocator>;
+  auto *a = new Allocator;
   a->Init(kReleaseToOSIntervalNever);
   std::mt19937 r;
 
   AllocatorCache cache;
   memset(&cache, 0, sizeof(cache));
   a->InitCache(&cache);
 
   EXPECT_EQ(a->Allocate(&cache, -1, 1), (void*)0);
for (uptr iter = 0; iter < kNumIter; iter++) {
     a->SwallowCache(&cache);
   }
   a->DestroyCache(&cache);
   a->TestOnlyUnmap();
 }
 
 #if SANITIZER_CAN_USE_ALLOCATOR64
 TEST(SanitizerCommon, CombinedAllocator64) {
-  TestCombinedAllocator<Allocator64,
-      LargeMmapAllocator<>,
-      SizeClassAllocatorLocalCache<Allocator64> > ();
+  TestCombinedAllocator<Allocator64, LargeMmapAllocator<>>();
 }
 
 TEST(SanitizerCommon, CombinedAllocator64Dynamic) {
-  TestCombinedAllocator<Allocator64Dynamic,
-      LargeMmapAllocator<>,
-      SizeClassAllocatorLocalCache<Allocator64Dynamic> > ();
+  TestCombinedAllocator<Allocator64Dynamic, LargeMmapAllocator<>>();
 }
 
 #if !SANITIZER_ANDROID
 TEST(SanitizerCommon, CombinedAllocator64Compact) {
-  TestCombinedAllocator<Allocator64Compact,
-      LargeMmapAllocator<>,
-      SizeClassAllocatorLocalCache<Allocator64Compact> > ();
+  TestCombinedAllocator<Allocator64Compact, LargeMmapAllocator<>>();
 }
 #endif
 
 TEST(SanitizerCommon, CombinedAllocator64VeryCompact) {
-  TestCombinedAllocator<Allocator64VeryCompact,
-      LargeMmapAllocator<>,
-      SizeClassAllocatorLocalCache<Allocator64VeryCompact> > ();
+  TestCombinedAllocator<Allocator64VeryCompact, LargeMmapAllocator<>>();
 }
 #endif
 
 TEST(SanitizerCommon, CombinedAllocator32Compact) {
-  TestCombinedAllocator<Allocator32Compact,
-      LargeMmapAllocator<>,
-      SizeClassAllocatorLocalCache<Allocator32Compact> > ();
+  TestCombinedAllocator<Allocator32Compact, LargeMmapAllocator<>>();
 }
 
 template <class AllocatorCache>
 void TestSizeClassAllocatorLocalCache() {
   AllocatorCache cache;
   typedef typename AllocatorCache::Allocator Allocator;
-  Allocator *a = new Allocator();
+  auto *a = new LocalAllocator<Allocator>();
 
   a->Init(kReleaseToOSIntervalNever);
   memset(&cache, 0, sizeof(cache));
   cache.Init(0);
 
   const uptr kNumAllocs = 10000;
   const int kNumIter = 100;
   uptr saved_total = 0;
void *AllocatorLeakTestWorker(void *arg) {
   Allocator *a = (Allocator*)(arg);
   static_allocator_cache.Allocate(a, 10);
   static_allocator_cache.Drain(a);
   return 0;
 }
 
 TEST(SanitizerCommon, AllocatorLeakTest) {
   typedef AllocatorCache::Allocator Allocator;
-  Allocator a;
+  LocalAllocator<Allocator> a;
   a.Init(kReleaseToOSIntervalNever);
   uptr total_used_memory = 0;
   for (int i = 0; i < 100; i++) {
     pthread_t t;
     PTHREAD_CREATE(&t, 0, AllocatorLeakTestWorker, &a);
     PTHREAD_JOIN(t, 0);
     if (i == 0)
       total_used_memory = a.TotalMemoryUsed();
static void *DeallocNewThreadWorker(void *arg) {
   NewThreadParams *params = reinterpret_cast<NewThreadParams*>(arg);
   params->thread_cache->Deallocate(params->allocator, params->class_id, params);
   return NULL;
 }
 
 // The allocator cache is supposed to be POD and zero initialized.  We should be
 // able to call Deallocate on a zeroed cache, and it will self-initialize.
 TEST(Allocator, AllocatorCacheDeallocNewThread) {
-  AllocatorCache::Allocator allocator;
+  LocalAllocator<AllocatorCache::Allocator> allocator;
   allocator.Init(kReleaseToOSIntervalNever);
   AllocatorCache main_cache;
   AllocatorCache child_cache;
   memset(&main_cache, 0, sizeof(main_cache));
   memset(&child_cache, 0, sizeof(child_cache));
 
   uptr class_id = DefaultSizeClassMap::ClassID(sizeof(NewThreadParams));
   NewThreadParams *params = reinterpret_cast<NewThreadParams*>(

 }
 
 void IterationTestCallback(uptr chunk, void *arg) {
   reinterpret_cast<std::set<uptr> *>(arg)->insert(chunk);
 }
 
 template <class Allocator>
 void TestSizeClassAllocatorIteration() {
-  Allocator *a = new Allocator;
+  auto *a = new LocalAllocator<Allocator>;
   a->Init(kReleaseToOSIntervalNever);
   SizeClassAllocatorLocalCache<Allocator> cache;
   memset(&cache, 0, sizeof(cache));
   cache.Init(0);
 
   static const uptr sizes[] = {1, 16, 30, 40, 100, 1000, 10000,
     50000, 60000, 100000, 120000, 300000, 500000, 1000000, 2000000};
 

 #endif
 #endif
 
 TEST(SanitizerCommon, SizeClassAllocator32Iteration) {
   TestSizeClassAllocatorIteration<Allocator32Compact>();
 }
 
 TEST(SanitizerCommon, LargeMmapAllocatorIteration) {
-  LargeMmapAllocator<NoOpMapUnmapCallback> a;
+  LocalAllocator<LargeMmapAllocator<NoOpMapUnmapCallback>> a;
   a.Init();
   AllocatorStats stats;
   stats.Init();
 
   static const uptr kNumAllocs = 1000;
   char *allocated[kNumAllocs];
   static const uptr size = 40;
   // Allocate some.
for (uptr i = 0; i < kNumAllocs; i++) {
     ASSERT_NE(reported_chunks.find(reinterpret_cast<uptr>(allocated[i])),
               reported_chunks.end());
   }
   for (uptr i = 0; i < kNumAllocs; i++)
     a.Deallocate(&stats, allocated[i]);
 }
 
 TEST(SanitizerCommon, LargeMmapAllocatorBlockBegin) {
-  LargeMmapAllocator<NoOpMapUnmapCallback> a;
+  LocalAllocator<LargeMmapAllocator<NoOpMapUnmapCallback>> a;
   a.Init();
   AllocatorStats stats;
   stats.Init();
 
   static const uptr kNumAllocs = 1024;
   static const uptr kNumExpectedFalseLookups = 10000000;
   char *allocated[kNumAllocs];
   static const uptr size = 4096;
for (uptr i = 0; i < kNumAllocs; i++)
     a.Deallocate(&stats, allocated[i]);
 }
 
 
 // Don't test OOM conditions on Win64 because it causes other tests on the same
 // machine to OOM.
 #if SANITIZER_CAN_USE_ALLOCATOR64 && !SANITIZER_WINDOWS64 && !SANITIZER_ANDROID
 typedef SizeClassMap<3, 4, 8, 63, 128, 16> SpecialSizeClassMap;
-template <typename AddressSpaceViewTy = LocalAddressSpaceView>
 struct AP64_SpecialSizeClassMap {
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 0;
   typedef SpecialSizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
 // Regression test for out-of-memory condition in PopulateFreeList().
 TEST(SanitizerCommon, SizeClassAllocator64PopulateFreeListOOM) {
   // In a world where regions are small and chunks are huge...
-  typedef SizeClassAllocator64<AP64_SpecialSizeClassMap<>> SpecialAllocator64;
+  typedef SizeClassAllocator64<AP64_SpecialSizeClassMap> SpecialAllocator64;
   const uptr kRegionSize =
       kAllocatorSize / SpecialSizeClassMap::kNumClassesRounded;
-  SpecialAllocator64 *a = new SpecialAllocator64;
+  LocalAllocator<SpecialAllocator64> *a =
+      new LocalAllocator<SpecialAllocator64>;
   a->Init(kReleaseToOSIntervalNever);
   SizeClassAllocatorLocalCache<SpecialAllocator64> cache;
   memset(&cache, 0, sizeof(cache));
   cache.Init(0);
 
   // ...one man is on a mission to overflow a region with a series of
   // successive allocations.
 
if (j % 7)
       EXPECT_EQ(m[j], 0);
     else
       EXPECT_EQ(m[j], (j % 100) + 1);
   }
 
   m.TestOnlyUnmap();
 }
 
-template <typename AddressSpaceView>
-using TestByteMapASVT =
-    TwoLevelByteMap<1 << 12, 1 << 13, AddressSpaceView, TestMapUnmapCallback>;
-using TestByteMap = TestByteMapASVT<LocalAddressSpaceView>;
+using TestByteMap = TwoLevelByteMap<1 << 12, 1 << 13, TestMapUnmapCallback>;
 
 struct TestByteMapParam {
   TestByteMap *m;
   size_t shard;
   size_t num_shards;
 };
 
 void *TwoLevelByteMapUserThread(void *param) {

compiler-rt/lib/scudo/scudo_allocator.h

 struct AP64 {
   static const uptr kSpaceBeg = AllocatorSpace;
   static const uptr kSpaceSize = AllocatorSize;
   static const uptr kMetadataSize = 0;
   typedef __scudo::SizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags =
       SizeClassAllocator64FlagMasks::kRandomShuffleChunks;
-  using AddressSpaceView = LocalAddressSpaceView;
 };
 typedef SizeClassAllocator64<AP64> PrimaryT;
 #else
 static const uptr NumRegions = SANITIZER_MMAP_RANGE_SIZE >> RegionSizeLog;
 # if SANITIZER_WORDSIZE == 32
 typedef FlatByteMap<NumRegions> ByteMap;
 # elif SANITIZER_WORDSIZE == 64
 typedef TwoLevelByteMap<(NumRegions >> 12), 1 << 12> ByteMap;
 # endif  // SANITIZER_WORDSIZE
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = 0;
   typedef __scudo::SizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = RegionSizeLog;
-  using AddressSpaceView = LocalAddressSpaceView;
   using ByteMap = __scudo::ByteMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags =
       SizeClassAllocator32FlagMasks::kRandomShuffleChunks |
       SizeClassAllocator32FlagMasks::kUseSeparateSizeClassForBatch;
 };
 typedef SizeClassAllocator32<AP32> PrimaryT;
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64

compiler-rt/lib/tsan/rtl/tsan_rtl.h

 namespace __tsan {
 
 #if !SANITIZER_GO
 struct MapUnmapCallback;
 #if defined(__mips64) || defined(__aarch64__) || defined(__powerpc__)
 static const uptr kAllocatorRegionSizeLog = 20;
 static const uptr kAllocatorNumRegions =
     SANITIZER_MMAP_RANGE_SIZE >> kAllocatorRegionSizeLog;
-using ByteMap = TwoLevelByteMap<(kAllocatorNumRegions >> 12), 1 << 12,
-                                LocalAddressSpaceView, MapUnmapCallback>;
+using ByteMap =
+    TwoLevelByteMap<(kAllocatorNumRegions >> 12), 1 << 12, MapUnmapCallback>;
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = 0;
   typedef __sanitizer::CompactSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = kAllocatorRegionSizeLog;
-  using AddressSpaceView = LocalAddressSpaceView;
   using ByteMap = __tsan::ByteMap;
   typedef __tsan::MapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
 typedef SizeClassAllocator32<AP32> PrimaryAllocator;
 #else
 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kSpaceBeg = Mapping::kHeapMemBeg;
   static const uptr kSpaceSize = Mapping::kHeapMemEnd - Mapping::kHeapMemBeg;
   static const uptr kMetadataSize = 0;
   typedef DefaultSizeClassMap SizeClassMap;
   typedef __tsan::MapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = LocalAddressSpaceView;
 };
 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 #endif
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<MapUnmapCallback> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
     SecondaryAllocator> Allocator;
 Allocator *allocator();