add support to configure V8 profiler output directory

Author: Mihail Slavchev

src/jni/Profiler.cpp

@@ -14,26 +14,26 @@ Profiler::Profiler()
 {
 }
 
-void Profiler::Init(const string& appName)
+void Profiler::Init(Isolate *isolate, const Local<Object>& globalObj, const string& appName, const string& outputDir)
 {
-	s_appName = appName;
+	m_appName = appName;
+	m_outputDir = outputDir;
+	auto extData = External::New(isolate, this);
+	globalObj->Set(ConvertToV8String("__startCPUProfiler"), FunctionTemplate::New(isolate, Profiler::StartCPUProfilerCallback, extData)->GetFunction());
+	globalObj->Set(ConvertToV8String("__stopCPUProfiler"), FunctionTemplate::New(isolate, Profiler::StopCPUProfilerCallback, extData)->GetFunction());
+	globalObj->Set(ConvertToV8String("__heapSnapshot"), FunctionTemplate::New(isolate, Profiler::HeapSnapshotMethodCallback, extData)->GetFunction());
+	globalObj->Set(ConvertToV8String("__startNDKProfiler"), FunctionTemplate::New(isolate, Profiler::StartNDKProfilerCallback, extData)->GetFunction());
+	globalObj->Set(ConvertToV8String("__stopNDKProfiler"), FunctionTemplate::New(isolate, Profiler::StopNDKProfilerCallback, extData)->GetFunction());
 }
 
 void Profiler::StartCPUProfilerCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
 	try
 	{
 		auto isolate = args.GetIsolate();
-		auto started = false;
-		if ((args.Length() == 1) && (args[0]->IsString()))
-		{
-			auto name = args[0]->ToString();
-			StartCPUProfiler(isolate, name);
-			started = true;
-		}
-
-		args.GetReturnValue().Set(Boolean::New(isolate, started));
-
+		auto extData = args.Data().As<External>();
+		auto thiz = static_cast<Profiler*>(extData->Value());
+		thiz->StartCPUProfilerCallbackImpl(args);
 	}
 	catch (NativeScriptException& e)
 	{
@@ -51,18 +51,27 @@ void Profiler::StartCPUProfilerCallback(const v8::FunctionCallbackInfo<v8::Value
 	}
 }
 
+void Profiler::StartCPUProfilerCallbackImpl(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+	auto isolate = args.GetIsolate();
+	auto started = false;
+	if ((args.Length() == 1) && (args[0]->IsString()))
+	{
+		auto name = args[0]->ToString();
+		StartCPUProfiler(isolate, name);
+		started = true;
+	}
+	args.GetReturnValue().Set(started);
+}
+
 void Profiler::StopCPUProfilerCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
 	try
 	{
 		auto isolate = args.GetIsolate();
-		auto stopped = false;
-		if ((args.Length() == 1) && (args[0]->IsString()))
-		{
-			auto name = args[0]->ToString();
-			stopped = StopCPUProfiler(isolate, name);
-		}
-		args.GetReturnValue().Set(Boolean::New(isolate, stopped));
+		auto extData = args.Data().As<External>();
+		auto thiz = static_cast<Profiler*>(extData->Value());
+		thiz->StopCPUProfilerCallbackImpl(args);
 	}
 	catch (NativeScriptException& e)
 	{
@@ -80,6 +89,18 @@ void Profiler::StopCPUProfilerCallback(const v8::FunctionCallbackInfo<v8::Value>
 	}
 }
 
+void Profiler::StopCPUProfilerCallbackImpl(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+	auto isolate = args.GetIsolate();
+	auto stopped = false;
+	if ((args.Length() == 1) && (args[0]->IsString()))
+	{
+		auto name = args[0]->ToString();
+		stopped = StopCPUProfiler(isolate, name);
+	}
+	args.GetReturnValue().Set(stopped);
+}
+
 void Profiler::StartCPUProfiler(Isolate *isolate, const Local<String>& name)
 {
 	auto v8prof = isolate->GetCpuProfiler();
@@ -113,7 +134,7 @@ bool Profiler::Write(CpuProfile *cpuProfile)
 
 	char filename[256];
 	auto profileName = ConvertToString(cpuProfile->GetTitle());
-	snprintf(filename, sizeof(filename), "/sdcard/%s-%s-%lu.%lu.cpuprofile", s_appName.c_str(), profileName.c_str(), sec, usec);
+	snprintf(filename, sizeof(filename), "%s/%s-%s-%lu.%lu.cpuprofile", m_outputDir.c_str(), m_appName.c_str(), profileName.c_str(), sec, usec);
 
 	auto fp = fopen(filename, "w");
 	if (nullptr == fp)
@@ -202,7 +223,10 @@ void Profiler::StartNDKProfilerCallback(const v8::FunctionCallbackInfo<v8::Value
 {
 	try
 	{
-		StartNDKProfiler();
+		auto isolate = args.GetIsolate();
+		auto extData = args.Data().As<External>();
+		auto thiz = static_cast<Profiler*>(extData->Value());
+		thiz->StartNDKProfiler();
 	}
 	catch (NativeScriptException& e)
 	{
@@ -224,7 +248,10 @@ void Profiler::StopNDKProfilerCallback(const v8::FunctionCallbackInfo<v8::Value>
 {
 	try
 	{
-		StopNDKProfiler();
+		auto isolate = args.GetIsolate();
+		auto extData = args.Data().As<External>();
+		auto thiz = static_cast<Profiler*>(extData->Value());
+		thiz->StopNDKProfiler();
 	}
 	catch (NativeScriptException& e)
 	{
@@ -292,30 +319,10 @@ void Profiler::HeapSnapshotMethodCallback(const v8::FunctionCallbackInfo<v8::Val
 {
 	try
 	{
-		struct timespec nowt;
-		clock_gettime(CLOCK_MONOTONIC, &nowt);
-		uint64_t now = (int64_t) nowt.tv_sec * 1000000000LL + nowt.tv_nsec;
-
-		unsigned long sec = static_cast<unsigned long>(now / 1000000);
-		unsigned long usec = static_cast<unsigned long>(now % 1000000);
-
-		char filename[256];
-		snprintf(filename, sizeof(filename), "/sdcard/%s-heapdump-%lu.%lu.heapsnapshot", s_appName.c_str(), sec, usec);
-
-		FILE* fp = fopen(filename, "w");
-		if (fp == nullptr)
-		{
-			return;
-		}
-
 		auto isolate = args.GetIsolate();
-
-		const HeapSnapshot* snap = isolate->GetHeapProfiler()->TakeHeapSnapshot();
-
-		FileOutputStream stream(fp);
-		snap->Serialize(&stream, HeapSnapshot::kJSON);
-		fclose(fp);
-		const_cast<HeapSnapshot*>(snap)->Delete();
+		auto extData = args.Data().As<External>();
+		auto thiz = static_cast<Profiler*>(extData->Value());
+		thiz->HeapSnapshotMethodCallbackImpl(args);
 	}
 	catch (NativeScriptException& e)
 	{
@@ -333,4 +340,31 @@ void Profiler::HeapSnapshotMethodCallback(const v8::FunctionCallbackInfo<v8::Val
 	}
 }
 
-string Profiler::s_appName;
+void Profiler::HeapSnapshotMethodCallbackImpl(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+	struct timespec nowt;
+	clock_gettime(CLOCK_MONOTONIC, &nowt);
+	uint64_t now = (int64_t) nowt.tv_sec * 1000000000LL + nowt.tv_nsec;
+
+	unsigned long sec = static_cast<unsigned long>(now / 1000000);
+	unsigned long usec = static_cast<unsigned long>(now % 1000000);
+
+	char filename[256];
+	snprintf(filename, sizeof(filename), "%s/%s-heapdump-%lu.%lu.heapsnapshot", m_outputDir.c_str(), m_appName.c_str(), sec, usec);
+
+	FILE* fp = fopen(filename, "w");
+	if (fp == nullptr)
+	{
+		return;
+	}
+
+	auto isolate = args.GetIsolate();
+
+	const HeapSnapshot* snap = isolate->GetHeapProfiler()->TakeHeapSnapshot();
+
+	FileOutputStream stream(fp);
+	snap->Serialize(&stream, HeapSnapshot::kJSON);
+	fclose(fp);
+	const_cast<HeapSnapshot*>(snap)->Delete();
+}
+

src/jni/Profiler.h

@@ -10,8 +10,11 @@ namespace tns
 	class Profiler
 	{
 		public:
-			static void Init(const std::string& appName);
+			Profiler();
+
+			void Init(v8::Isolate *isolate, const v8::Local<v8::Object>& globalObj, const std::string& appName, const std::string& outputDir);
 
+		private:
 			static void StartCPUProfilerCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
 
 			static void StopCPUProfilerCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -22,20 +25,25 @@ namespace tns
 
 			static void HeapSnapshotMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-		private:
-			Profiler();
+			void StartCPUProfilerCallbackImpl(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+			void StopCPUProfilerCallbackImpl(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+			void HeapSnapshotMethodCallbackImpl(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+			void StartCPUProfiler(v8::Isolate *isolate, const v8::Local<v8::String>& name);
 
-			static void StartCPUProfiler(v8::Isolate *isolate, const v8::Local<v8::String>& name);
+			bool StopCPUProfiler(v8::Isolate *isolate, const v8::Local<v8::String>& name);
 
-			static bool StopCPUProfiler(v8::Isolate *isolate, const v8::Local<v8::String>& name);
+			void StartNDKProfiler();
 
-			static void StartNDKProfiler();
+			void StopNDKProfiler();
 
-			static void StopNDKProfiler();
+			bool Write(v8::CpuProfile *cpuProfile);
 
-			static bool Write(v8::CpuProfile *cpuProfile);
+			std::string m_appName;
 
-			static std::string s_appName;
+			std::string m_outputDir;
 	};
 }
 

src/jni/Runtime.cpp

@@ -13,7 +13,6 @@
 #include "Version.h"
 #include "JEnv.h"
 #include "WeakRef.h"
-#include "Profiler.h"
 #include "NativeScriptAssert.h"
 #include "JsDebugger.h"
 #include "SimpleProfiler.h"
@@ -135,11 +134,12 @@ void Runtime::Init(jstring filesPath, bool verboseLoggingEnabled, jstring packag
 	Constants::V8_HEAP_SNAPSHOT = (bool)snapshot;
 	JniLocalRef snapshotScript(m_env.GetObjectArrayElement(args, 3));
 	Constants::V8_HEAP_SNAPSHOT_SCRIPT = ArgConverter::jstringToString(snapshotScript);
+	JniLocalRef profilerOutputDir(m_env.GetObjectArrayElement(args, 4));
 
 	DEBUG_WRITE("Initializing Telerik NativeScript");
 
 	NativeScriptException::Init(m_objectManager);
-	m_isolate = PrepareV8Runtime(filesRoot, packageName, jsDebugger);
+	m_isolate = PrepareV8Runtime(filesRoot, packageName, jsDebugger, profilerOutputDir);
 
 	s_isolate2RuntimesCache.insert(make_pair(m_isolate, this));
 }
@@ -335,7 +335,7 @@ void Runtime::PassUncaughtExceptionToJsNative(JNIEnv *env, jobject obj, jthrowab
 	}
 }
 
-Isolate* Runtime::PrepareV8Runtime(const string& filesPath, jstring packageName, jobject jsDebugger)
+Isolate* Runtime::PrepareV8Runtime(const string& filesPath, jstring packageName, jobject jsDebugger, jstring profilerOutputDir)
 {
 	auto platform = v8::platform::CreateDefaultPlatform();
 	V8::InitializePlatform(platform);
@@ -384,11 +384,6 @@ Isolate* Runtime::PrepareV8Runtime(const string& filesPath, jstring packageName,
 
 	const auto readOnlyFlags = static_cast<PropertyAttribute>(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
 
-	globalTemplate->Set(ConvertToV8String("__startNDKProfiler"), FunctionTemplate::New(isolate, Profiler::StartNDKProfilerCallback));
-	globalTemplate->Set(ConvertToV8String("__stopNDKProfiler"), FunctionTemplate::New(isolate, Profiler::StopNDKProfilerCallback));
-	globalTemplate->Set(ConvertToV8String("__startCPUProfiler"), FunctionTemplate::New(isolate, Profiler::StartCPUProfilerCallback));
-	globalTemplate->Set(ConvertToV8String("__stopCPUProfiler"), FunctionTemplate::New(isolate, Profiler::StopCPUProfilerCallback));
-	globalTemplate->Set(ConvertToV8String("__heapSnapshot"), FunctionTemplate::New(isolate, Profiler::HeapSnapshotMethodCallback));
 	globalTemplate->Set(ConvertToV8String("__log"), FunctionTemplate::New(isolate, CallbackHandlers::LogMethodCallback));
 	globalTemplate->Set(ConvertToV8String("__dumpReferenceTables"), FunctionTemplate::New(isolate, CallbackHandlers::DumpReferenceTablesMethodCallback));
 	globalTemplate->Set(ConvertToV8String("__debugbreak"), FunctionTemplate::New(isolate, JsDebugger::DebugBreakCallback));
@@ -428,8 +423,9 @@ Isolate* Runtime::PrepareV8Runtime(const string& filesPath, jstring packageName,
 
 	CallbackHandlers::Init(isolate, m_objectManager);
 
-	string pckName = ArgConverter::jstringToString(packageName);
-	Profiler::Init(pckName);
+	auto pckName = ArgConverter::jstringToString(packageName);
+	auto outputDir = ArgConverter::jstringToString(profilerOutputDir);
+	m_profiler.Init(isolate, global, pckName, outputDir);
 	JsDebugger::Init(isolate, pckName, jsDebugger);
 
 	MetadataNode::BuildMetadata(filesPath);

src/jni/Runtime.h

@@ -6,6 +6,7 @@
 #include "ObjectManager.h"
 #include "SimpleAllocator.h"
 #include "WeakRef.h"
+#include "Profiler.h"
 
 jobject ConvertJsValueToJavaObject(tns::JEnv& env, const v8::Local<v8::Value>& value, int classReturnType);
 
@@ -51,8 +52,10 @@ namespace tns
 
 			WeakRef m_weakRef;
 
+			Profiler m_profiler;
+
 			static void PrepareExtendFunction(v8::Isolate *isolate, jstring filesPath);
-			v8::Isolate* PrepareV8Runtime(const std::string& filesPath, jstring packageName, jobject jsDebugger);
+			v8::Isolate* PrepareV8Runtime(const std::string& filesPath, jstring packageName, jobject jsDebugger, jstring profilerOutputDir);
 			jobject ConvertJsValueToJavaObject(JEnv& env, const v8::Local<v8::Value>& value, int classReturnType);
 
 			static std::map<int, Runtime*> s_id2RuntimeCache;

src/src/com/tns/V8Config.java

@@ -10,6 +10,7 @@ class V8Config
 	private static final String CodeCacheKey = "codeCache";
 	private static final String HeapSnapshotKey = "heapSnapshot";
 	private static final String HeapSnapshotScriptKey = "heapSnapshotScript";
+	private static final String ProfilerOutputDirKey = "profilerOutputDir";
 
 	public static Object[] fromPackageJSON(File appDir)
 	{
@@ -44,6 +45,10 @@ public static Object[] fromPackageJSON(File appDir)
 					String value = androidObject.getString(HeapSnapshotScriptKey);
 					result[3] = FileSystem.resolveRelativePath(appDir.getPath(), value, appDir + "/app/");
 				}
+				if(androidObject.has(ProfilerOutputDirKey))
+				{
+					result[4] = androidObject.getString(ProfilerOutputDirKey);
+				}
 			}
 		}
 		catch (Exception e)
@@ -64,6 +69,8 @@ private static Object[] makeDefaultOptions()
 			// enable v8 heap snapshot, false by default
 			false,
 			// arbitrary script to be included in the snapshot
+			"",
+			// V8 profiler output directory
 			""
 		};
 

test-app/assets/app/package.json

@@ -1,6 +1,7 @@
 {
 	"main": "boot.js",
 	"android": {
-		"v8Flags": "--expose_gc"
+		"v8Flags": "--expose_gc",
+		"profilerOutputDir": "/sdcard"
 	}
 }