QV8Profiler: Rename the global static instance
[profile/ivi/qtdeclarative.git] / src / declarative / debugger / qv8profilerservice.cpp
1 /****************************************************************************
2 **
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
6 **
7 ** This file is part of the QtDeclarative module of the Qt Toolkit.
8 **
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** GNU Lesser General Public License Usage
11 ** This file may be used under the terms of the GNU Lesser General Public
12 ** License version 2.1 as published by the Free Software Foundation and
13 ** appearing in the file LICENSE.LGPL included in the packaging of this
14 ** file. Please review the following information to ensure the GNU Lesser
15 ** General Public License version 2.1 requirements will be met:
16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
17 **
18 ** In addition, as a special exception, Nokia gives you certain additional
19 ** rights. These rights are described in the Nokia Qt LGPL Exception
20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
21 **
22 ** GNU General Public License Usage
23 ** Alternatively, this file may be used under the terms of the GNU General
24 ** Public License version 3.0 as published by the Free Software Foundation
25 ** and appearing in the file LICENSE.GPL included in the packaging of this
26 ** file. Please review the following information to ensure the GNU General
27 ** Public License version 3.0 requirements will be met:
28 ** http://www.gnu.org/copyleft/gpl.html.
29 **
30 ** Other Usage
31 ** Alternatively, this file may be used in accordance with the terms and
32 ** conditions contained in a signed written agreement between you and Nokia.
33 **
34 **
35 **
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42 #include "qv8profilerservice_p.h"
43 #include "qdeclarativedebugservice_p_p.h"
44 #include <private/qdeclarativeengine_p.h>
45 #include <private/qv8profiler_p.h>
46
47 #include <QtCore/QHash>
48
49 QT_BEGIN_NAMESPACE
50
51 Q_GLOBAL_STATIC(QV8ProfilerService, v8ProfilerInstance)
52
53 class ByteArrayOutputStream : public v8::OutputStream
54 {
55     QByteArray *_buffer;
56 public:
57     ByteArrayOutputStream(QByteArray *buffer)
58         : v8::OutputStream(),
59           _buffer(buffer) {}
60     void EndOfStream() {}
61     WriteResult WriteAsciiChunk(char *data, int size)
62     {
63         QByteArray b(data, size);
64         _buffer->append(b);
65         return kContinue;
66     }
67 };
68
69 // convert to a QByteArray that can be sent to the debug client
70 QByteArray QV8ProfilerData::toByteArray() const
71 {
72     QByteArray data;
73     //### using QDataStream is relatively expensive
74     QDataStream ds(&data, QIODevice::WriteOnly);
75     ds << messageType << filename << functionname << lineNumber << totalTime << selfTime << treeLevel;
76
77     return data;
78 }
79
80 class QV8ProfilerServicePrivate : public QDeclarativeDebugServicePrivate
81 {
82     Q_DECLARE_PUBLIC(QV8ProfilerService)
83
84 public:
85     QV8ProfilerServicePrivate()
86         :initialized(false)
87     {
88     }
89
90     void takeSnapshot(v8::HeapSnapshot::Type);
91
92     void printProfileTree(const v8::CpuProfileNode *node, int level = 0);
93     void sendMessages();
94
95     QList<QV8ProfilerData> m_data;
96
97     bool initialized;
98     QList<QDeclarativeEngine *> engines;
99 };
100
101 QV8ProfilerService::QV8ProfilerService(QObject *parent)
102     : QDeclarativeDebugService(*(new QV8ProfilerServicePrivate()), QLatin1String("V8Profiler"), parent)
103 {
104     Q_D(QV8ProfilerService);
105     if (status() == Enabled) {
106         // ,block mode, client attached
107         while (!d->initialized)
108             waitForMessage();
109     }
110 }
111
112 QV8ProfilerService::~QV8ProfilerService()
113 {
114 }
115
116 QV8ProfilerService *QV8ProfilerService::instance()
117 {
118     return v8ProfilerInstance();
119 }
120
121 void QV8ProfilerService::addEngine(QDeclarativeEngine *engine)
122 {
123     Q_D(QV8ProfilerService);
124     Q_ASSERT(engine);
125     Q_ASSERT(!d->engines.contains(engine));
126
127     d->engines.append(engine);
128 }
129
130 void QV8ProfilerService::removeEngine(QDeclarativeEngine *engine)
131 {
132     Q_D(QV8ProfilerService);
133     Q_ASSERT(engine);
134     Q_ASSERT(d->engines.contains(engine));
135
136     d->engines.removeOne(engine);
137 }
138
139 void QV8ProfilerService::messageReceived(const QByteArray &message)
140 {
141     Q_D(QV8ProfilerService);
142
143     QDataStream ds(message);
144     QByteArray command;
145     QByteArray option;
146     QByteArray title;
147     ds >> command >> option;
148
149     if (command == "V8PROFILER") {
150         ds >>  title;
151         if (option == "start") {
152             startProfiling(QString::fromUtf8(title));
153         } else if (option == "stop") {
154             stopProfiling(QString::fromUtf8(title));
155             // Send messages to client
156             d->sendMessages();
157         }
158         d->initialized = true;
159     }
160
161     if (command == "V8SNAPSHOT") {
162         if (option == "full")
163             d->takeSnapshot(v8::HeapSnapshot::kFull);
164         else if (option == "delete") {
165             v8::HeapProfiler::DeleteAllSnapshots();
166         }
167     }
168
169     QDeclarativeDebugService::messageReceived(message);
170 }
171
172 void QV8ProfilerService::startProfiling(const QString &title)
173 {
174     // Start Profiling
175     v8::HandleScope handle_scope;
176     v8::Handle<v8::String> v8title = v8::String::New(reinterpret_cast<const uint16_t*>(title.data()), title.size());
177     v8::CpuProfiler::StartProfiling(v8title);
178 }
179
180 void QV8ProfilerService::stopProfiling(const QString &title)
181 {
182     Q_D(QV8ProfilerService);
183     // Stop profiling
184     v8::HandleScope handle_scope;
185     v8::Handle<v8::String> v8title = v8::String::New(reinterpret_cast<const uint16_t*>(title.data()), title.size());
186     const v8::CpuProfile *cpuProfile = v8::CpuProfiler::StopProfiling(v8title);
187     if (cpuProfile) {
188         // can happen at start
189         const v8::CpuProfileNode *rootNode = cpuProfile->GetTopDownRoot();
190         d->printProfileTree(rootNode);
191     }
192 }
193
194 void QV8ProfilerServicePrivate::printProfileTree(const v8::CpuProfileNode *node, int level)
195 {
196     for (int index = 0 ; index < node->GetChildrenCount() ; index++) {
197         const v8::CpuProfileNode* childNode = node->GetChild(index);
198         if (QV8Engine::toStringStatic(childNode->GetScriptResourceName()).length() > 0) {
199
200             QV8ProfilerData rd = {(int)QV8ProfilerService::V8Entry, QV8Engine::toStringStatic(childNode->GetScriptResourceName()),
201                 QV8Engine::toStringStatic(childNode->GetFunctionName()),
202                 childNode->GetLineNumber(), childNode->GetTotalTime(), childNode->GetSelfTime(), level};
203             m_data.append(rd);
204
205             // different nodes might have common children: fix at client side
206             if (childNode->GetChildrenCount() > 0) {
207                 printProfileTree(childNode, level+1);
208             }
209         }
210     }
211 }
212
213 void QV8ProfilerServicePrivate::takeSnapshot(v8::HeapSnapshot::Type snapshotType)
214 {
215     Q_Q(QV8ProfilerService);
216
217     v8::HandleScope scope;
218     v8::Local<v8::String> title = v8::String::New("");
219
220     QByteArray jsonSnapshot;
221     ByteArrayOutputStream bos(&jsonSnapshot);
222     const v8::HeapSnapshot *snapshot = v8::HeapProfiler::TakeSnapshot(title, snapshotType);
223     snapshot->Serialize(&bos, v8::HeapSnapshot::kJSON);
224
225     QByteArray data;
226     QDataStream ds(&data, QIODevice::WriteOnly);
227     ds << (int)QV8ProfilerService::V8Snapshot << jsonSnapshot;
228
229     q->sendMessage(data);
230 }
231
232 void QV8ProfilerServicePrivate::sendMessages()
233 {
234     Q_Q(QV8ProfilerService);
235
236     for (int i = 0; i < m_data.count(); ++i)
237         q->sendMessage(m_data.at(i).toByteArray());
238     m_data.clear();
239
240     //indicate completion
241     QByteArray data;
242     QDataStream ds(&data, QIODevice::WriteOnly);
243     ds << (int)QV8ProfilerService::V8Complete;
244
245     q->sendMessage(data);
246 }
247
248
249 QT_END_NAMESPACE