The Chrome DevTools protocol part of the XDK

amalyshe · Raphael Kubo da Costa · commit d79eb7386a48 · 2015-01-26T16:51:15.000+02:00
in-depth allocation tracker

There are three new commands are added by analogy with Chrome DevTools
allocation tracker. Start/Stop and Event which is sent by timer.
Command stopTrackingHeapXDK accepts three parameters: stack depth for unwinding,
Sample After Value - period of timer and a flag to collect retention
information or not. Event sends to the host currently collected data about
symbols/callstack/objects. Command stopTrackingHeapXDK returns the final
info witch is similar to Event passed format with one more parameter: duration
of the collection.

Basing on this info consumer can build allocation call tree for any period of
time, annotate source by self and total allocation mertics and annotate
allocation call tree by the objects, which retain other objects in the memory
diff --git a/Source/bindings/core/v8/ScriptProfiler.cpp b/Source/bindings/core/v8/ScriptProfiler.cpp
@@ -316,4 +316,58 @@ void ScriptProfiler::setIdle(bool isIdle)
         profiler->SetIdle(isIdle);
 }
 
+namespace {
+
+class HeapXDKStream : public v8::OutputStream {
+public:
+    HeapXDKStream(ScriptProfiler::OutputStream* stream) : m_stream(stream) { }
+    virtual void EndOfStream() override { }
+
+    virtual WriteResult WriteAsciiChunk(char* data, int size) override
+    {
+        ASSERT(false);
+        return kAbort;
+    }
+
+    virtual WriteResult WriteHeapXDKChunk(const char* symbols, int symbolsSize,
+                                          const char* frames, int framesSize,
+                                          const char* types, int typesSize,
+                                          const char* chunks, int chunksSize,
+                                          const char* retentions,
+                                          int retentionSize) override
+    {
+        m_stream->write(symbols, symbolsSize, frames, framesSize,
+                        types, typesSize, chunks, chunksSize,
+                        retentions, retentionSize);
+        return kContinue;
+    }
+
+private:
+    ScriptProfiler::OutputStream* m_stream;
+};
+
+}
+
+void ScriptProfiler::requestHeapXDKUpdate(ScriptProfiler::OutputStream* stream)
+{
+    HeapXDKStream heapXDKStream(stream);
+    v8::Isolate::GetCurrent()->GetHeapProfiler()->GetHeapXDKStats(
+            &heapXDKStream);
+}
+
+void ScriptProfiler::startTrackingHeapObjectsXDK(int stackDepth,
+                                                 bool retentions)
+{
+    v8::Isolate::GetCurrent()->GetHeapProfiler()->StartTrackingHeapObjectsXDK(
+            stackDepth, retentions);
+}
+
+PassRefPtr<HeapProfileXDK> ScriptProfiler::stopTrackingHeapObjectsXDK()
+{
+    return HeapProfileXDK::create(
+            v8::Isolate::GetCurrent()
+                    ->GetHeapProfiler()->StopTrackingHeapObjectsXDK());
+}
+
+
 } // namespace blink
diff --git a/Source/bindings/core/v8/ScriptProfiler.h b/Source/bindings/core/v8/ScriptProfiler.h
@@ -57,6 +57,11 @@ class ScriptProfiler {
     public:
         virtual ~OutputStream() { }
         virtual void write(const uint32_t* chunk, const int size) = 0;
+        virtual void write(const char* symbols, int symbolsSize,
+                           const char* frames, int framesSize,
+                           const char* types, int typesSize,
+                           const char* chunks, int chunksSize,
+                           const char* retentions, int retentionsSize) { };
     };
 
     static void collectGarbage();
@@ -70,6 +75,9 @@ class ScriptProfiler {
     static void startTrackingHeapObjects(bool trackAllocations);
     static void stopTrackingHeapObjects();
     static unsigned requestHeapStatsUpdate(OutputStream*);
+    static void startTrackingHeapObjectsXDK(int stackDepth, bool retentions);
+    static PassRefPtr<HeapProfileXDK> stopTrackingHeapObjectsXDK();
+    static void requestHeapXDKUpdate(OutputStream*);
     static void initialize();
     static void visitNodeWrappers(WrappedNodeVisitor*);
     static HashMap<String, double>* currentProfileNameIdleTimeMap();
diff --git a/Source/core/inspector/InspectorHeapProfilerAgent.cpp b/Source/core/inspector/InspectorHeapProfilerAgent.cpp
@@ -61,6 +61,20 @@ class InspectorHeapProfilerAgent::HeapStatsUpdateTask final : public NoBaseWillB
     Timer<HeapStatsUpdateTask> m_timer;
 };
 
+
+class InspectorHeapProfilerAgent::HeapXDKUpdateTask final : public NoBaseWillBeGarbageCollectedFinalized<InspectorHeapProfilerAgent::HeapXDKUpdateTask> {
+public:
+    HeapXDKUpdateTask(InspectorHeapProfilerAgent*);
+    void startTimer(float sav);
+    void resetTimer() { m_timer.stop(); }
+    void onTimer(Timer<HeapXDKUpdateTask>*);
+
+private:
+    InspectorHeapProfilerAgent* m_heapProfilerAgent;
+    Timer<HeapXDKUpdateTask> m_timer;
+};
+
+
 PassOwnPtrWillBeRawPtr<InspectorHeapProfilerAgent> InspectorHeapProfilerAgent::create(InjectedScriptManager* injectedScriptManager)
 {
     return adoptPtrWillBeNoop(new InspectorHeapProfilerAgent(injectedScriptManager));
@@ -326,5 +340,118 @@ void InspectorHeapProfilerAgent::trace(Visitor* visitor)
     InspectorBaseAgent::trace(visitor);
 }
 
+static PassRefPtr<TypeBuilder::HeapProfiler::HeapEventXDK> createHeapProfileXDK(const HeapProfileXDK& heapProfileXDK)
+{
+    RefPtr<TypeBuilder::HeapProfiler::HeapEventXDK> profile = TypeBuilder::HeapProfiler::HeapEventXDK::create()
+        .setDuration(heapProfileXDK.getDuration())
+        .setSymbols(heapProfileXDK.getSymbols())
+        .setFrames(heapProfileXDK.getFrames())
+        .setTypes(heapProfileXDK.getTypes())
+        .setChunks(heapProfileXDK.getChunks())
+        .setRetentions(heapProfileXDK.getRetentions());
+    return profile.release();
+}
+
+InspectorHeapProfilerAgent::HeapXDKUpdateTask::HeapXDKUpdateTask(InspectorHeapProfilerAgent* heapProfilerAgent)
+    : m_heapProfilerAgent(heapProfilerAgent)
+    , m_timer(this, &HeapXDKUpdateTask::onTimer)
+{
+}
+
+void InspectorHeapProfilerAgent::HeapXDKUpdateTask::onTimer(Timer<HeapXDKUpdateTask>*)
+{
+    // The timer is stopped on m_heapProfilerAgent destruction,
+    // so this method will never be called after m_heapProfilerAgent has been destroyed.
+    m_heapProfilerAgent->requestHeapXDKUpdate();
+}
+
+void InspectorHeapProfilerAgent::HeapXDKUpdateTask::startTimer(float sav)
+{
+    ASSERT(!m_timer.isActive());
+    m_timer.startRepeating(sav, FROM_HERE);
+}
+
+void InspectorHeapProfilerAgent::startTrackingHeapXDK(ErrorString*,
+                                                      const int* stack_depth,
+                                                      const int* sav,
+                                                      const bool* retentions)
+{
+    m_state->setBoolean(HeapProfilerAgentState::heapObjectsTrackingEnabled, true);
+
+    // inline of startTrackingHeapObjectsInternal(allocationTrackingEnabled);
+    if (m_heapXDKUpdateTask)
+        return;
+    int stackDepth = 8;
+    if (stack_depth) {
+      stackDepth = *stack_depth;
+    }
+    float sav_timer = 1;
+    if (sav) {
+      sav_timer = (float)*sav / 1000.;
+    }
+    bool needRetentions = retentions && *retentions;
+    ScriptProfiler::startTrackingHeapObjectsXDK(stackDepth, needRetentions );
+    m_heapXDKUpdateTask = adoptPtr(new HeapXDKUpdateTask(this));
+    m_heapXDKUpdateTask->startTimer(sav_timer);
+}
+
+class InspectorHeapProfilerAgent::HeapXDKStream final : public ScriptProfiler::OutputStream {
+public:
+    HeapXDKStream(InspectorHeapProfilerAgent* heapProfilerAgent)
+        : m_heapProfilerAgent(heapProfilerAgent)
+    {
+    }
+
+    virtual void write(const uint32_t* chunk, const int size){}
+    virtual void write(const char* symbols, int symbolsSize,
+                       const char* frames, int framesSize,
+                       const char* types, int typesSize,
+                       const char* chunks, int chunksSize,
+                       const char* retentions, int retentionsSize) override
+    {
+        m_heapProfilerAgent->pushHeapXDKUpdate(symbols, symbolsSize, frames, framesSize,
+                                               types, typesSize, chunks, chunksSize,
+                                               retentions, retentionsSize);
+    }
+private:
+    InspectorHeapProfilerAgent* m_heapProfilerAgent;
+};
+
+void InspectorHeapProfilerAgent::requestHeapXDKUpdate()
+{
+    if (!m_frontend)
+        return;
+    HeapXDKStream stream(this);
+    ScriptProfiler::requestHeapXDKUpdate(&stream);
+}
+
+void InspectorHeapProfilerAgent::stopTrackingHeapXDK(ErrorString* error, RefPtr<TypeBuilder::HeapProfiler::HeapEventXDK>& profile)
+{
+    if (!m_heapXDKUpdateTask) {
+        *error = "Heap object tracking is not started.";
+        return;
+    }
+
+    RefPtr<HeapProfileXDK> heapProfileXDK = ScriptProfiler::stopTrackingHeapObjectsXDK();
+    profile = createHeapProfileXDK(*heapProfileXDK);
+
+    m_heapXDKUpdateTask->resetTimer();
+    m_heapXDKUpdateTask.clear();
+    m_state->setBoolean(HeapProfilerAgentState::heapObjectsTrackingEnabled, false);
+
+}
+void InspectorHeapProfilerAgent::pushHeapXDKUpdate( const char* symbols, int symbolsSize,
+                                        const char* frames, int framesSize,
+                                        const char* types, int typesSize,
+                                        const char* chunks, int chunksSize,
+                                        const char* retentions, int retentionsSize)
+{
+    if (!m_frontend)
+        return;
+    m_frontend->heapXDKUpdate(String(symbols, symbolsSize), String(frames, framesSize),
+                              String(types, typesSize), String(chunks, chunksSize),
+                              String(retentions, retentionsSize));
+}
+
 } // namespace blink
 
diff --git a/Source/core/inspector/InspectorHeapProfilerAgent.h b/Source/core/inspector/InspectorHeapProfilerAgent.h
@@ -61,6 +61,8 @@ class InspectorHeapProfilerAgent final : public InspectorBaseAgent<InspectorHeap
     virtual void disable(ErrorString*) override;
     virtual void startTrackingHeapObjects(ErrorString*, const bool* trackAllocations) override;
     virtual void stopTrackingHeapObjects(ErrorString*, const bool* reportProgress) override;
+    virtual void startTrackingHeapXDK(ErrorString*, const int* stack_depth, const int* sav, const bool* retentions) override;
+    virtual void stopTrackingHeapXDK(ErrorString*, RefPtr<TypeBuilder::HeapProfiler::HeapEventXDK>&) override;
 
     virtual void setFrontend(InspectorFrontend*) override;
     virtual void clearFrontend() override;
@@ -75,18 +77,29 @@ class InspectorHeapProfilerAgent final : public InspectorBaseAgent<InspectorHeap
     class HeapStatsStream;
     class HeapStatsUpdateTask;
 
+    class HeapXDKStream;
+    class HeapXDKUpdateTask;
+
     explicit InspectorHeapProfilerAgent(InjectedScriptManager*);
 
     void requestHeapStatsUpdate();
     void pushHeapStatsUpdate(const uint32_t* const data, const int size);
 
+    void requestHeapXDKUpdate();
+    void pushHeapXDKUpdate(const char* symbols, int symbolsSize,
+                           const char* frames, int framesSize,
+                           const char* types, int typesSize,
+                           const char* chunks, int chunksSize,
+                           const char* retentions, int retentionsSize);
+
     void startTrackingHeapObjectsInternal(bool trackAllocations);
     void stopTrackingHeapObjectsInternal();
 
     RawPtrWillBeMember<InjectedScriptManager> m_injectedScriptManager;
     InspectorFrontend::HeapProfiler* m_frontend;
     unsigned m_nextUserInitiatedHeapSnapshotNumber;
     OwnPtrWillBeMember<HeapStatsUpdateTask> m_heapStatsUpdateTask;
+    OwnPtrWillBeMember<HeapXDKUpdateTask> m_heapXDKUpdateTask;
 };
 
 } // namespace blink
diff --git a/Source/core/inspector/ScriptProfile.cpp b/Source/core/inspector/ScriptProfile.cpp
@@ -135,4 +135,34 @@ PassRefPtr<TypeBuilder::Array<double> > ScriptProfile::buildInspectorObjectForTi
     return array.release();
 }
 
+String HeapProfileXDK::getSymbols() const
+{
+    return String(m_event->getSymbols()); 
+}
+
+String HeapProfileXDK::getFrames() const
+{
+    return String(m_event->getFrames()); 
+}
+
+String HeapProfileXDK::getTypes() const
+{
+    return String(m_event->getTypes()); 
+}
+
+String HeapProfileXDK::getChunks() const
+{
+    return String(m_event->getChunks()); 
+}
+
+int HeapProfileXDK::getDuration() const
+{
+    return (int)m_event->getDuration(); 
+}
+
+String HeapProfileXDK::getRetentions() const
+{
+    return String(m_event->getRetentions());
+}
+
 } // namespace blink
diff --git a/Source/core/inspector/ScriptProfile.h b/Source/core/inspector/ScriptProfile.h
@@ -69,6 +69,30 @@ class ScriptProfile final : public RefCountedWillBeGarbageCollectedFinalized<Scr
     double m_idleTime;
 };
 
+class HeapProfileXDK final : public RefCountedWillBeGarbageCollectedFinalized<HeapProfileXDK> {
+public:
+    static PassRefPtrWillBeRawPtr<HeapProfileXDK> create(v8::HeapEventXDK* event)
+    {
+        return adoptRefWillBeNoop(new HeapProfileXDK(event));
+    }
+
+    String getSymbols() const;
+    String getFrames() const;
+    String getTypes() const;
+    String getChunks() const;
+    String getRetentions() const;
+    int getDuration() const;
+
+private:
+    HeapProfileXDK(v8::HeapEventXDK* event)
+        : m_event(event)
+    {
+    }
+
+    v8::HeapEventXDK* m_event;
+
+};
+
 } // namespace blink
 
 #endif // ScriptProfile_h
diff --git a/Source/devtools/protocol.json b/Source/devtools/protocol.json
@@ -3918,6 +3918,19 @@
                 "id": "HeapSnapshotObjectId",
                 "type": "string",
                 "description": "Heap snapshot object id."
+            },
+            {
+                "id": "HeapEventXDK",
+                "type": "object",
+                "description": "",
+                "properties": [
+                    { "name": "duration", "type": "integer" },
+                    { "name": "symbols", "type": "string" },
+                    { "name": "frames", "type": "string" },
+                    { "name": "types", "type": "string" },
+                    { "name": "chunks", "type": "string" },
+		    { "name": "retentions", "type": "string" }
+                ]
             }
         ],
         "commands": [
@@ -3940,6 +3953,20 @@
                 ]
 
             },
+            {
+                "name": "startTrackingHeapXDK",
+                "parameters": [
+                    { "name": "stack_depth", "type": "integer", "optional": true },
+                    { "name": "sav", "type": "integer", "optional": true },
+                    { "name": "retentions", "type": "boolean", "optional": true }
+                ]
+            },
+            {
+                "name": "stopTrackingHeapXDK",
+                "returns": [
+                    { "name": "profileXDK", "$ref": "HeapEventXDK", "description": "Recorded profile." }
+                ]
+            },
             {
                 "name": "takeHeapSnapshot",
                 "parameters": [
@@ -4001,7 +4028,17 @@
                 "parameters": [
                     { "name": "statsUpdate", "type": "array", "items": { "type": "integer" }, "description": "An array of triplets. Each triplet describes a fragment. The first integer is the fragment index, the second integer is a total count of objects for the fragment, the third integer is a total size of the objects for the fragment."}
                 ]
-            }
+            },
+	    {
+                "name": "heapXDKUpdate",
+                "parameters": [
+		    { "name": "symbols", "type": "string" },
+		    { "name": "frames", "type": "string" },
+		    { "name": "types", "type": "string" },
+		    { "name": "chunks", "type": "string" },
+		    { "name": "retentions", "type": "string" }
+		 ]
+	    }
         ]
     },
     {
