InspectorHeapAgent.cpp [plain text]
#include "config.h"
#include "InspectorHeapAgent.h"
#include "HeapProfiler.h"
#include "HeapSnapshot.h"
#include "InjectedScript.h"
#include "InjectedScriptManager.h"
#include "InspectorEnvironment.h"
#include "JSCInlines.h"
#include "VM.h"
#include <wtf/Stopwatch.h>
using namespace JSC;
namespace Inspector {
InspectorHeapAgent::InspectorHeapAgent(AgentContext& context)
: InspectorAgentBase(ASCIILiteral("Heap"))
, m_injectedScriptManager(context.injectedScriptManager)
, m_frontendDispatcher(std::make_unique<HeapFrontendDispatcher>(context.frontendRouter))
, m_backendDispatcher(HeapBackendDispatcher::create(context.backendDispatcher, this))
, m_environment(context.environment)
{
}
InspectorHeapAgent::~InspectorHeapAgent()
{
}
void InspectorHeapAgent::didCreateFrontendAndBackend(FrontendRouter*, BackendDispatcher*)
{
}
void InspectorHeapAgent::willDestroyFrontendAndBackend(DisconnectReason)
{
m_tracking = false;
ErrorString ignored;
disable(ignored);
}
void InspectorHeapAgent::enable(ErrorString&)
{
if (m_enabled)
return;
m_enabled = true;
m_environment.vm().heap.addObserver(this);
}
void InspectorHeapAgent::disable(ErrorString&)
{
if (!m_enabled)
return;
m_enabled = false;
m_environment.vm().heap.removeObserver(this);
clearHeapSnapshots();
}
void InspectorHeapAgent::gc(ErrorString&)
{
VM& vm = m_environment.vm();
JSLockHolder lock(vm);
sanitizeStackForVM(&vm);
vm.heap.collectNow(Sync, CollectionScope::Full);
}
void InspectorHeapAgent::snapshot(ErrorString&, double* timestamp, String* snapshotData)
{
VM& vm = m_environment.vm();
JSLockHolder lock(vm);
HeapSnapshotBuilder snapshotBuilder(vm.ensureHeapProfiler());
snapshotBuilder.buildSnapshot();
*timestamp = m_environment.executionStopwatch()->elapsedTime();
*snapshotData = snapshotBuilder.json([&] (const HeapSnapshotNode& node) {
if (Structure* structure = node.cell->structure(vm)) {
if (JSGlobalObject* globalObject = structure->globalObject()) {
if (!m_environment.canAccessInspectedScriptState(globalObject->globalExec()))
return false;
}
}
return true;
});
}
void InspectorHeapAgent::startTracking(ErrorString& errorString)
{
if (m_tracking)
return;
m_tracking = true;
double timestamp;
String snapshotData;
snapshot(errorString, ×tamp, &snapshotData);
m_frontendDispatcher->trackingStart(timestamp, snapshotData);
}
void InspectorHeapAgent::stopTracking(ErrorString& errorString)
{
if (!m_tracking)
return;
m_tracking = false;
double timestamp;
String snapshotData;
snapshot(errorString, ×tamp, &snapshotData);
m_frontendDispatcher->trackingComplete(timestamp, snapshotData);
}
std::optional<HeapSnapshotNode> InspectorHeapAgent::nodeForHeapObjectIdentifier(ErrorString& errorString, unsigned heapObjectIdentifier)
{
HeapProfiler* heapProfiler = m_environment.vm().heapProfiler();
if (!heapProfiler) {
errorString = ASCIILiteral("No heap snapshot");
return std::nullopt;
}
HeapSnapshot* snapshot = heapProfiler->mostRecentSnapshot();
if (!snapshot) {
errorString = ASCIILiteral("No heap snapshot");
return std::nullopt;
}
const std::optional<HeapSnapshotNode> optionalNode = snapshot->nodeForObjectIdentifier(heapObjectIdentifier);
if (!optionalNode) {
errorString = ASCIILiteral("No object for identifier, it may have been collected");
return std::nullopt;
}
return optionalNode;
}
void InspectorHeapAgent::getPreview(ErrorString& errorString, int heapObjectId, Inspector::Protocol::OptOutput<String>* resultString, RefPtr<Inspector::Protocol::Debugger::FunctionDetails>& functionDetails, RefPtr<Inspector::Protocol::Runtime::ObjectPreview>& objectPreview)
{
VM& vm = m_environment.vm();
JSLockHolder lock(vm);
DeferGC deferGC(vm.heap);
unsigned heapObjectIdentifier = static_cast<unsigned>(heapObjectId);
const std::optional<HeapSnapshotNode> optionalNode = nodeForHeapObjectIdentifier(errorString, heapObjectIdentifier);
if (!optionalNode)
return;
JSCell* cell = optionalNode->cell;
if (cell->isString()) {
*resultString = asString(cell)->tryGetValue();
return;
}
Structure* structure = cell->structure(vm);
if (!structure) {
errorString = ASCIILiteral("Unable to get object details - Structure");
return;
}
JSGlobalObject* globalObject = structure->globalObject();
if (!globalObject) {
errorString = ASCIILiteral("Unable to get object details - GlobalObject");
return;
}
InjectedScript injectedScript = m_injectedScriptManager.injectedScriptFor(globalObject->globalExec());
if (injectedScript.hasNoValue()) {
errorString = ASCIILiteral("Unable to get object details - InjectedScript");
return;
}
if (cell->inherits(vm, JSFunction::info())) {
injectedScript.functionDetails(errorString, cell, functionDetails);
return;
}
objectPreview = injectedScript.previewValue(cell);
}
void InspectorHeapAgent::getRemoteObject(ErrorString& errorString, int heapObjectId, const String* const optionalObjectGroup, RefPtr<Inspector::Protocol::Runtime::RemoteObject>& result)
{
VM& vm = m_environment.vm();
JSLockHolder lock(vm);
DeferGC deferGC(vm.heap);
unsigned heapObjectIdentifier = static_cast<unsigned>(heapObjectId);
const std::optional<HeapSnapshotNode> optionalNode = nodeForHeapObjectIdentifier(errorString, heapObjectIdentifier);
if (!optionalNode)
return;
JSCell* cell = optionalNode->cell;
Structure* structure = cell->structure(vm);
if (!structure) {
errorString = ASCIILiteral("Unable to get object details");
return;
}
JSGlobalObject* globalObject = structure->globalObject();
if (!globalObject) {
errorString = ASCIILiteral("Unable to get object details");
return;
}
InjectedScript injectedScript = m_injectedScriptManager.injectedScriptFor(globalObject->globalExec());
if (injectedScript.hasNoValue()) {
errorString = ASCIILiteral("Unable to get object details - InjectedScript");
return;
}
String objectGroup = optionalObjectGroup ? *optionalObjectGroup : String();
result = injectedScript.wrapObject(cell, objectGroup, true);
}
static Inspector::Protocol::Heap::GarbageCollection::Type protocolTypeForHeapOperation(CollectionScope scope)
{
switch (scope) {
case CollectionScope::Full:
return Inspector::Protocol::Heap::GarbageCollection::Type::Full;
case CollectionScope::Eden:
return Inspector::Protocol::Heap::GarbageCollection::Type::Partial;
}
ASSERT_NOT_REACHED();
return Inspector::Protocol::Heap::GarbageCollection::Type::Full;
}
void InspectorHeapAgent::willGarbageCollect()
{
if (!m_enabled)
return;
m_gcStartTime = m_environment.executionStopwatch()->elapsedTime();
}
void InspectorHeapAgent::didGarbageCollect(CollectionScope scope)
{
if (!m_enabled) {
m_gcStartTime = NAN;
return;
}
if (std::isnan(m_gcStartTime)) {
return;
}
double endTime = m_environment.executionStopwatch()->elapsedTime();
dispatchGarbageCollectedEvent(protocolTypeForHeapOperation(scope), m_gcStartTime, endTime);
m_gcStartTime = NAN;
}
void InspectorHeapAgent::clearHeapSnapshots()
{
VM& vm = m_environment.vm();
JSLockHolder lock(vm);
if (HeapProfiler* heapProfiler = vm.heapProfiler()) {
heapProfiler->clearSnapshots();
HeapSnapshotBuilder::resetNextAvailableObjectIdentifier();
}
}
void InspectorHeapAgent::dispatchGarbageCollectedEvent(Inspector::Protocol::Heap::GarbageCollection::Type type, double startTime, double endTime)
{
auto protocolObject = Inspector::Protocol::Heap::GarbageCollection::create()
.setType(type)
.setStartTime(startTime)
.setEndTime(endTime)
.release();
m_frontendDispatcher->garbageCollected(WTFMove(protocolObject));
}
}