Optimize test for pointer being in a partition on 32-bit.

Source/wtf/PageAllocator.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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WTF_PageAllocator_h
 #define WTF_PageAllocator_h
 
+#include "wtf/CPU.h"
+#include <stdint.h>
+
 namespace WTF {
 
 // Our granulatity of page allocation is 64KB. This is a Windows limitation,
 // but we apply the same requirement for all platforms in order to keep
 // things simple and consistent.
 // We term these 64KB allocations "super pages". They're just a clump of
 // underlying 4KB system pages.
-static const size_t kSuperPageSize = 1 << 16; // 64KB
+static const size_t kSuperPageShift = 16; // 64KB
+static const size_t kSuperPageSize = 1 << kSuperPageShift;
 static const size_t kSuperPageOffsetMask = kSuperPageSize - 1;
 static const size_t kSuperPageBaseMask = ~kSuperPageOffsetMask;
 
 // All Blink-supported systems have 4096 sized system pages and can handle
 // permissions and commit / decommit at this granularity.
 static const size_t kSystemPageSize = 4096;
 static const size_t kSystemPageOffsetMask = kSystemPageSize - 1;
 
 static const size_t kNumSystemPagesPerSuperPage = kSuperPageSize / kSystemPageSize;
 
@@ skipping 13 matching lines @@
 // Subsequently accessing any address in the range will fault, the addresses
 // will not be re-used by future allocations.
 // len must be a multiple of kSystemPageSize bytes.
 void setSystemPagesInaccessible(void* addr, size_t len);
 
 // Decommit one or more system pages. Decommitted means that the physical memory
 // is released to the system, but the virtual address space remains reserved.
 // System pages are re-committed by writing to them.
 // Clients should not make any assumptions about the contents of decommitted
 // system pages, before or after they write to the page. The only guarantee
-// provided is that the contents of the system page will be deterministic again // after writing to it. In particlar note that system pages are not guaranteed
+// provided is that the contents of the system page will be deterministic again
+// after writing to it. In particlar note that system pages are not guaranteed
 // to be zero-filled upon re-commit.
 // len must be a multiple of kSystemPageSize bytes.
 void decommitSystemPages(void* addr, size_t len);
 
 // Returns a suitable pointer for starting to allocate super pages.
 // The pointer is not guaranteed to be "unused", but does represent an address
 // that has a good chance of being unused. The pointer is also randomized to
 // provide reasonable ASLR.
 char* getRandomSuperPageBase();
 
+#if CPU(32BIT)
+class SuperPageBitmap {

[Tom Sepez, 2013/10/02 16:51:31]

Not sure this buys a lot over just having the s_bitmap in the partition alloc
class itself and doing the arithmetic there.  You've already got idefs sprinkled
liberally thoughout.

[Tom Sepez, 2013/10/02 16:57:33]

Alternatively, you could call this a SuperPageTracker, and put both the bitmap
and linked list implementations into it, ifdef'd appropriately.  Then you could
avoid having CPU() ifdefs outside of this code as it would abstract away the
differences.

+public:
+    ALWAYS_INLINE static bool isPointerInSuperPage(void* ptr)
+    {
+        uintptr_t raw = reinterpret_cast<uintptr_t>(ptr);
+        size_t idx = raw >> (kSuperPageShift + 3);
+        size_t bit = raw & 7;

[Tom Sepez, 2013/10/02 16:51:31]

This doesn't seem right.  You want the low 3 bits of the shifted pointer to use
as the "bit within byte" index, not the low three bits of the pointer itself. 

+        return s_bitmap[idx] & (1 << bit);
+    }
+
+    static void registerSuperPage(void* ptr);
+    static void unregisterSuperPage(void* ptr);
+
+private:
+    static unsigned char s_bitmap[1 << (32 - kSuperPageShift - 3)];

[Tom Sepez, 2013/10/02 16:51:31]

I'd like this as a constant so we can assert that idx is less than it in the
debug build.

+};
+#endif
+
 } // namespace WTF
 
 #endif // WTF_PageAllocator_h