[Sanitizer][RISCV][AArch64][Android] Adjust allocator tests

[luismarques]

Summary

On 64-bit systems with small VMAs (e.g. 39-bit) we can't use SizeClassAllocator64 parameterized with size class maps containing a large number of classes, as that will make the allocator region size too small (< 2^32). Several tests were already disabled for Android because of this.

This patch provides the correct allocator configuration for RISC-V (riscv64), generalizes the gating condition for tests that can't be enabled for small VMA systems, and tweaks the tests that can be made compatible with those systems to enable them.

I think the previous gating on Android should instead be AArch64+Android, so the patch reflects that, but feedback regarding the correct target gating is welcome.

I believe that the tests remaining gated can't be tweaked, as they specifically test allocators with incompatible size class maps (for small VMAs), so I deleted kostyak's comment to reflect that. Please let me know if I missed something there.

[vitalybuka]

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

1127

ALLOCATOR64_SMALL_SPACE ? 15 : 21

[luismarques]

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

1127

That would currently work but I don't think it's correct in general, so I think it would be misleading.
The class id here depends on the actual allocator size, which for other targets could be different from 0x2000000000ULL even if ALLOCATOR64_SMALL_SPACE == 1.
Your comment might indicate that my patch here is a bit misleading, though. I was originally going to go with a more verbose if (size X) Class2 = ... else if (size Y) Class2 = ... else abort, but it seemed verbose and it clashed with the const. Maybe I should reconsider that now.

[vitalybuka]

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

45

this name does not match how tests define kAllocatorSpace
If we rename ALLOCATOR64_SMALL_SPACE -> ALLOCATOR64_SMALL_SIZE it will be more consistent

1127

It's a test, and I would rather have logic as straightforward as possible.
I don't like that tests depends on some magical constant which can be changed.
It would be nice if select size for the platform, not calculate it indirectly.

ALLOCATOR64_SMALL_SPACE is good enough.
But renamed ALLOCATOR64_SMALL_SIZE will make it consistent.

[luismarques]

Address review feedback.

[luismarques]

Fix silly mistake in the last update.

[luismarques]

Before relanding, I need to check/fix the SizeClassAllocator64PopulateFreeListOOM test for Android x86, as the respective buildbot failed in the first landing attempt.

[luismarques]

Rebased.
Tested with the sanitizer-x86_64-linux-android and sanitizer-windows buildbots, so this time there shouldn't be buildbot failures when committing.

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

 #if SANITIZER_SOLARIS && defined(__sparcv9)
 // FIXME: These tests probably fail because Solaris/sparcv9 uses the full
 // 64-bit address space.  Needs more investigation
 #define SKIP_ON_SOLARIS_SPARCV9(x) DISABLED_##x
 #else
 #define SKIP_ON_SOLARIS_SPARCV9(x) x
 #endif
 
+// On 64-bit systems with small virtual address spaces (e.g. 39-bit) we can't
+// use size class maps with a large number of classes, as that will make the
+// SizeClassAllocator64 region size too small (< 2^32).
+#if SANITIZER_ANDROID && defined(__aarch64__)
+#define ALLOCATOR64_SMALL_SIZE 1
+#elif SANITIZER_RISCV64
+#define ALLOCATOR64_SMALL_SIZE 1
+#else
+#define ALLOCATOR64_SMALL_SIZE 0
+#endif
+
 // Too slow for debug build
 #if !SANITIZER_DEBUG
 
 #if SANITIZER_CAN_USE_ALLOCATOR64
 #if SANITIZER_WINDOWS
 // On Windows 64-bit there is no easy way to find a large enough fixed address
 // space that is always available. Thus, a dynamically allocated address space
 // is used instead (i.e. ~(uptr)0).
 static const uptr kAllocatorSpace = ~(uptr)0;
 static const uptr kAllocatorSize  =  0x8000000000ULL;  // 500G
 static const u64 kAddressSpaceSize = 1ULL << 47;
 typedef DefaultSizeClassMap SizeClassMap;
 #elif SANITIZER_ANDROID && defined(__aarch64__)
 static const uptr kAllocatorSpace = 0x3000000000ULL;
 static const uptr kAllocatorSize  = 0x2000000000ULL;
 static const u64 kAddressSpaceSize = 1ULL << 39;
 typedef VeryCompactSizeClassMap SizeClassMap;
+#elif SANITIZER_RISCV64
+const uptr kAllocatorSpace = ~(uptr)0;
+const uptr kAllocatorSize = 0x2000000000ULL;  // 128G.
+static const u64 kAddressSpaceSize = 1ULL << 38;
+typedef VeryDenseSizeClassMap 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>

 TEST(SanitizerCommon, SizeClassAllocator64) {
   TestSizeClassAllocator<Allocator64>();
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64Dynamic) {
   TestSizeClassAllocator<Allocator64Dynamic>();
 }
 
-#if !SANITIZER_ANDROID
+#if !ALLOCATOR64_SMALL_SIZE
 // Android only has 39-bit address space, so mapping 2 * kAllocatorSize
 // sometimes fails.
 TEST(SanitizerCommon, SizeClassAllocator64DynamicPremapped) {
   ScopedPremappedHeap h;
   TestSizeClassAllocator<Allocator64Dynamic>(h.Addr());
 }
 
-//FIXME(kostyak): find values so that those work on Android as well.
 TEST(SanitizerCommon, SizeClassAllocator64Compact) {
   TestSizeClassAllocator<Allocator64Compact>();
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64Dense) {
   TestSizeClassAllocator<Allocator64Dense>();
 }
 #endif

 TEST(SanitizerCommon, SizeClassAllocator64MetadataStress) {
   SizeClassAllocatorMetadataStress<Allocator64>();
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64DynamicMetadataStress) {
   SizeClassAllocatorMetadataStress<Allocator64Dynamic>();
 }
 
-#if !SANITIZER_ANDROID
+#if !ALLOCATOR64_SMALL_SIZE
 TEST(SanitizerCommon, SizeClassAllocator64DynamicPremappedMetadataStress) {
   ScopedPremappedHeap h;
   SizeClassAllocatorMetadataStress<Allocator64Dynamic>(h.Addr());
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64CompactMetadataStress) {
   SizeClassAllocatorMetadataStress<Allocator64Compact>();
 }

 TEST(SanitizerCommon, SizeClassAllocator64GetBlockBegin) {
   SizeClassAllocatorGetBlockBeginStress<Allocator64>(
       1ULL << (SANITIZER_ANDROID ? 31 : 33));
 }
 TEST(SanitizerCommon, SizeClassAllocator64DynamicGetBlockBegin) {
   SizeClassAllocatorGetBlockBeginStress<Allocator64Dynamic>(
       1ULL << (SANITIZER_ANDROID ? 31 : 33));
 }
-#if !SANITIZER_ANDROID
+#if !ALLOCATOR64_SMALL_SIZE
 TEST(SanitizerCommon, SizeClassAllocator64DynamicPremappedGetBlockBegin) {
   ScopedPremappedHeap h;
   SizeClassAllocatorGetBlockBeginStress<Allocator64Dynamic>(
       1ULL << (SANITIZER_ANDROID ? 31 : 33), h.Addr());
 }
 TEST(SanitizerCommon, SizeClassAllocator64CompactGetBlockBegin) {
   SizeClassAllocatorGetBlockBeginStress<Allocator64Compact>(1ULL << 33);
 }
TEST(SanitizerCommon, LargeMmapAllocatorMapUnmapCallback) {
   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
+#if SANITIZER_CAN_USE_ALLOCATOR64 && !SANITIZER_WINDOWS64
 TEST(SanitizerCommon, SizeClassAllocator64Overflow) {
   Allocator64 a;
   a.Init(kReleaseToOSIntervalNever);
   Allocator64::AllocatorCache 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)) {
+    uptr class_id = a.kNumClasses - 1;
+    if (!a.GetFromAllocator(&stats, class_id, chunks, kNumChunks)) {
       allocation_failed = true;
       break;
     }
   }
   EXPECT_EQ(allocation_failed, true);
 
   a.TestOnlyUnmap();
 }

 TEST(SanitizerCommon, CombinedAllocator64) {
   TestCombinedAllocator<Allocator64>();
 }
 
 TEST(SanitizerCommon, CombinedAllocator64Dynamic) {
   TestCombinedAllocator<Allocator64Dynamic>();
 }
 
-#if !SANITIZER_ANDROID
+#if !ALLOCATOR64_SMALL_SIZE
 #if !SANITIZER_WINDOWS
 // Windows fails to map 1TB, so disable this test.
 TEST(SanitizerCommon, CombinedAllocator64DynamicPremapped) {
   ScopedPremappedHeap h;
   TestCombinedAllocator<Allocator64Dynamic>(h.Addr());
 }
 #endif
 

 TEST(SanitizerCommon, SizeClassAllocator64LocalCache) {
   TestSizeClassAllocatorLocalCache<Allocator64>();
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64DynamicLocalCache) {
   TestSizeClassAllocatorLocalCache<Allocator64Dynamic>();
 }
 
-#if !SANITIZER_ANDROID
+#if !ALLOCATOR64_SMALL_SIZE
 TEST(SanitizerCommon, SizeClassAllocator64DynamicPremappedLocalCache) {
   ScopedPremappedHeap h;
   TestSizeClassAllocatorLocalCache<Allocator64Dynamic>(h.Addr());
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64CompactLocalCache) {
   TestSizeClassAllocatorLocalCache<Allocator64Compact>();
 }

 // to run them all at the same time. FIXME: Make them not flaky and reenable.
 #if !SANITIZER_WINDOWS
 TEST(SanitizerCommon, SizeClassAllocator64Iteration) {
   TestSizeClassAllocatorIteration<Allocator64>();
 }
 TEST(SanitizerCommon, SizeClassAllocator64DynamicIteration) {
   TestSizeClassAllocatorIteration<Allocator64Dynamic>();
 }
-#if !SANITIZER_ANDROID
+#if !ALLOCATOR64_SMALL_SIZE
 TEST(SanitizerCommon, SizeClassAllocator64DynamicPremappedIteration) {
   ScopedPremappedHeap h;
   TestSizeClassAllocatorIteration<Allocator64Dynamic>(h.Addr());
 }
 #endif
 #endif
 #endif
 
TEST(SanitizerCommon, LargeMmapAllocatorBlockBegin) {
 
   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 __sanitizer::SizeClassMap<3, 4, 8, 38, 128, 16> SpecialSizeClassMap;
+#if SANITIZER_CAN_USE_ALLOCATOR64 && !SANITIZER_WINDOWS64
+typedef __sanitizer::SizeClassMap<2, 22, 22, 34, 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;
TEST(SanitizerCommon, SizeClassAllocator64PopulateFreeListOOM) {
   a->Init(kReleaseToOSIntervalNever);
   SpecialAllocator64::AllocatorCache 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.
 
-  const uptr kClassID = 107;
+  const uptr kClassID = ALLOCATOR64_SMALL_SIZE ? 18 : 24;
   const uptr kAllocationSize = SpecialSizeClassMap::Size(kClassID);
   ASSERT_LT(2 * kAllocationSize, kRegionSize);
   ASSERT_GT(3 * kAllocationSize, kRegionSize);
   EXPECT_NE(cache.Allocate(a, kClassID), nullptr);
   EXPECT_NE(cache.Allocate(a, kClassID), nullptr);
   EXPECT_EQ(cache.Allocate(a, kClassID), nullptr);
 
-  const uptr Class2 = 100;
+  const uptr Class2 = ALLOCATOR64_SMALL_SIZE ? 15 : 21;
   const uptr Size2 = SpecialSizeClassMap::Size(Class2);
   ASSERT_EQ(Size2 * 8, kRegionSize);
   char *p[7];
   for (int i = 0; i < 7; i++) {
     p[i] = (char*)cache.Allocate(a, Class2);
     EXPECT_NE(p[i], nullptr);
     fprintf(stderr, "p[%d] %p s = %lx\n", i, (void*)p[i], Size2);
     p[i][Size2 - 1] = 42;
for (uptr class_id = 1; class_id <= Allocator::SizeClassMapT::kLargestClassID;
     ASSERT_EQ(memory_mapper.reported_pages.size(), verified_released_pages);
   }
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64ReleaseFreeMemoryToOS) {
   TestReleaseFreeMemoryToOS<Allocator64>();
 }
 
-#if !SANITIZER_ANDROID
+#if !ALLOCATOR64_SMALL_SIZE
 TEST(SanitizerCommon, SizeClassAllocator64CompactReleaseFreeMemoryToOS) {
   TestReleaseFreeMemoryToOS<Allocator64Compact>();
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64VeryCompactReleaseFreeMemoryToOS) {
   TestReleaseFreeMemoryToOS<Allocator64VeryCompact>();
 }
-#endif  // !SANITIZER_ANDROID
+#endif  // !ALLOCATOR64_SMALL_SIZE
 
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64
 
 TEST(SanitizerCommon, TwoLevelByteMap) {
   const u64 kSize1 = 1 << 6, kSize2 = 1 << 12;
   const u64 n = kSize1 * kSize2;
   TwoLevelByteMap<kSize1, kSize2> m;
   m.Init();