[scudo] Correct performance regression in Secondary

[cryptoad]

Summary

This wasn't noticed: RoundUpTo doesn't produce a constant expression, so the
sizes were not constant either. Enforce them to be static const, replace
RoundUpTo by its expression. The compiler can now optimize the associated
computations accordingly.

Also looking at the produced assembly, PageSize was fetched multiple times
during Allocate, so keep a local value of it. As a result it's fetched once
and kept in a register.

[alekseyshl]

lib/scudo/scudo_allocator_secondary.h

131

Maybe use constexpr?

[cryptoad]

Replacing some const with constexpr.

lib/scudo/scudo_allocator_secondary.h

 
 #ifndef SCUDO_ALLOCATOR_H_
 # error "This file must be included inside scudo_allocator.h."
 #endif
 
 class ScudoLargeMmapAllocator {
  public:
   void Init() {
-    PageSize = GetPageSizeCached();
+    PageSizeCached = GetPageSizeCached();
   }
 
   void *Allocate(AllocatorStats *Stats, uptr Size, uptr Alignment) {
-    uptr UserSize = Size - AlignedChunkHeaderSize;
+    const uptr UserSize = Size - AlignedChunkHeaderSize;
     // The Scudo frontend prevents us from allocating more than
     // MaxAllowedMallocSize, so integer overflow checks would be superfluous.
     uptr MapSize = Size + AlignedReservedAddressRangeSize;
     if (Alignment > MinAlignment)
       MapSize += Alignment;
+    const uptr PageSize = PageSizeCached;
     MapSize = RoundUpTo(MapSize, PageSize);
     // Account for 2 guard pages, one before and one after the chunk.
     MapSize += 2 * PageSize;
 
     ReservedAddressRange AddressRange;
     uptr MapBeg = AddressRange.Init(MapSize);
     if (MapBeg == ~static_cast<uptr>(0))
       return ReturnNullOrDieOnFailure::OnOOM();
if (Alignment > MinAlignment) {
       }
       MapSize = MapEnd - MapBeg;
     }
 
     CHECK_LE(UserEnd, MapEnd - PageSize);
     // Actually mmap the memory, preserving the guard pages on either side
     CHECK_EQ(MapBeg + PageSize,
              AddressRange.Map(MapBeg + PageSize, MapSize - 2 * PageSize));
-    uptr Ptr = UserBeg - AlignedChunkHeaderSize;
+    const uptr Ptr = UserBeg - AlignedChunkHeaderSize;
     ReservedAddressRange *StoredRange = getReservedAddressRange(Ptr);
     *StoredRange = AddressRange;
 
     // The primary adds the whole class size to the stats when allocating a
     // chunk, so we will do something similar here. But we will not account for
     // the guard pages.
     {
       SpinMutexLock l(&StatsMutex);
       Stats->Add(AllocatorStatAllocated, MapSize - 2 * PageSize);
       Stats->Add(AllocatorStatMapped, MapSize - 2 * PageSize);
     }
 
     return reinterpret_cast<void *>(Ptr);
   }
 
   void Deallocate(AllocatorStats *Stats, void *Ptr) {
     // Since we're unmapping the entirety of where the ReservedAddressRange
     // actually is, copy onto the stack.
+    const uptr PageSize = PageSizeCached;
     ReservedAddressRange AddressRange = *getReservedAddressRange(Ptr);
     {
       SpinMutexLock l(&StatsMutex);
       Stats->Sub(AllocatorStatAllocated, AddressRange.size() - 2 * PageSize);
       Stats->Sub(AllocatorStatMapped, AddressRange.size() - 2 * PageSize);
     }
     AddressRange.Unmap(reinterpret_cast<uptr>(AddressRange.base()),
                        AddressRange.size());
   }
 
   uptr GetActuallyAllocatedSize(void *Ptr) {
     ReservedAddressRange *StoredRange = getReservedAddressRange(Ptr);
     // Deduct PageSize as ReservedAddressRange size includes the trailing guard
     // page.
     uptr MapEnd = reinterpret_cast<uptr>(StoredRange->base()) +
-        StoredRange->size() - PageSize;
+        StoredRange->size() - PageSizeCached;
     return MapEnd - reinterpret_cast<uptr>(Ptr);
   }
 
  private:
   ReservedAddressRange *getReservedAddressRange(uptr Ptr) {
     return reinterpret_cast<ReservedAddressRange*>(
         Ptr - sizeof(ReservedAddressRange));
   }
   ReservedAddressRange *getReservedAddressRange(const void *Ptr) {
     return getReservedAddressRange(reinterpret_cast<uptr>(Ptr));
   }
 
-  const uptr AlignedReservedAddressRangeSize =
-      RoundUpTo(sizeof(ReservedAddressRange), MinAlignment);
-  const uptr HeadersSize =
+  static const uptr AlignedReservedAddressRangeSize =
+      (sizeof(ReservedAddressRange) + MinAlignment - 1) & ~(MinAlignment - 1);
+  static const uptr HeadersSize =
       AlignedReservedAddressRangeSize + AlignedChunkHeaderSize;
 
-  uptr PageSize;
+  uptr PageSizeCached;
   SpinMutex StatsMutex;
 };
 
 #endif  // SCUDO_ALLOCATOR_SECONDARY_H_