asan/win: Disable a few tests that fail on bots with not a lot of memory.

[thakis]

Summary

This is very ad-hoc: I just disabled all tests that failed in three runs on some of our Windows bots. Is there some general pattern that matches the tests I'm disabling, and do other tests match that pattern too? Put differently: Are there other similar tests in this file I should disable?

[thakis]

add context lines

[etienneb]

I'm able to repro. This bug is happening when the memory pressure on the system is too high (not enough virtual memory).

[ RUN      ] SanitizerCommon.SizeClassAllocator64GetBlockBegin
==551160==ERROR: SanitizerTool failed to allocate 0x10000 (65536) bytes of memory at address 0xd74046000 (error code: 1455)
==551160==Dumping process modules:
        0x000076fd0000-0x0000770ef000 C:\Windows\system32\kernel32.dll
        0x0000771f0000-0x00007739a000 C:\Windows\SYSTEM32\ntdll.dll
        0x00013f930000-0x00014081e000 C:\src\llvm\ninja64\projects\compiler-rt\lib\sanitizer_common\tests\Sanitizer-x86_64-Test.exe
        0x07fef51d0000-0x07fef52f5000 C:\Windows\system32\dbghelp.dll
        0x07fefa620000-0x07fefa623000 C:\Windows\system32\api-ms-win-core-synch-l1-2-0.DLL
        0x07fefd060000-0x07fefd0ca000 C:\Windows\system32\KERNELBASE.dll
        0x07fefd330000-0x07fefd40b000 C:\Windows\system32\ADVAPI32.dll
        0x07fefdc90000-0x07fefdcaf000 C:\Windows\SYSTEM32\sechost.dll
        0x07fefe110000-0x07fefe23d000 C:\Windows\system32\RPCRT4.dll
        0x07feff330000-0x07feff3cf000 C:\Windows\system32\msvcrt.dll
==551160==Sanitizer CHECK failed: C:\src\llvm\llvm\projects\compiler-rt\lib\sanitizer_common\sanitizer_common.cc:120 ((0 && "unable to mmap")) != (0) (0, 0

To put pressure, I'm using sysinternal "testlimit64".

C:\src\SysInternals>testlimit64 -d -c 18000

Testlimit v5.24 - test Windows limits
Copyright (C) 2012-2015 Mark Russinovich
Sysinternals - www.sysinternals.com

Process ID: 623200

Leaking private bytes with touch (MB)...
Leaked 18000 MB of private memory (18000 MB total leaked). Lasterror: 0
The operation completed successfully.

[etienneb]

lib/sanitizer_common/tests/sanitizer_allocator_test.cc

578

That one will be flaky.

It's the same test than above, but with a "fixed" memory address.
So, issues with memory pressure should be the same.

[thakis]

disable a few more

[thakis]

r277882, thanks!

lib/sanitizer_common/tests/sanitizer_allocator_test.cc

for (uptr x = 0, step = kAddressSpaceSize / 100000;
     if (a->PointerIsMine(reinterpret_cast<void *>(x)))
       Ident(a->GetBlockBegin(reinterpret_cast<void *>(x)));
 
   a->TestOnlyUnmap();
   delete a;
 }
 
 #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
 TEST(SanitizerCommon, SizeClassAllocator64) {
   TestSizeClassAllocator<Allocator64>();
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64Dynamic) {
   TestSizeClassAllocator<Allocator64Dynamic>();
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64Compact) {
   TestSizeClassAllocator<Allocator64Compact>();
 }
 #endif
+#endif
 
 TEST(SanitizerCommon, SizeClassAllocator32Compact) {
   TestSizeClassAllocator<Allocator32Compact>();
 }
 
 template <class Allocator>
 void SizeClassAllocatorMetadataStress() {
   Allocator *a = new Allocator;
for (size_t i = 0; i <= G8 / size; i++) {
     EXPECT_EQ(x, beg);
   }
 
   a->TestOnlyUnmap();
   delete a;
 }
 
 #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
 TEST(SanitizerCommon, SizeClassAllocator64GetBlockBegin) {
   SizeClassAllocatorGetBlockBeginStress<Allocator64>();
 }
 TEST(SanitizerCommon, SizeClassAllocator64DynamicGetBlockBegin) {
   SizeClassAllocatorGetBlockBeginStress<Allocator64Dynamic>();
 }
 TEST(SanitizerCommon, SizeClassAllocator64CompactGetBlockBegin) {
   SizeClassAllocatorGetBlockBeginStress<Allocator64Compact>();
 }
 TEST(SanitizerCommon, SizeClassAllocator32CompactGetBlockBegin) {
   SizeClassAllocatorGetBlockBeginStress<Allocator32Compact>();
 }
+#endif
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64
 
 struct TestMapUnmapCallback {
   static int map_count, unmap_count;
   void OnMap(uptr p, uptr size) const { map_count++; }
   void OnUnmap(uptr p, uptr size) const { unmap_count++; }
 };
 int TestMapUnmapCallback::map_count;
for (int class_id = 1; class_id <= 5; class_id++) {
     }
   }
 
   a->TestOnlyUnmap();
   delete a;
 }
 
 #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
 TEST(SanitizerCommon, SizeClassAllocator64LocalCache) {
   TestSizeClassAllocatorLocalCache<
       SizeClassAllocatorLocalCache<Allocator64> >();
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64DynamicLocalCache) {
   TestSizeClassAllocatorLocalCache<
       SizeClassAllocatorLocalCache<Allocator64Dynamic> >();
 }
 
 TEST(SanitizerCommon, SizeClassAllocator64CompactLocalCache) {
   TestSizeClassAllocatorLocalCache<
       SizeClassAllocatorLocalCache<Allocator64Compact> >();
 }
 #endif
+#endif
 
 TEST(SanitizerCommon, SizeClassAllocator32CompactLocalCache) {
   TestSizeClassAllocatorLocalCache<
       SizeClassAllocatorLocalCache<Allocator32Compact> >();
 }
 
 #if SANITIZER_CAN_USE_ALLOCATOR64
 typedef SizeClassAllocatorLocalCache<Allocator64> AllocatorCache;