diff options
Diffstat (limited to 'src/3rdparty/v8/src/zone.h')
-rw-r--r-- | src/3rdparty/v8/src/zone.h | 80 |
1 files changed, 53 insertions, 27 deletions
diff --git a/src/3rdparty/v8/src/zone.h b/src/3rdparty/v8/src/zone.h index 8648465..01e887e 100644 --- a/src/3rdparty/v8/src/zone.h +++ b/src/3rdparty/v8/src/zone.h @@ -64,6 +64,8 @@ class Isolate; class Zone { public: + explicit Zone(Isolate* isolate); + ~Zone() { DeleteKeptSegment(); } // 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); @@ -114,9 +116,6 @@ class Zone { // 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 @@ -148,7 +147,6 @@ class Zone { class ZoneObject { public: // Allocate a new ZoneObject of 'size' bytes in the Zone. - INLINE(void* operator new(size_t size)); INLINE(void* operator new(size_t size, Zone* zone)); // Ideally, the delete operator should be private instead of @@ -164,16 +162,16 @@ class ZoneObject { }; -// The ZoneListAllocationPolicy is used to specialize the GenericList -// implementation to allocate ZoneLists and their elements in the -// Zone. -class ZoneListAllocationPolicy { +// The ZoneAllocationPolicy is used to specialize generic data +// structures to allocate themselves and their elements in the Zone. +struct ZoneAllocationPolicy { public: - // Allocate 'size' bytes of memory in the zone. - static void* New(int size); + explicit ZoneAllocationPolicy(Zone* zone) : zone_(zone) { } + INLINE(void* New(size_t size)); + INLINE(static void Delete(void *pointer)) { } - // De-allocation attempts are silently ignored. - static void Delete(void* p) { } + private: + Zone* zone_; }; @@ -182,20 +180,48 @@ class ZoneListAllocationPolicy { // Zone. ZoneLists cannot be deleted individually; you can delete all // objects in the Zone by calling Zone::DeleteAll(). template<typename T> -class ZoneList: public List<T, ZoneListAllocationPolicy> { +class ZoneList: public List<T, ZoneAllocationPolicy> { public: - INLINE(void* operator new(size_t size)); - INLINE(void* operator new(size_t size, Zone* zone)); - // Construct a new ZoneList with the given capacity; the length is // always zero. The capacity must be non-negative. - explicit ZoneList(int capacity) - : List<T, ZoneListAllocationPolicy>(capacity) { } + ZoneList(int capacity, Zone* zone) + : List<T, ZoneAllocationPolicy>(capacity, ZoneAllocationPolicy(zone)) { } + + INLINE(void* operator new(size_t size, Zone* zone)); // Construct a new ZoneList by copying the elements of the given ZoneList. - explicit ZoneList(const ZoneList<T>& other) - : List<T, ZoneListAllocationPolicy>(other.length()) { - AddAll(other); + ZoneList(const ZoneList<T>& other, Zone* zone) + : List<T, ZoneAllocationPolicy>(other.length(), + ZoneAllocationPolicy(zone)) { + AddAll(other, ZoneAllocationPolicy(zone)); + } + + // We add some convenience wrappers so that we can pass in a Zone + // instead of a (less convenient) ZoneAllocationPolicy. + INLINE(void Add(const T& element, Zone* zone)) { + List<T, ZoneAllocationPolicy>::Add(element, ZoneAllocationPolicy(zone)); + } + INLINE(void AddAll(const List<T, ZoneAllocationPolicy>& other, + Zone* zone)) { + List<T, ZoneAllocationPolicy>::AddAll(other, ZoneAllocationPolicy(zone)); + } + INLINE(void AddAll(const Vector<T>& other, Zone* zone)) { + List<T, ZoneAllocationPolicy>::AddAll(other, ZoneAllocationPolicy(zone)); + } + INLINE(void InsertAt(int index, const T& element, Zone* zone)) { + List<T, ZoneAllocationPolicy>::InsertAt(index, element, + ZoneAllocationPolicy(zone)); + } + INLINE(Vector<T> AddBlock(T value, int count, Zone* zone)) { + return List<T, ZoneAllocationPolicy>::AddBlock(value, count, + ZoneAllocationPolicy(zone)); + } + INLINE(void Allocate(int length, Zone* zone)) { + List<T, ZoneAllocationPolicy>::Allocate(length, ZoneAllocationPolicy(zone)); + } + INLINE(void Initialize(int capacity, Zone* zone)) { + List<T, ZoneAllocationPolicy>::Initialize(capacity, + ZoneAllocationPolicy(zone)); } void operator delete(void* pointer) { UNREACHABLE(); } @@ -208,7 +234,7 @@ class ZoneList: public List<T, ZoneListAllocationPolicy> { // outer-most scope. class ZoneScope BASE_EMBEDDED { public: - INLINE(ZoneScope(Isolate* isolate, ZoneScopeMode mode)); + INLINE(ZoneScope(Zone* zone, ZoneScopeMode mode)); virtual ~ZoneScope(); @@ -223,7 +249,7 @@ class ZoneScope BASE_EMBEDDED { inline static int nesting(); private: - Isolate* isolate_; + Zone* zone_; ZoneScopeMode mode_; }; @@ -232,15 +258,15 @@ class ZoneScope BASE_EMBEDDED { // 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, ZoneListAllocationPolicy> { +class ZoneSplayTree: public SplayTree<Config, ZoneAllocationPolicy> { public: - ZoneSplayTree() - : SplayTree<Config, ZoneListAllocationPolicy>() {} + explicit ZoneSplayTree(Zone* zone) + : SplayTree<Config, ZoneAllocationPolicy>(ZoneAllocationPolicy(zone)) {} ~ZoneSplayTree(); }; -typedef TemplateHashMapImpl<ZoneListAllocationPolicy> ZoneHashMap; +typedef TemplateHashMapImpl<ZoneAllocationPolicy> ZoneHashMap; } } // namespace v8::internal |