V8GCController.cpp [plain text]
#include "config.h"
#include "V8GCController.h"
#include "ActiveDOMObject.h"
#include "Attr.h"
#include "DOMDataStore.h"
#include "Frame.h"
#include "HTMLImageElement.h"
#include "HTMLNames.h"
#include "MessagePort.h"
#include "SVGElement.h"
#include "V8DOMMap.h"
#include "V8MessagePort.h"
#include "V8Proxy.h"
#include "WrapperTypeInfo.h"
#include <algorithm>
#include <utility>
#include <v8.h>
#include <v8-debug.h>
#include <wtf/HashMap.h>
#include <wtf/StdLibExtras.h>
#include <wtf/UnusedParam.h>
namespace WebCore {
#ifndef NDEBUG
typedef HashMap<v8::Value*, GlobalHandleInfo*> GlobalHandleMap;
static GlobalHandleMap& globalHandleMap()
{
DEFINE_STATIC_LOCAL(GlobalHandleMap, staticGlobalHandleMap, ());
return staticGlobalHandleMap;
}
static void enumerateGlobalHandles()
{
for (GlobalHandleMap::iterator it = globalHandleMap().begin(), end = globalHandleMap().end(); it != end; ++it) {
GlobalHandleInfo* info = it->second;
UNUSED_PARAM(info);
v8::Value* handle = it->first;
UNUSED_PARAM(handle);
}
}
void V8GCController::registerGlobalHandle(GlobalHandleType type, void* host, v8::Persistent<v8::Value> handle)
{
ASSERT(!globalHandleMap().contains(*handle));
globalHandleMap().set(*handle, new GlobalHandleInfo(host, type));
}
void V8GCController::unregisterGlobalHandle(void* host, v8::Persistent<v8::Value> handle)
{
ASSERT(globalHandleMap().contains(*handle));
GlobalHandleInfo* info = globalHandleMap().take(*handle);
ASSERT(info->m_host == host);
delete info;
}
#endif // ifndef NDEBUG
typedef HashMap<Node*, v8::Object*> DOMNodeMap;
typedef HashMap<void*, v8::Object*> DOMObjectMap;
#ifndef NDEBUG
static void enumerateDOMObjectMap(DOMObjectMap& wrapperMap)
{
for (DOMObjectMap::iterator it = wrapperMap.begin(), end = wrapperMap.end(); it != end; ++it) {
v8::Persistent<v8::Object> wrapper(it->second);
WrapperTypeInfo* type = V8DOMWrapper::domWrapperType(wrapper);
void* object = it->first;
UNUSED_PARAM(type);
UNUSED_PARAM(object);
}
}
class DOMObjectVisitor : public DOMWrapperMap<void>::Visitor {
public:
void visitDOMWrapper(void* object, v8::Persistent<v8::Object> wrapper)
{
WrapperTypeInfo* type = V8DOMWrapper::domWrapperType(wrapper);
UNUSED_PARAM(type);
UNUSED_PARAM(object);
}
};
class EnsureWeakDOMNodeVisitor : public DOMWrapperMap<Node>::Visitor {
public:
void visitDOMWrapper(Node* object, v8::Persistent<v8::Object> wrapper)
{
UNUSED_PARAM(object);
ASSERT(wrapper.IsWeak());
}
};
#endif // NDEBUG
static DOMObjectMap& gcProtectedMap()
{
DEFINE_STATIC_LOCAL(DOMObjectMap, staticGcProtectedMap, ());
return staticGcProtectedMap;
}
void V8GCController::gcProtect(void* domObject)
{
if (!domObject)
return;
if (gcProtectedMap().contains(domObject))
return;
if (!getDOMObjectMap().contains(domObject))
return;
v8::Persistent<v8::Object> wrapper = getDOMObjectMap().get(domObject);
if (wrapper.IsEmpty())
return;
gcProtectedMap().set(domObject, *v8::Persistent<v8::Object>::New(wrapper));
}
void V8GCController::gcUnprotect(void* domObject)
{
if (!domObject)
return;
if (!gcProtectedMap().contains(domObject))
return;
v8::Persistent<v8::Object> wrapper(gcProtectedMap().take(domObject));
wrapper.Dispose();
}
class GCPrologueVisitor : public DOMWrapperMap<void>::Visitor {
public:
void visitDOMWrapper(void* object, v8::Persistent<v8::Object> wrapper)
{
WrapperTypeInfo* typeInfo = V8DOMWrapper::domWrapperType(wrapper);
if (V8MessagePort::info.equals(typeInfo)) {
MessagePort* port1 = static_cast<MessagePort*>(object);
if (port1->isEntangled() || port1->hasPendingActivity())
wrapper.ClearWeak();
} else {
ActiveDOMObject* activeDOMObject = typeInfo->toActiveDOMObject(wrapper);
if (activeDOMObject && activeDOMObject->hasPendingActivity())
wrapper.ClearWeak();
}
}
};
class GrouperItem {
public:
GrouperItem(uintptr_t groupId, Node* node, v8::Persistent<v8::Object> wrapper)
: m_groupId(groupId)
, m_node(node)
, m_wrapper(wrapper)
{
}
uintptr_t groupId() const { return m_groupId; }
Node* node() const { return m_node; }
v8::Persistent<v8::Object> wrapper() const { return m_wrapper; }
private:
uintptr_t m_groupId;
Node* m_node;
v8::Persistent<v8::Object> m_wrapper;
};
bool operator<(const GrouperItem& a, const GrouperItem& b)
{
return a.groupId() < b.groupId();
}
typedef Vector<GrouperItem> GrouperList;
class ObjectGrouperVisitor : public DOMWrapperMap<Node>::Visitor {
public:
ObjectGrouperVisitor()
{
}
void visitDOMWrapper(Node* node, v8::Persistent<v8::Object> wrapper)
{
uintptr_t groupId;
if (node->inDocument() || (node->hasTagName(HTMLNames::imgTag) && !static_cast<HTMLImageElement*>(node)->haveFiredLoadEvent()))
groupId = reinterpret_cast<uintptr_t>(node->document());
else {
Node* root = node;
if (node->isAttributeNode()) {
root = static_cast<Attr*>(node)->ownerElement();
if (!root)
return;
} else {
while (root->parent())
root = root->parent();
if (root == node && !node->hasChildNodes() && !node->hasAttributes())
return;
}
groupId = reinterpret_cast<uintptr_t>(root);
}
m_grouper.append(GrouperItem(groupId, node, wrapper));
}
void applyGrouping()
{
std::sort(m_grouper.begin(), m_grouper.end());
for (size_t i = 0; i < m_grouper.size(); ) {
size_t nextKeyIndex = m_grouper.size();
for (size_t j = i; j < m_grouper.size(); ++j) {
if (m_grouper[i].groupId() != m_grouper[j].groupId()) {
nextKeyIndex = j;
break;
}
}
ASSERT(nextKeyIndex > i);
if (nextKeyIndex - i <= 1) {
i = nextKeyIndex;
continue;
}
Vector<v8::Persistent<v8::Value> > group;
group.reserveCapacity(nextKeyIndex - i);
for (; i < nextKeyIndex; ++i) {
v8::Persistent<v8::Value> wrapper = m_grouper[i].wrapper();
if (!wrapper.IsEmpty())
group.append(wrapper);
}
if (group.size() > 1)
v8::V8::AddObjectGroup(&group[0], group.size());
ASSERT(i == nextKeyIndex);
}
}
private:
GrouperList m_grouper;
};
void V8GCController::gcPrologue()
{
v8::HandleScope scope;
#ifndef NDEBUG
DOMObjectVisitor domObjectVisitor;
visitDOMObjectsInCurrentThread(&domObjectVisitor);
#endif
GCPrologueVisitor prologueVisitor;
visitActiveDOMObjectsInCurrentThread(&prologueVisitor);
ObjectGrouperVisitor objectGrouperVisitor;
visitDOMNodesInCurrentThread(&objectGrouperVisitor);
objectGrouperVisitor.applyGrouping();
}
class GCEpilogueVisitor : public DOMWrapperMap<void>::Visitor {
public:
void visitDOMWrapper(void* object, v8::Persistent<v8::Object> wrapper)
{
WrapperTypeInfo* typeInfo = V8DOMWrapper::domWrapperType(wrapper);
if (V8MessagePort::info.equals(typeInfo)) {
MessagePort* port1 = static_cast<MessagePort*>(object);
if ((!wrapper.IsWeak() && !wrapper.IsNearDeath()) || port1->hasPendingActivity())
wrapper.MakeWeak(port1, &DOMDataStore::weakActiveDOMObjectCallback);
} else {
ActiveDOMObject* activeDOMObject = typeInfo->toActiveDOMObject(wrapper);
if (activeDOMObject && activeDOMObject->hasPendingActivity()) {
ASSERT(!wrapper.IsWeak());
wrapper.MakeWeak(object, &DOMDataStore::weakActiveDOMObjectCallback);
}
}
}
};
int V8GCController::workingSetEstimateMB = 0;
namespace {
int getMemoryUsageInMB()
{
#if PLATFORM(CHROMIUM)
return ChromiumBridge::memoryUsageMB();
#else
return 0;
#endif
}
}
void V8GCController::gcEpilogue()
{
v8::HandleScope scope;
GCEpilogueVisitor epilogueVisitor;
visitActiveDOMObjectsInCurrentThread(&epilogueVisitor);
workingSetEstimateMB = getMemoryUsageInMB();
#ifndef NDEBUG
DOMObjectVisitor domObjectVisitor;
visitDOMObjectsInCurrentThread(&domObjectVisitor);
EnsureWeakDOMNodeVisitor weakDOMNodeVisitor;
visitDOMNodesInCurrentThread(&weakDOMNodeVisitor);
enumerateDOMObjectMap(gcProtectedMap());
enumerateGlobalHandles();
#endif
}
void V8GCController::checkMemoryUsage()
{
#if PLATFORM(CHROMIUM)
const int lowUsageMB = 256; const int highUsageMB = 1024; const int highUsageDeltaMB = 128;
int memoryUsageMB = getMemoryUsageInMB();
if ((memoryUsageMB > lowUsageMB && memoryUsageMB > 2 * workingSetEstimateMB) || (memoryUsageMB > highUsageMB && memoryUsageMB > workingSetEstimateMB + highUsageDeltaMB))
v8::V8::LowMemoryNotification();
#endif
}
}