summaryrefslogtreecommitdiffstats
path: root/js/src/builtin/Profilers.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/builtin/Profilers.cpp')
-rw-r--r--js/src/builtin/Profilers.cpp576
1 files changed, 576 insertions, 0 deletions
diff --git a/js/src/builtin/Profilers.cpp b/js/src/builtin/Profilers.cpp
new file mode 100644
index 000000000..0d30a1c6b
--- /dev/null
+++ b/js/src/builtin/Profilers.cpp
@@ -0,0 +1,576 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sts=4 et sw=4 tw=99:
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Profiling-related API */
+
+#include "builtin/Profilers.h"
+
+#include "mozilla/Sprintf.h"
+
+#include <stdarg.h>
+
+#ifdef MOZ_CALLGRIND
+# include <valgrind/callgrind.h>
+#endif
+
+#ifdef __APPLE__
+#ifdef MOZ_INSTRUMENTS
+# include "devtools/Instruments.h"
+#endif
+#endif
+
+#ifdef XP_WIN
+# include <process.h>
+# define getpid _getpid
+#endif
+
+#include "vm/Probes.h"
+
+#include "jscntxtinlines.h"
+
+using namespace js;
+
+using mozilla::ArrayLength;
+
+/* Thread-unsafe error management */
+
+static char gLastError[2000];
+
+#if defined(__APPLE__) || defined(__linux__) || defined(MOZ_CALLGRIND)
+static void
+MOZ_FORMAT_PRINTF(1, 2)
+UnsafeError(const char* format, ...)
+{
+ va_list args;
+ va_start(args, format);
+ (void) VsprintfLiteral(gLastError, format, args);
+ va_end(args);
+}
+#endif
+
+JS_PUBLIC_API(const char*)
+JS_UnsafeGetLastProfilingError()
+{
+ return gLastError;
+}
+
+#ifdef __APPLE__
+static bool
+StartOSXProfiling(const char* profileName, pid_t pid)
+{
+ bool ok = true;
+ const char* profiler = nullptr;
+#ifdef MOZ_INSTRUMENTS
+ ok = Instruments::Start(pid);
+ profiler = "Instruments";
+#endif
+ if (!ok) {
+ if (profileName)
+ UnsafeError("Failed to start %s for %s", profiler, profileName);
+ else
+ UnsafeError("Failed to start %s", profiler);
+ return false;
+ }
+ return true;
+}
+#endif
+
+JS_PUBLIC_API(bool)
+JS_StartProfiling(const char* profileName, pid_t pid)
+{
+ bool ok = true;
+#ifdef __APPLE__
+ ok = StartOSXProfiling(profileName, pid);
+#endif
+#ifdef __linux__
+ if (!js_StartPerf())
+ ok = false;
+#endif
+ return ok;
+}
+
+JS_PUBLIC_API(bool)
+JS_StopProfiling(const char* profileName)
+{
+ bool ok = true;
+#ifdef __APPLE__
+#ifdef MOZ_INSTRUMENTS
+ Instruments::Stop(profileName);
+#endif
+#endif
+#ifdef __linux__
+ if (!js_StopPerf())
+ ok = false;
+#endif
+ return ok;
+}
+
+/*
+ * Start or stop whatever platform- and configuration-specific profiling
+ * backends are available.
+ */
+static bool
+ControlProfilers(bool toState)
+{
+ bool ok = true;
+
+ if (! probes::ProfilingActive && toState) {
+#ifdef __APPLE__
+#if defined(MOZ_INSTRUMENTS)
+ const char* profiler;
+#ifdef MOZ_INSTRUMENTS
+ ok = Instruments::Resume();
+ profiler = "Instruments";
+#endif
+ if (!ok) {
+ UnsafeError("Failed to start %s", profiler);
+ }
+#endif
+#endif
+#ifdef MOZ_CALLGRIND
+ if (! js_StartCallgrind()) {
+ UnsafeError("Failed to start Callgrind");
+ ok = false;
+ }
+#endif
+ } else if (probes::ProfilingActive && ! toState) {
+#ifdef __APPLE__
+#ifdef MOZ_INSTRUMENTS
+ Instruments::Pause();
+#endif
+#endif
+#ifdef MOZ_CALLGRIND
+ if (! js_StopCallgrind()) {
+ UnsafeError("failed to stop Callgrind");
+ ok = false;
+ }
+#endif
+ }
+
+ probes::ProfilingActive = toState;
+
+ return ok;
+}
+
+/*
+ * Pause/resume whatever profiling mechanism is currently compiled
+ * in, if applicable. This will not affect things like dtrace.
+ *
+ * Do not mix calls to these APIs with calls to the individual
+ * profilers' pause/resume functions, because only overall state is
+ * tracked, not the state of each profiler.
+ */
+JS_PUBLIC_API(bool)
+JS_PauseProfilers(const char* profileName)
+{
+ return ControlProfilers(false);
+}
+
+JS_PUBLIC_API(bool)
+JS_ResumeProfilers(const char* profileName)
+{
+ return ControlProfilers(true);
+}
+
+JS_PUBLIC_API(bool)
+JS_DumpProfile(const char* outfile, const char* profileName)
+{
+ bool ok = true;
+#ifdef MOZ_CALLGRIND
+ js_DumpCallgrind(outfile);
+#endif
+ return ok;
+}
+
+#ifdef MOZ_PROFILING
+
+struct RequiredStringArg {
+ JSContext* mCx;
+ char* mBytes;
+ RequiredStringArg(JSContext* cx, const CallArgs& args, size_t argi, const char* caller)
+ : mCx(cx), mBytes(nullptr)
+ {
+ if (args.length() <= argi) {
+ JS_ReportErrorASCII(cx, "%s: not enough arguments", caller);
+ } else if (!args[argi].isString()) {
+ JS_ReportErrorASCII(cx, "%s: invalid arguments (string expected)", caller);
+ } else {
+ mBytes = JS_EncodeString(cx, args[argi].toString());
+ }
+ }
+ operator void*() {
+ return (void*) mBytes;
+ }
+ ~RequiredStringArg() {
+ js_free(mBytes);
+ }
+};
+
+static bool
+StartProfiling(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ if (args.length() == 0) {
+ args.rval().setBoolean(JS_StartProfiling(nullptr, getpid()));
+ return true;
+ }
+
+ RequiredStringArg profileName(cx, args, 0, "startProfiling");
+ if (!profileName)
+ return false;
+
+ if (args.length() == 1) {
+ args.rval().setBoolean(JS_StartProfiling(profileName.mBytes, getpid()));
+ return true;
+ }
+
+ if (!args[1].isInt32()) {
+ JS_ReportErrorASCII(cx, "startProfiling: invalid arguments (int expected)");
+ return false;
+ }
+ pid_t pid = static_cast<pid_t>(args[1].toInt32());
+ args.rval().setBoolean(JS_StartProfiling(profileName.mBytes, pid));
+ return true;
+}
+
+static bool
+StopProfiling(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ if (args.length() == 0) {
+ args.rval().setBoolean(JS_StopProfiling(nullptr));
+ return true;
+ }
+
+ RequiredStringArg profileName(cx, args, 0, "stopProfiling");
+ if (!profileName)
+ return false;
+ args.rval().setBoolean(JS_StopProfiling(profileName.mBytes));
+ return true;
+}
+
+static bool
+PauseProfilers(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ if (args.length() == 0) {
+ args.rval().setBoolean(JS_PauseProfilers(nullptr));
+ return true;
+ }
+
+ RequiredStringArg profileName(cx, args, 0, "pauseProfiling");
+ if (!profileName)
+ return false;
+ args.rval().setBoolean(JS_PauseProfilers(profileName.mBytes));
+ return true;
+}
+
+static bool
+ResumeProfilers(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ if (args.length() == 0) {
+ args.rval().setBoolean(JS_ResumeProfilers(nullptr));
+ return true;
+ }
+
+ RequiredStringArg profileName(cx, args, 0, "resumeProfiling");
+ if (!profileName)
+ return false;
+ args.rval().setBoolean(JS_ResumeProfilers(profileName.mBytes));
+ return true;
+}
+
+/* Usage: DumpProfile([filename[, profileName]]) */
+static bool
+DumpProfile(JSContext* cx, unsigned argc, Value* vp)
+{
+ bool ret;
+ CallArgs args = CallArgsFromVp(argc, vp);
+ if (args.length() == 0) {
+ ret = JS_DumpProfile(nullptr, nullptr);
+ } else {
+ RequiredStringArg filename(cx, args, 0, "dumpProfile");
+ if (!filename)
+ return false;
+
+ if (args.length() == 1) {
+ ret = JS_DumpProfile(filename.mBytes, nullptr);
+ } else {
+ RequiredStringArg profileName(cx, args, 1, "dumpProfile");
+ if (!profileName)
+ return false;
+
+ ret = JS_DumpProfile(filename.mBytes, profileName.mBytes);
+ }
+ }
+
+ args.rval().setBoolean(ret);
+ return true;
+}
+
+static bool
+GetMaxGCPauseSinceClear(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ args.rval().setNumber(uint32_t(cx->runtime()->gc.stats.getMaxGCPauseSinceClear()));
+ return true;
+}
+
+static bool
+ClearMaxGCPauseAccumulator(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ args.rval().setNumber(uint32_t(cx->runtime()->gc.stats.clearMaxGCPauseAccumulator()));
+ return true;
+}
+
+#if defined(MOZ_INSTRUMENTS)
+
+static bool
+IgnoreAndReturnTrue(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ args.rval().setBoolean(true);
+ return true;
+}
+
+#endif
+
+#ifdef MOZ_CALLGRIND
+static bool
+StartCallgrind(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ args.rval().setBoolean(js_StartCallgrind());
+ return true;
+}
+
+static bool
+StopCallgrind(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ args.rval().setBoolean(js_StopCallgrind());
+ return true;
+}
+
+static bool
+DumpCallgrind(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ if (args.length() == 0) {
+ args.rval().setBoolean(js_DumpCallgrind(nullptr));
+ return true;
+ }
+
+ RequiredStringArg outFile(cx, args, 0, "dumpCallgrind");
+ if (!outFile)
+ return false;
+
+ args.rval().setBoolean(js_DumpCallgrind(outFile.mBytes));
+ return true;
+}
+#endif
+
+static const JSFunctionSpec profiling_functions[] = {
+ JS_FN("startProfiling", StartProfiling, 1,0),
+ JS_FN("stopProfiling", StopProfiling, 1,0),
+ JS_FN("pauseProfilers", PauseProfilers, 1,0),
+ JS_FN("resumeProfilers", ResumeProfilers, 1,0),
+ JS_FN("dumpProfile", DumpProfile, 2,0),
+ JS_FN("getMaxGCPauseSinceClear", GetMaxGCPauseSinceClear, 0, 0),
+ JS_FN("clearMaxGCPauseAccumulator", ClearMaxGCPauseAccumulator, 0, 0),
+#if defined(MOZ_INSTRUMENTS)
+ /* Keep users of the old shark API happy. */
+ JS_FN("connectShark", IgnoreAndReturnTrue, 0,0),
+ JS_FN("disconnectShark", IgnoreAndReturnTrue, 0,0),
+ JS_FN("startShark", StartProfiling, 0,0),
+ JS_FN("stopShark", StopProfiling, 0,0),
+#endif
+#ifdef MOZ_CALLGRIND
+ JS_FN("startCallgrind", StartCallgrind, 0,0),
+ JS_FN("stopCallgrind", StopCallgrind, 0,0),
+ JS_FN("dumpCallgrind", DumpCallgrind, 1,0),
+#endif
+ JS_FS_END
+};
+
+#endif
+
+JS_PUBLIC_API(bool)
+JS_DefineProfilingFunctions(JSContext* cx, HandleObject obj)
+{
+ assertSameCompartment(cx, obj);
+#ifdef MOZ_PROFILING
+ return JS_DefineFunctions(cx, obj, profiling_functions);
+#else
+ return true;
+#endif
+}
+
+#ifdef MOZ_CALLGRIND
+
+JS_FRIEND_API(bool)
+js_StartCallgrind()
+{
+ JS_SILENCE_UNUSED_VALUE_IN_EXPR(CALLGRIND_START_INSTRUMENTATION);
+ JS_SILENCE_UNUSED_VALUE_IN_EXPR(CALLGRIND_ZERO_STATS);
+ return true;
+}
+
+JS_FRIEND_API(bool)
+js_StopCallgrind()
+{
+ JS_SILENCE_UNUSED_VALUE_IN_EXPR(CALLGRIND_STOP_INSTRUMENTATION);
+ return true;
+}
+
+JS_FRIEND_API(bool)
+js_DumpCallgrind(const char* outfile)
+{
+ if (outfile) {
+ JS_SILENCE_UNUSED_VALUE_IN_EXPR(CALLGRIND_DUMP_STATS_AT(outfile));
+ } else {
+ JS_SILENCE_UNUSED_VALUE_IN_EXPR(CALLGRIND_DUMP_STATS);
+ }
+
+ return true;
+}
+
+#endif /* MOZ_CALLGRIND */
+
+#ifdef __linux__
+
+/*
+ * Code for starting and stopping |perf|, the Linux profiler.
+ *
+ * Output from profiling is written to mozperf.data in your cwd.
+ *
+ * To enable, set MOZ_PROFILE_WITH_PERF=1 in your environment.
+ *
+ * To pass additional parameters to |perf record|, provide them in the
+ * MOZ_PROFILE_PERF_FLAGS environment variable. If this variable does not
+ * exist, we default it to "--call-graph". (If you don't want --call-graph but
+ * don't want to pass any other args, define MOZ_PROFILE_PERF_FLAGS to the empty
+ * string.)
+ *
+ * If you include --pid or --output in MOZ_PROFILE_PERF_FLAGS, you're just
+ * asking for trouble.
+ *
+ * Our split-on-spaces logic is lame, so don't expect MOZ_PROFILE_PERF_FLAGS to
+ * work if you pass an argument which includes a space (e.g.
+ * MOZ_PROFILE_PERF_FLAGS="-e 'foo bar'").
+ */
+
+#include <signal.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+static bool perfInitialized = false;
+static pid_t perfPid = 0;
+
+bool js_StartPerf()
+{
+ const char* outfile = "mozperf.data";
+
+ if (perfPid != 0) {
+ UnsafeError("js_StartPerf: called while perf was already running!\n");
+ return false;
+ }
+
+ // Bail if MOZ_PROFILE_WITH_PERF is empty or undefined.
+ if (!getenv("MOZ_PROFILE_WITH_PERF") ||
+ !strlen(getenv("MOZ_PROFILE_WITH_PERF"))) {
+ return true;
+ }
+
+ /*
+ * Delete mozperf.data the first time through -- we're going to append to it
+ * later on, so we want it to be clean when we start out.
+ */
+ if (!perfInitialized) {
+ perfInitialized = true;
+ unlink(outfile);
+ char cwd[4096];
+ printf("Writing perf profiling data to %s/%s\n",
+ getcwd(cwd, sizeof(cwd)), outfile);
+ }
+
+ pid_t mainPid = getpid();
+
+ pid_t childPid = fork();
+ if (childPid == 0) {
+ /* perf record --pid $mainPID --output=$outfile $MOZ_PROFILE_PERF_FLAGS */
+
+ char mainPidStr[16];
+ SprintfLiteral(mainPidStr, "%d", mainPid);
+ const char* defaultArgs[] = {"perf", "record", "--pid", mainPidStr, "--output", outfile};
+
+ Vector<const char*, 0, SystemAllocPolicy> args;
+ if (!args.append(defaultArgs, ArrayLength(defaultArgs)))
+ return false;
+
+ const char* flags = getenv("MOZ_PROFILE_PERF_FLAGS");
+ if (!flags) {
+ flags = "--call-graph";
+ }
+
+ UniqueChars flags2((char*)js_malloc(strlen(flags) + 1));
+ if (!flags2)
+ return false;
+ strcpy(flags2.get(), flags);
+
+ // Split |flags2| on spaces.
+ char* toksave;
+ char* tok = strtok_r(flags2.get(), " ", &toksave);
+ while (tok) {
+ if (!args.append(tok))
+ return false;
+ tok = strtok_r(nullptr, " ", &toksave);
+ }
+
+ if (!args.append((char*) nullptr))
+ return false;
+
+ execvp("perf", const_cast<char**>(args.begin()));
+
+ /* Reached only if execlp fails. */
+ fprintf(stderr, "Unable to start perf.\n");
+ exit(1);
+ }
+ if (childPid > 0) {
+ perfPid = childPid;
+
+ /* Give perf a chance to warm up. */
+ usleep(500 * 1000);
+ return true;
+ }
+ UnsafeError("js_StartPerf: fork() failed\n");
+ return false;
+}
+
+bool js_StopPerf()
+{
+ if (perfPid == 0) {
+ UnsafeError("js_StopPerf: perf is not running.\n");
+ return true;
+ }
+
+ if (kill(perfPid, SIGINT)) {
+ UnsafeError("js_StopPerf: kill failed\n");
+
+ // Try to reap the process anyway.
+ waitpid(perfPid, nullptr, WNOHANG);
+ }
+ else {
+ waitpid(perfPid, nullptr, 0);
+ }
+
+ perfPid = 0;
+ return true;
+}
+
+#endif /* __linux__ */