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

src/allocation.h

 // Copyright 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 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // 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 V8_ALLOCATION_H_
 #define V8_ALLOCATION_H_
 
+#include "v8-global-context.h"
+
 namespace v8 {
 namespace internal {
 
-
-// A class that controls whether allocation is allowed.  This is for
-// the C++ heap only!
-class NativeAllocationChecker {
- public:
-  typedef enum { ALLOW, DISALLOW } NativeAllocationAllowed;
-  explicit inline NativeAllocationChecker(NativeAllocationAllowed allowed)
-      : allowed_(allowed) {
-#ifdef DEBUG
-    if (allowed == DISALLOW) {
-      allocation_disallowed_++;
-    }
-#endif
-  }
-  ~NativeAllocationChecker() {
-#ifdef DEBUG
-    if (allowed_ == DISALLOW) {
-      allocation_disallowed_--;
-    }
-#endif
-    ASSERT(allocation_disallowed_ >= 0);
-  }
-  static inline bool allocation_allowed() {
-    return allocation_disallowed_ == 0;
-  }
- private:
-  // This static counter ensures that NativeAllocationCheckers can be nested.
-  static int allocation_disallowed_;
-  // This flag applies to this particular instance.
-  NativeAllocationAllowed allowed_;
-};
-
-
 // Superclass for classes managed with new & delete.
 class Malloced {
  public:
   void* operator new(size_t size) { return New(size); }
   void  operator delete(void* p) { Delete(p); }
 
   static void FatalProcessOutOfMemory();
   static void* New(size_t size);
   static void Delete(void* p);
 };
@@ skipping 51 matching lines @@
 
 
 // Allocation policy for allocating in the C free store using malloc
 // and free. Used as the default policy for lists.
 class FreeStoreAllocationPolicy {
  public:
   INLINE(static void* New(size_t size)) { return Malloced::New(size); }
   INLINE(static void Delete(void* p)) { Malloced::Delete(p); }
 };
 
-
 // Allocation policy for allocating in preallocated space.
 // Used as an allocation policy for ScopeInfo when generating
 // stack traces.
 class PreallocatedStorage : public AllStatic {
  public:
   explicit PreallocatedStorage(size_t size);
   size_t size() { return size_; }
   static void* New(size_t size);
   static void Delete(void* p);
 
   // Preallocate a set number of bytes.
   static void Init(size_t size);
 
  private:
   size_t size_;
   PreallocatedStorage* previous_;
   PreallocatedStorage* next_;
-  static bool preallocated_;
-
-  static PreallocatedStorage in_use_list_;
-  static PreallocatedStorage free_list_;
 
   void LinkTo(PreallocatedStorage* other);
   void Unlink();
   DISALLOW_IMPLICIT_CONSTRUCTORS(PreallocatedStorage);
 };
 
+class StorageData {
+ private:
+  // This static counter ensures that NativeAllocationCheckers can be nested.
+  int allocation_disallowed_;
+  bool preallocated_;
+
+  PreallocatedStorage in_use_list_;
+  PreallocatedStorage free_list_;
+  #ifdef DEBUG
+   private:
+    bool rset_used_;  // state of the remembered set
+  #endif
+
+  StorageData();
+  friend class V8Context;
+  friend class PreallocatedStorage;
+  friend class NativeAllocationChecker;
+  friend class Page;
+  DISALLOW_COPY_AND_ASSIGN(StorageData);
+};
+
+// A class that controls whether allocation is allowed.  This is for
+// the C++ heap only!
+class NativeAllocationChecker {
+ public:
+  typedef enum { ALLOW, DISALLOW } NativeAllocationAllowed;
+  explicit inline NativeAllocationChecker(NativeAllocationAllowed allowed)
+      : allowed_(allowed) {
+#ifdef DEBUG
+    if (allowed == DISALLOW) {
+      v8_context()->storage_data_.allocation_disallowed_++;
+    }
+#endif
+  }
+  ~NativeAllocationChecker() {
+#ifdef DEBUG
+    if (allowed_ == DISALLOW) {
+      v8_context()->storage_data_.allocation_disallowed_--;
+    }
+#endif
+    ASSERT(v8_context()->storage_data_.allocation_disallowed_ >= 0);
+  }
+  static inline bool allocation_allowed() {
+    V8Context * const v8context = v8_context();
+    return v8context ?
+      v8context->storage_data_.allocation_disallowed_ == 0: true;
+  }
+ private:
+  // This static counter ensures that NativeAllocationCheckers can be nested.
+  static int allocation_disallowed_;
+  // This flag applies to this particular instance.
+  NativeAllocationAllowed allowed_;
+};
 
 } }  // namespace v8::internal
 
 #endif  // V8_ALLOCATION_H_