One Zone per CompilationInfo.

src/zone.h

 // Copyright 2012 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 46 matching lines @@
 
 // Note: There is no need to initialize the Zone; the first time an
 // allocation is attempted, a segment of memory will be requested
 // through a call to malloc().
 
 // Note: The implementation is inherently not thread safe. Do not use
 // from multi-threaded code.
 
 class Zone {
  public:
+  explicit Zone(Isolate* isolate);
   // Allocate 'size' bytes of memory in the Zone; expands the Zone by
   // allocating new segments of memory on demand using malloc().
   inline void* New(int size);
 
   template <typename T>
   inline T* NewArray(int length);
 
-  // Deletes all objects and free all memory allocated in the Zone. Keeps one
-  // small (size <= kMaximumKeptSegmentSize) segment around if it finds one.
-  void DeleteAll();
+  // This method dispatches to either DeleteAll or to DeleteAllButOne
+  // depending on whether this is the singleton Zone in the isolate or
+  // not.
+  void Destroy();

[danno, 2012/06/14 14:22:19]

Why not just make sure that the destructor of the Zone cleans up everything? In
the isolate case, the destructor never gets called and you will always keep
around the extra small segment.

[sanjoy, 2012/06/15 09:24:31]

Yes, that is much cleaner.  Done.

 
   // Deletes the last small segment kept around by DeleteAll().
   void DeleteKeptSegment();
 
   // Returns true if more memory has been allocated in zones than
   // the limit allows.
   inline bool excess_allocation();
 
   inline void adjust_segment_bytes_allocated(int delta);
 
   inline Isolate* isolate() { return isolate_; }
 
   static unsigned allocation_size_;
 
  private:
   friend class Isolate;
   friend class ZoneScope;
 
+  // Frees all memory allocated to this Zone.
+  void DeleteAll();
+
+  // Deletes all objects and free all memory allocated in the Zone. Keeps one
+  // small (size <= kMaximumKeptSegmentSize) segment around if it finds one.
+  void DeleteAllButOne();
+
   // All pointers returned from New() have this alignment.  In addition, if the
   // object being allocated has a size that is divisible by 8 then its alignment
   // will be 8.
   static const int kAlignment = kPointerSize;
 
   // Never allocate segments smaller than this size in bytes.
   static const int kMinimumSegmentSize = 8 * KB;
 
   // Never allocate segments larger than this size in bytes.
   static const int kMaximumSegmentSize = 1 * MB;
 
   // Never keep segments larger than this size in bytes around.
   static const int kMaximumKeptSegmentSize = 64 * KB;
 
   // Report zone excess when allocation exceeds this limit.
   int zone_excess_limit_;
 
   // The number of bytes allocated in segments.  Note that this number
   // includes memory allocated from the OS but not yet allocated from
   // the zone.
   int segment_bytes_allocated_;
 
-  // Each isolate gets its own zone.
-  Zone();
-
   // Expand the Zone to hold at least 'size' more bytes and allocate
   // the bytes. Returns the address of the newly allocated chunk of
   // memory in the Zone. Should only be called if there isn't enough
   // room in the Zone already.
   Address NewExpand(int size);
 
   // Creates a new segment, sets it size, and pushes it to the front
   // of the segment chain. Returns the new segment.
   Segment* NewSegment(int size);
 
@@ skipping 20 matching lines @@
   // Allocate a new ZoneObject of 'size' bytes in the Zone.
   INLINE(void* operator new(size_t size, Zone* zone));
 
   // Ideally, the delete operator should be private instead of
   // public, but unfortunately the compiler sometimes synthesizes
   // (unused) destructors for classes derived from ZoneObject, which
   // require the operator to be visible. MSVC requires the delete
   // operator to be public.
 
   // ZoneObjects should never be deleted individually; use
-  // Zone::DeleteAll() to delete all zone objects in one go.
+  // Zone::Destroy() to delete all zone objects in one go.
   void operator delete(void*, size_t) { UNREACHABLE(); }
   void operator delete(void* pointer, Zone* zone) { UNREACHABLE(); }
 };
 
 
 // The ZoneAllocationPolicy is used to specialize generic data
 // structures to allocate themselves and their elements in the Zone.
 struct ZoneAllocationPolicy {
  public:
   explicit ZoneAllocationPolicy(Zone* zone) : zone_(zone) { }
   INLINE(void* New(size_t size));
   INLINE(static void Delete(void *pointer)) { }
 
  private:
   Zone* zone_;
 };
 
 
 // ZoneLists are growable lists with constant-time access to the
 // elements. The list itself and all its elements are allocated in the
 // Zone. ZoneLists cannot be deleted individually; you can delete all
-// objects in the Zone by calling Zone::DeleteAll().
+// objects in the Zone by calling Zone::Destroy().
 template<typename T>
 class ZoneList: public List<T, ZoneAllocationPolicy> {
  public:
   // Construct a new ZoneList with the given capacity; the length is
   // always zero. The capacity must be non-negative.
   ZoneList(int capacity, Zone* zone)
       : List<T, ZoneAllocationPolicy>(capacity, ZoneAllocationPolicy(zone)) { }
 
   INLINE(void* operator new(size_t size, Zone* zone));
 
@@ skipping 35 matching lines @@
   void operator delete(void* pointer) { UNREACHABLE(); }
   void operator delete(void* pointer, Zone* zone) { UNREACHABLE(); }
 };
 
 
 // ZoneScopes keep track of the current parsing and compilation
 // nesting and cleans up generated ASTs in the Zone when exiting the
 // outer-most scope.
 class ZoneScope BASE_EMBEDDED {
  public:
-  INLINE(ZoneScope(Isolate* isolate, ZoneScopeMode mode));
+  INLINE(ZoneScope(Zone* zone, ZoneScopeMode mode));
 
   virtual ~ZoneScope();
 
   inline bool ShouldDeleteOnExit();
 
   // For ZoneScopes that do not delete on exit by default, call this
   // method to request deletion on exit.
   void DeleteOnExit() {
     mode_ = DELETE_ON_EXIT;
   }
 
   inline static int nesting();
 
  private:
-  Isolate* isolate_;
+  Zone* zone_;
   ZoneScopeMode mode_;
 };
 
 
 // A zone splay tree.  The config type parameter encapsulates the
 // different configurations of a concrete splay tree (see splay-tree.h).
 // The tree itself and all its elements are allocated in the Zone.
 template <typename Config>
 class ZoneSplayTree: public SplayTree<Config, ZoneAllocationPolicy> {
  public:
   explicit ZoneSplayTree(Zone* zone)
       : SplayTree<Config, ZoneAllocationPolicy>(ZoneAllocationPolicy(zone)) {}
   ~ZoneSplayTree();
 };
 
 
 typedef TemplateHashMapImpl<ZoneAllocationPolicy> ZoneHashMap;
 
 } }  // namespace v8::internal
 
 #endif  // V8_ZONE_H_