v8::internal::GlobalHandles Class Reference

#include <global-handles.h>

Collaboration diagram for v8::internal::GlobalHandles:

Classes
class	Node
class	NodeBlock
class	NodeIterator

Public Types
typedef WeakCallbackData< v8::Value, void >::Callback	WeakCallback

Public Member Functions
	~GlobalHandles ()
Handle< Object >	Create (Object *value)
void	RecordStats (HeapStats *stats)
int	NumberOfWeakHandles ()
int	NumberOfGlobalObjectWeakHandles ()
int	global_handles_count () const
int	PostGarbageCollectionProcessing (GarbageCollector collector)
void	IterateStrongRoots (ObjectVisitor *v)
void	IterateAllRoots (ObjectVisitor *v)
void	IterateAllRootsWithClassIds (ObjectVisitor *v)
void	IterateAllRootsInNewSpaceWithClassIds (ObjectVisitor *v)
void	IterateWeakRoots (ObjectVisitor *v)
void	IdentifyWeakHandles (WeakSlotCallback f)
void	IterateNewSpaceStrongAndDependentRoots (ObjectVisitor *v)
void	IdentifyNewSpaceWeakIndependentHandles (WeakSlotCallbackWithHeap f)
void	IterateNewSpaceWeakIndependentRoots (ObjectVisitor *v)
bool	IterateObjectGroups (ObjectVisitor *v, WeakSlotCallbackWithHeap can_skip)
void	AddObjectGroup (Object ***handles, size_t length, v8::RetainedObjectInfo *info)
void	SetObjectGroupId (Object **handle, UniqueId id)
void	SetRetainedObjectInfo (UniqueId id, RetainedObjectInfo *info)
void	SetReferenceFromGroup (UniqueId id, Object **child)
void	SetReference (HeapObject **parent, Object **child)
List< ObjectGroup * > *	object_groups ()
List< ImplicitRefGroup * > *	implicit_ref_groups ()
void	RemoveObjectGroups ()
void	RemoveImplicitRefGroups ()
void	TearDown ()
Isolate *	isolate ()

Static Public Member Functions
static Handle< Object >	CopyGlobal (Object **location)
static void	Destroy (Object **location)
static void	MakeWeak (Object **location, void *parameter, WeakCallback weak_callback)
static void *	ClearWeakness (Object **location)
static void	MarkIndependent (Object **location)
static void	MarkPartiallyDependent (Object **location)
static bool	IsIndependent (Object **location)
static bool	IsNearDeath (Object **location)
static bool	IsWeak (Object **location)

Private Member Functions
	GlobalHandles (Isolate *isolate)
void	ComputeObjectGroupsAndImplicitReferences ()
	DISALLOW_COPY_AND_ASSIGN (GlobalHandles)

Private Attributes
Isolate *	isolate_
int	number_of_global_handles_
NodeBlock *	first_block_
NodeBlock *	first_used_block_
Node *	first_free_
List< Node * >	new_space_nodes_
int	post_gc_processing_count_
List< ObjectGroup * >	object_groups_
List< ImplicitRefGroup * >	implicit_ref_groups_
List< ObjectGroupConnection >	object_group_connections_
List< ObjectGroupRetainerInfo >	retainer_infos_
List< ObjectGroupConnection >	implicit_ref_connections_

Static Private Attributes
static const int	kObjectGroupConnectionsCapacity = 20

Friends
class	Isolate

Detailed Description

Definition at line 100 of file global-handles.h.

Member Typedef Documentation

WeakCallback

typedef WeakCallbackData<v8::Value, void>::Callback v8::internal::GlobalHandles::WeakCallback

Definition at line 113 of file global-handles.h.

Constructor & Destructor Documentation

~GlobalHandles()

v8::internal::GlobalHandles::~GlobalHandles

(

)

Definition at line 437 of file global-handles.cc.

                              {
  NodeBlock* block = first_block_;
  while (block != NULL) {
    NodeBlock* tmp = block->next();
    delete block;
    block = tmp;
  }
  first_block_ = NULL;
}

References first_block_, v8::internal::GlobalHandles::NodeBlock::next(), and NULL.

Here is the call graph for this function:

GlobalHandles()

v8::internal::GlobalHandles::GlobalHandles ( Isolate *  isolate )

explicitprivate

Definition at line 427 of file global-handles.cc.

    : isolate_(isolate),
      number_of_global_handles_(0),
      first_block_(NULL),
      first_used_block_(NULL),
      first_free_(NULL),
      post_gc_processing_count_(0),
      object_group_connections_(kObjectGroupConnectionsCapacity) {}

Member Function Documentation

AddObjectGroup()

void v8::internal::GlobalHandles::AddObjectGroup	(	Object ***	handles,
		size_t	length,
		v8::RetainedObjectInfo *	info
	)

Definition at line 816 of file global-handles.cc.

                                                               {
#ifdef DEBUG
  for (size_t i = 0; i < length; ++i) {
    DCHECK(!Node::FromLocation(handles[i])->is_independent());
  }
#endif
  if (length == 0) {
    if (info != NULL) info->Dispose();
    return;
  }
  ObjectGroup* group = new ObjectGroup(length);
  for (size_t i = 0; i < length; ++i)
    group->objects[i] = handles[i];
  group->info = info;
  object_groups_.Add(group);
}

References DCHECK, v8::RetainedObjectInfo::Dispose(), v8::internal::GlobalHandles::Node::FromLocation(), v8::internal::ObjectGroup::info, NULL, object_groups_, and v8::internal::ObjectGroup::objects.

Here is the call graph for this function:

ClearWeakness()

void * v8::internal::GlobalHandles::ClearWeakness ( Object **  location )

static

Definition at line 485 of file global-handles.cc.

                                                    {
  return Node::FromLocation(location)->ClearWeakness();
}

References v8::internal::GlobalHandles::Node::ClearWeakness(), and v8::internal::GlobalHandles::Node::FromLocation().

Referenced by v8::internal::ScriptCache::Clear(), and v8::V8::ClearWeak().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeObjectGroupsAndImplicitReferences()

void v8::internal::GlobalHandles::ComputeObjectGroupsAndImplicitReferences ( )

private

Definition at line 888 of file global-handles.cc.

                                                             {
  if (object_group_connections_.length() == 0) {
    for (int i = 0; i < retainer_infos_.length(); ++i)
      retainer_infos_[i].info->Dispose();
    retainer_infos_.Clear();
    implicit_ref_connections_.Clear();
    return;
  }
 
  object_group_connections_.Sort();
  retainer_infos_.Sort();
  implicit_ref_connections_.Sort();
 
  int info_index = 0;  // For iterating retainer_infos_.
  UniqueId current_group_id(0);
  int current_group_start = 0;
 
  int current_implicit_refs_start = 0;
  int current_implicit_refs_end = 0;
  for (int i = 0; i <= object_group_connections_.length(); ++i) {
    if (i == 0)
      current_group_id = object_group_connections_[i].id;
    if (i == object_group_connections_.length() ||
        current_group_id != object_group_connections_[i].id) {
      // Group detected: objects in indices [current_group_start, i[.
 
      // Find out which implicit references are related to this group. (We want
      // to ignore object groups which only have 1 object, but that object is
      // needed as a representative object for the implicit refrerence group.)
      while (current_implicit_refs_start < implicit_ref_connections_.length() &&
             implicit_ref_connections_[current_implicit_refs_start].id <
                 current_group_id)
        ++current_implicit_refs_start;
      current_implicit_refs_end = current_implicit_refs_start;
      while (current_implicit_refs_end < implicit_ref_connections_.length() &&
             implicit_ref_connections_[current_implicit_refs_end].id ==
                 current_group_id)
        ++current_implicit_refs_end;
 
      if (current_implicit_refs_end > current_implicit_refs_start) {
        // Find a representative object for the implicit references.
        HeapObject** representative = NULL;
        for (int j = current_group_start; j < i; ++j) {
          Object** object = object_group_connections_[j].object;
          if ((*object)->IsHeapObject()) {
            representative = reinterpret_cast<HeapObject**>(object);
            break;
          }
        }
        if (representative) {
          ImplicitRefGroup* group = new ImplicitRefGroup(
              representative,
              current_implicit_refs_end - current_implicit_refs_start);
          for (int j = current_implicit_refs_start;
               j < current_implicit_refs_end;
               ++j) {
            group->children[j - current_implicit_refs_start] =
                implicit_ref_connections_[j].object;
          }
          implicit_ref_groups_.Add(group);
        }
        current_implicit_refs_start = current_implicit_refs_end;
      }
 
      // Find a RetainedObjectInfo for the group.
      RetainedObjectInfo* info = NULL;
      while (info_index < retainer_infos_.length() &&
             retainer_infos_[info_index].id < current_group_id) {
        retainer_infos_[info_index].info->Dispose();
        ++info_index;
      }
      if (info_index < retainer_infos_.length() &&
          retainer_infos_[info_index].id == current_group_id) {
        // This object group has an associated ObjectGroupRetainerInfo.
        info = retainer_infos_[info_index].info;
        ++info_index;
      }
 
      // Ignore groups which only contain one object.
      if (i > current_group_start + 1) {
        ObjectGroup* group = new ObjectGroup(i - current_group_start);
        for (int j = current_group_start; j < i; ++j) {
          group->objects[j - current_group_start] =
              object_group_connections_[j].object;
        }
        group->info = info;
        object_groups_.Add(group);
      } else if (info) {
        info->Dispose();
      }
 
      if (i < object_group_connections_.length()) {
        current_group_id = object_group_connections_[i].id;
        current_group_start = i;
      }
    }
  }
  object_group_connections_.Clear();
  object_group_connections_.Initialize(kObjectGroupConnectionsCapacity);
  retainer_infos_.Clear();
  implicit_ref_connections_.Clear();
}

References v8::internal::ImplicitRefGroup::children, v8::RetainedObjectInfo::Dispose(), implicit_ref_connections_, implicit_ref_groups_, v8::internal::ObjectGroup::info, kObjectGroupConnectionsCapacity, NULL, object_group_connections_, object_groups_, v8::internal::ObjectGroup::objects, and retainer_infos_.

Referenced by implicit_ref_groups(), IterateObjectGroups(), and object_groups().

Here is the call graph for this function:

Here is the caller graph for this function:

CopyGlobal()

Handle< Object > v8::internal::GlobalHandles::CopyGlobal ( Object **  location )

static

Definition at line 467 of file global-handles.cc.

                                                          {
  DCHECK(location != NULL);
  return Node::FromLocation(location)->GetGlobalHandles()->Create(*location);
}

References Create(), DCHECK, v8::internal::GlobalHandles::Node::FromLocation(), v8::internal::GlobalHandles::Node::GetGlobalHandles(), and NULL.

Referenced by v8::V8::CopyPersistent().

Here is the call graph for this function:

Here is the caller graph for this function:

Create()

Handle< Object > v8::internal::GlobalHandles::Create

(

Object *

value

)

Definition at line 448 of file global-handles.cc.

                                                  {
  if (first_free_ == NULL) {
    first_block_ = new NodeBlock(this, first_block_);
    first_block_->PutNodesOnFreeList(&first_free_);
  }
  DCHECK(first_free_ != NULL);
  // Take the first node in the free list.
  Node* result = first_free_;
  first_free_ = result->next_free();
  result->Acquire(value);
  if (isolate_->heap()->InNewSpace(value) &&
      !result->is_in_new_space_list()) {
    new_space_nodes_.Add(result);
    result->set_in_new_space_list(true);
  }
  return result->handle();
}

References v8::internal::GlobalHandles::Node::Acquire(), DCHECK, first_block_, first_free_, v8::internal::GlobalHandles::Node::handle(), v8::internal::Isolate::heap(), v8::internal::Heap::InNewSpace(), v8::internal::GlobalHandles::Node::is_in_new_space_list(), isolate_, new_space_nodes_, v8::internal::GlobalHandles::Node::next_free, NULL, v8::internal::GlobalHandles::NodeBlock::PutNodesOnFreeList(), and v8::internal::GlobalHandles::Node::set_in_new_space_list().

Referenced by v8::internal::ScriptCache::Add(), CopyGlobal(), v8::internal::DebugInfoListNode::DebugInfoListNode(), v8::V8::GlobalizeReference(), v8::internal::Debug::Load(), v8::internal::ArrayConcatVisitor::set_storage(), v8::internal::Debug::SetEventListener(), and v8::internal::AllocationTracker::UnresolvedLocation::UnresolvedLocation().

Here is the call graph for this function:

Here is the caller graph for this function:

Destroy()

void v8::internal::GlobalHandles::Destroy ( Object **  location )

static

Definition at line 473 of file global-handles.cc.

                                             {
  if (location != NULL) Node::FromLocation(location)->Release();
}

References v8::internal::GlobalHandles::Node::FromLocation(), NULL, and v8::internal::GlobalHandles::Node::Release().

Referenced by v8::internal::ScriptCache::Clear(), v8::internal::ArrayConcatVisitor::clear_storage(), v8::internal::DestroyGlobalHandle(), v8::V8::DisposeGlobal(), v8::internal::AllocationTracker::UnresolvedLocation::HandleWeakScript(), v8::internal::ScriptCache::HandleWeakScript(), v8::internal::Isolate::PopPromise(), v8::internal::Debug::SetEventListener(), v8::internal::Debug::Unload(), v8::internal::DebugInfoListNode::~DebugInfoListNode(), and v8::internal::AllocationTracker::UnresolvedLocation::~UnresolvedLocation().

Here is the call graph for this function:

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

v8::internal::GlobalHandles::DISALLOW_COPY_AND_ASSIGN ( GlobalHandles  )

private

global_handles_count()

int v8::internal::GlobalHandles::global_handles_count ( ) const

inline

Definition at line 135 of file global-handles.h.

                                   {
    return number_of_global_handles_;
  }

References number_of_global_handles_.

IdentifyNewSpaceWeakIndependentHandles()

void v8::internal::GlobalHandles::IdentifyNewSpaceWeakIndependentHandles

(

WeakSlotCallbackWithHeap

f

)

Definition at line 543 of file global-handles.cc.

                                {
  for (int i = 0; i < new_space_nodes_.length(); ++i) {
    Node* node = new_space_nodes_[i];
    DCHECK(node->is_in_new_space_list());
    if ((node->is_independent() || node->is_partially_dependent()) &&
        node->IsWeak() && f(isolate_->heap(), node->location())) {
      node->MarkPending();
    }
  }
}

References DCHECK, v8::internal::Isolate::heap(), v8::internal::GlobalHandles::Node::is_in_new_space_list(), v8::internal::GlobalHandles::Node::is_independent(), v8::internal::GlobalHandles::Node::is_partially_dependent(), isolate_, v8::internal::GlobalHandles::Node::IsWeak(), v8::internal::GlobalHandles::Node::location(), v8::internal::GlobalHandles::Node::MarkPending(), and new_space_nodes_.

Referenced by v8::internal::Heap::Scavenge().

Here is the call graph for this function:

Here is the caller graph for this function:

IdentifyWeakHandles()

void v8::internal::GlobalHandles::IdentifyWeakHandles

(

WeakSlotCallback

f

)

Definition at line 522 of file global-handles.cc.

                                                          {
  for (NodeIterator it(this); !it.done(); it.Advance()) {
    if (it.node()->IsWeak() && f(it.node()->location())) {
      it.node()->MarkPending();
    }
  }
}

References v8::internal::GlobalHandles::NodeIterator::done().

Referenced by v8::internal::MarkCompactCollector::MarkLiveObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

implicit_ref_groups()

List<ImplicitRefGroup*>* v8::internal::GlobalHandles::implicit_ref_groups ( )

inline

Definition at line 233 of file global-handles.h.

                                                 {
    ComputeObjectGroupsAndImplicitReferences();
    return &implicit_ref_groups_;
  }

References ComputeObjectGroupsAndImplicitReferences(), and implicit_ref_groups_.

Referenced by v8::internal::NativeObjectsExplorer::FillImplicitReferences(), and v8::internal::MarkCompactCollector::MarkImplicitRefGroups().

Here is the call graph for this function:

Here is the caller graph for this function:

IsIndependent()

bool v8::internal::GlobalHandles::IsIndependent ( Object **  location )

static

Definition at line 500 of file global-handles.cc.

                                                   {
  return Node::FromLocation(location)->is_independent();
}

References v8::internal::GlobalHandles::Node::FromLocation(), and v8::internal::GlobalHandles::Node::is_independent().

Here is the call graph for this function:

IsNearDeath()

bool v8::internal::GlobalHandles::IsNearDeath ( Object **  location )

static

Definition at line 505 of file global-handles.cc.

                                                 {
  return Node::FromLocation(location)->IsNearDeath();
}

References v8::internal::GlobalHandles::Node::FromLocation(), and v8::internal::GlobalHandles::Node::IsNearDeath().

Here is the call graph for this function:

isolate()

Isolate* v8::internal::GlobalHandles::isolate ( )

inline

Definition at line 245 of file global-handles.h.

{ return isolate_; }

References isolate_.

Referenced by v8::internal::GlobalHandles::Node::DecreaseBlockUses(), v8::internal::GlobalHandles::Node::IncreaseBlockUses(), v8::internal::GlobalHandles::Node::MarkPartiallyDependent(), and v8::internal::GlobalHandles::Node::PostGarbageCollectionProcessing().

Here is the caller graph for this function:

IsWeak()

bool v8::internal::GlobalHandles::IsWeak ( Object **  location )

static

Definition at line 510 of file global-handles.cc.

                                            {
  return Node::FromLocation(location)->IsWeak();
}

References v8::internal::GlobalHandles::Node::FromLocation(), and v8::internal::GlobalHandles::Node::IsWeak().

Here is the call graph for this function:

IterateAllRoots()

void v8::internal::GlobalHandles::IterateAllRoots

(

ObjectVisitor *

v

)

Definition at line 702 of file global-handles.cc.

                                                    {
  for (NodeIterator it(this); !it.done(); it.Advance()) {
    if (it.node()->IsRetainer()) {
      v->VisitPointer(it.node()->location());
    }
  }
}

References v8::internal::GlobalHandles::NodeIterator::done().

Referenced by v8::internal::Heap::IterateStrongRoots(), and v8::internal::V8HeapExplorer::TagGlobalObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

IterateAllRootsInNewSpaceWithClassIds()

void v8::internal::GlobalHandles::IterateAllRootsInNewSpaceWithClassIds

(

ObjectVisitor *

v

)

Definition at line 721 of file global-handles.cc.

                                                                          {
  for (int i = 0; i < new_space_nodes_.length(); ++i) {
    Node* node = new_space_nodes_[i];
    if (node->IsRetainer() && node->has_wrapper_class_id()) {
      v->VisitEmbedderReference(node->location(),
                                node->wrapper_class_id());
    }
  }
}

References v8::internal::GlobalHandles::Node::has_wrapper_class_id(), v8::internal::GlobalHandles::Node::IsRetainer(), v8::internal::GlobalHandles::Node::location(), new_space_nodes_, and v8::internal::GlobalHandles::Node::wrapper_class_id().

Referenced by v8::V8::VisitHandlesForPartialDependence().

Here is the call graph for this function:

Here is the caller graph for this function:

IterateAllRootsWithClassIds()

void v8::internal::GlobalHandles::IterateAllRootsWithClassIds

(

ObjectVisitor *

v

)

Definition at line 711 of file global-handles.cc.

                                                                {
  for (NodeIterator it(this); !it.done(); it.Advance()) {
    if (it.node()->IsRetainer() && it.node()->has_wrapper_class_id()) {
      v->VisitEmbedderReference(it.node()->location(),
                                it.node()->wrapper_class_id());
    }
  }
}

References v8::internal::GlobalHandles::NodeIterator::done().

Referenced by v8::internal::NativeObjectsExplorer::FillRetainedObjects(), and v8::V8::VisitHandlesWithClassIds().

Here is the call graph for this function:

Here is the caller graph for this function:

IterateNewSpaceStrongAndDependentRoots()

void v8::internal::GlobalHandles::IterateNewSpaceStrongAndDependentRoots

(

ObjectVisitor *

v

)

Definition at line 531 of file global-handles.cc.

                                                                           {
  for (int i = 0; i < new_space_nodes_.length(); ++i) {
    Node* node = new_space_nodes_[i];
    if (node->IsStrongRetainer() ||
        (node->IsWeakRetainer() && !node->is_independent() &&
         !node->is_partially_dependent())) {
        v->VisitPointer(node->location());
    }
  }
}

References v8::internal::GlobalHandles::Node::is_independent(), v8::internal::GlobalHandles::Node::is_partially_dependent(), v8::internal::GlobalHandles::Node::IsStrongRetainer(), v8::internal::GlobalHandles::Node::IsWeakRetainer(), v8::internal::GlobalHandles::Node::location(), and new_space_nodes_.

Referenced by v8::internal::Heap::IterateStrongRoots().

Here is the call graph for this function:

Here is the caller graph for this function:

IterateNewSpaceWeakIndependentRoots()

void v8::internal::GlobalHandles::IterateNewSpaceWeakIndependentRoots

(

ObjectVisitor *

v

)

Definition at line 556 of file global-handles.cc.

                                                                        {
  for (int i = 0; i < new_space_nodes_.length(); ++i) {
    Node* node = new_space_nodes_[i];
    DCHECK(node->is_in_new_space_list());
    if ((node->is_independent() || node->is_partially_dependent()) &&
        node->IsWeakRetainer()) {
      v->VisitPointer(node->location());
    }
  }
}

References DCHECK, v8::internal::GlobalHandles::Node::is_in_new_space_list(), v8::internal::GlobalHandles::Node::is_independent(), v8::internal::GlobalHandles::Node::is_partially_dependent(), v8::internal::GlobalHandles::Node::IsWeakRetainer(), v8::internal::GlobalHandles::Node::location(), and new_space_nodes_.

Referenced by v8::internal::Heap::Scavenge().

Here is the call graph for this function:

Here is the caller graph for this function:

IterateObjectGroups()

bool v8::internal::GlobalHandles::IterateObjectGroups	(	ObjectVisitor *	v,
		WeakSlotCallbackWithHeap	can_skip
	)

Definition at line 568 of file global-handles.cc.

                                                                           {
  ComputeObjectGroupsAndImplicitReferences();
  int last = 0;
  bool any_group_was_visited = false;
  for (int i = 0; i < object_groups_.length(); i++) {
    ObjectGroup* entry = object_groups_.at(i);
    DCHECK(entry != NULL);
 
    Object*** objects = entry->objects;
    bool group_should_be_visited = false;
    for (size_t j = 0; j < entry->length; j++) {
      Object* object = *objects[j];
      if (object->IsHeapObject()) {
        if (!can_skip(isolate_->heap(), &object)) {
          group_should_be_visited = true;
          break;
        }
      }
    }
 
    if (!group_should_be_visited) {
      object_groups_[last++] = entry;
      continue;
    }
 
    // An object in the group requires visiting, so iterate over all
    // objects in the group.
    for (size_t j = 0; j < entry->length; ++j) {
      Object* object = *objects[j];
      if (object->IsHeapObject()) {
        v->VisitPointer(&object);
        any_group_was_visited = true;
      }
    }
 
    // Once the entire group has been iterated over, set the object
    // group to NULL so it won't be processed again.
    delete entry;
    object_groups_.at(i) = NULL;
  }
  object_groups_.Rewind(last);
  return any_group_was_visited;
}

References ComputeObjectGroupsAndImplicitReferences(), DCHECK, v8::internal::Isolate::heap(), isolate_, v8::internal::ObjectGroup::length, NULL, object_groups_, and v8::internal::ObjectGroup::objects.

Referenced by v8::internal::MarkCompactCollector::ProcessEphemeralMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

IterateStrongRoots()

void v8::internal::GlobalHandles::IterateStrongRoots

(

ObjectVisitor *

v

)

Definition at line 693 of file global-handles.cc.

                                                       {
  for (NodeIterator it(this); !it.done(); it.Advance()) {
    if (it.node()->IsStrongRetainer()) {
      v->VisitPointer(it.node()->location());
    }
  }
}

References v8::internal::GlobalHandles::NodeIterator::done().

Referenced by v8::internal::Heap::IterateStrongRoots().

Here is the call graph for this function:

Here is the caller graph for this function:

IterateWeakRoots()

void v8::internal::GlobalHandles::IterateWeakRoots

(

ObjectVisitor *

v

)

Definition at line 515 of file global-handles.cc.

                                                     {
  for (NodeIterator it(this); !it.done(); it.Advance()) {
    if (it.node()->IsWeakRetainer()) v->VisitPointer(it.node()->location());
  }
}

References v8::internal::GlobalHandles::NodeIterator::done().

Referenced by v8::internal::MarkCompactCollector::MarkLiveObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeWeak()

void v8::internal::GlobalHandles::MakeWeak ( Object **  location, void *  parameter, WeakCallback  weak_callback  )

static

Definition at line 478 of file global-handles.cc.

                                                         {
  Node::FromLocation(location)->MakeWeak(parameter, weak_callback);
}

References v8::internal::GlobalHandles::Node::FromLocation(), and v8::internal::GlobalHandles::Node::MakeWeak().

Referenced by v8::internal::ScriptCache::Add(), v8::internal::DebugInfoListNode::DebugInfoListNode(), v8::V8::MakeWeak(), and v8::internal::AllocationTracker::UnresolvedLocation::UnresolvedLocation().

Here is the call graph for this function:

Here is the caller graph for this function:

MarkIndependent()

void v8::internal::GlobalHandles::MarkIndependent ( Object **  location )

static

Definition at line 490 of file global-handles.cc.

                                                     {
  Node::FromLocation(location)->MarkIndependent();
}

References v8::internal::GlobalHandles::Node::FromLocation(), and v8::internal::GlobalHandles::Node::MarkIndependent().

Here is the call graph for this function:

MarkPartiallyDependent()

void v8::internal::GlobalHandles::MarkPartiallyDependent ( Object **  location )

static

Definition at line 495 of file global-handles.cc.

                                                            {
  Node::FromLocation(location)->MarkPartiallyDependent();
}

References v8::internal::GlobalHandles::Node::FromLocation(), and v8::internal::GlobalHandles::Node::MarkPartiallyDependent().

Here is the call graph for this function:

NumberOfGlobalObjectWeakHandles()

int v8::internal::GlobalHandles::NumberOfGlobalObjectWeakHandles

(

)

Definition at line 743 of file global-handles.cc.

                                                   {
  int count = 0;
  for (NodeIterator it(this); !it.done(); it.Advance()) {
    if (it.node()->IsWeakRetainer() &&
        it.node()->object()->IsJSGlobalObject()) {
      count++;
    }
  }
  return count;
}

References v8::internal::GlobalHandles::NodeIterator::done().

Here is the call graph for this function:

NumberOfWeakHandles()

int v8::internal::GlobalHandles::NumberOfWeakHandles

(

)

Definition at line 732 of file global-handles.cc.

                                       {
  int count = 0;
  for (NodeIterator it(this); !it.done(); it.Advance()) {
    if (it.node()->IsWeakRetainer()) {
      count++;
    }
  }
  return count;
}

References v8::internal::GlobalHandles::NodeIterator::done().

Referenced by v8::internal::StartupSerializer::SerializeStrongReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

object_groups()

List<ObjectGroup*>* v8::internal::GlobalHandles::object_groups ( )

inline

Definition at line 228 of file global-handles.h.

                                      {
    ComputeObjectGroupsAndImplicitReferences();
    return &object_groups_;
  }

References ComputeObjectGroupsAndImplicitReferences(), and object_groups_.

Referenced by v8::internal::NativeObjectsExplorer::FillRetainedObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

PostGarbageCollectionProcessing()

int v8::internal::GlobalHandles::PostGarbageCollectionProcessing

(

GarbageCollector

collector

)

Definition at line 614 of file global-handles.cc.

                                {
  // Process weak global handle callbacks. This must be done after the
  // GC is completely done, because the callbacks may invoke arbitrary
  // API functions.
  DCHECK(isolate_->heap()->gc_state() == Heap::NOT_IN_GC);
  const int initial_post_gc_processing_count = ++post_gc_processing_count_;
  int freed_nodes = 0;
  if (collector == SCAVENGER) {
    for (int i = 0; i < new_space_nodes_.length(); ++i) {
      Node* node = new_space_nodes_[i];
      DCHECK(node->is_in_new_space_list());
      if (!node->IsRetainer()) {
        // Free nodes do not have weak callbacks. Do not use them to compute
        // the freed_nodes.
        continue;
      }
      // Skip dependent handles. Their weak callbacks might expect to be
      // called between two global garbage collection callbacks which
      // are not called for minor collections.
      if (!node->is_independent() && !node->is_partially_dependent()) {
        continue;
      }
      node->clear_partially_dependent();
      if (node->PostGarbageCollectionProcessing(isolate_)) {
        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).
          return freed_nodes;
        }
      }
      if (!node->IsRetainer()) {
        freed_nodes++;
      }
    }
  } else {
    for (NodeIterator it(this); !it.done(); it.Advance()) {
      if (!it.node()->IsRetainer()) {
        // Free nodes do not have weak callbacks. Do not use them to compute
        // the freed_nodes.
        continue;
      }
      it.node()->clear_partially_dependent();
      if (it.node()->PostGarbageCollectionProcessing(isolate_)) {
        if (initial_post_gc_processing_count != post_gc_processing_count_) {
          // See the comment above.
          return freed_nodes;
        }
      }
      if (!it.node()->IsRetainer()) {
        freed_nodes++;
      }
    }
  }
  // Update the list of new space nodes.
  int last = 0;
  for (int i = 0; i < new_space_nodes_.length(); ++i) {
    Node* node = new_space_nodes_[i];
    DCHECK(node->is_in_new_space_list());
    if (node->IsRetainer()) {
      if (isolate_->heap()->InNewSpace(node->object())) {
        new_space_nodes_[last++] = node;
        isolate_->heap()->IncrementNodesCopiedInNewSpace();
      } else {
        node->set_in_new_space_list(false);
        isolate_->heap()->IncrementNodesPromoted();
      }
    } else {
      node->set_in_new_space_list(false);
      isolate_->heap()->IncrementNodesDiedInNewSpace();
    }
  }
  new_space_nodes_.Rewind(last);
  return freed_nodes;
}

References v8::internal::GlobalHandles::Node::clear_partially_dependent(), DCHECK, v8::internal::GlobalHandles::NodeIterator::done(), v8::internal::Heap::gc_state(), v8::internal::Isolate::heap(), v8::internal::Heap::IncrementNodesCopiedInNewSpace(), v8::internal::Heap::IncrementNodesDiedInNewSpace(), v8::internal::Heap::IncrementNodesPromoted(), v8::internal::Heap::InNewSpace(), v8::internal::GlobalHandles::Node::is_in_new_space_list(), v8::internal::GlobalHandles::Node::is_independent(), v8::internal::GlobalHandles::Node::is_partially_dependent(), isolate_, v8::internal::GlobalHandles::Node::IsRetainer(), new_space_nodes_, v8::internal::Heap::NOT_IN_GC, v8::internal::GlobalHandles::Node::object(), post_gc_processing_count_, v8::internal::GlobalHandles::Node::PostGarbageCollectionProcessing(), v8::internal::SCAVENGER, and v8::internal::GlobalHandles::Node::set_in_new_space_list().

Referenced by v8::internal::Heap::PerformGarbageCollection().

Here is the call graph for this function:

Here is the caller graph for this function:

RecordStats()

void v8::internal::GlobalHandles::RecordStats

(

HeapStats *

stats

)

Definition at line 755 of file global-handles.cc.

                                                {
  *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->free_global_handle_count = 0;
  for (NodeIterator it(this); !it.done(); it.Advance()) {
    *stats->global_handle_count += 1;
    if (it.node()->state() == Node::WEAK) {
      *stats->weak_global_handle_count += 1;
    } else if (it.node()->state() == Node::PENDING) {
      *stats->pending_global_handle_count += 1;
    } else if (it.node()->state() == Node::NEAR_DEATH) {
      *stats->near_death_global_handle_count += 1;
    } else if (it.node()->state() == Node::FREE) {
      *stats->free_global_handle_count += 1;
    }
  }
}

References v8::internal::GlobalHandles::NodeIterator::done(), v8::internal::GlobalHandles::Node::FREE, v8::internal::HeapStats::free_global_handle_count, v8::internal::HeapStats::global_handle_count, v8::internal::GlobalHandles::Node::NEAR_DEATH, v8::internal::HeapStats::near_death_global_handle_count, v8::internal::GlobalHandles::Node::PENDING, v8::internal::HeapStats::pending_global_handle_count, v8::internal::GlobalHandles::Node::WEAK, and v8::internal::HeapStats::weak_global_handle_count.

Referenced by v8::internal::Heap::RecordStats().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveImplicitRefGroups()

void v8::internal::GlobalHandles::RemoveImplicitRefGroups

(

)

Definition at line 874 of file global-handles.cc.

                                            {
  for (int i = 0; i < implicit_ref_groups_.length(); i++) {
    delete implicit_ref_groups_.at(i);
  }
  implicit_ref_groups_.Clear();
  implicit_ref_connections_.Clear();
}

References implicit_ref_connections_, and implicit_ref_groups_.

Referenced by v8::internal::MarkCompactCollector::AfterMarking(), v8::internal::NativeObjectsExplorer::FillImplicitReferences(), and v8::internal::Heap::Scavenge().

Here is the caller graph for this function:

RemoveObjectGroups()

void v8::internal::GlobalHandles::RemoveObjectGroups

(

)

Definition at line 862 of file global-handles.cc.

                                       {
  for (int i = 0; i < object_groups_.length(); i++)
    delete object_groups_.at(i);
  object_groups_.Clear();
  for (int i = 0; i < retainer_infos_.length(); ++i)
    retainer_infos_[i].info->Dispose();
  retainer_infos_.Clear();
  object_group_connections_.Clear();
  object_group_connections_.Initialize(kObjectGroupConnectionsCapacity);
}

References kObjectGroupConnectionsCapacity, object_group_connections_, object_groups_, and retainer_infos_.

Referenced by v8::internal::MarkCompactCollector::AfterMarking(), v8::internal::NativeObjectsExplorer::FillRetainedObjects(), and v8::internal::Heap::Scavenge().

Here is the caller graph for this function:

SetObjectGroupId()

void v8::internal::GlobalHandles::SetObjectGroupId	(	Object **	handle,
		UniqueId	id
	)

Definition at line 836 of file global-handles.cc.

                                                  {
  object_group_connections_.Add(ObjectGroupConnection(id, handle));
}

References v8::internal::handle(), and object_group_connections_.

Referenced by v8::Isolate::SetObjectGroupId().

Here is the call graph for this function:

Here is the caller graph for this function:

SetReference()

void v8::internal::GlobalHandles::SetReference	(	HeapObject **	parent,
		Object **	child
	)

Definition at line 854 of file global-handles.cc.

                                                                    {
  DCHECK(!Node::FromLocation(child)->is_independent());
  ImplicitRefGroup* group = new ImplicitRefGroup(parent, 1);
  group->children[0] = child;
  implicit_ref_groups_.Add(group);
}

References v8::internal::ImplicitRefGroup::children, DCHECK, v8::internal::GlobalHandles::Node::FromLocation(), and implicit_ref_groups_.

Referenced by v8::Isolate::SetReference().

Here is the call graph for this function:

Here is the caller graph for this function:

SetReferenceFromGroup()

void v8::internal::GlobalHandles::SetReferenceFromGroup	(	UniqueId	id,
		Object **	child
	)

Definition at line 848 of file global-handles.cc.

                                                                     {
  DCHECK(!Node::FromLocation(child)->is_independent());
  implicit_ref_connections_.Add(ObjectGroupConnection(id, child));
}

References DCHECK, v8::internal::GlobalHandles::Node::FromLocation(), and implicit_ref_connections_.

Referenced by v8::Isolate::SetReferenceFromGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

SetRetainedObjectInfo()

void v8::internal::GlobalHandles::SetRetainedObjectInfo	(	UniqueId	id,
		RetainedObjectInfo *	info
	)

Definition at line 842 of file global-handles.cc.

                                                                    {
  retainer_infos_.Add(ObjectGroupRetainerInfo(id, info));
}

References retainer_infos_.

Referenced by v8::internal::HeapProfiler::SetRetainedObjectInfo().

Here is the caller graph for this function:

TearDown()

void v8::internal::GlobalHandles::TearDown

(

)

Definition at line 883 of file global-handles.cc.

                             {
  // TODO(1428): invoke weak callbacks.
}

Referenced by v8::internal::Heap::TearDown().

Here is the caller graph for this function:

Friends And Related Function Documentation

Isolate

friend class Isolate

friend

Definition at line 300 of file global-handles.h.

Member Data Documentation

first_block_

NodeBlock* v8::internal::GlobalHandles::first_block_

private

Definition at line 275 of file global-handles.h.

Referenced by Create(), and ~GlobalHandles().

first_free_

Node* v8::internal::GlobalHandles::first_free_

private

Definition at line 281 of file global-handles.h.

Referenced by Create(), and v8::internal::GlobalHandles::Node::DecreaseBlockUses().

first_used_block_

NodeBlock* v8::internal::GlobalHandles::first_used_block_

private

Definition at line 278 of file global-handles.h.

Referenced by v8::internal::GlobalHandles::NodeBlock::DecreaseUses(), and v8::internal::GlobalHandles::NodeBlock::IncreaseUses().

implicit_ref_connections_

List<ObjectGroupConnection> v8::internal::GlobalHandles::implicit_ref_connections_

private

Definition at line 298 of file global-handles.h.

Referenced by ComputeObjectGroupsAndImplicitReferences(), RemoveImplicitRefGroups(), and SetReferenceFromGroup().

implicit_ref_groups_

List<ImplicitRefGroup*> v8::internal::GlobalHandles::implicit_ref_groups_

private

Definition at line 292 of file global-handles.h.

Referenced by ComputeObjectGroupsAndImplicitReferences(), implicit_ref_groups(), RemoveImplicitRefGroups(), and SetReference().

isolate_

Isolate* v8::internal::GlobalHandles::isolate_

private

Definition at line 269 of file global-handles.h.

Referenced by Create(), IdentifyNewSpaceWeakIndependentHandles(), isolate(), IterateObjectGroups(), and PostGarbageCollectionProcessing().

kObjectGroupConnectionsCapacity

const int v8::internal::GlobalHandles::kObjectGroupConnectionsCapacity = 20

staticprivate

Definition at line 262 of file global-handles.h.

Referenced by ComputeObjectGroupsAndImplicitReferences(), and RemoveObjectGroups().

new_space_nodes_

List<Node*> v8::internal::GlobalHandles::new_space_nodes_

private

Definition at line 285 of file global-handles.h.

Referenced by Create(), IdentifyNewSpaceWeakIndependentHandles(), IterateAllRootsInNewSpaceWithClassIds(), IterateNewSpaceStrongAndDependentRoots(), IterateNewSpaceWeakIndependentRoots(), and PostGarbageCollectionProcessing().

number_of_global_handles_

int v8::internal::GlobalHandles::number_of_global_handles_

private

Definition at line 272 of file global-handles.h.

Referenced by v8::internal::GlobalHandles::Node::DecreaseBlockUses(), global_handles_count(), and v8::internal::GlobalHandles::Node::IncreaseBlockUses().

object_group_connections_

List<ObjectGroupConnection> v8::internal::GlobalHandles::object_group_connections_

private

Definition at line 296 of file global-handles.h.

Referenced by ComputeObjectGroupsAndImplicitReferences(), RemoveObjectGroups(), and SetObjectGroupId().

object_groups_

List<ObjectGroup*> v8::internal::GlobalHandles::object_groups_

private

Definition at line 291 of file global-handles.h.

Referenced by AddObjectGroup(), ComputeObjectGroupsAndImplicitReferences(), IterateObjectGroups(), object_groups(), and RemoveObjectGroups().

post_gc_processing_count_

int v8::internal::GlobalHandles::post_gc_processing_count_

private

Definition at line 287 of file global-handles.h.

Referenced by PostGarbageCollectionProcessing().

retainer_infos_

List<ObjectGroupRetainerInfo> v8::internal::GlobalHandles::retainer_infos_

private

Definition at line 297 of file global-handles.h.

Referenced by ComputeObjectGroupsAndImplicitReferences(), RemoveObjectGroups(), and SetRetainedObjectInfo().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/global-handles.h
• /mnt/V8SourceCode/src/global-handles.cc