Changeset 20229 in webkit for trunk/JavaScriptCore/wtf

Timestamp:

Mar 15, 2007, 10:12:59 PM (18 years ago)

Author:

mjs

Message:

JavaScriptCore:

Reviewed by Geoff and Steve.

• fix some portability issues with TCMalloc.

• JavaScriptCore.vcproj/WTF/WTF.vcproj:
• kjs/config.h:
• wtf/FastMalloc.cpp: (WTF::SizeClass): (WTF::InitSizeClasses): (WTF::TCMalloc_PageHeap::Split): (WTF::TCMalloc_PageHeap::RegisterSizeClass): (WTF::TCMalloc_Central_FreeList::length): (WTF::TCMalloc_ThreadCache::InitTSD): (WTF::TCMalloc_ThreadCache::CreateCacheIfNecessary):
• wtf/TCSpinLock.h:
• wtf/TCSystemAlloc.cpp: (TryVirtualAlloc): (TCMalloc_SystemAlloc):

WebCore:

Reviewed by Geoff and Steve.

• config.h: Remove unneeded hack.

Location:

trunk/JavaScriptCore/wtf

Files:

• FastMalloc.cpp (modified) (9 diffs)
• TCSpinLock.h (modified) (2 diffs)
• TCSystemAlloc.cpp (modified) (5 diffs)

trunk/JavaScriptCore/wtf/FastMalloc.cpp

@@ -190 +190 @@
 #include <stdio.h>
 #include <string.h>
-#include <unistd.h>
 
 #if WTF_CHANGES
@@ -329 +328 @@
 #endif
 
-static inline int SizeClass(size_t size) {
+static inline size_t SizeClass(size_t size) {
   if (size == 0) size = 1;
   const int lg = LgFloor(size);
   const int align = size_shift[lg];
-  return static_cast<int>(size_base[lg]) + ((size-1) >> align);
+  return size_base[lg] + ((size-1) >> align);
 }
 
@@ -350 +349 @@
 
   size_t next_class = 1;
-  int alignshift = kAlignShift;
+  unsigned char alignshift = kAlignShift;
   int last_lg = -1;
   for (size_t size = kAlignment; size <= kMaxSize; size += (1 << alignshift)) {
@@ -365 +364 @@
         alignshift++;
       }
-      size_base[lg] = next_class - ((size-1) >> alignshift);
+      size_base[lg] = static_cast<unsigned char>(next_class - ((size-1) >> alignshift));
       size_shift[lg] = alignshift;
     }
@@ -819 +818 @@
   Event(span, 'T', n);
 
-  const int extra = span->length - n;
+  const Length extra = span->length - n;
   Span* leftover = NewSpan(span->start + n, extra);
   Event(leftover, 'U', extra);
@@ -909 +908 @@
   ASSERT(GetDescriptor(span->start+span->length-1) == span);
   Event(span, 'C', sc);
-  span->sizeclass = sc;
+  span->sizeclass = static_cast<unsigned int>(sc);
   for (Length i = 1; i < span->length-1; i++) {
     pagemap_.set(span->start+i, span);
@@ -1142 +1141 @@
   // REQUIRES: lock_ is held
   // Number of free objects in cache
-  int length() const { return counter_; }
+  size_t length() const { return counter_; }
 
   // Lock -- exposed because caller grabs it before touching this object
@@ -1565 +1564 @@
 #endif
   for (TCMalloc_ThreadCache* h = thread_heaps; h != NULL; h = h->next_) {
-    if (h->tid_ == zero) {
+    if (pthread_equal(h->tid_, zero)) {
       h->tid_ = pthread_self();
     }
@@ -1589 +1588 @@
     // and added to the linked list.  So we search for that first.
     for (TCMalloc_ThreadCache* h = thread_heaps; h != NULL; h = h->next_) {
-      if (h->tid_ == me) {
+      if (pthread_equal(h->tid_, me)) {
         heap = h;
         break;

trunk/JavaScriptCore/wtf/TCSpinLock.h

@@ -35 +35 @@
 
 #include "config.h"
+
+#if (PLATFORM(X86) || PLATFORM(PPC)) && COMPILER(GCC)
+
 #include <time.h>       /* For nanosleep() */
+
 #include <sched.h>      /* For sched_yield() */
+
 #if HAVE(STDINT_H)
 #include <stdint.h>
@@ -46 +51 @@
 #include <stdlib.h>     /* for abort() */
 
-#if (PLATFORM(X86) || PLATFORM(PPC)) && COMPILER(GCC)
 static void TCMalloc_SlowLock(volatile unsigned int* lockword);
 

trunk/JavaScriptCore/wtf/TCSystemAlloc.cpp

@@ -39 +39 @@
 #include <sys/types.h>
 #endif
-#if !PLATFORM(WIN_OS)
+#if PLATFORM(WIN_OS)
+#include "windows.h"
+#else
 #include <unistd.h>
 #include <sys/mman.h>
@@ -74 +76 @@
 static bool use_sbrk = false;
 static bool use_mmap = true;
+static bool use_VirtualAlloc = true;
 
 // Flags to keep us from retrying allocators that failed.
@@ -79 +82 @@
 static bool sbrk_failure = false;
 static bool mmap_failure = false;
+static bool VirtualAlloc_failure = false;
 
 #ifndef WTF_CHANGES
@@ -173 +177 @@
 #endif /* HAVE(MMAP) */
 
+#if HAVE(VIRTUALALLOC)
+
+static void* TryVirtualAlloc(size_t size, size_t alignment) {
+  // Enforce page alignment
+  if (pagesize == 0) {
+    SYSTEM_INFO system_info;
+    GetSystemInfo(&system_info);
+    pagesize = system_info.dwPageSize;
+  }
+  if (alignment < pagesize) alignment = pagesize;
+  size = ((size + alignment - 1) / alignment) * alignment;
+
+  // Ask for extra memory if alignment > pagesize
+  size_t extra = 0;
+  if (alignment > pagesize) {
+    extra = alignment - pagesize;
+  }
+  void* result = VirtualAlloc(NULL, size + extra,
+                              MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, 
+                              PAGE_READWRITE);
+
+  if (result == NULL) {
+    VirtualAlloc_failure = true;
+    return NULL;
+  }
+
+  // Adjust the return memory so it is aligned
+  uintptr_t ptr = reinterpret_cast<uintptr_t>(result);
+  size_t adjust = 0;
+  if ((ptr & (alignment - 1)) != 0) {
+    adjust = alignment - (ptr & (alignment - 1));
+  }
+
+  // Return the unused memory to the system - we'd like to release but the best we can do
+  // is decommit, since Windows only lets you free the whole allocation.
+  if (adjust > 0) {
+    VirtualFree(reinterpret_cast<void*>(ptr), adjust, MEM_DECOMMIT);
+  }
+  if (adjust < extra) {
+    VirtualFree(reinterpret_cast<void*>(ptr + adjust + size), extra-adjust, MEM_DECOMMIT);
+  }
+
+  ptr += adjust;
+  return reinterpret_cast<void*>(ptr);
+}
+
+#endif /* HAVE(MMAP) */
+
 #ifndef WTF_CHANGES
 static void* TryDevMem(size_t size, size_t alignment) {
@@ -283 +335 @@
 #endif
 
+#if HAVE(VIRTUALALLOC)
+    if (use_VirtualAlloc && !VirtualAlloc_failure) {
+      void* result = TryVirtualAlloc(size, alignment);
+      if (result != NULL) return result;
+    }
+#endif
+
     // nothing worked - reset failure flags and try again
     devmem_failure = false;
     sbrk_failure = false;
     mmap_failure = false;
+    VirtualAlloc_failure = false;
   }
   return NULL;