Revision: 16467
Author: dcar...@chromium.org
Date: Mon Sep 2 11:20:42 2013 UTC
Log: thread isolate in PreallocatedStorageAllocationPolicy
R=svenpa...@chromium.org
BUG=
Review URL: https://codereview.chromium.org/23479015
http://code.google.com/p/v8/source/detail?r=16467
Modified:
/branches/bleeding_edge/src/allocation-inl.h
/branches/bleeding_edge/src/allocation.h
/branches/bleeding_edge/src/isolate.cc
/branches/bleeding_edge/src/list.h
/branches/bleeding_edge/src/string-stream.cc
/branches/bleeding_edge/src/zone.h
/branches/bleeding_edge/test/cctest/test-list.cc
=======================================
--- /branches/bleeding_edge/src/allocation-inl.h Mon Jun 4 14:42:58 2012
UTC
+++ /branches/bleeding_edge/src/allocation-inl.h Mon Sep 2 11:20:42 2013
UTC
@@ -35,12 +35,12 @@
void* PreallocatedStorageAllocationPolicy::New(size_t size) {
- return Isolate::Current()->PreallocatedStorageNew(size);
+ return isolate_->PreallocatedStorageNew(size);
}
void PreallocatedStorageAllocationPolicy::Delete(void* p) {
- return Isolate::Current()->PreallocatedStorageDelete(p);
+ return isolate_->PreallocatedStorageDelete(p);
}
=======================================
--- /branches/bleeding_edge/src/allocation.h Mon Jun 4 14:42:58 2012 UTC
+++ /branches/bleeding_edge/src/allocation.h Mon Sep 2 11:20:42 2013 UTC
@@ -104,6 +104,7 @@
// and free. Used as the default policy for lists.
class FreeStoreAllocationPolicy {
public:
+ typedef FreeStoreAllocationPolicy Deleter;
INLINE(void* New(size_t size)) { return Malloced::New(size); }
INLINE(static void Delete(void* p)) { Malloced::Delete(p); }
};
@@ -131,9 +132,21 @@
};
-struct PreallocatedStorageAllocationPolicy {
+class Isolate;
+
+
+class PreallocatedStorageAllocationPolicy {
+ public:
+ typedef PreallocatedStorageAllocationPolicy Deleter;
+ INLINE(explicit PreallocatedStorageAllocationPolicy(Isolate* isolate))
+ : isolate_(isolate) { }
+ INLINE(PreallocatedStorageAllocationPolicy(
+ const PreallocatedStorageAllocationPolicy& policy))
+ : isolate_(policy.isolate_) { }
INLINE(void* New(size_t size));
- INLINE(static void Delete(void* ptr));
+ INLINE(void Delete(void* ptr));
+ private:
+ Isolate* isolate_;
};
=======================================
--- /branches/bleeding_edge/src/isolate.cc Fri Aug 30 14:54:59 2013 UTC
+++ /branches/bleeding_edge/src/isolate.cc Mon Sep 2 11:20:42 2013 UTC
@@ -2059,7 +2059,7 @@
delete eternal_handles_;
eternal_handles_ = NULL;
- delete string_stream_debug_object_cache_;
+ DebugObjectCache::Delete(string_stream_debug_object_cache_);
string_stream_debug_object_cache_ = NULL;
delete external_reference_table_;
=======================================
--- /branches/bleeding_edge/src/list.h Fri May 3 08:48:53 2013 UTC
+++ /branches/bleeding_edge/src/list.h Mon Sep 2 11:20:42 2013 UTC
@@ -48,13 +48,15 @@
// template <typename T,
// class AllocationPolicy = FreeStoreAllocationPolicy> class
List;
template <typename T, class AllocationPolicy>
-class List {
+class List : private AllocationPolicy::Deleter {
public:
- explicit List(AllocationPolicy allocator = AllocationPolicy()) {
+ explicit List(AllocationPolicy allocator = AllocationPolicy())
+ : AllocationPolicy::Deleter(allocator) {
Initialize(0, allocator);
}
INLINE(explicit List(int capacity,
- AllocationPolicy allocator = AllocationPolicy())) {
+ AllocationPolicy allocator = AllocationPolicy()))
+ : AllocationPolicy::Deleter(allocator) {
Initialize(capacity, allocator);
}
INLINE(~List()) { DeleteData(data_); }
@@ -71,13 +73,20 @@
return allocator.New(static_cast<int>(size));
}
INLINE(void operator delete(void* p)) {
- AllocationPolicy::Delete(p);
+ AllocationPolicy::Deleter::Delete(p);
}
// Please the MSVC compiler. We should never have to execute this.
INLINE(void operator delete(void* p, AllocationPolicy allocator)) {
UNREACHABLE();
}
+
+ // Delete via the instance Deleter
+ static void Delete(List* p) {
+ if (p == NULL) return;
+ p->~List();
+ p->AllocationPolicy::Deleter::Delete(p);
+ }
// Returns a reference to the element at index i. This reference is
// not safe to use after operations that can change the list's
@@ -179,7 +188,7 @@
return static_cast<T*>(allocator.New(n * sizeof(T)));
}
INLINE(void DeleteData(T* data)) {
- AllocationPolicy::Delete(data);
+ this->AllocationPolicy::Deleter::Delete(data);
}
// Increase the capacity of a full list, and add an element.
=======================================
--- /branches/bleeding_edge/src/string-stream.cc Wed Jun 26 14:04:25 2013
UTC
+++ /branches/bleeding_edge/src/string-stream.cc Mon Sep 2 11:20:42 2013
UTC
@@ -204,7 +204,9 @@
}
if (debug_object_cache->length() < kMentionedObjectCacheMaxSize) {
Add("#%d#", debug_object_cache->length());
- debug_object_cache->Add(HeapObject::cast(o));
+ HeapObject* ho = HeapObject::cast(o);
+ PreallocatedStorageAllocationPolicy policy(ho->GetIsolate());
+ debug_object_cache->Add(ho, policy);
} else {
Add("@%p", o);
}
@@ -299,8 +301,9 @@
Isolate* isolate = Isolate::Current();
isolate->set_string_stream_current_security_token(NULL);
if (isolate->string_stream_debug_object_cache() == NULL) {
+ PreallocatedStorageAllocationPolicy policy(isolate);
isolate->set_string_stream_debug_object_cache(
- new List<HeapObject*, PreallocatedStorageAllocationPolicy>(0));
+ new(policy) DebugObjectCache(policy));
}
isolate->string_stream_debug_object_cache()->Clear();
}
=======================================
--- /branches/bleeding_edge/src/zone.h Wed Aug 7 11:24:14 2013 UTC
+++ /branches/bleeding_edge/src/zone.h Mon Sep 2 11:20:42 2013 UTC
@@ -174,6 +174,11 @@
// structures to allocate themselves and their elements in the Zone.
struct ZoneAllocationPolicy {
public:
+ class Deleter {
+ public:
+ INLINE(explicit Deleter(const ZoneAllocationPolicy&)) {}
+ INLINE(static void Delete(void *pointer)) { }
+ };
explicit ZoneAllocationPolicy(Zone* zone) : zone_(zone) { }
INLINE(void* New(size_t size));
INLINE(static void Delete(void *pointer)) { }
=======================================
--- /branches/bleeding_edge/test/cctest/test-list.cc Fri Jul 5 09:52:11
2013 UTC
+++ /branches/bleeding_edge/test/cctest/test-list.cc Mon Sep 2 11:20:42
2013 UTC
@@ -35,6 +35,8 @@
// Use a testing allocator that clears memory before deletion.
class ZeroingAllocationPolicy {
public:
+ typedef ZeroingAllocationPolicy Deleter;
+
void* New(size_t size) {
// Stash the size in the first word to use for Delete.
size_t true_size = size + sizeof(size_t);
--
--
v8-dev mailing list
v8-dev@googlegroups.com
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to v8-dev+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.
