Patch for allowing several V8 instances in process:...

src/platform-win32.cc

 // Copyright 2006-2008 the V8 project authors. 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 375 matching lines @@
     case +2*kHour: return "Eastern Europe";
     case +3*kHour: return "Russia";
     case +5*kHour + 30: return "India";
     case +8*kHour: return "China";
     case +9*kHour: return "Japan";
     case +12*kHour: return "New Zealand";
     default: return "Local";
   }
 }
 
+static MutexLockAdapter time_lock(OS::CreateMutex());
 
 // Initialize timezone information. The timezone information is obtained from
 // windows. If we cannot get the timezone information we fall back to CET.
 // Please notice that this code is not thread-safe.
 void Time::TzSet() {
+  V8SharedStateLocker time_locker(&time_lock);
   // Just return if timezone information has already been initialized.
   if (tz_initialized_) return;
 
   // Initialize POSIX time zone data.
   _tzset();
   // Obtain timezone information from operating system.
   memset(&tzinfo_, 0, sizeof(tzinfo_));
   if (GetTimeZoneInformation(&tzinfo_) == TIME_ZONE_ID_INVALID) {
     // If we cannot get timezone information we fall back to CET.
     tzinfo_.Bias = -60;
@@ skipping 88 matching lines @@
     GetSystemTimeAsFileTime(&init_time.ft_);
     init_ticks = ticks_now = timeGetTime();
     initialized = true;
   }
 
   // Finally, compute the actual time.  Why is this so hard.
   DWORD elapsed = ticks_now - init_ticks;
   this->time_.t_ = init_time.t_ + (static_cast<int64_t>(elapsed) * 10000);
 }
 
-
 // Return the local timezone offset in milliseconds east of UTC. This
 // takes into account whether daylight saving is in effect at the time.
 // Only times in the 32-bit Unix range may be passed to this function.
 // Also, adding the time-zone offset to the input must not overflow.
 // The function EquivalentTime() in date-delay.js guarantees this.
 int64_t Time::LocalOffset() {
   // Initialize timezone information, if needed.
   TzSet();
 
   Time rounded_to_second(*this);
@@ skipping 262 matching lines @@
 
 
 // We keep the lowest and highest addresses mapped as a quick way of
 // determining that pointers are outside the heap (used mostly in assertions
 // and verification).  The estimate is conservative, ie, not all addresses in
 // 'allocated' space are actually allocated to our heap.  The range is
 // [lowest, highest), inclusive on the low and and exclusive on the high end.
 static void* lowest_ever_allocated = reinterpret_cast<void*>(-1);
 static void* highest_ever_allocated = reinterpret_cast<void*>(0);
 
+static MutexLockAdapter heap_limits_lock(OS::CreateMutex());
 
 static void UpdateAllocatedSpaceLimits(void* address, int size) {
-  lowest_ever_allocated = Min(lowest_ever_allocated, address);
-  highest_ever_allocated =
-      Max(highest_ever_allocated,
-          reinterpret_cast<void*>(reinterpret_cast<char*>(address) + size));
+  V8SharedStateLocker heap_limits_locker(&heap_limits_lock);
+  lowest_ever_allocated = Min(
+    lowest_ever_allocated, reinterpret_cast<void*>(address));
+  highest_ever_allocated = Max(highest_ever_allocated,
+    reinterpret_cast<void*>(reinterpret_cast<char*>(address) + size));
 }
 
 
 bool OS::IsOutsideAllocatedSpace(void* pointer) {
+  V8SharedStateLocker heap_limits_locker(&heap_limits_lock);
   if (pointer < lowest_ever_allocated || pointer >= highest_ever_allocated)
     return true;
   // Ask the Windows API
   if (IsBadWritePtr(pointer, 1))
     return true;
   return false;
 }
 
 
 // Get the system's page size used by VirtualAlloc() or the next power
 // of two. The reason for always returning a power of two is that the
 // rounding up in OS::Allocate expects that.
 static size_t GetPageSize() {
-  static size_t page_size = 0;
+  static volatile size_t page_size = 0;
   if (page_size == 0) {
     SYSTEM_INFO info;
     GetSystemInfo(&info);
     page_size = RoundUpToPowerOf2(info.dwPageSize);
   }
   return page_size;
 }
 
 
 // The allocation alignment is the guaranteed alignment for
@@ skipping 1073 matching lines @@
 
   // Release the thread handles
   CloseHandle(data_->sampler_thread_);
   CloseHandle(data_->profiled_thread_);
 }
 
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 } }  // namespace v8::internal