Source code

Revision control

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* 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/Compiler.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 "js/CharacterEncoding.h"
#include "js/PropertySpec.h"
#include "js/Utility.h"
#include "util/Text.h"
#include "vm/Probes.h"
#include "vm/JSContext-inl.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
ok = js_DumpCallgrind(outfile);
#endif
return ok;
}
#ifdef MOZ_PROFILING
static UniqueChars RequiredStringArg(JSContext* cx, const CallArgs& args,
size_t argi, const char* caller) {
if (args.length() <= argi) {
JS_ReportErrorASCII(cx, "%s: not enough arguments", caller);
return nullptr;
}
if (!args[argi].isString()) {
JS_ReportErrorASCII(cx, "%s: invalid arguments (string expected)", caller);
return nullptr;
}
return JS_EncodeStringToLatin1(cx, args[argi].toString());
}
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;
}
UniqueChars profileName = RequiredStringArg(cx, args, 0, "startProfiling");
if (!profileName) {
return false;
}
if (args.length() == 1) {
args.rval().setBoolean(JS_StartProfiling(profileName.get(), 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.get(), 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;
}
UniqueChars profileName = RequiredStringArg(cx, args, 0, "stopProfiling");
if (!profileName) {
return false;
}
args.rval().setBoolean(JS_StopProfiling(profileName.get()));
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;
}
UniqueChars profileName = RequiredStringArg(cx, args, 0, "pauseProfiling");
if (!profileName) {
return false;
}
args.rval().setBoolean(JS_PauseProfilers(profileName.get()));
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;
}
UniqueChars profileName = RequiredStringArg(cx, args, 0, "resumeProfiling");
if (!profileName) {
return false;
}
args.rval().setBoolean(JS_ResumeProfilers(profileName.get()));
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 {
UniqueChars filename = RequiredStringArg(cx, args, 0, "dumpProfile");
if (!filename) {
return false;
}
if (args.length() == 1) {
ret = JS_DumpProfile(filename.get(), nullptr);
} else {
UniqueChars profileName = RequiredStringArg(cx, args, 1, "dumpProfile");
if (!profileName) {
return false;
}
ret = JS_DumpProfile(filename.get(), profileName.get());
}
}
args.rval().setBoolean(ret);
return true;
}
static bool GetMaxGCPauseSinceClear(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
args.rval().setNumber(
cx->runtime()->gc.stats().getMaxGCPauseSinceClear().ToMicroseconds());
return true;
}
static bool ClearMaxGCPauseAccumulator(JSContext* cx, unsigned argc,
Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
args.rval().setNumber(
cx->runtime()->gc.stats().clearMaxGCPauseAccumulator().ToMicroseconds());
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;
}
UniqueChars outFile = RequiredStringArg(cx, args, 0, "dumpCallgrind");
if (!outFile) {
return false;
}
args.rval().setBoolean(js_DumpCallgrind(outFile.get()));
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) {
cx->check(obj);
#ifdef MOZ_PROFILING
return JS_DefineFunctions(cx, obj, profiling_functions);
#else
return true;
#endif
}
#ifdef MOZ_CALLGRIND
/* Wrapper for various macros to stop warnings coming from their expansions. */
# if defined(__clang__)
# define JS_SILENCE_UNUSED_VALUE_IN_EXPR(expr) \
JS_BEGIN_MACRO \
_Pragma("clang diagnostic push") /* If these _Pragmas cause warnings \
for you, try disabling ccache. */ \
_Pragma("clang diagnostic ignored \"-Wunused-value\"") { \
expr; \
} \
_Pragma("clang diagnostic pop") \
JS_END_MACRO
# elif MOZ_IS_GCC
# define JS_SILENCE_UNUSED_VALUE_IN_EXPR(expr) \
JS_BEGIN_MACRO \
_Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Wunused-but-set-variable\"") \
expr; \
_Pragma("GCC diagnostic pop") \
JS_END_MACRO
# endif
# if !defined(JS_SILENCE_UNUSED_VALUE_IN_EXPR)
# define JS_SILENCE_UNUSED_VALUE_IN_EXPR(expr) \
JS_BEGIN_MACRO \
expr; \
JS_END_MACRO
# endif
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 = DuplicateString(flags);
if (!flags2) {
return false;
}
// 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__ */