v8::internal::HeapObjectsMap Class Reference

#include <heap-snapshot-generator.h>

Collaboration diagram for v8::internal::HeapObjectsMap:

Classes
struct	EntryInfo
struct	TimeInterval

Public Member Functions
	HeapObjectsMap (Heap *heap)
Heap *	heap () const
SnapshotObjectId	FindEntry (Address addr)
SnapshotObjectId	FindOrAddEntry (Address addr, unsigned int size, bool accessed=true)
bool	MoveObject (Address from, Address to, int size)
void	UpdateObjectSize (Address addr, int size)
SnapshotObjectId	last_assigned_id () const
void	StopHeapObjectsTracking ()
SnapshotObjectId	PushHeapObjectsStats (OutputStream *stream)
size_t	GetUsedMemorySize () const
SnapshotObjectId	GenerateId (v8::RetainedObjectInfo *info)
int	FindUntrackedObjects ()
void	UpdateHeapObjectsMap ()
void	RemoveDeadEntries ()

Static Public Attributes
static const int	kObjectIdStep = 2
static const SnapshotObjectId	kInternalRootObjectId = 1
static const SnapshotObjectId	kGcRootsObjectId
static const SnapshotObjectId	kGcRootsFirstSubrootId
static const SnapshotObjectId	kFirstAvailableObjectId

Private Member Functions
	DISALLOW_COPY_AND_ASSIGN (HeapObjectsMap)

Private Attributes
SnapshotObjectId	next_id_
HashMap	entries_map_
List< EntryInfo >	entries_
List< TimeInterval >	time_intervals_
Heap *	heap_

Detailed Description

Definition at line 204 of file heap-snapshot-generator.h.

Constructor & Destructor Documentation

HeapObjectsMap()

v8::internal::HeapObjectsMap::HeapObjectsMap ( Heap *  heap )

explicit

Definition at line 369 of file heap-snapshot-generator.cc.

    : next_id_(kFirstAvailableObjectId),
      entries_map_(AddressesMatch),
      heap_(heap) {
  // This dummy element solves a problem with entries_map_.
  // When we do lookup in HashMap we see no difference between two cases:
  // it has an entry with NULL as the value or it has created
  // a new entry on the fly with NULL as the default value.
  // With such dummy element we have a guaranty that all entries_map_ entries
  // will have the value field grater than 0.
  // This fact is using in MoveObject method.
  entries_.Add(EntryInfo(0, NULL, 0));
}

References entries_, and NULL.

Member Function Documentation

DISALLOW_COPY_AND_ASSIGN()

v8::internal::HeapObjectsMap::DISALLOW_COPY_AND_ASSIGN ( HeapObjectsMap  )

private

FindEntry()

SnapshotObjectId v8::internal::HeapObjectsMap::FindEntry

(

Address

addr

)

Definition at line 437 of file heap-snapshot-generator.cc.

                                                       {
  HashMap::Entry* entry = entries_map_.Lookup(addr, ComputePointerHash(addr),
                                              false);
  if (entry == NULL) return 0;
  int entry_index = static_cast<int>(reinterpret_cast<intptr_t>(entry->value));
  EntryInfo& entry_info = entries_.at(entry_index);
  DCHECK(static_cast<uint32_t>(entries_.length()) > entries_map_.occupancy());
  return entry_info.id;
}

References v8::internal::ComputePointerHash(), DCHECK, entries_, entries_map_, v8::internal::HeapObjectsMap::EntryInfo::id, v8::internal::TemplateHashMapImpl< AllocationPolicy >::Lookup(), NULL, and v8::internal::TemplateHashMapImpl< AllocationPolicy >::occupancy().

Here is the call graph for this function:

FindOrAddEntry()

SnapshotObjectId v8::internal::HeapObjectsMap::FindOrAddEntry	(	Address	addr,
		unsigned int	size,
		bool	accessed = true
	)

Definition at line 448 of file heap-snapshot-generator.cc.

                                                               {
  DCHECK(static_cast<uint32_t>(entries_.length()) > entries_map_.occupancy());
  HashMap::Entry* entry = entries_map_.Lookup(addr, ComputePointerHash(addr),
                                              true);
  if (entry->value != NULL) {
    int entry_index =
        static_cast<int>(reinterpret_cast<intptr_t>(entry->value));
    EntryInfo& entry_info = entries_.at(entry_index);
    entry_info.accessed = accessed;
    if (FLAG_heap_profiler_trace_objects) {
      PrintF("Update object size : %p with old size %d and new size %d\n",
             addr,
             entry_info.size,
             size);
    }
    entry_info.size = size;
    return entry_info.id;
  }
  entry->value = reinterpret_cast<void*>(entries_.length());
  SnapshotObjectId id = next_id_;
  next_id_ += kObjectIdStep;
  entries_.Add(EntryInfo(id, addr, size, accessed));
  DCHECK(static_cast<uint32_t>(entries_.length()) > entries_map_.occupancy());
  return id;
}

References v8::internal::HeapObjectsMap::EntryInfo::accessed, v8::internal::ComputePointerHash(), DCHECK, entries_, entries_map_, v8::internal::HeapObjectsMap::EntryInfo::id, kObjectIdStep, v8::internal::TemplateHashMapImpl< AllocationPolicy >::Lookup(), next_id_, NULL, v8::internal::TemplateHashMapImpl< AllocationPolicy >::occupancy(), v8::internal::PrintF(), size, and v8::internal::HeapObjectsMap::EntryInfo::size.

Referenced by v8::internal::V8HeapExplorer::AddEntry(), v8::internal::AllocationTracker::AllocationEvent(), UpdateHeapObjectsMap(), and UpdateObjectSize().

Here is the call graph for this function:

Here is the caller graph for this function:

FindUntrackedObjects()

int v8::internal::HeapObjectsMap::FindUntrackedObjects

(

)

Definition at line 555 of file heap-snapshot-generator.cc.

                                         {
  List<HeapObjectInfo> heap_objects(1000);
 
  HeapIterator iterator(heap_);
  int untracked = 0;
  for (HeapObject* obj = iterator.next();
       obj != NULL;
       obj = iterator.next()) {
    HashMap::Entry* entry = entries_map_.Lookup(
      obj->address(), ComputePointerHash(obj->address()), false);
    if (entry == NULL) {
      ++untracked;
      if (FLAG_heap_profiler_trace_objects) {
        heap_objects.Add(HeapObjectInfo(obj, 0));
      }
    } else {
      int entry_index = static_cast<int>(
          reinterpret_cast<intptr_t>(entry->value));
      EntryInfo& entry_info = entries_.at(entry_index);
      if (FLAG_heap_profiler_trace_objects) {
        heap_objects.Add(HeapObjectInfo(obj,
                         static_cast<int>(entry_info.size)));
        if (obj->Size() != static_cast<int>(entry_info.size))
          ++untracked;
      } else {
        CHECK_EQ(obj->Size(), static_cast<int>(entry_info.size));
      }
    }
  }
  if (FLAG_heap_profiler_trace_objects) {
    PrintF("\nBegin HeapObjectsMap::FindUntrackedObjects. %d entries in map.\n",
           entries_map_.occupancy());
    heap_objects.Sort(comparator);
    int last_printed_object = -1;
    bool print_next_object = false;
    for (int i = 0; i < heap_objects.length(); ++i) {
      const HeapObjectInfo& object_info = heap_objects[i];
      if (!object_info.IsValid()) {
        ++untracked;
        if (last_printed_object != i - 1) {
          if (i > 0) {
            PrintF("%d objects were skipped\n", i - 1 - last_printed_object);
            heap_objects[i - 1].Print();
          }
        }
        object_info.Print();
        last_printed_object = i;
        print_next_object = true;
      } else if (print_next_object) {
        object_info.Print();
        print_next_object = false;
        last_printed_object = i;
      }
    }
    if (last_printed_object < heap_objects.length() - 1) {
      PrintF("Last %d objects were skipped\n",
             heap_objects.length() - 1 - last_printed_object);
    }
    PrintF("End HeapObjectsMap::FindUntrackedObjects. %d entries in map.\n\n",
           entries_map_.occupancy());
  }
  return untracked;
}

References v8::internal::List< T, AllocationPolicy >::Add(), CHECK_EQ, v8::internal::anonymous_namespace{heap-snapshot-generator.cc}::comparator(), v8::internal::ComputePointerHash(), entries_, entries_map_, heap_, v8::internal::TemplateHashMapImpl< AllocationPolicy >::Lookup(), NULL, v8::internal::TemplateHashMapImpl< AllocationPolicy >::occupancy(), v8::internal::PrintF(), v8::internal::HeapObjectsMap::EntryInfo::size, and v8::internal::List< T, AllocationPolicy >::Sort().

Here is the call graph for this function:

GenerateId()

SnapshotObjectId v8::internal::HeapObjectsMap::GenerateId

(

v8::RetainedObjectInfo *

info

)

Definition at line 696 of file heap-snapshot-generator.cc.

                                                                      {
  SnapshotObjectId id = static_cast<SnapshotObjectId>(info->GetHash());
  const char* label = info->GetLabel();
  id ^= StringHasher::HashSequentialString(label,
                                           static_cast<int>(strlen(label)),
                                           heap_->HashSeed());
  intptr_t element_count = info->GetElementCount();
  if (element_count != -1)
    id ^= ComputeIntegerHash(static_cast<uint32_t>(element_count),
                             v8::internal::kZeroHashSeed);
  return id << 1;
}

References v8::internal::ComputeIntegerHash(), v8::RetainedObjectInfo::GetElementCount(), v8::RetainedObjectInfo::GetHash(), v8::RetainedObjectInfo::GetLabel(), v8::internal::Heap::HashSeed(), v8::internal::StringHasher::HashSequentialString(), heap_, and v8::internal::kZeroHashSeed.

Referenced by v8::internal::BasicHeapEntriesAllocator::AllocateEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

GetUsedMemorySize()

size_t v8::internal::HeapObjectsMap::GetUsedMemorySize

(

)

const

Definition at line 710 of file heap-snapshot-generator.cc.

                                               {
  return
      sizeof(*this) +
      sizeof(HashMap::Entry) * entries_map_.capacity() +
      GetMemoryUsedByList(entries_) +
      GetMemoryUsedByList(time_intervals_);
}

References v8::internal::TemplateHashMapImpl< AllocationPolicy >::capacity(), entries_, entries_map_, v8::internal::GetMemoryUsedByList(), and time_intervals_.

Here is the call graph for this function:

heap()

Heap* v8::internal::HeapObjectsMap::heap ( ) const

inline

Definition at line 208 of file heap-snapshot-generator.h.

{ return heap_; }

References heap_.

Referenced by v8::internal::AllocationTracker::AllocationEvent().

Here is the caller graph for this function:

last_assigned_id()

SnapshotObjectId v8::internal::HeapObjectsMap::last_assigned_id ( ) const

inline

Definition at line 216 of file heap-snapshot-generator.h.

                                            {
    return next_id_ - kObjectIdStep;
  }

References kObjectIdStep, and next_id_.

Referenced by PushHeapObjectsStats(), and v8::internal::HeapSnapshot::RememberLastJSObjectId().

Here is the caller graph for this function:

MoveObject()

bool v8::internal::HeapObjectsMap::MoveObject	(	Address	from,
		Address	to,
		int	size
	)

Definition at line 384 of file heap-snapshot-generator.cc.

                                                                         {
  DCHECK(to != NULL);
  DCHECK(from != NULL);
  if (from == to) return false;
  void* from_value = entries_map_.Remove(from, ComputePointerHash(from));
  if (from_value == NULL) {
    // It may occur that some untracked object moves to an address X and there
    // is a tracked object at that address. In this case we should remove the
    // entry as we know that the object has died.
    void* to_value = entries_map_.Remove(to, ComputePointerHash(to));
    if (to_value != NULL) {
      int to_entry_info_index =
          static_cast<int>(reinterpret_cast<intptr_t>(to_value));
      entries_.at(to_entry_info_index).addr = NULL;
    }
  } else {
    HashMap::Entry* to_entry = entries_map_.Lookup(to, ComputePointerHash(to),
                                                   true);
    if (to_entry->value != NULL) {
      // We found the existing entry with to address for an old object.
      // Without this operation we will have two EntryInfo's with the same
      // value in addr field. It is bad because later at RemoveDeadEntries
      // one of this entry will be removed with the corresponding entries_map_
      // entry.
      int to_entry_info_index =
          static_cast<int>(reinterpret_cast<intptr_t>(to_entry->value));
      entries_.at(to_entry_info_index).addr = NULL;
    }
    int from_entry_info_index =
        static_cast<int>(reinterpret_cast<intptr_t>(from_value));
    entries_.at(from_entry_info_index).addr = to;
    // Size of an object can change during its life, so to keep information
    // about the object in entries_ consistent, we have to adjust size when the
    // object is migrated.
    if (FLAG_heap_profiler_trace_objects) {
      PrintF("Move object from %p to %p old size %6d new size %6d\n",
             from,
             to,
             entries_.at(from_entry_info_index).size,
             object_size);
    }
    entries_.at(from_entry_info_index).size = object_size;
    to_entry->value = from_value;
  }
  return from_value != NULL;
}

References v8::internal::ComputePointerHash(), DCHECK, entries_, entries_map_, v8::internal::TemplateHashMapImpl< AllocationPolicy >::Lookup(), NULL, v8::internal::PrintF(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Remove(), and to().

Here is the call graph for this function:

PushHeapObjectsStats()

SnapshotObjectId v8::internal::HeapObjectsMap::PushHeapObjectsStats

(

OutputStream *

stream

)

Definition at line 620 of file heap-snapshot-generator.cc.

                                                                          {
  UpdateHeapObjectsMap();
  time_intervals_.Add(TimeInterval(next_id_));
  int prefered_chunk_size = stream->GetChunkSize();
  List<v8::HeapStatsUpdate> stats_buffer;
  DCHECK(!entries_.is_empty());
  EntryInfo* entry_info = &entries_.first();
  EntryInfo* end_entry_info = &entries_.last() + 1;
  for (int time_interval_index = 0;
       time_interval_index < time_intervals_.length();
       ++time_interval_index) {
    TimeInterval& time_interval = time_intervals_[time_interval_index];
    SnapshotObjectId time_interval_id = time_interval.id;
    uint32_t entries_size = 0;
    EntryInfo* start_entry_info = entry_info;
    while (entry_info < end_entry_info && entry_info->id < time_interval_id) {
      entries_size += entry_info->size;
      ++entry_info;
    }
    uint32_t entries_count =
        static_cast<uint32_t>(entry_info - start_entry_info);
    if (time_interval.count != entries_count ||
        time_interval.size != entries_size) {
      stats_buffer.Add(v8::HeapStatsUpdate(
          time_interval_index,
          time_interval.count = entries_count,
          time_interval.size = entries_size));
      if (stats_buffer.length() >= prefered_chunk_size) {
        OutputStream::WriteResult result = stream->WriteHeapStatsChunk(
            &stats_buffer.first(), stats_buffer.length());
        if (result == OutputStream::kAbort) return last_assigned_id();
        stats_buffer.Clear();
      }
    }
  }
  DCHECK(entry_info == end_entry_info);
  if (!stats_buffer.is_empty()) {
    OutputStream::WriteResult result = stream->WriteHeapStatsChunk(
        &stats_buffer.first(), stats_buffer.length());
    if (result == OutputStream::kAbort) return last_assigned_id();
  }
  stream->EndOfStream();
  return last_assigned_id();
}

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::HeapObjectsMap::TimeInterval::count, DCHECK, v8::OutputStream::EndOfStream(), entries_, v8::internal::List< T, AllocationPolicy >::first(), v8::OutputStream::GetChunkSize(), v8::internal::HeapObjectsMap::TimeInterval::id, v8::OutputStream::kAbort, last_assigned_id(), next_id_, v8::internal::HeapObjectsMap::EntryInfo::size, v8::internal::HeapObjectsMap::TimeInterval::size, time_intervals_, UpdateHeapObjectsMap(), and v8::OutputStream::WriteHeapStatsChunk().

Here is the call graph for this function:

RemoveDeadEntries()

void v8::internal::HeapObjectsMap::RemoveDeadEntries

(

)

Definition at line 666 of file heap-snapshot-generator.cc.

                                       {
  DCHECK(entries_.length() > 0 &&
         entries_.at(0).id == 0 &&
         entries_.at(0).addr == NULL);
  int first_free_entry = 1;
  for (int i = 1; i < entries_.length(); ++i) {
    EntryInfo& entry_info = entries_.at(i);
    if (entry_info.accessed) {
      if (first_free_entry != i) {
        entries_.at(first_free_entry) = entry_info;
      }
      entries_.at(first_free_entry).accessed = false;
      HashMap::Entry* entry = entries_map_.Lookup(
          entry_info.addr, ComputePointerHash(entry_info.addr), false);
      DCHECK(entry);
      entry->value = reinterpret_cast<void*>(first_free_entry);
      ++first_free_entry;
    } else {
      if (entry_info.addr) {
        entries_map_.Remove(entry_info.addr,
                            ComputePointerHash(entry_info.addr));
      }
    }
  }
  entries_.Rewind(first_free_entry);
  DCHECK(static_cast<uint32_t>(entries_.length()) - 1 ==
         entries_map_.occupancy());
}

References v8::internal::HeapObjectsMap::EntryInfo::accessed, v8::internal::HeapObjectsMap::EntryInfo::addr, v8::internal::ComputePointerHash(), DCHECK, entries_, entries_map_, v8::internal::TemplateHashMapImpl< AllocationPolicy >::Lookup(), NULL, v8::internal::TemplateHashMapImpl< AllocationPolicy >::occupancy(), and v8::internal::TemplateHashMapImpl< AllocationPolicy >::Remove().

Referenced by UpdateHeapObjectsMap().

Here is the call graph for this function:

Here is the caller graph for this function:

StopHeapObjectsTracking()

void v8::internal::HeapObjectsMap::StopHeapObjectsTracking

(

)

Definition at line 477 of file heap-snapshot-generator.cc.

                                             {
  time_intervals_.Clear();
}

References time_intervals_.

UpdateHeapObjectsMap()

void v8::internal::HeapObjectsMap::UpdateHeapObjectsMap

(

)

Definition at line 482 of file heap-snapshot-generator.cc.

                                          {
  if (FLAG_heap_profiler_trace_objects) {
    PrintF("Begin HeapObjectsMap::UpdateHeapObjectsMap. map has %d entries.\n",
           entries_map_.occupancy());
  }
  heap_->CollectAllGarbage(Heap::kMakeHeapIterableMask,
                          "HeapObjectsMap::UpdateHeapObjectsMap");
  HeapIterator iterator(heap_);
  for (HeapObject* obj = iterator.next();
       obj != NULL;
       obj = iterator.next()) {
    FindOrAddEntry(obj->address(), obj->Size());
    if (FLAG_heap_profiler_trace_objects) {
      PrintF("Update object      : %p %6d. Next address is %p\n",
             obj->address(),
             obj->Size(),
             obj->address() + obj->Size());
    }
  }
  RemoveDeadEntries();
  if (FLAG_heap_profiler_trace_objects) {
    PrintF("End HeapObjectsMap::UpdateHeapObjectsMap. map has %d entries.\n",
           entries_map_.occupancy());
  }
}

References v8::internal::Heap::CollectAllGarbage(), entries_map_, FindOrAddEntry(), heap_, v8::internal::Heap::kMakeHeapIterableMask, NULL, v8::internal::TemplateHashMapImpl< AllocationPolicy >::occupancy(), v8::internal::PrintF(), and RemoveDeadEntries().

Referenced by PushHeapObjectsStats().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateObjectSize()

void v8::internal::HeapObjectsMap::UpdateObjectSize	(	Address	addr,
		int	size
	)

Definition at line 432 of file heap-snapshot-generator.cc.

                                                            {
  FindOrAddEntry(addr, size, false);
}

References FindOrAddEntry(), and size.

Here is the call graph for this function:

Member Data Documentation

entries_

List<EntryInfo> v8::internal::HeapObjectsMap::entries_

private

Definition at line 257 of file heap-snapshot-generator.h.

Referenced by FindEntry(), FindOrAddEntry(), FindUntrackedObjects(), GetUsedMemorySize(), HeapObjectsMap(), MoveObject(), PushHeapObjectsStats(), and RemoveDeadEntries().

entries_map_

HashMap v8::internal::HeapObjectsMap::entries_map_

private

Definition at line 256 of file heap-snapshot-generator.h.

Referenced by FindEntry(), FindOrAddEntry(), FindUntrackedObjects(), GetUsedMemorySize(), MoveObject(), RemoveDeadEntries(), and UpdateHeapObjectsMap().

heap_

Heap* v8::internal::HeapObjectsMap::heap_

private

Definition at line 259 of file heap-snapshot-generator.h.

Referenced by FindUntrackedObjects(), GenerateId(), heap(), and UpdateHeapObjectsMap().

kFirstAvailableObjectId

const SnapshotObjectId v8::internal::HeapObjectsMap::kFirstAvailableObjectId

static

Initial value:

=
    HeapObjectsMap::kGcRootsFirstSubrootId +
    VisitorSynchronization::kNumberOfSyncTags * HeapObjectsMap::kObjectIdStep

Definition at line 230 of file heap-snapshot-generator.h.

Referenced by v8::internal::HeapSnapshot::AddSyntheticRootEntries().

kGcRootsFirstSubrootId

const SnapshotObjectId v8::internal::HeapObjectsMap::kGcRootsFirstSubrootId

static

Initial value:

=
    HeapObjectsMap::kGcRootsObjectId + HeapObjectsMap::kObjectIdStep

Definition at line 229 of file heap-snapshot-generator.h.

Referenced by v8::internal::HeapSnapshot::AddSyntheticRootEntries().

kGcRootsObjectId

const SnapshotObjectId v8::internal::HeapObjectsMap::kGcRootsObjectId

static

Initial value:

=
    HeapObjectsMap::kInternalRootObjectId + HeapObjectsMap::kObjectIdStep

Definition at line 228 of file heap-snapshot-generator.h.

Referenced by v8::internal::HeapSnapshot::AddGcRootsEntry().

kInternalRootObjectId

const SnapshotObjectId v8::internal::HeapObjectsMap::kInternalRootObjectId = 1

static

Definition at line 227 of file heap-snapshot-generator.h.

Referenced by v8::internal::HeapSnapshot::AddRootEntry().

kObjectIdStep

const int v8::internal::HeapObjectsMap::kObjectIdStep = 2

static

Definition at line 226 of file heap-snapshot-generator.h.

Referenced by v8::internal::HeapSnapshot::AddSyntheticRootEntries(), FindOrAddEntry(), and last_assigned_id().

next_id_

SnapshotObjectId v8::internal::HeapObjectsMap::next_id_

private

Definition at line 255 of file heap-snapshot-generator.h.

Referenced by FindOrAddEntry(), last_assigned_id(), and PushHeapObjectsStats().

time_intervals_

List<TimeInterval> v8::internal::HeapObjectsMap::time_intervals_

private

Definition at line 258 of file heap-snapshot-generator.h.

Referenced by GetUsedMemorySize(), PushHeapObjectsStats(), and StopHeapObjectsTracking().

---

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

• /mnt/V8SourceCode/src/heap-snapshot-generator.h
• /mnt/V8SourceCode/src/heap-snapshot-generator.cc