[scudo] Reduce the scope of AllocAfterFork

[cryptoad]

Summary

ScudoWrappersCppTest.AllocAfterFork was failing obscurely sometimes.
Someone pointed us to Linux's vm.max_map_count that can be
significantly lower on some machines than others. It turned out that
on a machine with that setting set to 65530, some ENOMEM errors
would occur with mmap & mprotect during that specific test.

Reducing the number of times we fork, and the maximum size allocated
during that test makes it pass on those machines.

[leonardchan]

LGTM unless others have stuff to bring up.

compiler-rt/lib/scudo/standalone/tests/wrappers_cpp_test.cpp

for (size_t I = 0U; I < sizeof(Threads) / sizeof(Threads[0]); I++)
     Ready = true;
     Cv.notify_all();
   }
   for (auto &T : Threads)
     T.join();
 }
 
 #if !SCUDO_FUCHSIA
-// TODO(kostyak): for me, this test fails in a specific configuration when ran
-//                by itself with some Scudo or GWP-ASan violation. Other people
-//                can't seem to reproduce the failure. Consider skipping this in
-//                the event it fails on the upstream bots.
 TEST(ScudoWrappersCppTest, AllocAfterFork) {
   std::atomic_bool Stop;
 
   // Create threads that simply allocate and free different sizes.
   std::vector<std::thread *> Threads;
   for (size_t N = 0; N < 5; N++) {
     std::thread *T = new std::thread([&Stop] {
       while (!Stop) {
-        for (size_t SizeLog = 3; SizeLog <= 21; SizeLog++) {
+        for (size_t SizeLog = 3; SizeLog <= 20; SizeLog++) {
           char *P = new char[1UL << SizeLog];
           EXPECT_NE(P, nullptr);
           // Make sure this value is not optimized away.
           asm volatile("" : : "r,m"(P) : "memory");
           delete[] P;
         }
       }
     });
     Threads.push_back(T);
   }
 
   // Create a thread to fork and allocate.
-  for (size_t N = 0; N < 100; N++) {
+  for (size_t N = 0; N < 50; N++) {
     pid_t Pid;
     if ((Pid = fork()) == 0) {
-      for (size_t SizeLog = 3; SizeLog <= 21; SizeLog++) {
+      for (size_t SizeLog = 3; SizeLog <= 20; SizeLog++) {
         char *P = new char[1UL << SizeLog];
         EXPECT_NE(P, nullptr);
         // Make sure this value is not optimized away.
         asm volatile("" : : "r,m"(P) : "memory");
         // Make sure we can touch all of the allocation.
         memset(P, 0x32, 1U << SizeLog);
         // EXPECT_LE(1U << SizeLog, malloc_usable_size(ptr));
         delete[] P;