NOINLINE void *allocate(uptr Size, Chunk::Origin Origin,                           uptr Alignment = MinAlignment,                           bool ZeroContents = false) {     initThreadMaybe();  // 初始化TSD Array 和 Primary SizeClass地址空间      // skip trivials.......      // If the requested size happens to be 0 (more common than you might think),     // allocate MinAlignment bytes on top of the header. Then add the extra     // bytes required to fulfill the alignment requirements: we allocate enough     // to be sure that there will be an address in the block that will satisfy     // the alignment.     const uptr NeededSize =         roundUpTo(Size, MinAlignment) +         ((Alignment > MinAlignment) ? Alignment : Chunk::getHeaderSize());      // skip trivials.......          void *Block = nullptr;     uptr ClassId = 0;     uptr SecondaryBlockEnd;     if (LIKELY(PrimaryT::canAllocate(NeededSize))) {       // 从 Primary Allocator分配small object       ClassId = SizeClassMap::getClassIdBySize(NeededSize);       DCHECK_NE(ClassId, 0U);       bool UnlockRequired;       auto *TSD = TSDRegistry.getTSDAndLock(&UnlockRequired);       Block = TSD->Cache.allocate(ClassId);       // If the allocation failed, the most likely reason with a 32-bit primary       // is the region being full. In that event, retry in each successively       // larger class until it fits. If it fails to fit in the largest class,       // fallback to the Secondary.       if (UNLIKELY(!Block)) {         while (ClassId < SizeClassMap::LargestClassId) {           Block = TSD->Cache.allocate(++ClassId);           if (LIKELY(Block)) {             break;           }         }         if (UNLIKELY(!Block)) {           ClassId = 0;         }       }       if (UnlockRequired)         TSD->unlock();     }     // 如果分配的是大内存，或者Primary 无法分配小内存，     // 则直接在Secondary Allocator进行分配     if (UNLIKELY(ClassId == 0))       Block = Secondary.allocate(NeededSize, Alignment, &SecondaryBlockEnd,                                  ZeroContents);        // skip trivials.......      const uptr BlockUptr = reinterpret_cast<uptr>(Block);     const uptr UnalignedUserPtr = BlockUptr + Chunk::getHeaderSize();     const uptr UserPtr = roundUpTo(UnalignedUserPtr, Alignment);      void *Ptr = reinterpret_cast<void *>(UserPtr);     void *TaggedPtr = Ptr;          // skip trivials.......      // 根据返回内存地址，设置chunk-header对象数据     Chunk::UnpackedHeader Header = {};     if (UNLIKELY(UnalignedUserPtr != UserPtr)) {       const uptr Offset = UserPtr - UnalignedUserPtr;       DCHECK_GE(Offset, 2 * sizeof(u32));       // The BlockMarker has no security purpose, but is specifically meant for       // the chunk iteration function that can be used in debugging situations.       // It is the only situation where we have to locate the start of a chunk       // based on its block address.       reinterpret_cast<u32 *>(Block)[0] = BlockMarker;       reinterpret_cast<u32 *>(Block)[1] = static_cast<u32>(Offset);       Header.Offset = (Offset >> MinAlignmentLog) & Chunk::OffsetMask;     }     Header.ClassId = ClassId & Chunk::ClassIdMask;     Header.State = Chunk::State::Allocated;     Header.Origin = Origin & Chunk::OriginMask;     Header.SizeOrUnusedBytes =         (ClassId ? Size : SecondaryBlockEnd - (UserPtr + Size)) &         Chunk::SizeOrUnusedBytesMask;      // 设置chunk-header，CheckSum用于完整性校验     Chunk::storeHeader(Cookie, Ptr, &Header);      // skip trivials.......      return TaggedPtr;   }