V8 profiler

Author: nakosung

Plugins/UnrealJS/Source/V8/Private/JavascriptIsolate_Private.cpp

@@ -330,6 +330,8 @@ class FJavascriptIsolateImplementation : public FJavascriptIsolate
 		ExportMemory(ObjectTemplate);
 
 		ExportMisc(ObjectTemplate);		
+
+		ExportProfiler(ObjectTemplate);
 	}		
 
 	~FJavascriptIsolateImplementation()
@@ -770,6 +772,172 @@ class FJavascriptIsolateImplementation : public FJavascriptIsolate
 			ReadOnly);
 	}	
 
+	static Local<Object> Visit(Isolate* isolate, const v8::CpuProfileNode* node) 
+	{
+		static TMap<const v8::CpuProfileNode*, Handle<Object>> Visited;
+
+		if (!isolate)
+		{
+			Visited.Empty();
+			return Local<Object>();
+		}
+		auto Existing = Visited.Find(node);
+		if (Existing) return *Existing;
+
+		FIsolateHelper I(isolate);
+
+		auto Out = Object::New(isolate);
+
+		Visited.Add(node, Out);
+
+		Out->Set(I.Keyword("ScriptResourceName"), node->GetScriptResourceName());
+		Out->Set(I.Keyword("FunctionName"), node->GetFunctionName());
+		Out->Set(I.Keyword("HitCount"), Integer::NewFromUnsigned(isolate,node->GetHitCount()));
+		Out->Set(I.Keyword("LineNumber"), Integer::New(isolate,node->GetLineNumber()));
+		Out->Set(I.Keyword("ColumnNumber"), Integer::New(isolate,node->GetColumnNumber()));
+		Out->Set(I.Keyword("ScriptId"), Integer::New(isolate, node->GetScriptId()));
+
+		{
+			uint32_t Num = node->GetHitLineCount();
+			TArray<v8::CpuProfileNode::LineTick> Buffer;
+			Buffer.AddDefaulted(Num);
+			node->GetLineTicks(Buffer.GetData(), Num);
+
+			auto Arr = Array::New(isolate, Num);
+			for (uint32_t Index = 0; Index < Num; ++Index)
+			{
+				const auto& info = Buffer[Index];
+				auto item = Object::New(isolate);
+				item->Set(I.Keyword("line"), Integer::New(isolate,info.line));
+				item->Set(I.Keyword("hit_count"), Integer::New(isolate, info.hit_count));
+				Arr->Set(Index, item);
+			}
+			Out->Set(I.Keyword("LineTicks"), Arr);
+		}
+
+		auto BailOutReason = node->GetBailoutReason();
+		if (BailOutReason)
+		{
+			Out->Set(I.Keyword("BailOutReason"), I.Keyword(BailOutReason));
+		}
+
+		{
+			const auto& deopt = node->GetDeoptInfos();
+			uint32_t Num = deopt.size();
+			if (Num)
+			{
+				auto Arr = Array::New(isolate, deopt.size());
+				for (uint32_t Index = 0; Index < Num; ++Index)
+				{
+					const auto& info = deopt[Index];
+					FString out;
+					for (const auto& frame : info.stack)
+					{
+						out.Append(FString::Printf(TEXT("%d:%d "), (int)frame.script_id, (int)frame.position));
+					}
+					auto item = Object::New(isolate);
+					item->Set(I.Keyword("reason"), I.Keyword(deopt[Index].deopt_reason));
+					item->Set(I.Keyword("stack"), I.String(out));
+					Arr->Set(Index, item);
+				}
+				Out->Set(I.Keyword("DeoptInfos"), Arr);
+			}
+		}
+		
+		uint32_t Num = node->GetChildrenCount();
+		if (Num)
+		{
+			auto Arr = Array::New(isolate, Num);
+			for (uint32_t Index = 0; Index < Num; ++Index)
+			{
+				Arr->Set(Index, Visit(isolate, node->GetChild(Index)));
+			}
+			Out->Set(I.Keyword("Children"), Arr);
+		}
+		return Out;
+	};
+
+	void ExportProfiler(Local<ObjectTemplate> global_templ)
+	{
+		FIsolateHelper I(isolate_);
+
+		Local<FunctionTemplate> Template = I.FunctionTemplate();
+
+		auto add_fn = [&](const char* name, FunctionCallback fn) {
+			Template->PrototypeTemplate()->Set(I.Keyword(name), I.FunctionTemplate(fn));
+		};		
+
+		add_fn("SetSamplingInterval", [](const FunctionCallbackInfo<Value>& info)
+		{
+			FIsolateHelper I(info.GetIsolate());
+
+			auto profiler = info.GetIsolate()->GetCpuProfiler();
+
+			if (info.Length() == 1)
+			{
+				profiler->SetSamplingInterval(info[0]->IntegerValue());
+			}
+		});
+
+		add_fn("StartProfiling", [](const FunctionCallbackInfo<Value>& info)
+		{
+			FIsolateHelper I(info.GetIsolate());
+
+			auto profiler = info.GetIsolate()->GetCpuProfiler();
+
+			if (info.Length() == 2)
+			{
+				profiler->StartProfiling(info[0].As<String>(), info[1]->BooleanValue());
+				info.GetReturnValue().Set(true);
+			}			
+		});
+
+		add_fn("StopProfiling", [](const FunctionCallbackInfo<Value>& info)
+		{
+			auto isolate = info.GetIsolate();
+			FIsolateHelper I(isolate);
+
+			auto profiler = isolate->GetCpuProfiler();
+
+			if (info.Length() == 1)
+			{				
+				auto Profile = profiler->StopProfiling(info[0].As<String>());
+
+				auto Out = Object::New(isolate);
+				Out->Set(I.Keyword("Root"), Visit(isolate, Profile->GetTopDownRoot()));
+				Out->Set(I.Keyword("Title"), Profile->GetTitle());
+
+				{
+					uint32_t Num = Profile->GetSamplesCount();
+					if (Num)
+					{
+						auto Arr = Array::New(isolate, Num);
+						for (uint32_t Index = 0; Index < Num; ++Index)
+						{
+							Arr->Set(Index, Visit(isolate, Profile->GetSample(Index)));
+						}
+						Out->Set(I.Keyword("Samples"), Arr);
+					}
+				}
+				
+
+				// cleanup
+				Visit(nullptr, nullptr);
+				
+				info.GetReturnValue().Set(Out);
+
+				Profile->Delete();
+			}
+		});
+
+		global_templ->Set(
+			I.Keyword("v8"),
+			// Create an instance
+			Template->GetFunction()->NewInstance(),
+			// Do not modify!
+			ReadOnly);
+	}
+
 	void ExportMisc(Local<ObjectTemplate> global_templ)
 	{
 		FIsolateHelper I(isolate_);

Plugins/UnrealJS/Source/V8/Private/V8PCH.h

@@ -9,6 +9,7 @@
 
 #include "v8.h"
 #include <v8-debug.h>
+#include <v8-profiler.h>
 
 #pragma warning( pop )