src/jit/PerfSpewer.cpp

/* -*- 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/. */

#include "jit/PerfSpewer.h"

#include "mozilla/IntegerPrintfMacros.h"
#include "mozilla/Printf.h"

#ifdef XP_UNIX
#  include <unistd.h>
#endif

#ifdef JS_ION_PERF
#  include "jit/JitSpewer.h"
#  include "jit/LIR.h"
#  include "jit/MIR.h"
#  include "jit/MIRGraph.h"
#endif

#include "vm/MutexIDs.h"

// perf expects its data to be in a file /tmp/perf-PID.map, but for Android
// and B2G the map files are written to /data/local/tmp/perf-PID.map
//
// Except that Android 4.3 no longer allows the browser to write to
// /data/local/tmp/ so also try /sdcard/.

#ifndef PERF_SPEW_DIR
#  if defined(__ANDROID__)
#    define PERF_SPEW_DIR "/data/local/tmp/"
#    define PERF_SPEW_DIR_2 "/sdcard/"
#  else
#    define PERF_SPEW_DIR "/tmp/"
#  endif
#endif

using namespace js;
using namespace js::jit;

#define PERF_MODE_NONE 1
#define PERF_MODE_FUNC 2
#define PERF_MODE_BLOCK 3

#ifdef JS_ION_PERF

static uint32_t PerfMode = 0;

static bool PerfChecked = false;

static FILE* PerfFilePtr = nullptr;

static js::Mutex* PerfMutex;

static bool openPerfMap(const char* dir) {
  const ssize_t bufferSize = 256;
  char filenameBuffer[bufferSize];

  if (snprintf(filenameBuffer, bufferSize, "%sperf-%d.map", dir, getpid()) >=
      bufferSize) {
    return false;
  }

  MOZ_ASSERT(!PerfFilePtr);
  PerfFilePtr = fopen(filenameBuffer, "a");

  if (!PerfFilePtr) {
    return false;
  }

  return true;
}

void js::jit::CheckPerf() {
  if (!PerfChecked) {
    const char* env = getenv("IONPERF");
    if (env == nullptr) {
      PerfMode = PERF_MODE_NONE;
      fprintf(stderr,
              "Warning: JIT perf reporting requires IONPERF set to \"block\" "
              "or \"func\". ");
      fprintf(stderr, "Perf mapping will be deactivated.\n");
    } else if (!strcmp(env, "none")) {
      PerfMode = PERF_MODE_NONE;
    } else if (!strcmp(env, "block")) {
      PerfMode = PERF_MODE_BLOCK;
    } else if (!strcmp(env, "func")) {
      PerfMode = PERF_MODE_FUNC;
    } else {
      fprintf(stderr, "Use IONPERF=func to record at function granularity\n");
      fprintf(stderr,
              "Use IONPERF=block to record at basic block granularity\n");
      fprintf(stderr, "\n");
      fprintf(stderr, "Be advised that using IONPERF will cause all scripts\n");
      fprintf(stderr, "to be leaked.\n");
      exit(0);
    }

    if (PerfMode != PERF_MODE_NONE) {
      PerfMutex = js_new<js::Mutex>(mutexid::PerfSpewer);
      if (!PerfMutex) {
        MOZ_CRASH("failed to allocate PerfMutex");
      }

      if (openPerfMap(PERF_SPEW_DIR)) {
        PerfChecked = true;
        return;
      }

#  if defined(__ANDROID__)
      if (openPerfMap(PERF_SPEW_DIR_2)) {
        PerfChecked = true;
        return;
      }
#  endif
      fprintf(stderr, "Failed to open perf map file.  Disabling IONPERF.\n");
      PerfMode = PERF_MODE_NONE;
    }
    PerfChecked = true;
  }
}

bool js::jit::PerfBlockEnabled() {
  MOZ_ASSERT(PerfMode);
  return PerfMode == PERF_MODE_BLOCK;
}

bool js::jit::PerfFuncEnabled() {
  MOZ_ASSERT(PerfMode);
  return PerfMode == PERF_MODE_FUNC;
}

namespace {
struct MOZ_RAII AutoLockPerfMap {
  AutoLockPerfMap() {
    if (!PerfEnabled()) {
      return;
    }
    PerfMutex->lock();
    MOZ_ASSERT(PerfFilePtr);
  }
  ~AutoLockPerfMap() {
    MOZ_ASSERT(PerfFilePtr);
    fflush(PerfFilePtr);
    PerfMutex->unlock();
  }
};
}  // namespace

uint32_t PerfSpewer::nextFunctionIndex = 0;

bool PerfSpewer::startBasicBlock(MBasicBlock* blk, MacroAssembler& masm) {
  if (!PerfBlockEnabled()) {
    return true;
  }

  const char* filename = blk->info().script()->filename();
  unsigned lineNumber, columnNumber;
  if (blk->pc()) {
    lineNumber = PCToLineNumber(blk->info().script(), blk->pc(), &columnNumber);
  } else {
    lineNumber = 0;
    columnNumber = 0;
  }
  Record r(filename, lineNumber, columnNumber, blk->id());
  masm.bind(&r.start);
  return basicBlocks_.append(r);
}

void PerfSpewer::endBasicBlock(MacroAssembler& masm) {
  if (!PerfBlockEnabled()) {
    return;
  }
  masm.bind(&basicBlocks_.back().end);
}

void PerfSpewer::noteEndInlineCode(MacroAssembler& masm) {
  if (!PerfBlockEnabled()) {
    return;
  }
  masm.bind(&endInlineCode);
}

void PerfSpewer::WriteEntry(const AutoLockPerfMap&, uintptr_t address,
                            size_t size, const char* fmt, ...) {
  va_list ap;
  va_start(ap, fmt);

  auto result = mozilla::Vsmprintf<js::SystemAllocPolicy>(fmt, ap);
  va_end(ap);

  fprintf(PerfFilePtr, "%" PRIxPTR " %zx %s\n", address, size, result.get());
}

void PerfSpewer::writeProfile(JSScript* script, JitCode* code,
                              MacroAssembler& masm) {
  AutoLockPerfMap lock;

  if (PerfFuncEnabled()) {
    uint32_t thisFunctionIndex = nextFunctionIndex++;
    size_t size = code->instructionsSize();
    if (size > 0) {
      WriteEntry(lock, reinterpret_cast<uintptr_t>(code->raw()), size,
                 "%s:%u: Func%02" PRIu32, script->filename(), script->lineno(),
                 thisFunctionIndex);
    }
    return;
  }

  if (PerfBlockEnabled() && basicBlocks_.length() > 0) {
    uint32_t thisFunctionIndex = nextFunctionIndex++;
    uintptr_t funcStart = uintptr_t(code->raw());
    uintptr_t funcEndInlineCode = funcStart + endInlineCode.offset();
    uintptr_t funcEnd = funcStart + code->instructionsSize();

    // function begins with the prologue, which is located before the first
    // basic block
    size_t prologueSize = basicBlocks_[0].start.offset();

    if (prologueSize > 0) {
      WriteEntry(lock, funcStart, prologueSize,
                 "%s:%u: Func%02" PRIu32 "-Prologue", script->filename(),
                 script->lineno(), thisFunctionIndex);
    }

    uintptr_t cur = funcStart + prologueSize;
    for (uint32_t i = 0; i < basicBlocks_.length(); i++) {
      Record& r = basicBlocks_[i];

      uintptr_t blockStart = funcStart + r.start.offset();
      uintptr_t blockEnd = funcStart + r.end.offset();

      MOZ_ASSERT(cur <= blockStart);
      if (cur < blockStart) {
        WriteEntry(lock, cur, blockStart - cur,
                   "%s:%u: Func%02" PRIu32 "-Block?", script->filename(),
                   script->lineno(), thisFunctionIndex);
      }
      cur = blockEnd;

      size_t size = blockEnd - blockStart;

      if (size > 0) {
        WriteEntry(lock, blockStart, size,
                   "%s:%u:%u: Func%02" PRIu32 "d-Block%" PRIu32, r.filename,
                   r.lineNumber, r.columnNumber, thisFunctionIndex, r.id);
      }
    }

    MOZ_ASSERT(cur <= funcEndInlineCode);
    if (cur < funcEndInlineCode) {
      WriteEntry(lock, cur, funcEndInlineCode - cur,
                 "%s:%u: Func%02" PRIu32 "-Epilogue", script->filename(),
                 script->lineno(), thisFunctionIndex);
    }

    MOZ_ASSERT(funcEndInlineCode <= funcEnd);
    if (funcEndInlineCode < funcEnd) {
      WriteEntry(lock, funcEndInlineCode, funcEnd - funcEndInlineCode,
                 "%s:%u: Func%02" PRIu32 "-OOL", script->filename(),
                 script->lineno(), thisFunctionIndex);
    }
  }
}

void js::jit::writePerfSpewerBaselineProfile(JSScript* script, JitCode* code) {
  if (!PerfEnabled()) {
    return;
  }

  size_t size = code->instructionsSize();
  if (size > 0) {
    AutoLockPerfMap lock;
    PerfSpewer::WriteEntry(lock, reinterpret_cast<uintptr_t>(code->raw()), size,
                           "%s:%u: Baseline", script->filename(),
                           script->lineno());
  }
}

void js::jit::writePerfSpewerJitCodeProfile(JitCode* code, const char* msg) {
  if (!code || !PerfEnabled()) {
    return;
  }

  size_t size = code->instructionsSize();
  if (size > 0) {
    AutoLockPerfMap lock;
    PerfSpewer::WriteEntry(lock, reinterpret_cast<uintptr_t>(code->raw()), size,
                           "%s (%p 0x%zx)", msg, code->raw(), size);
  }
}

void js::jit::writePerfSpewerWasmMap(uintptr_t base, uintptr_t size,
                                     const char* filename,
                                     const char* annotation) {
  if (!PerfFuncEnabled() || size == 0U) {
    return;
  }

  AutoLockPerfMap lock;
  PerfSpewer::WriteEntry(lock, base, size, "%s: Function %s", filename,
                         annotation);
}

void js::jit::writePerfSpewerWasmFunctionMap(uintptr_t base, uintptr_t size,
                                             const char* filename,
                                             unsigned lineno,
                                             const char* funcName) {
  if (!PerfFuncEnabled() || size == 0U) {
    return;
  }

  AutoLockPerfMap lock;
  PerfSpewer::WriteEntry(lock, base, size, "%s:%u: Function %s", filename,
                         lineno, funcName);
}

#endif  // defined (JS_ION_PERF)