Changeset 39673 in webkit for trunk/JavaScriptCore

Timestamp:

Jan 6, 2009, 11:41:33 PM (16 years ago)

Author:

[email protected]

Message:

<rdar://problem/6040850> JavaScript register file should use VirtualAlloc on Windows

Reviewed by Gavin Barraclough.

Fairly simple, just reserve 4Mb of address space for the
register file, and then commit one section at a time. We
don't release committed memory as we drop back, but then
mac doesn't either so this probably not too much of a
problem.

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• interpreter/RegisterFile.cpp (modified) (1 diff)
• interpreter/RegisterFile.h (modified) (4 diffs)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2009-01-06  Oliver Hunt  <[email protected]>
+
+        Reviewed by Gavin Barraclough.
+
+        <rdar://problem/6040850> JavaScript register file should use VirtualAlloc on Windows
+
+        Fairly simple, just reserve 4Mb of address space for the
+        register file, and then commit one section at a time.  We
+        don't release committed memory as we drop back, but then
+        mac doesn't either so this probably not too much of a 
+        problem.
+
+        * interpreter/RegisterFile.cpp:
+        (JSC::RegisterFile::~RegisterFile):
+        * interpreter/RegisterFile.h:
+        (JSC::RegisterFile::RegisterFile):
+        (JSC::RegisterFile::grow):
+
 2009-01-06  Alexey Proskuryakov  <[email protected]>
 

trunk/JavaScriptCore/interpreter/RegisterFile.cpp

@@ -37 +37 @@
     munmap(m_buffer, ((m_max - m_start) + m_maxGlobals) * sizeof(Register));
 #elif HAVE(VIRTUALALLOC)
-    // FIXME: Use VirtualFree.
-    fastFree(m_buffer);
+    VirtualFree(m_buffer, 0, MEM_RELEASE);
 #else
     #error "Don't know how to release virtual memory on this platform."

trunk/JavaScriptCore/interpreter/RegisterFile.h

@@ -112 +112 @@
         static const size_t defaultCapacity = 524288;
         static const size_t defaultMaxGlobals = 8192;
+        static const size_t allocationSize = 1 << 14;
+        static const size_t allocationSizeMask = allocationSize - 1;
 
         RegisterFile(size_t capacity = defaultCapacity, size_t maxGlobals = defaultMaxGlobals)
@@ -130 +132 @@
             }
 #elif HAVE(VIRTUALALLOC)
-            // FIXME: Use VirtualAlloc, and commit pages as we go.
-            m_buffer = static_cast<Register*>(fastMalloc(bufferLength));
+            // Ensure bufferLength is a multiple of allocation size
+            bufferLength = (bufferLength + allocationSizeMask) & ~allocationSizeMask;
+            m_buffer = static_cast<Register*>(VirtualAlloc(0, bufferLength, MEM_RESERVE, PAGE_READWRITE));
+            if (!m_buffer) {
+                fprintf(stderr, "Could not allocate register file: %d\n", errno);
+                CRASH();
+            }
+            int initialAllocation = (maxGlobals * sizeof(Register) + allocationSizeMask) & ~allocationSizeMask;
+            void* commitCheck = VirtualAlloc(m_buffer, initialAllocation, MEM_COMMIT, PAGE_READWRITE);
+            if (commitCheck != m_buffer) {
+                fprintf(stderr, "Could not allocate register file: %d\n", errno);
+                CRASH();
+            }
+            m_maxCommitted = reinterpret_cast<Register*>(reinterpret_cast<char*>(m_buffer) + initialAllocation);
 #else
             #error "Don't know how to reserve virtual memory on this platform."
@@ -161 +175 @@
                     return false;
 #if !HAVE(MMAP) && HAVE(VIRTUALALLOC)
-                // FIXME: Use VirtualAlloc, and commit pages as we go.
+                if (newEnd > m_maxCommitted) {
+                    ptrdiff_t additionalAllocation = ((reinterpret_cast<char*>(newEnd)  - reinterpret_cast<char*>(m_maxCommitted)) + allocationSizeMask) & ~allocationSizeMask;
+                    if (!VirtualAlloc(m_maxCommitted, additionalAllocation, MEM_COMMIT, PAGE_READWRITE)) {
+                        fprintf(stderr, "Could not allocate register file: %d\n", errno);
+                        CRASH();
+                    }
+                    m_maxCommitted = reinterpret_cast<Register*>(reinterpret_cast<char*>(m_maxCommitted) + additionalAllocation);
+                }
 #endif
                 m_end = newEnd;
@@ -184 +205 @@
         Register* m_max;
         Register* m_buffer;
+#if HAVE(VIRTUALALLOC)
+        Register* m_maxCommitted;
+#endif
+
         JSGlobalObject* m_globalObject; // The global object whose vars are currently stored in the register file.
     };