Use u16 to store Count/MaxCount

[Chia-hungDuan]

Summary

The Count/MaxCount used in TransferBatch and PerClass can be fit in u16 in
current configurations and it's also reasonable to have a u16 limit. The
spare 16 bits will be used for additional status like pages mapping
status in a TransferBatch.

[cryptoad]

While this is true, making the Counts smaller can have structure alignement consequences.
You probably want to make sure that TransferBatch, FreeBatch, PreClass etc all look fine (size multiple of sizeof(uptr) etc). If not the case, you would have to pad.
Other things to keep in consideration: u32 vs u16 in getMaxCachedHint, TransferBatch::get and others (static_cast<u32> might be a giveaway of some integer size inconsitency).
If all works out, that might mean that the SizeClassConfig will have to be adapted to best fit the new sizes.

[cryptoad]

compiler-rt/lib/scudo/standalone/local_cache.h

38–39

I should probably be a u16 as well for consitency, and this might mean propagating it to the callers as well

131–132

PerClass might not be properly aligned anymore on 64-bit archs?

compiler-rt/lib/scudo/standalone/size_class_map.h

38

N is a u32 vs the result that is a u16.
Can the expression be slimplified with less static casting?

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

138–139

Probably u16?

139–140

Same

[Chia-hungDuan]

Address review comments

[Chia-hungDuan]

compiler-rt/lib/scudo/standalone/local_cache.h

131–132

I added an alignas(SCUDO_CACHE_LINE_SIZE) here. I may want to reorder the fields to make the one with higher alignment requirements come first. Will do that in the later CL if that's a good idea.

compiler-rt/lib/scudo/standalone/size_class_map.h

38

The inner cast is replaced by explicit template argument

[Chia-hungDuan]

Fix type truncation error

[cferris]

Only some small comment nits.

compiler-rt/lib/scudo/standalone/primary32.h

385

Small nit, should be result will also fit in u16.

compiler-rt/lib/scudo/standalone/primary64.h

395

Same as above "will also fit".

compiler-rt/lib/scudo/standalone/size_class_map.h

35

Might be better worded as "guaranteed to fit"

36

Is this supposed to be aware?

I don't quite understand the comment, maybe it needs to be reworded slightly.

[Chia-hungDuan]

Address review comments

compiler-rt/lib/scudo/standalone/size_class_map.h

36

Right, it should be "aware". Because the result of Max() is u32. Without the static_cast, it'll be an implicit truncation. I wanted to emphasize that "we know the truncation will happen" by using explicit casting. I think the previous sentence is enough. Removed the later one.

[cferris]

LGTM

Any other reviewers, please take a quick look to make everything looks okay. If you feel that you might not understand all of the deeper changes, we'd still appreciate a higher level review to make sure there are no obvious errors.

[Chia-hungDuan]

Rebase only

[dyung]

@Chia-hungDuan, your change is causing a build failure on our internal bots that run older versions of gcc, specifically 7.5.0 and 9.4.0. It fails with the following error:

/home/dyung/src/upstream/llvm_clean_git/compiler-rt/lib/scudo/standalone/local_cache.h:190:14: error: conversion from ‘int’ to ‘scudo::u16’ {aka ‘short unsigned int’} may change value [-Werror=conversion]                                        
  190 |     C->Count -= Count;                                                                                                                                                                                                                      
      |     ~~~~~~~~~^~~~~~~~
/home/dyung/src/upstream/llvm_clean_git/compiler-rt/lib/scudo/standalone/local_cache.h:154:23: error: conversion from ‘int’ to ‘scudo::u16’ {aka ‘short unsigned int’} may change value [-Werror=conversion]                                        
  154 |       P->MaxCount = 2 * TransferBatch::getMaxCached(Size);                                                                                                                                                                                  
      |                     ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Can you take a look and revert if it will take you a while to fix?

[Chia-hungDuan]

In D133145#3857730, @dyung wrote:

@Chia-hungDuan, your change is causing a build failure on our internal bots that run older versions of gcc, specifically 7.5.0 and 9.4.0. It fails with the following error:

/home/dyung/src/upstream/llvm_clean_git/compiler-rt/lib/scudo/standalone/local_cache.h:190:14: error: conversion from ‘int’ to ‘scudo::u16’ {aka ‘short unsigned int’} may change value [-Werror=conversion]                                        
  190 |     C->Count -= Count;                                                                                                                                                                                                                      
      |     ~~~~~~~~~^~~~~~~~

This looks weird to me. Both of them are u16 already. Can you check why it thinks C-Count is int?

/home/dyung/src/upstream/llvm_clean_git/compiler-rt/lib/scudo/standalone/local_cache.h:154:23: error: conversion from ‘int’ to ‘scudo::u16’ {aka ‘short unsigned int’} may change value [-Werror=conversion]

154 |       P->MaxCount = 2 * TransferBatch::getMaxCached(Size);                                                                                                                                                                                  
    |                     ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

https://reviews.llvm.org/D135945. I think this will resolve the warning.

Can you take a look and revert if it will take you a while to fix?

[dyung]

There are also two additional failures for this reason that I think were introduced in follow-up commits:

/home/siadmin/jenkins/w/opensource/opensource_build/working_dir/compiler-rt/lib/scudo/standalone/primary64.h:445:49: error: conversion to 'scudo::u16 {aka short unsigned int}' from 'int' may alter its value [-Werror=conversion]
         u16 UnusedSlots = BG->MaxCachedPerBatch - CurBatch->getCount();

/home/siadmin/jenkins/w/opensource/opensource_build/working_dir/compiler-rt/lib/scudo/standalone/local_cache.h:34:13: error: conversion to 'scudo::u16 {aka short unsigned int}' from 'int' may alter its value [-Werror=conversion]
       Count += N;
       ~~~~~~^~~~

In D133145#3857812, @Chia-hungDuan wrote:

In D133145#3857730, @dyung wrote:

@Chia-hungDuan, your change is causing a build failure on our internal bots that run older versions of gcc, specifically 7.5.0 and 9.4.0. It fails with the following error:

/home/dyung/src/upstream/llvm_clean_git/compiler-rt/lib/scudo/standalone/local_cache.h:190:14: error: conversion from ‘int’ to ‘scudo::u16’ {aka ‘short unsigned int’} may change value [-Werror=conversion]                                        
  190 |     C->Count -= Count;                                                                                                                                                                                                                      
      |     ~~~~~~~~~^~~~~~~~

This looks weird to me. Both of them are u16 already. Can you check why it thinks C-Count is int?

This is odd, I'm trying to figure out why this is a problem. If I had to guess, since scudo::u16 is a custom type, maybe C++ is generating a conversion implicitly for the arithmetic operators?

[ronlieb]

we are seeing the same issue compiling compiler-rt with these patches in trunk, are the various buildbots catching this also?
for awareness: @saiislam

[n-omer]

In D133145#3858231, @ronlieb wrote:

we are seeing the same issue compiling compiler-rt with these patches in trunk, are the various buildbots catching this also?
for awareness: @saiislam

Don't think any of the buildbots are catching this.

[n-omer]

In D133145#3857812, @Chia-hungDuan wrote:

In D133145#3857730, @dyung wrote:

@Chia-hungDuan, your change is causing a build failure on our internal bots that run older versions of gcc, specifically 7.5.0 and 9.4.0. It fails with the following error:

/home/dyung/src/upstream/llvm_clean_git/compiler-rt/lib/scudo/standalone/local_cache.h:190:14: error: conversion from ‘int’ to ‘scudo::u16’ {aka ‘short unsigned int’} may change value [-Werror=conversion]                                        
  190 |     C->Count -= Count;                                                                                                                                                                                                                      
      |     ~~~~~~~~~^~~~~~~~

This looks weird to me. Both of them are u16 already. Can you check why it thinks C-Count is int?

/home/dyung/src/upstream/llvm_clean_git/compiler-rt/lib/scudo/standalone/local_cache.h:154:23: error: conversion from ‘int’ to ‘scudo::u16’ {aka ‘short unsigned int’} may change value [-Werror=conversion]

154 |       P->MaxCount = 2 * TransferBatch::getMaxCached(Size);                                                                                                                                                                                  
    |                     ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

https://reviews.llvm.org/D135945. I think this will resolve the warning.

Can you take a look and revert if it will take you a while to fix?

Hi @Chia-hungDuan, The patch breaks the build on a supported compiler and two people have now noticed it, so we're thinking of reverting it because has been broken for 16 hours. Can you please confirm if you're actively looking at it?

[Chia-hungDuan]

In D133145#3858495, @n-omer wrote:

In D133145#3857812, @Chia-hungDuan wrote:

In D133145#3857730, @dyung wrote:

@Chia-hungDuan, your change is causing a build failure on our internal bots that run older versions of gcc, specifically 7.5.0 and 9.4.0. It fails with the following error:

/home/dyung/src/upstream/llvm_clean_git/compiler-rt/lib/scudo/standalone/local_cache.h:190:14: error: conversion from ‘int’ to ‘scudo::u16’ {aka ‘short unsigned int’} may change value [-Werror=conversion]                                        
  190 |     C->Count -= Count;                                                                                                                                                                                                                      
      |     ~~~~~~~~~^~~~~~~~

This looks weird to me. Both of them are u16 already. Can you check why it thinks C-Count is int?

/home/dyung/src/upstream/llvm_clean_git/compiler-rt/lib/scudo/standalone/local_cache.h:154:23: error: conversion from ‘int’ to ‘scudo::u16’ {aka ‘short unsigned int’} may change value [-Werror=conversion]

154 |       P->MaxCount = 2 * TransferBatch::getMaxCached(Size);                                                                                                                                                                                  
    |                     ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

https://reviews.llvm.org/D135945. I think this will resolve the warning.

Can you take a look and revert if it will take you a while to fix?

Hi @Chia-hungDuan, The patch breaks the build on a supported compiler and two people have now noticed it, so we're thinking of reverting it because has been broken for 16 hours. Can you please confirm if you're actively looking at it?

I'm looking at this issue and the PPC bots issue now. I'll revert them if there's no easy fix for this.

[Chia-hungDuan]

https://reviews.llvm.org/D135945 is supposed to fix the warning. @ronlieb, @n-omer, could you help on verifying this? Thanks

compiler-rt/lib/scudo/standalone/local_cache.h

 //===-- local_cache.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_LOCAL_CACHE_H_
 #define SCUDO_LOCAL_CACHE_H_
 
 #include "internal_defs.h"
+#include "platform.h"
 #include "report.h"
 #include "stats.h"
 
 namespace scudo {
 
 template <class SizeClassAllocator> struct SizeClassAllocatorLocalCache {
   typedef typename SizeClassAllocator::SizeClassMap SizeClassMap;
   typedef typename SizeClassAllocator::CompactPtrT CompactPtrT;
 
   struct TransferBatch {
-    static const u32 MaxNumCached = SizeClassMap::MaxNumCachedHint;
-    void setFromArray(CompactPtrT *Array, u32 N) {
+    static const u16 MaxNumCached = SizeClassMap::MaxNumCachedHint;
+    void setFromArray(CompactPtrT *Array, u16 N) {
       DCHECK_LE(N, MaxNumCached);
       Count = N;
       memcpy(Batch, Array, sizeof(Batch[0]) * Count);
     }
     void clear() { Count = 0; }
     void add(CompactPtrT P) {
       DCHECK_LT(Count, MaxNumCached);
       Batch[Count++] = P;
     }
     void copyToArray(CompactPtrT *Array) const {
       memcpy(Array, Batch, sizeof(Batch[0]) * Count);
     }
-    u32 getCount() const { return Count; }
-    CompactPtrT get(u32 I) const {
+    u16 getCount() const { return Count; }
+    CompactPtrT get(u16 I) const {
       DCHECK_LE(I, Count);
       return Batch[I];
     }
-    static u32 getMaxCached(uptr Size) {
+    static u16 getMaxCached(uptr Size) {
       return Min(MaxNumCached, SizeClassMap::getMaxCachedHint(Size));
     }
     TransferBatch *Next;
 
   private:
-    u32 Count;
     CompactPtrT Batch[MaxNumCached];
+    u16 Count;
   };
 
   void init(GlobalStats *S, SizeClassAllocator *A) {
     DCHECK(isEmpty());
     Stats.init();
     if (LIKELY(S))
       S->link(&Stats);
     Allocator = A;
if (ClassId != BatchClassId)
       B = allocate(BatchClassId);
     return reinterpret_cast<TransferBatch *>(B);
   }
 
   LocalStats &getStats() { return Stats; }
 
 private:
   static const uptr NumClasses = SizeClassMap::NumClasses;
   static const uptr BatchClassId = SizeClassMap::BatchClassId;
-  struct PerClass {
-    u32 Count;
-    u32 MaxCount;
+  struct alignas(SCUDO_CACHE_LINE_SIZE) PerClass {
+    u16 Count;
+    u16 MaxCount;
     // Note: ClassSize is zero for the transfer batch.
     uptr ClassSize;
     CompactPtrT Chunks[2 * TransferBatch::MaxNumCached];
   };
   PerClass PerClassArray[NumClasses] = {};
   LocalStats Stats;
   SizeClassAllocator *Allocator = nullptr;
 
NOINLINE bool refill(PerClass *C, uptr ClassId) {
     C->Count = B->getCount();
     B->copyToArray(C->Chunks);
     B->clear();
     destroyBatch(ClassId, B);
     return true;
   }
 
   NOINLINE void drain(PerClass *C, uptr ClassId) {
-    const u32 Count = Min(C->MaxCount / 2, C->Count);
+    const u16 Count = Min(static_cast<u16>(C->MaxCount / 2), C->Count);
     TransferBatch *B =
         createBatch(ClassId, Allocator->decompactPtr(ClassId, C->Chunks[0]));
     if (UNLIKELY(!B))
       reportOutOfMemory(SizeClassAllocator::getSizeByClassId(BatchClassId));
     B->setFromArray(&C->Chunks[0], Count);
     C->Count -= Count;
     for (uptr I = 0; I < C->Count; I++)
       C->Chunks[I] = C->Chunks[I + Count];
     Allocator->pushBatch(ClassId, B);
   }
 };
 
 } // namespace scudo
 
 #endif // SCUDO_LOCAL_CACHE_H_

compiler-rt/lib/scudo/standalone/primary32.h

if (Sci->CurrentRegion) {
       if (UNLIKELY(!Region))
         return nullptr;
       C->getStats().add(StatMapped, RegionSize);
       Sci->CurrentRegion = Region;
       Offset = 0;
     }
 
     const uptr Size = getSizeByClassId(ClassId);
-    const u32 MaxCount = TransferBatch::getMaxCached(Size);
+    const u16 MaxCount = TransferBatch::getMaxCached(Size);
     DCHECK_GT(MaxCount, 0U);
     // The maximum number of blocks we should carve in the region is dictated
     // by the maximum number of batches we want to fill, and the amount of
     // memory left in the current region (we use the lowest of the two). This
     // will not be 0 as we ensure that a region can at least hold one block (via
     // static_assert and at the end of this function).
     const u32 NumberOfBlocks =
         Min(MaxNumBatches * MaxCount,
NOINLINE TransferBatch *populateFreeList(CacheT *C, uptr ClassId,
     // No need to shuffle the batches size class.
     if (ClassId != SizeClassMap::BatchClassId)
       shuffle(ShuffleArray, NumberOfBlocks, &Sci->RandState);
     for (u32 I = 0; I < NumberOfBlocks;) {
       TransferBatch *B =
           C->createBatch(ClassId, reinterpret_cast<void *>(ShuffleArray[I]));
       if (UNLIKELY(!B))
         return nullptr;
-      const u32 N = Min(MaxCount, NumberOfBlocks - I);
+      // `MaxCount` is u16 so the result will be also fit in u16.
+      const u16 N = static_cast<u16>(Min<u32>(MaxCount, NumberOfBlocks - I));
       B->setFromArray(&ShuffleArray[I], N);
       Sci->FreeList.push_back(B);
       I += N;
     }
     TransferBatch *B = Sci->FreeList.front();
     Sci->FreeList.pop_front();
     DCHECK(B);
     DCHECK_GT(B->getCount(), 0);

compiler-rt/lib/scudo/standalone/primary64.h

private:
 
   static uptr decompactPtrInternal(uptr Base, CompactPtrT CompactPtr) {
     return Base + (static_cast<uptr>(CompactPtr) << CompactPtrScale);
   }
 
   NOINLINE TransferBatch *populateFreeList(CacheT *C, uptr ClassId,
                                            RegionInfo *Region) {
     const uptr Size = getSizeByClassId(ClassId);
-    const u32 MaxCount = TransferBatch::getMaxCached(Size);
+    const u16 MaxCount = TransferBatch::getMaxCached(Size);
 
     const uptr RegionBeg = Region->RegionBeg;
     const uptr MappedUser = Region->MappedUser;
     const uptr TotalUserBytes = Region->AllocatedUser + MaxCount * Size;
     // Map more space for blocks, if necessary.
     if (TotalUserBytes > MappedUser) {
       // Do the mmap for the user memory.
       const uptr MapSize =
NOINLINE TransferBatch *populateFreeList(CacheT *C, uptr ClassId,
     if (ClassId != SizeClassMap::BatchClassId)
       shuffle(ShuffleArray, NumberOfBlocks, &Region->RandState);
     for (u32 I = 0; I < NumberOfBlocks;) {
       TransferBatch *B =
           C->createBatch(ClassId, reinterpret_cast<void *>(decompactPtrInternal(
                                       CompactPtrBase, ShuffleArray[I])));
       if (UNLIKELY(!B))
         return nullptr;
-      const u32 N = Min(MaxCount, NumberOfBlocks - I);
+      // `MaxCount` is u16 so the result will be also fit in u16.
+      const u16 N = static_cast<u16>(Min<u32>(MaxCount, NumberOfBlocks - I));
       B->setFromArray(&ShuffleArray[I], N);
       Region->FreeList.push_back(B);
       I += N;
     }
     TransferBatch *B = Region->FreeList.front();
     Region->FreeList.pop_front();
     DCHECK(B);
     DCHECK_GT(B->getCount(), 0);

compiler-rt/lib/scudo/standalone/release.h

releaseFreeMemoryToOS(const IntrusiveList<TransferBatchT> &FreeList,
   const uptr RoundedRegionSize = PagesCount << PageSizeLog;
   const uptr RoundedSize = NumberOfRegions * RoundedRegionSize;
 
   // Iterate over free chunks and count how many free chunks affect each
   // allocated page.
   if (BlockSize <= PageSize && PageSize % BlockSize == 0) {
     // Each chunk affects one page only.
     for (const auto &It : FreeList) {
-      for (u32 I = 0; I < It.getCount(); I++) {
+      for (u16 I = 0; I < It.getCount(); I++) {
         const uptr P = DecompactPtr(It.get(I)) - Recorder->getBase();
         if (P >= RoundedSize)
           continue;
         const uptr RegionIndex = NumberOfRegions == 1U ? 0 : P / RegionSize;
         const uptr PInRegion = P - RegionIndex * RegionSize;
         Counters.inc(RegionIndex, PInRegion >> PageSizeLog);
       }
     }
   } else {
     // In all other cases chunks might affect more than one page.
     DCHECK_GE(RegionSize, BlockSize);
     const uptr LastBlockInRegion = ((RegionSize / BlockSize) - 1U) * BlockSize;
     for (const auto &It : FreeList) {
-      for (u32 I = 0; I < It.getCount(); I++) {
+      for (u16 I = 0; I < It.getCount(); I++) {
         const uptr P = DecompactPtr(It.get(I)) - Recorder->getBase();
         if (P >= RoundedSize)
           continue;
         const uptr RegionIndex = NumberOfRegions == 1U ? 0 : P / RegionSize;
         uptr PInRegion = P - RegionIndex * RegionSize;
         Counters.incRange(RegionIndex, PInRegion >> PageSizeLog,
                           (PInRegion + BlockSize - 1) >> PageSizeLog);
         // The last block in a region might straddle a page, so if it's

compiler-rt/lib/scudo/standalone/size_class_map.h

 inline uptr scaledLog2(uptr Size, uptr ZeroLog, uptr LogBits) {
   const uptr L = getMostSignificantSetBitIndex(Size);
   const uptr LBits = (Size >> (L - LogBits)) - (1 << LogBits);
   const uptr HBits = (L - ZeroLog) << LogBits;
   return LBits + HBits;
 }
 
 template <typename Config> struct SizeClassMapBase {
-  static u32 getMaxCachedHint(uptr Size) {
+  static u16 getMaxCachedHint(uptr Size) {
     DCHECK_NE(Size, 0);
     u32 N;
     // Force a 32-bit division if the template parameters allow for it.
     if (Config::MaxBytesCachedLog > 31 || Config::MaxSizeLog > 31)
       N = static_cast<u32>((1UL << Config::MaxBytesCachedLog) / Size);
     else
       N = (1U << Config::MaxBytesCachedLog) / static_cast<u32>(Size);
-    return Max(1U, Min(Config::MaxNumCachedHint, N));
+
+    // Note that Config::MaxNumCachedHint is u16 so the result is ensured to be
+    // fit in u16. The explicit casting is to denote the truncation is awared.
+    return static_cast<u16>(Max(1U, Min<u32>(Config::MaxNumCachedHint, N)));
   }
 };
 
 // SizeClassMap maps allocation sizes into size classes and back, in an
 // efficient table-free manner.
 //
 // Class 0 is a special class that doesn't abide by the same rules as other
 // classes. The allocator uses it to hold batches.
 //
class FixedSizeClassMap : public SizeClassMapBase<Config> {
 
   static const uptr MinSize = 1UL << Config::MinSizeLog;
   static const uptr MidSize = 1UL << Config::MidSizeLog;
   static const uptr MidClass = MidSize / MinSize;
   static const u8 S = Config::NumBits - 1;
   static const uptr M = (1UL << S) - 1;
 
 public:
-  static const u32 MaxNumCachedHint = Config::MaxNumCachedHint;
+  static const u16 MaxNumCachedHint = Config::MaxNumCachedHint;
 
   static const uptr MaxSize = (1UL << Config::MaxSizeLog) + Config::SizeDelta;
   static const uptr NumClasses =
       MidClass + ((Config::MaxSizeLog - Config::MidSizeLog) << S) + 1;
   static_assert(NumClasses <= 256, "");
   static const uptr LargestClassId = NumClasses - 1;
   static const uptr BatchClassId = 0;
 
if (Size <= Config::SizeDelta + (1 << Config::MinSizeLog))
       return 1;
     Size -= Config::SizeDelta;
     DCHECK_LE(Size, MaxSize);
     if (Size <= MidSize)
       return (Size + MinSize - 1) >> Config::MinSizeLog;
     return MidClass + 1 + scaledLog2(Size - 1, Config::MidSizeLog, S);
   }
 
-  static u32 getMaxCachedHint(uptr Size) {
+  static u16 getMaxCachedHint(uptr Size) {
     DCHECK_LE(Size, MaxSize);
     return Base::getMaxCachedHint(Size);
   }
 };
 
 template <typename Config>
 class TableSizeClassMap : public SizeClassMapBase<Config> {
   typedef SizeClassMapBase<Config> Base;
struct LSBTable {
     bool UseCompressedFormat = false;
     u8 CompressedMin = 0;
     u64 CompressedValue = 0;
   };
 
   static constexpr LSBTable LTable = {};
 
 public:
-  static const u32 MaxNumCachedHint = Config::MaxNumCachedHint;
+  static const u16 MaxNumCachedHint = Config::MaxNumCachedHint;
 
   static const uptr NumClasses = ClassesSize + 1;
   static_assert(NumClasses < 256, "");
   static const uptr LargestClassId = NumClasses - 1;
   static const uptr BatchClassId = 0;
   static const uptr MaxSize = Config::Classes[LargestClassId - 1];
 
   static uptr getSizeByClassId(uptr ClassId) {
if (Size <= Config::Classes[0])
       return 1;
     Size -= Config::SizeDelta;
     DCHECK_LE(Size, MaxSize);
     if (Size <= (1 << Config::MidSizeLog))
       return ((Size - 1) >> Config::MinSizeLog) + 1;
     return SzTable.Tab[scaledLog2(Size - 1, Config::MidSizeLog, S)];
   }
 
-  static u32 getMaxCachedHint(uptr Size) {
+  static u16 getMaxCachedHint(uptr Size) {
     DCHECK_LE(Size, MaxSize);
     return Base::getMaxCachedHint(Size);
   }
 };
 
 struct DefaultSizeClassConfig {
   static const uptr NumBits = 3;
   static const uptr MinSizeLog = 5;
   static const uptr MidSizeLog = 8;
   static const uptr MaxSizeLog = 17;
-  static const u32 MaxNumCachedHint = 14;
+  static const u16 MaxNumCachedHint = 14;
   static const uptr MaxBytesCachedLog = 10;
   static const uptr SizeDelta = 0;
 };
 
 typedef FixedSizeClassMap<DefaultSizeClassConfig> DefaultSizeClassMap;
 
 struct FuchsiaSizeClassConfig {
   static const uptr NumBits = 3;
   static const uptr MinSizeLog = 5;
   static const uptr MidSizeLog = 8;
   static const uptr MaxSizeLog = 17;
-  static const u32 MaxNumCachedHint = 10;
+  static const u16 MaxNumCachedHint = 10;
   static const uptr MaxBytesCachedLog = 10;
   static const uptr SizeDelta = Chunk::getHeaderSize();
 };
 
 typedef FixedSizeClassMap<FuchsiaSizeClassConfig> FuchsiaSizeClassMap;
 
 struct AndroidSizeClassConfig {
 #if SCUDO_WORDSIZE == 64U
   static const uptr NumBits = 7;
   static const uptr MinSizeLog = 4;
   static const uptr MidSizeLog = 6;
   static const uptr MaxSizeLog = 16;
-  static const u32 MaxNumCachedHint = 13;
+  static const u16 MaxNumCachedHint = 13;
   static const uptr MaxBytesCachedLog = 13;
 
   static constexpr u32 Classes[] = {
       0x00020, 0x00030, 0x00040, 0x00050, 0x00060, 0x00070, 0x00090, 0x000b0,
       0x000c0, 0x000e0, 0x00120, 0x00160, 0x001c0, 0x00250, 0x00320, 0x00450,
       0x00670, 0x00830, 0x00a10, 0x00c30, 0x01010, 0x01210, 0x01bd0, 0x02210,
       0x02d90, 0x03790, 0x04010, 0x04810, 0x05a10, 0x07310, 0x08210, 0x10010,
   };
   static const uptr SizeDelta = 16;
 #else
   static const uptr NumBits = 8;
   static const uptr MinSizeLog = 4;
   static const uptr MidSizeLog = 7;
   static const uptr MaxSizeLog = 16;
-  static const u32 MaxNumCachedHint = 14;
+  static const u16 MaxNumCachedHint = 14;
   static const uptr MaxBytesCachedLog = 13;
 
   static constexpr u32 Classes[] = {
       0x00020, 0x00030, 0x00040, 0x00050, 0x00060, 0x00070, 0x00080, 0x00090,
       0x000a0, 0x000b0, 0x000c0, 0x000e0, 0x000f0, 0x00110, 0x00120, 0x00130,
       0x00150, 0x00160, 0x00170, 0x00190, 0x001d0, 0x00210, 0x00240, 0x002a0,
       0x00330, 0x00370, 0x003a0, 0x00400, 0x00430, 0x004a0, 0x00530, 0x00610,
       0x00730, 0x00840, 0x00910, 0x009c0, 0x00a60, 0x00b10, 0x00ca0, 0x00e00,

 #endif
 
 struct SvelteSizeClassConfig {
 #if SCUDO_WORDSIZE == 64U
   static const uptr NumBits = 4;
   static const uptr MinSizeLog = 4;
   static const uptr MidSizeLog = 8;
   static const uptr MaxSizeLog = 14;
-  static const u32 MaxNumCachedHint = 13;
+  static const u16 MaxNumCachedHint = 13;
   static const uptr MaxBytesCachedLog = 10;
   static const uptr SizeDelta = Chunk::getHeaderSize();
 #else
   static const uptr NumBits = 4;
   static const uptr MinSizeLog = 3;
   static const uptr MidSizeLog = 7;
   static const uptr MaxSizeLog = 14;
-  static const u32 MaxNumCachedHint = 14;
+  static const u16 MaxNumCachedHint = 14;
   static const uptr MaxBytesCachedLog = 10;
   static const uptr SizeDelta = Chunk::getHeaderSize();
 #endif
 };
 
 typedef FixedSizeClassMap<SvelteSizeClassConfig> SvelteSizeClassMap;
 
 // Trusty is configured to only have one region containing blocks of size
 // 2^7 bytes.
 struct TrustySizeClassConfig {
   static const uptr NumBits = 1;
   static const uptr MinSizeLog = 7;
   static const uptr MidSizeLog = 7;
   static const uptr MaxSizeLog = 7;
-  static const u32 MaxNumCachedHint = 8;
+  static const u16 MaxNumCachedHint = 8;
   static const uptr MaxBytesCachedLog = 10;
   static const uptr SizeDelta = 0;
 };
 
 typedef FixedSizeClassMap<TrustySizeClassConfig> TrustySizeClassMap;
 
 template <typename SCMap> inline void printMap() {
   ScopedString Buffer;

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

TEST(ScudoCombinedDeathTest, SKIP_ON_FUCHSIA(testSEGV)) {
   scudo::unmap(P, Size, UNMAP_ALL, &Data);
 }
 
 struct DeathSizeClassConfig {
   static const scudo::uptr NumBits = 1;
   static const scudo::uptr MinSizeLog = 10;
   static const scudo::uptr MidSizeLog = 10;
   static const scudo::uptr MaxSizeLog = 13;
-  static const scudo::u32 MaxNumCachedHint = 4;
+  static const scudo::u16 MaxNumCachedHint = 4;
   static const scudo::uptr MaxBytesCachedLog = 12;
   static const scudo::uptr SizeDelta = 0;
 };
 
 static const scudo::uptr DeathRegionSizeLog = 20U;
 struct DeathConfig {
   static const bool MaySupportMemoryTagging = false;
 

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

TEST(ScudoPrimaryTest, Primary64OOM) {
   const scudo::uptr ClassId = Primary::SizeClassMap::LargestClassId;
   const scudo::uptr Size = Primary::getSizeByClassId(ClassId);
   for (scudo::uptr I = 0; I < 10000U; I++) {
     TransferBatch *B = Allocator.popBatch(&Cache, ClassId);
     if (!B) {
       AllocationFailed = true;
       break;
     }
-    for (scudo::u32 J = 0; J < B->getCount(); J++)
+    for (scudo::u16 J = 0; J < B->getCount(); J++)
       memset(Allocator.decompactPtr(ClassId, B->get(J)), 'B', Size);
     Batches.push_back(B);
   }
   while (!Batches.empty()) {
     Allocator.pushBatch(ClassId, Batches.back());
     Batches.pop_back();
   }
   Cache.destroy(nullptr);

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

for (scudo::uptr I = From; I < To; I += PageSize)
       ReportedPages.insert(I);
   }
 
   scudo::uptr getBase() const { return 0; }
 };
 
 // Simplified version of a TransferBatch.
 template <class SizeClassMap> struct FreeBatch {
-  static const scudo::u32 MaxCount = SizeClassMap::MaxNumCachedHint;
+  static const scudo::u16 MaxCount = SizeClassMap::MaxNumCachedHint;
   void clear() { Count = 0; }
   void add(scudo::uptr P) {
     DCHECK_LT(Count, MaxCount);
     Batch[Count++] = P;
   }
-  scudo::u32 getCount() const { return Count; }
-  scudo::uptr get(scudo::u32 I) const {
+  scudo::u16 getCount() const { return Count; }
+  scudo::uptr get(scudo::u16 I) const {
     DCHECK_LE(I, Count);
     return Batch[I];
   }
   FreeBatch *Next;
 
 private:
-  scudo::u32 Count;
   scudo::uptr Batch[MaxCount];
+  scudo::u16 Count;
 };
 
 template <class SizeClassMap> void testReleaseFreeMemoryToOS() {
   typedef FreeBatch<SizeClassMap> Batch;
   const scudo::uptr PagesCount = 1024;
   const scudo::uptr PageSize = scudo::getPageSizeCached();
   std::mt19937 R;
   scudo::u32 RandState = 42;

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

TEST(ScudoSizeClassMapTest, AndroidSizeClassMap) {
   testSizeClassMap<scudo::AndroidSizeClassMap>();
 }
 
 struct OneClassSizeClassConfig {
   static const scudo::uptr NumBits = 1;
   static const scudo::uptr MinSizeLog = 5;
   static const scudo::uptr MidSizeLog = 5;
   static const scudo::uptr MaxSizeLog = 5;
-  static const scudo::u32 MaxNumCachedHint = 0;
+  static const scudo::u16 MaxNumCachedHint = 0;
   static const scudo::uptr MaxBytesCachedLog = 0;
   static const scudo::uptr SizeDelta = 0;
 };
 
 TEST(ScudoSizeClassMapTest, OneClassSizeClassMap) {
   testSizeClassMap<scudo::FixedSizeClassMap<OneClassSizeClassConfig>>();
 }
 
 #if SCUDO_CAN_USE_PRIMARY64
 struct LargeMaxSizeClassConfig {
   static const scudo::uptr NumBits = 3;
   static const scudo::uptr MinSizeLog = 4;
   static const scudo::uptr MidSizeLog = 8;
   static const scudo::uptr MaxSizeLog = 63;
-  static const scudo::u32 MaxNumCachedHint = 128;
+  static const scudo::u16 MaxNumCachedHint = 128;
   static const scudo::uptr MaxBytesCachedLog = 16;
   static const scudo::uptr SizeDelta = 0;
 };
 
 TEST(ScudoSizeClassMapTest, LargeMaxSizeClassMap) {
   testSizeClassMap<scudo::FixedSizeClassMap<LargeMaxSizeClassConfig>>();
 }
 #endif

compiler-rt/lib/scudo/standalone/tools/compute_size_class_config.cpp

int main(int argc, char **argv) {
 
   printf(R"(// wastage = %zu
 
 struct MySizeClassConfig {
   static const uptr NumBits = %zu;
   static const uptr MinSizeLog = %zu;
   static const uptr MidSizeLog = %zu;
   static const uptr MaxSizeLog = %zu;
-  static const u32 MaxNumCachedHint = 14;
+  static const u16 MaxNumCachedHint = 14;
   static const uptr MaxBytesCachedLog = 14;
 
   static constexpr u32 Classes[] = {)",
          measureWastage(allocs, classes, pageSize, headerSize), numBits,
          minSizeLog, midSizeLog, maxSizeLog);
   for (size_t i = 0; i != classes.size(); ++i) {
     if ((i % 8) == 0)
       printf("\n      ");