v8::internal::ScriptCache Class Reference

#include <debug.h>

Inheritance diagram for v8::internal::ScriptCache:

Collaboration diagram for v8::internal::ScriptCache:

Public Member Functions
	ScriptCache (Isolate *isolate)
virtual	~ScriptCache ()
void	Add (Handle< Script > script)
Handle< FixedArray >	GetScripts ()

Private Member Functions
void	Clear ()
Private Member Functions inherited from v8::internal::TemplateHashMapImpl< FreeStoreAllocationPolicy >
	TemplateHashMapImpl (MatchFun match, uint32_t capacity=kDefaultHashMapCapacity, FreeStoreAllocationPolicy allocator=FreeStoreAllocationPolicy())
	~TemplateHashMapImpl ()
Entry *	Lookup (void *key, uint32_t hash, bool insert, FreeStoreAllocationPolicy allocator=FreeStoreAllocationPolicy())
void *	Remove (void *key, uint32_t hash)
void	Clear ()
uint32_t	occupancy () const
uint32_t	capacity () const
Entry *	Start () const
Entry *	Next (Entry *p) const

Static Private Member Functions
static uint32_t	Hash (int key)
static void	HandleWeakScript (const v8::WeakCallbackData< v8::Value, void > &data)
Static Private Member Functions inherited from v8::internal::TemplateHashMapImpl< FreeStoreAllocationPolicy >
static bool	PointersMatch (void *key1, void *key2)

Private Attributes
Isolate *	isolate_

Additional Inherited Members
Private Types inherited from v8::internal::TemplateHashMapImpl< FreeStoreAllocationPolicy >
typedef bool(*	MatchFun) (void *key1, void *key2)
Static Private Attributes inherited from v8::internal::TemplateHashMapImpl< FreeStoreAllocationPolicy >
static const uint32_t	kDefaultHashMapCapacity

Detailed Description

Definition at line 151 of file debug.h.

Constructor & Destructor Documentation

ScriptCache()

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

explicit

Definition at line 591 of file debug.cc.

                                         : HashMap(HashMap::PointersMatch),
                                             isolate_(isolate) {
  Heap* heap = isolate_->heap();
  HandleScope scope(isolate_);
 
  // Perform two GCs to get rid of all unreferenced scripts. The first GC gets
  // rid of all the cached script wrappers and the second gets rid of the
  // scripts which are no longer referenced.
  heap->CollectAllGarbage(Heap::kMakeHeapIterableMask, "ScriptCache");
  heap->CollectAllGarbage(Heap::kMakeHeapIterableMask, "ScriptCache");
 
  // Scan heap for Script objects.
  HeapIterator iterator(heap);
  DisallowHeapAllocation no_allocation;
 
  for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
    if (obj->IsScript() && Script::cast(obj)->HasValidSource()) {
      Add(Handle<Script>(Script::cast(obj)));
    }
  }
}

References Add(), v8::internal::Heap::CollectAllGarbage(), v8::internal::Isolate::heap(), isolate_, v8::internal::Heap::kMakeHeapIterableMask, and NULL.

Here is the call graph for this function:

~ScriptCache()

virtual v8::internal::ScriptCache::~ScriptCache ( )

inlinevirtual

Definition at line 154 of file debug.h.

{ Clear(); }

References Clear().

Here is the call graph for this function:

Member Function Documentation

Add()

void v8::internal::ScriptCache::Add

(

Handle< Script >

script

)

Definition at line 614 of file debug.cc.

                                           {
  GlobalHandles* global_handles = isolate_->global_handles();
  // Create an entry in the hash map for the script.
  int id = script->id()->value();
  HashMap::Entry* entry =
      HashMap::Lookup(reinterpret_cast<void*>(id), Hash(id), true);
  if (entry->value != NULL) {
#ifdef DEBUG
    // The code deserializer may introduce duplicate Script objects.
    // Assert that the Script objects with the same id have the same name.
    Handle<Script> found(reinterpret_cast<Script**>(entry->value));
    DCHECK(script->id() == found->id());
    DCHECK(!script->name()->IsString() ||
           String::cast(script->name())->Equals(String::cast(found->name())));
#endif
    return;
  }
  // Globalize the script object, make it weak and use the location of the
  // global handle as the value in the hash map.
  Handle<Script> script_ =
      Handle<Script>::cast(global_handles->Create(*script));
  GlobalHandles::MakeWeak(reinterpret_cast<Object**>(script_.location()),
                          this,
                          ScriptCache::HandleWeakScript);
  entry->value = script_.location();
}

References v8::internal::Handle< T >::cast(), v8::internal::GlobalHandles::Create(), DCHECK, v8::internal::Isolate::global_handles(), HandleWeakScript(), Hash(), isolate_, v8::internal::TemplateHashMapImpl< FreeStoreAllocationPolicy >::Lookup(), v8::internal::GlobalHandles::MakeWeak(), and NULL.

Referenced by v8::internal::Debug::OnAfterCompile(), and ScriptCache().

Here is the call graph for this function:

Here is the caller graph for this function:

Clear()

void v8::internal::ScriptCache::Clear ( )

private

Definition at line 657 of file debug.cc.

                        {
  // Iterate the script cache to get rid of all the weak handles.
  for (HashMap::Entry* entry = Start(); entry != NULL; entry = Next(entry)) {
    DCHECK(entry != NULL);
    Object** location = reinterpret_cast<Object**>(entry->value);
    DCHECK((*location)->IsScript());
    GlobalHandles::ClearWeakness(location);
    GlobalHandles::Destroy(location);
  }
  // Clear the content of the hash map.
  HashMap::Clear();
}

References v8::internal::TemplateHashMapImpl< FreeStoreAllocationPolicy >::Clear(), v8::internal::GlobalHandles::ClearWeakness(), DCHECK, v8::internal::GlobalHandles::Destroy(), v8::internal::TemplateHashMapImpl< FreeStoreAllocationPolicy >::Next(), NULL, and v8::internal::TemplateHashMapImpl< FreeStoreAllocationPolicy >::Start().

Referenced by ~ScriptCache().

Here is the call graph for this function:

Here is the caller graph for this function:

GetScripts()

Handle< FixedArray > v8::internal::ScriptCache::GetScripts

(

)

Definition at line 642 of file debug.cc.

                                           {
  Factory* factory = isolate_->factory();
  Handle<FixedArray> instances = factory->NewFixedArray(occupancy());
  int count = 0;
  for (HashMap::Entry* entry = Start(); entry != NULL; entry = Next(entry)) {
    DCHECK(entry->value != NULL);
    if (entry->value != NULL) {
      instances->set(count, *reinterpret_cast<Script**>(entry->value));
      count++;
    }
  }
  return instances;
}

References DCHECK, v8::internal::Isolate::factory(), isolate_, v8::internal::TemplateHashMapImpl< FreeStoreAllocationPolicy >::Next(), NULL, v8::internal::TemplateHashMapImpl< FreeStoreAllocationPolicy >::occupancy(), and v8::internal::TemplateHashMapImpl< FreeStoreAllocationPolicy >::Start().

Referenced by v8::internal::Debug::GetLoadedScripts().

Here is the call graph for this function:

Here is the caller graph for this function:

HandleWeakScript()

void v8::internal::ScriptCache::HandleWeakScript ( const v8::WeakCallbackData< v8::Value, void > &  data )

staticprivate

Definition at line 671 of file debug.cc.

                                                   {
  // Retrieve the script identifier.
  Handle<Object> object = Utils::OpenHandle(*data.GetValue());
  int id = Handle<Script>::cast(object)->id()->value();
  void* key = reinterpret_cast<void*>(id);
  uint32_t hash = Hash(id);
 
  // Remove the corresponding entry from the cache.
  ScriptCache* script_cache =
      reinterpret_cast<ScriptCache*>(data.GetParameter());
  HashMap::Entry* entry = script_cache->Lookup(key, hash, false);
  Object** location = reinterpret_cast<Object**>(entry->value);
  script_cache->Remove(key, hash);
 
  // Clear the weak handle.
  GlobalHandles::Destroy(location);
}

References v8::internal::Handle< T >::cast(), v8::internal::GlobalHandles::Destroy(), v8::WeakCallbackData< T, P >::GetParameter(), v8::WeakCallbackData< T, P >::GetValue(), Hash(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Lookup(), v8::Utils::OpenHandle(), and v8::internal::TemplateHashMapImpl< AllocationPolicy >::Remove().

Referenced by Add().

Here is the call graph for this function:

Here is the caller graph for this function:

Hash()

static uint32_t v8::internal::ScriptCache::Hash ( int  key )

inlinestaticprivate

Definition at line 164 of file debug.h.

                                {
    return ComputeIntegerHash(key, v8::internal::kZeroHashSeed);
  }

References v8::internal::ComputeIntegerHash(), and v8::internal::kZeroHashSeed.

Referenced by Add(), and HandleWeakScript().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

isolate_

Isolate* v8::internal::ScriptCache::isolate_

private

Definition at line 175 of file debug.h.

Referenced by Add(), GetScripts(), and ScriptCache().

---

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

• /mnt/V8SourceCode/src/debug.h
• /mnt/V8SourceCode/src/debug.cc