[scudo] CanCache should use Size + HeadersSize instead of RoundedSize

[Chia-hungDuan]

Summary

Cached block may have nearly aligned address for a certain alignment so
that we don't have to round up the size in advance. The rounding should
only happen at determing the availability of a cached block.

[Chia-hungDuan]

Just reviewed this again. canCache() may still want to consider the size of headers. Instead of using Size nor RoundedSize, Size + size-of-all-headers is more reasonable here.

[Chia-hungDuan]

Pass Size + HeadersSize instead.

[cferris]

LGTM as long as I am correct about the one comment I left.

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

265

I presume you are passing in the HeadersSize to avoid calling getHeadersSize() again. Or to add tests for the function in the future.

If I'm wrong, let me know.

[Chia-hungDuan]

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

265

Calling getHeadersSize() in Cache will be MapAllocator<Config>::getHeadersSize(). Instead of adding direct dependency with MapAllocator, I tend to inject the dependency by passing the size. (However, it's called MapAllocatorCache...)

No strong opinion here, let me know if you think calling getHeadersSize is better.

[cferris]

LGTM.

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

265

I think it's fine the way it is. Having the parameter does allow for testing that value in the future.

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

void store(const Options &Options, LargeBlock::Header *H) EXCLUDES(Mutex) {
     if (EmptyCache)
       empty();
     else if (Interval >= 0)
       releaseOlderThan(Time - static_cast<u64>(Interval) * 1000000);
     if (!EntryCached)
       Entry.MemMap.unmap(Entry.MemMap.getBase(), Entry.MemMap.getCapacity());
   }
 
   bool retrieve(Options Options, uptr Size, uptr Alignment,
                 LargeBlock::Header **H, bool *Zeroed) EXCLUDES(Mutex) {
     const uptr PageSize = getPageSizeCached();
     const u32 MaxCount = atomic_load_relaxed(&MaxEntriesCount);
     bool Found = false;
     CachedBlock Entry;
     uptr HeaderPos = 0;
     {
       ScopedLock L(Mutex);
void *MapAllocator<Config>::allocate(const Options &Options, uptr Size,
   const uptr PageSize = getPageSizeCached();
   uptr RoundedSize =
       roundUp(roundUp(Size, Alignment) + LargeBlock::getHeaderSize() +
                   Chunk::getHeaderSize(),
               PageSize);
   if (Alignment > PageSize)
     RoundedSize += Alignment - PageSize;
 
-  if (Alignment < PageSize && Cache.canCache(RoundedSize)) {
+  if (Alignment < PageSize && Cache.canCache(Size)) {
     LargeBlock::Header *H;
     bool Zeroed;
     if (Cache.retrieve(Options, Size, Alignment, &H, &Zeroed)) {
       const uptr BlockEnd = H->CommitBase + H->CommitSize;
       if (BlockEndPtr)
         *BlockEndPtr = BlockEnd;
       uptr HInt = reinterpret_cast<uptr>(H);
       if (allocatorSupportsMemoryTagging<Config>())