Add partitionAllocActualSize() for predicting actual size of allocation

Source/wtf/PartitionAlloc.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 547 matching lines @@
 
     ptr = partitionCookieFreePointerAdjust(ptr);
     ASSERT(partitionPointerIsValid(ptr));
     PartitionPage* page = partitionPointerToPage(ptr);
     spinLockLock(&root->lock);
     partitionFreeWithPage(ptr, page);
     spinLockUnlock(&root->lock);
 #endif
 }
 
+ALWAYS_INLINE size_t partitionDirectMapSize(size_t size)
+{

[Chris Evans, 2014/02/21 22:33:37]

Can we have a comment such as "caller must handle integer overflow", and an
ASSERT?

[Jens Widell, 2014/02/22 09:23:30]

Assuming (which I hear is a good idea in general) that size_t is at least 32-bit
and unsigned, the calculation here is safe from overflow well above the actual
size limit (INT_MAX - kSystemPageSize).

I've added a comment about the caller being required to check the size limit
(which is stricter than just guarding against overflow,) and assert that the
size is allowed.

+    return (size + kSystemPageOffsetMask) & kSystemPageBaseMask;
+}
+
+ALWAYS_INLINE size_t partitionAllocPredictSize(PartitionRootGeneric* root, size_t size)

[Chris Evans, 2014/02/21 22:33:37]

I think we're doing a more accurate job than predicting. Perhaps
partitionAllocActualSize() ?

[Jens Widell, 2014/02/22 09:23:30]

Renamed it.

+{
+#if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
+    return size;
+#else
+    ASSERT(root->initialized);
+    size = partitionCookieSizeAdjustAdd(size);
+    PartitionBucket* bucket = partitionGenericSizeToBucket(root, size);
+    if (LIKELY(bucket->numSystemPagesPerSlotSpan)) {

[Chris Evans, 2014/02/21 22:33:37]

Can we make this into a small function? This check is now duplicated with other
places (at least partitionFreeSlowPath and partitionAllocSlowPath). I think we
could use a simple partitionBucketIsDirectMapped() and this will make the code
much more readable.

[Chris Evans, 2014/02/21 22:33:37]

Can we abstract this to a simple function, partitionBucketIsDirectMapped()? It'd
make things more readable and we can also use it in a couple of places
(partitionAllocSlowPath, partitionAllocFastPath) to de-duplicate.

[Jens Widell, 2014/02/22 09:23:30]

Added such a helper. Also made a constant out of "INT_MAX - kSystemPageSize" for
the maximum size of direct mapped allocations (and thus any allocations, I
guess.)

+        size = bucket->slotSize;
+    } else {
+        ASSERT(bucket == &PartitionRootGeneric::gPagedBucket);
+        if (size > INT_MAX - kSystemPageSize) {
+            // Too large to allocate => return the size unchanged.
+        } else {
+            size = partitionDirectMapSize(size);
+        }
+    }
+    return partitionCookieSizeAdjustSubtract(size);
+#endif
+}
+
 ALWAYS_INLINE bool partitionAllocSupportsGetSize()
 {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
     return false;
 #else
     return true;
 #endif
 }
 
 ALWAYS_INLINE size_t partitionAllocGetSize(void* ptr)
@@ skipping 38 matching lines @@
 using WTF::SizeSpecificPartitionAllocator;
 using WTF::PartitionAllocatorGeneric;
 using WTF::PartitionRoot;
 using WTF::partitionAllocInit;
 using WTF::partitionAllocShutdown;
 using WTF::partitionAlloc;
 using WTF::partitionFree;
 using WTF::partitionAllocGeneric;
 using WTF::partitionFreeGeneric;
 using WTF::partitionReallocGeneric;
+using WTF::partitionAllocPredictSize;
 using WTF::partitionAllocSupportsGetSize;
 using WTF::partitionAllocGetSize;
 
 #endif // WTF_PartitionAlloc_h