Index: src/zone.h |
=================================================================== |
--- src/zone.h (revision 3427) |
+++ src/zone.h (working copy) |
@@ -85,14 +85,6 @@ |
// Never keep segments larger than this size in bytes around. |
static const int kMaximumKeptSegmentSize = 64 * KB; |
- // Report zone excess when allocation exceeds this limit. |
- static 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. |
- static int segment_bytes_allocated_; |
- |
// The Zone is intentionally a singleton; you should not try to |
// allocate instances of the class. |
Zone() { UNREACHABLE(); } |
@@ -103,16 +95,42 @@ |
// memory in the Zone. Should only be called if there isn't enough |
// room in the Zone already. |
static Address NewExpand(int size); |
+}; |
+class Segment; |
+class ZoneData { |
+ friend class Zone; |
+ // 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_; |
+ |
// The free region in the current (front) segment is represented as |
// the half-open interval [position, limit). The 'position' variable |
// is guaranteed to be aligned as dictated by kAlignment. |
- static Address position_; |
- static Address limit_; |
+ Address position_; |
+ Address limit_; |
+ |
+ Segment* head_; |
+ int bytes_allocated_; |
+ int nesting_; |
+ bool allow_allocation_; |
+ |
+ ZoneData(); |
+ |
+ friend class V8Context; |
+ friend class ZoneScope; |
+ friend class AssertNoZoneAllocation; |
+ friend class Zone; |
+ friend class Segment; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(ZoneData); |
}; |
- |
// ZoneObject is an abstraction that helps define classes of objects |
// allocated in the Zone. Use it as a base class; see ast.h. |
class ZoneObject { |
@@ -134,17 +152,21 @@ |
class AssertNoZoneAllocation { |
public: |
- AssertNoZoneAllocation() : prev_(allow_allocation_) { |
- allow_allocation_ = false; |
+ AssertNoZoneAllocation() { |
+ V8Context* const v8context = v8_context(); |
+ prev_ = v8context->zone_data_.allow_allocation_; |
+ v8context->zone_data_.allow_allocation_ = false; |
} |
- ~AssertNoZoneAllocation() { allow_allocation_ = prev_; } |
- static bool allow_allocation() { return allow_allocation_; } |
+ ~AssertNoZoneAllocation() { |
+ v8_context()->zone_data_.allow_allocation_ = prev_; |
+ } |
+ static bool allow_allocation(const ZoneData& zone_data) { |
+ return zone_data.allow_allocation_; |
+ } |
private: |
bool prev_; |
- static bool allow_allocation_; |
}; |
- |
// The ZoneListAllocationPolicy is used to specialize the GenericList |
// implementation to allocate ZoneLists and their elements in the |
// Zone. |
@@ -178,16 +200,16 @@ |
class ZoneScope BASE_EMBEDDED { |
public: |
explicit ZoneScope(ZoneScopeMode mode) : mode_(mode) { |
- nesting_++; |
+ v8_context()->zone_data_.nesting_++; |
} |
virtual ~ZoneScope() { |
if (ShouldDeleteOnExit()) Zone::DeleteAll(); |
- --nesting_; |
+ --v8_context()->zone_data_.nesting_; |
} |
bool ShouldDeleteOnExit() { |
- return nesting_ == 1 && mode_ == DELETE_ON_EXIT; |
+ return v8_context()->zone_data_.nesting_ == 1 && mode_ == DELETE_ON_EXIT; |
} |
// For ZoneScopes that do not delete on exit by default, call this |
@@ -196,11 +218,10 @@ |
mode_ = DELETE_ON_EXIT; |
} |
- static int nesting() { return nesting_; } |
+ static int nesting(const ZoneData& zone_data) { return zone_data.nesting_; } |
private: |
ZoneScopeMode mode_; |
- static int nesting_; |
}; |