Changeset 21017 in webkit for trunk/JavaScriptCore/kjs/collector.cpp

Timestamp:

Apr 22, 2007, 9:01:47 PM (18 years ago)

Author:

mjs

Message:

Reviewed by Darin.

• change blocks to 64k in size, and use various platform-specific calls to allocate at 64k-aligned addresses ​http://bugs.webkit.org/show_bug.cgi?id=13383

• kjs/collector.cpp: (KJS::allocateBlock): New function to allocate 64k of 64k-aligned memory (KJS::freeBlock): Corresponding free (KJS::Collector::allocate): (KJS::Collector::collect):

File:

• trunk/JavaScriptCore/kjs/collector.cpp (modified) (8 diffs)

trunk/JavaScriptCore/kjs/collector.cpp

@@ -39 +39 @@
 
 #include <mach/mach_port.h>
+#include <mach/mach_init.h>
 #include <mach/task.h>
 #include <mach/thread_act.h>
+#include <mach/vm_map.h>
 
 #elif PLATFORM(WIN_OS)
@@ -47 +49 @@
 
 #elif PLATFORM(UNIX)
+
+#include <stdlib.h>
+#include <sys/mman.h>
 
 #if HAVE(PTHREAD_NP_H)
@@ -59 +64 @@
 
 namespace KJS {
-
 
 
@@ -68 +72 @@
 template<> struct CellSize<sizeof(uint64_t)> { static const size_t m_value = 80; }; // 64-bit
 
-const size_t BLOCK_SIZE = (8 * 4096);
+const size_t BLOCK_SIZE = (16 * 4096); // 64k
 const size_t SPARE_EMPTY_BLOCKS = 2;
 const size_t MIN_ARRAY_SIZE = 14;
@@ -76 +80 @@
 
 // derived constants
+const size_t PTR_IN_BLOCK_MASK = (BLOCK_SIZE - 1);
+const size_t BLOCK_MASK = (~PTR_IN_BLOCK_MASK);
 const size_t MINIMUM_CELL_SIZE = CellSize<sizeof(void*)>::m_value;
 const size_t CELL_ARRAY_LENGTH = (MINIMUM_CELL_SIZE / sizeof(double)) + (MINIMUM_CELL_SIZE % sizeof(double) != 0 ? 1 : 0);
@@ -135 +141 @@
 bool GCLock::isLocked = false;
 #endif
+
+static CollectorBlock* allocateBlock()
+{
+#if PLATFORM(DARWIN)    
+    vm_address_t address = 0;
+    vm_map(current_task(), &address, BLOCK_SIZE, PTR_IN_BLOCK_MASK, VM_FLAGS_ANYWHERE, MEMORY_OBJECT_NULL, 0, FALSE, VM_PROT_DEFAULT, VM_PROT_DEFAULT, VM_INHERIT_DEFAULT);
+#elif PLATFORM(WIN)
+     // windows virtual address granularity is naturally 64k
+    LPVOID address = VirtualAlloc(NULL, BLOCK_SIZE, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#elif HAVE(POSIX_MEMALIGN)
+    void* address;
+    posix_memalign(address, BLOCK_SIZE, BLOCK_SIZE);
+    memset(reinterpret_cast<void*>(address), 0, BLOCK_SIZE);
+#else
+    static size_t pagesize = getpagesize();
+    
+    size_t extra = 0;
+    if (BLOCK_SIZE > pagesize)
+        extra = BLOCK_SIZE - pagesize;
+
+    void* mmapResult = mmap(NULL, BLOCK_SIZE + extra, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+    uintptr_t address = reinterpret_cast<uintptr_t>(mmapResult);
+
+    size_t adjust = 0;
+    if ((address & PTR_IN_BLOCK_MASK) != 0)
+        adjust = BLOCK_SIZE - (address & PTR_IN_BLOCK_MASK);
+
+    if (adjust > 0)
+        munmap(reinterpret_cast<void*>(address), adjust);
+
+    if (adjust < extra)
+        munmap(reinterpret_cast<void*>(address + adjust + BLOCK_SIZE), extra - adjust);
+
+    address += adjust;
+    memset(reinterpret_cast<void*>(address), 0, BLOCK_SIZE);
+#endif
+
+    return reinterpret_cast<CollectorBlock*>(address);
+}
+
+static void freeBlock(CollectorBlock* block)
+{
+#if PLATFORM(DARWIN)    
+    vm_deallocate(current_task(), reinterpret_cast<vm_address_t>(block), BLOCK_SIZE);
+#elif PLATFORM(WIN)
+    VirtualFree(block, BLOCK_SIZE, MEM_RELEASE);
+#elif HAVE(POSIX_MEMALIGN)
+    free(block);
+#else
+    munmap(block, BLOCK_SIZE);
+#endif
+}
 
 void* Collector::allocate(size_t s)
@@ -186 +244 @@
     }
 
-    targetBlock = static_cast<CollectorBlock *>(fastCalloc(1, sizeof(CollectorBlock)));
+    targetBlock = allocateBlock();
     targetBlock->freeList = targetBlock->cells;
     targetBlockUsedCells = 0;
@@ -800 +858 @@
       if (emptyBlocks > SPARE_EMPTY_BLOCKS) {
 #if !DEBUG_COLLECTOR
-        fastFree(curBlock);
+        freeBlock(curBlock);
 #endif
         // swap with the last block so we compact as we go