blob: 5339840988d4e6f3c719ef84e6e4b49867ef16d0 [file] [log] [blame]
// Copyright 2009 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
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// 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.
#include "v8.h"
#include "api.h"
#include "global-handles.h"
namespace v8 {
namespace internal {
class GlobalHandles::Node : public Malloced {
public:
void Initialize(Object* object) {
// Set the initial value of the handle.
object_ = object;
state_ = NORMAL;
parameter_or_next_free_.parameter = NULL;
callback_ = NULL;
}
Node() {
state_ = DESTROYED;
}
explicit Node(Object* object) {
Initialize(object);
// Initialize link structure.
next_ = NULL;
}
~Node() {
if (state_ != DESTROYED) Destroy();
#ifdef DEBUG
// Zap the values for eager trapping.
object_ = NULL;
next_ = NULL;
parameter_or_next_free_.next_free = NULL;
#endif
}
void Destroy() {
if (state_ == WEAK || IsNearDeath()) {
GlobalHandles::number_of_weak_handles_--;
if (object_->IsJSGlobalObject()) {
GlobalHandles::number_of_global_object_weak_handles_--;
}
}
state_ = DESTROYED;
}
// Accessors for next_.
Node* next() { return next_; }
void set_next(Node* value) { next_ = value; }
Node** next_addr() { return &next_; }
// Accessors for next free node in the free list.
Node* next_free() {
ASSERT(state_ == DESTROYED);
return parameter_or_next_free_.next_free;
}
void set_next_free(Node* value) {
ASSERT(state_ == DESTROYED);
parameter_or_next_free_.next_free = value;
}
// Returns a link from the handle.
static Node* FromLocation(Object** location) {
ASSERT(OFFSET_OF(Node, object_) == 0);
return reinterpret_cast<Node*>(location);
}
// Returns the handle.
Handle<Object> handle() { return Handle<Object>(&object_); }
// Make this handle weak.
void MakeWeak(void* parameter, WeakReferenceCallback callback) {
LOG(HandleEvent("GlobalHandle::MakeWeak", handle().location()));
ASSERT(state_ != DESTROYED);
if (state_ != WEAK && !IsNearDeath()) {
GlobalHandles::number_of_weak_handles_++;
if (object_->IsJSGlobalObject()) {
GlobalHandles::number_of_global_object_weak_handles_++;
}
}
state_ = WEAK;
set_parameter(parameter);
callback_ = callback;
}
void ClearWeakness() {
LOG(HandleEvent("GlobalHandle::ClearWeakness", handle().location()));
ASSERT(state_ != DESTROYED);
if (state_ == WEAK || IsNearDeath()) {
GlobalHandles::number_of_weak_handles_--;
if (object_->IsJSGlobalObject()) {
GlobalHandles::number_of_global_object_weak_handles_--;
}
}
state_ = NORMAL;
set_parameter(NULL);
}
bool IsNearDeath() {
// Check for PENDING to ensure correct answer when processing callbacks.
return state_ == PENDING || state_ == NEAR_DEATH;
}
bool IsWeak() {
return state_ == WEAK;
}
// Returns the id for this weak handle.
void set_parameter(void* parameter) {
ASSERT(state_ != DESTROYED);
parameter_or_next_free_.parameter = parameter;
}
void* parameter() {
ASSERT(state_ != DESTROYED);
return parameter_or_next_free_.parameter;
}
// Returns the callback for this weak handle.
WeakReferenceCallback callback() { return callback_; }
bool PostGarbageCollectionProcessing() {
if (state_ != Node::PENDING) return false;
LOG(HandleEvent("GlobalHandle::Processing", handle().location()));
WeakReferenceCallback func = callback();
if (func == NULL) {
Destroy();
return false;
}
void* par = parameter();
state_ = NEAR_DEATH;
set_parameter(NULL);
v8::Persistent<v8::Object> object = ToApi<v8::Object>(handle());
{
// Forbid reuse of destroyed nodes as they might be already deallocated.
// It's fine though to reuse nodes that were destroyed in weak callback
// as those cannot be deallocated until we are back from the callback.
set_first_free(NULL);
if (first_deallocated()) {
first_deallocated()->set_next(head());
}
// Check that we are not passing a finalized external string to
// the callback.
ASSERT(!object_->IsExternalAsciiString() ||
ExternalAsciiString::cast(object_)->resource() != NULL);
ASSERT(!object_->IsExternalTwoByteString() ||
ExternalTwoByteString::cast(object_)->resource() != NULL);
// Leaving V8.
VMState state(EXTERNAL);
func(object, par);
}
// Absense of explicit cleanup or revival of weak handle
// in most of the cases would lead to memory leak.
ASSERT(state_ != NEAR_DEATH);
return true;
}
// Place the handle address first to avoid offset computation.
Object* object_; // Storage for object pointer.
// Transition diagram:
// NORMAL <-> WEAK -> PENDING -> NEAR_DEATH -> { NORMAL, WEAK, DESTROYED }
enum State {
NORMAL, // Normal global handle.
WEAK, // Flagged as weak but not yet finalized.
PENDING, // Has been recognized as only reachable by weak handles.
NEAR_DEATH, // Callback has informed the handle is near death.
DESTROYED
};
State state_;
private:
// Handle specific callback.
WeakReferenceCallback callback_;
// Provided data for callback. In DESTROYED state, this is used for
// the free list link.
union {
void* parameter;
Node* next_free;
} parameter_or_next_free_;
// Linkage for the list.
Node* next_;
public:
TRACK_MEMORY("GlobalHandles::Node")
};
class GlobalHandles::Pool BASE_EMBEDDED {
public:
Pool() {
current_ = new Chunk();
current_->previous = NULL;
next_ = current_->nodes;
limit_ = current_->nodes + kNodesPerChunk;
}
~Pool() {
if (current_ != NULL) {
Release();
}
}
Node* Allocate() {
if (next_ < limit_) {
return next_++;
}
return SlowAllocate();
}
void Release() {
Chunk* current = current_;
ASSERT(current != NULL); // At least a single block must by allocated
do {
Chunk* previous = current->previous;
delete current;
current = previous;
} while (current != NULL);
current_ = NULL;
next_ = limit_ = NULL;
}
private:
static const int kNodesPerChunk = (1 << 12) - 1;
struct Chunk : public Malloced {
Chunk* previous;
Node nodes[kNodesPerChunk];
};
Node* SlowAllocate() {
Chunk* chunk = new Chunk();
chunk->previous = current_;
current_ = chunk;
Node* new_nodes = current_->nodes;
next_ = new_nodes + 1;
limit_ = new_nodes + kNodesPerChunk;
return new_nodes;
}
Chunk* current_;
Node* next_;
Node* limit_;
};
static GlobalHandles::Pool pool_;
Handle<Object> GlobalHandles::Create(Object* value) {
Counters::global_handles.Increment();
Node* result;
if (first_free()) {
// Take the first node in the free list.
result = first_free();
set_first_free(result->next_free());
} else if (first_deallocated()) {
// Next try deallocated list
result = first_deallocated();
set_first_deallocated(result->next_free());
ASSERT(result->next() == head());
set_head(result);
} else {
// Allocate a new node.
result = pool_.Allocate();
result->set_next(head());
set_head(result);
}
result->Initialize(value);
return result->handle();
}
void GlobalHandles::Destroy(Object** location) {
Counters::global_handles.Decrement();
if (location == NULL) return;
Node* node = Node::FromLocation(location);
node->Destroy();
// Link the destroyed.
node->set_next_free(first_free());
set_first_free(node);
}
void GlobalHandles::MakeWeak(Object** location, void* parameter,
WeakReferenceCallback callback) {
ASSERT(callback != NULL);
Node::FromLocation(location)->MakeWeak(parameter, callback);
}
void GlobalHandles::ClearWeakness(Object** location) {
Node::FromLocation(location)->ClearWeakness();
}
bool GlobalHandles::IsNearDeath(Object** location) {
return Node::FromLocation(location)->IsNearDeath();
}
bool GlobalHandles::IsWeak(Object** location) {
return Node::FromLocation(location)->IsWeak();
}
void GlobalHandles::IterateWeakRoots(ObjectVisitor* v) {
// Traversal of GC roots in the global handle list that are marked as
// WEAK or PENDING.
for (Node* current = head_; current != NULL; current = current->next()) {
if (current->state_ == Node::WEAK
|| current->state_ == Node::PENDING
|| current->state_ == Node::NEAR_DEATH) {
v->VisitPointer(&current->object_);
}
}
}
void GlobalHandles::IterateWeakRoots(WeakReferenceGuest f,
WeakReferenceCallback callback) {
for (Node* current = head_; current != NULL; current = current->next()) {
if (current->IsWeak() && current->callback() == callback) {
f(current->object_, current->parameter());
}
}
}
void GlobalHandles::IdentifyWeakHandles(WeakSlotCallback f) {
for (Node* current = head_; current != NULL; current = current->next()) {
if (current->state_ == Node::WEAK) {
if (f(&current->object_)) {
current->state_ = Node::PENDING;
LOG(HandleEvent("GlobalHandle::Pending", current->handle().location()));
}
}
}
}
int post_gc_processing_count = 0;
bool GlobalHandles::PostGarbageCollectionProcessing() {
// Process weak global handle callbacks. This must be done after the
// GC is completely done, because the callbacks may invoke arbitrary
// API functions.
// At the same time deallocate all DESTROYED nodes.
ASSERT(Heap::gc_state() == Heap::NOT_IN_GC);
const int initial_post_gc_processing_count = ++post_gc_processing_count;
bool next_gc_likely_to_collect_more = false;
Node** p = &head_;
while (*p != NULL) {
if ((*p)->PostGarbageCollectionProcessing()) {
if (initial_post_gc_processing_count != post_gc_processing_count) {
// Weak callback triggered another GC and another round of
// PostGarbageCollection processing. The current node might
// have been deleted in that round, so we need to bail out (or
// restart the processing).
break;
}
}
if ((*p)->state_ == Node::DESTROYED) {
// Delete the link.
Node* node = *p;
*p = node->next(); // Update the link.
if (first_deallocated()) {
first_deallocated()->set_next(node);
}
node->set_next_free(first_deallocated());
set_first_deallocated(node);
next_gc_likely_to_collect_more = true;
} else {
p = (*p)->next_addr();
}
}
set_first_free(NULL);
if (first_deallocated()) {
first_deallocated()->set_next(head());
}
return next_gc_likely_to_collect_more;
}
void GlobalHandles::IterateStrongRoots(ObjectVisitor* v) {
// Traversal of global handles marked as NORMAL.
for (Node* current = head_; current != NULL; current = current->next()) {
if (current->state_ == Node::NORMAL) {
v->VisitPointer(&current->object_);
}
}
}
void GlobalHandles::IterateAllRoots(ObjectVisitor* v) {
for (Node* current = head_; current != NULL; current = current->next()) {
if (current->state_ != Node::DESTROYED) {
v->VisitPointer(&current->object_);
}
}
}
void GlobalHandles::TearDown() {
// Reset all the lists.
set_head(NULL);
set_first_free(NULL);
set_first_deallocated(NULL);
pool_.Release();
}
int GlobalHandles::number_of_weak_handles_ = 0;
int GlobalHandles::number_of_global_object_weak_handles_ = 0;
GlobalHandles::Node* GlobalHandles::head_ = NULL;
GlobalHandles::Node* GlobalHandles::first_free_ = NULL;
GlobalHandles::Node* GlobalHandles::first_deallocated_ = NULL;
void GlobalHandles::RecordStats(HeapStats* stats) {
*stats->global_handle_count = 0;
*stats->weak_global_handle_count = 0;
*stats->pending_global_handle_count = 0;
*stats->near_death_global_handle_count = 0;
*stats->destroyed_global_handle_count = 0;
for (Node* current = head_; current != NULL; current = current->next()) {
*stats->global_handle_count += 1;
if (current->state_ == Node::WEAK) {
*stats->weak_global_handle_count += 1;
} else if (current->state_ == Node::PENDING) {
*stats->pending_global_handle_count += 1;
} else if (current->state_ == Node::NEAR_DEATH) {
*stats->near_death_global_handle_count += 1;
} else if (current->state_ == Node::DESTROYED) {
*stats->destroyed_global_handle_count += 1;
}
}
}
#ifdef DEBUG
void GlobalHandles::PrintStats() {
int total = 0;
int weak = 0;
int pending = 0;
int near_death = 0;
int destroyed = 0;
for (Node* current = head_; current != NULL; current = current->next()) {
total++;
if (current->state_ == Node::WEAK) weak++;
if (current->state_ == Node::PENDING) pending++;
if (current->state_ == Node::NEAR_DEATH) near_death++;
if (current->state_ == Node::DESTROYED) destroyed++;
}
PrintF("Global Handle Statistics:\n");
PrintF(" allocated memory = %" V8_PTR_PREFIX "dB\n", sizeof(Node) * total);
PrintF(" # weak = %d\n", weak);
PrintF(" # pending = %d\n", pending);
PrintF(" # near_death = %d\n", near_death);
PrintF(" # destroyed = %d\n", destroyed);
PrintF(" # total = %d\n", total);
}
void GlobalHandles::Print() {
PrintF("Global handles:\n");
for (Node* current = head_; current != NULL; current = current->next()) {
PrintF(" handle %p to %p (weak=%d)\n",
reinterpret_cast<void*>(current->handle().location()),
reinterpret_cast<void*>(*current->handle()),
current->state_ == Node::WEAK);
}
}
#endif
List<ObjectGroup*>* GlobalHandles::ObjectGroups() {
// Lazily initialize the list to avoid startup time static constructors.
static List<ObjectGroup*> groups(4);
return &groups;
}
void GlobalHandles::AddGroup(Object*** handles, size_t length) {
ObjectGroup* new_entry = new ObjectGroup(length);
for (size_t i = 0; i < length; ++i)
new_entry->objects_.Add(handles[i]);
ObjectGroups()->Add(new_entry);
}
void GlobalHandles::RemoveObjectGroups() {
List<ObjectGroup*>* object_groups = ObjectGroups();
for (int i = 0; i< object_groups->length(); i++) {
delete object_groups->at(i);
}
object_groups->Clear();
}
} } // namespace v8::internal