LCOV - code coverage report
Current view: top level - src - perf-jit.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 0 132 0.0 %
Date: 2017-04-26 Functions: 0 16 0.0 %

          Line data    Source code
       1             : // Copyright 2016 the V8 project authors. All rights reserved.
       2             : // Redistribution and use in source and binary forms, with or without
       3             : // modification, are permitted provided that the following conditions are
       4             : // met:
       5             : //
       6             : //     * Redistributions of source code must retain the above copyright
       7             : //       notice, this list of conditions and the following disclaimer.
       8             : //     * Redistributions in binary form must reproduce the above
       9             : //       copyright notice, this list of conditions and the following
      10             : //       disclaimer in the documentation and/or other materials provided
      11             : //       with the distribution.
      12             : //     * Neither the name of Google Inc. nor the names of its
      13             : //       contributors may be used to endorse or promote products derived
      14             : //       from this software without specific prior written permission.
      15             : //
      16             : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      17             : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      18             : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      19             : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      20             : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      21             : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      22             : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      23             : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      24             : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      25             : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      26             : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      27             : 
      28             : #include "src/perf-jit.h"
      29             : 
      30             : #include <memory>
      31             : 
      32             : #include "src/assembler.h"
      33             : #include "src/eh-frame.h"
      34             : #include "src/objects-inl.h"
      35             : #include "src/source-position-table.h"
      36             : 
      37             : #if V8_OS_LINUX
      38             : #include <fcntl.h>
      39             : #include <sys/mman.h>
      40             : #include <unistd.h>
      41             : #endif  // V8_OS_LINUX
      42             : 
      43             : namespace v8 {
      44             : namespace internal {
      45             : 
      46             : #if V8_OS_LINUX
      47             : 
      48             : struct PerfJitHeader {
      49             :   uint32_t magic_;
      50             :   uint32_t version_;
      51             :   uint32_t size_;
      52             :   uint32_t elf_mach_target_;
      53             :   uint32_t reserved_;
      54             :   uint32_t process_id_;
      55             :   uint64_t time_stamp_;
      56             :   uint64_t flags_;
      57             : 
      58             :   static const uint32_t kMagic = 0x4A695444;
      59             :   static const uint32_t kVersion = 1;
      60             : };
      61             : 
      62             : struct PerfJitBase {
      63             :   enum PerfJitEvent {
      64             :     kLoad = 0,
      65             :     kMove = 1,
      66             :     kDebugInfo = 2,
      67             :     kClose = 3,
      68             :     kUnwindingInfo = 4
      69             :   };
      70             : 
      71             :   uint32_t event_;
      72             :   uint32_t size_;
      73             :   uint64_t time_stamp_;
      74             : };
      75             : 
      76             : struct PerfJitCodeLoad : PerfJitBase {
      77             :   uint32_t process_id_;
      78             :   uint32_t thread_id_;
      79             :   uint64_t vma_;
      80             :   uint64_t code_address_;
      81             :   uint64_t code_size_;
      82             :   uint64_t code_id_;
      83             : };
      84             : 
      85             : struct PerfJitDebugEntry {
      86             :   uint64_t address_;
      87             :   int line_number_;
      88             :   int column_;
      89             :   // Followed by null-terminated name or \0xff\0 if same as previous.
      90             : };
      91             : 
      92             : struct PerfJitCodeDebugInfo : PerfJitBase {
      93             :   uint64_t address_;
      94             :   uint64_t entry_count_;
      95             :   // Followed by entry_count_ instances of PerfJitDebugEntry.
      96             : };
      97             : 
      98             : struct PerfJitCodeUnwindingInfo : PerfJitBase {
      99             :   uint64_t unwinding_size_;
     100             :   uint64_t eh_frame_hdr_size_;
     101             :   uint64_t mapped_size_;
     102             :   // Followed by size_ - sizeof(PerfJitCodeUnwindingInfo) bytes of data.
     103             : };
     104             : 
     105             : const char PerfJitLogger::kFilenameFormatString[] = "./jit-%d.dump";
     106             : 
     107             : // Extra padding for the PID in the filename
     108             : const int PerfJitLogger::kFilenameBufferPadding = 16;
     109             : 
     110             : base::LazyRecursiveMutex PerfJitLogger::file_mutex_;
     111             : // The following static variables are protected by PerfJitLogger::file_mutex_.
     112             : uint64_t PerfJitLogger::reference_count_ = 0;
     113             : void* PerfJitLogger::marker_address_ = nullptr;
     114             : uint64_t PerfJitLogger::code_index_ = 0;
     115             : FILE* PerfJitLogger::perf_output_handle_ = nullptr;
     116             : 
     117           0 : void PerfJitLogger::OpenJitDumpFile() {
     118             :   // Open the perf JIT dump file.
     119           0 :   perf_output_handle_ = nullptr;
     120             : 
     121             :   int bufferSize = sizeof(kFilenameFormatString) + kFilenameBufferPadding;
     122             :   ScopedVector<char> perf_dump_name(bufferSize);
     123             :   int size = SNPrintF(perf_dump_name, kFilenameFormatString,
     124           0 :                       base::OS::GetCurrentProcessId());
     125           0 :   CHECK_NE(size, -1);
     126             : 
     127             :   int fd = open(perf_dump_name.start(), O_CREAT | O_TRUNC | O_RDWR, 0666);
     128           0 :   if (fd == -1) return;
     129             : 
     130           0 :   marker_address_ = OpenMarkerFile(fd);
     131           0 :   if (marker_address_ == nullptr) return;
     132             : 
     133           0 :   perf_output_handle_ = fdopen(fd, "w+");
     134           0 :   if (perf_output_handle_ == nullptr) return;
     135             : 
     136           0 :   setvbuf(perf_output_handle_, NULL, _IOFBF, kLogBufferSize);
     137             : }
     138             : 
     139           0 : void PerfJitLogger::CloseJitDumpFile() {
     140           0 :   if (perf_output_handle_ == nullptr) return;
     141           0 :   fclose(perf_output_handle_);
     142           0 :   perf_output_handle_ = nullptr;
     143             : }
     144             : 
     145           0 : void* PerfJitLogger::OpenMarkerFile(int fd) {
     146           0 :   long page_size = sysconf(_SC_PAGESIZE);  // NOLINT(runtime/int)
     147           0 :   if (page_size == -1) return nullptr;
     148             : 
     149             :   // Mmap the file so that there is a mmap record in the perf_data file.
     150             :   //
     151             :   // The map must be PROT_EXEC to ensure it is not ignored by perf record.
     152             :   void* marker_address =
     153           0 :       mmap(nullptr, page_size, PROT_READ | PROT_EXEC, MAP_PRIVATE, fd, 0);
     154           0 :   return (marker_address == MAP_FAILED) ? nullptr : marker_address;
     155             : }
     156             : 
     157           0 : void PerfJitLogger::CloseMarkerFile(void* marker_address) {
     158           0 :   if (marker_address == nullptr) return;
     159           0 :   long page_size = sysconf(_SC_PAGESIZE);  // NOLINT(runtime/int)
     160           0 :   if (page_size == -1) return;
     161           0 :   munmap(marker_address, page_size);
     162             : }
     163             : 
     164           0 : PerfJitLogger::PerfJitLogger() {
     165             :   base::LockGuard<base::RecursiveMutex> guard_file(file_mutex_.Pointer());
     166             : 
     167           0 :   reference_count_++;
     168             :   // If this is the first logger, open the file and write the header.
     169           0 :   if (reference_count_ == 1) {
     170           0 :     OpenJitDumpFile();
     171           0 :     if (perf_output_handle_ == nullptr) return;
     172           0 :     LogWriteHeader();
     173             :   }
     174             : }
     175             : 
     176           0 : PerfJitLogger::~PerfJitLogger() {
     177             :   base::LockGuard<base::RecursiveMutex> guard_file(file_mutex_.Pointer());
     178             : 
     179           0 :   reference_count_--;
     180             :   // If this was the last logger, close the file.
     181           0 :   if (reference_count_ == 0) {
     182             :     CloseJitDumpFile();
     183             :   }
     184           0 : }
     185             : 
     186           0 : uint64_t PerfJitLogger::GetTimestamp() {
     187             :   struct timespec ts;
     188           0 :   int result = clock_gettime(CLOCK_MONOTONIC, &ts);
     189             :   DCHECK_EQ(0, result);
     190             :   USE(result);
     191             :   static const uint64_t kNsecPerSec = 1000000000;
     192           0 :   return (ts.tv_sec * kNsecPerSec) + ts.tv_nsec;
     193             : }
     194             : 
     195           0 : void PerfJitLogger::LogRecordedBuffer(AbstractCode* abstract_code,
     196             :                                       SharedFunctionInfo* shared,
     197             :                                       const char* name, int length) {
     198           0 :   if (FLAG_perf_basic_prof_only_functions &&
     199           0 :       (abstract_code->kind() != AbstractCode::FUNCTION &&
     200           0 :        abstract_code->kind() != AbstractCode::INTERPRETED_FUNCTION &&
     201           0 :        abstract_code->kind() != AbstractCode::OPTIMIZED_FUNCTION)) {
     202           0 :     return;
     203             :   }
     204             : 
     205             :   base::LockGuard<base::RecursiveMutex> guard_file(file_mutex_.Pointer());
     206             : 
     207           0 :   if (perf_output_handle_ == nullptr) return;
     208             : 
     209             :   // We only support non-interpreted functions.
     210           0 :   if (!abstract_code->IsCode()) return;
     211             :   Code* code = abstract_code->GetCode();
     212             :   DCHECK(code->instruction_start() == code->address() + Code::kHeaderSize);
     213             : 
     214             :   // Debug info has to be emitted first.
     215           0 :   if (FLAG_perf_prof && shared != nullptr) {
     216           0 :     LogWriteDebugInfo(code, shared);
     217             :   }
     218             : 
     219             :   const char* code_name = name;
     220           0 :   uint8_t* code_pointer = reinterpret_cast<uint8_t*>(code->instruction_start());
     221             :   // Code generated by Crankshaft or Turbofan will have the safepoint table
     222             :   // directly after instructions. There is no need to record the safepoint table
     223             :   // itself.
     224             :   uint32_t code_size = code->is_crankshafted() ? code->safepoint_table_offset()
     225           0 :                                                : code->instruction_size();
     226             : 
     227             :   // Unwinding info comes right after debug info.
     228           0 :   if (FLAG_perf_prof_unwinding_info) LogWriteUnwindingInfo(code);
     229             : 
     230             :   static const char string_terminator[] = "\0";
     231             : 
     232             :   PerfJitCodeLoad code_load;
     233           0 :   code_load.event_ = PerfJitCodeLoad::kLoad;
     234           0 :   code_load.size_ = sizeof(code_load) + length + 1 + code_size;
     235           0 :   code_load.time_stamp_ = GetTimestamp();
     236             :   code_load.process_id_ =
     237           0 :       static_cast<uint32_t>(base::OS::GetCurrentProcessId());
     238           0 :   code_load.thread_id_ = static_cast<uint32_t>(base::OS::GetCurrentThreadId());
     239           0 :   code_load.vma_ = 0x0;  //  Our addresses are absolute.
     240           0 :   code_load.code_address_ = reinterpret_cast<uint64_t>(code_pointer);
     241           0 :   code_load.code_size_ = code_size;
     242           0 :   code_load.code_id_ = code_index_;
     243             : 
     244           0 :   code_index_++;
     245             : 
     246             :   LogWriteBytes(reinterpret_cast<const char*>(&code_load), sizeof(code_load));
     247             :   LogWriteBytes(code_name, length);
     248             :   LogWriteBytes(string_terminator, 1);
     249           0 :   LogWriteBytes(reinterpret_cast<const char*>(code_pointer), code_size);
     250             : }
     251             : 
     252             : namespace {
     253             : 
     254           0 : std::unique_ptr<char[]> GetScriptName(Handle<Script> script) {
     255           0 :   Object* name_or_url = script->GetNameOrSourceURL();
     256           0 :   int name_length = 0;
     257             :   std::unique_ptr<char[]> name_string;
     258           0 :   if (name_or_url->IsString()) {
     259             :     return String::cast(name_or_url)
     260           0 :         ->ToCString(DISALLOW_NULLS, FAST_STRING_TRAVERSAL, &name_length);
     261             :   } else {
     262           0 :     const char unknown[] = "<unknown>";
     263           0 :     name_length = static_cast<int>(strlen(unknown));
     264           0 :     char* buffer = NewArray<char>(name_length);
     265             :     base::OS::StrNCpy(buffer, name_length + 1, unknown,
     266           0 :                       static_cast<size_t>(name_length));
     267             :     return std::unique_ptr<char[]>(buffer);
     268             :   }
     269             : }
     270             : 
     271           0 : SourcePositionInfo GetSourcePositionInfo(Handle<Code> code,
     272             :                                          Handle<SharedFunctionInfo> function,
     273             :                                          SourcePosition pos) {
     274           0 :   if (code->is_turbofanned() || code->is_crankshafted()) {
     275             :     DisallowHeapAllocation disallow;
     276           0 :     return pos.InliningStack(code)[0];
     277             :   } else {
     278           0 :     return SourcePositionInfo(pos, function);
     279             :   }
     280             : }
     281             : 
     282             : }  // namespace
     283             : 
     284           0 : void PerfJitLogger::LogWriteDebugInfo(Code* code, SharedFunctionInfo* shared) {
     285             :   // Compute the entry count and get the name of the script.
     286             :   uint32_t entry_count = 0;
     287           0 :   for (SourcePositionTableIterator iterator(code->SourcePositionTable());
     288           0 :        !iterator.done(); iterator.Advance()) {
     289           0 :     entry_count++;
     290             :   }
     291           0 :   if (entry_count == 0) return;
     292             :   Handle<Script> script(Script::cast(shared->script()));
     293             : 
     294             :   PerfJitCodeDebugInfo debug_info;
     295             : 
     296           0 :   debug_info.event_ = PerfJitCodeLoad::kDebugInfo;
     297           0 :   debug_info.time_stamp_ = GetTimestamp();
     298           0 :   debug_info.address_ = reinterpret_cast<uint64_t>(code->instruction_start());
     299           0 :   debug_info.entry_count_ = entry_count;
     300             : 
     301             :   uint32_t size = sizeof(debug_info);
     302             :   // Add the sizes of fixed parts of entries.
     303           0 :   size += entry_count * sizeof(PerfJitDebugEntry);
     304             :   // Add the size of the name after each entry.
     305             : 
     306             :   Handle<Code> code_handle(code);
     307             :   Handle<SharedFunctionInfo> function_handle(shared);
     308           0 :   for (SourcePositionTableIterator iterator(code->SourcePositionTable());
     309           0 :        !iterator.done(); iterator.Advance()) {
     310             :     SourcePositionInfo info(GetSourcePositionInfo(code_handle, function_handle,
     311           0 :                                                   iterator.source_position()));
     312             :     Handle<Script> script(Script::cast(info.function->script()));
     313           0 :     std::unique_ptr<char[]> name_string = GetScriptName(script);
     314           0 :     size += (static_cast<uint32_t>(strlen(name_string.get())) + 1);
     315             :   }
     316             : 
     317           0 :   int padding = ((size + 7) & (~7)) - size;
     318           0 :   debug_info.size_ = size + padding;
     319             :   LogWriteBytes(reinterpret_cast<const char*>(&debug_info), sizeof(debug_info));
     320             : 
     321             :   Address code_start = code->instruction_start();
     322             : 
     323           0 :   for (SourcePositionTableIterator iterator(code->SourcePositionTable());
     324           0 :        !iterator.done(); iterator.Advance()) {
     325             :     SourcePositionInfo info(GetSourcePositionInfo(code_handle, function_handle,
     326           0 :                                                   iterator.source_position()));
     327             :     PerfJitDebugEntry entry;
     328             :     // The entry point of the function will be placed straight after the ELF
     329             :     // header when processed by "perf inject". Adjust the position addresses
     330             :     // accordingly.
     331             :     entry.address_ = reinterpret_cast<intptr_t>(
     332           0 :         code_start + iterator.code_offset() + kElfHeaderSize);
     333           0 :     entry.line_number_ = info.line + 1;
     334           0 :     entry.column_ = info.column + 1;
     335             :     LogWriteBytes(reinterpret_cast<const char*>(&entry), sizeof(entry));
     336             :     Handle<Script> script(Script::cast(info.function->script()));
     337           0 :     std::unique_ptr<char[]> name_string = GetScriptName(script);
     338             :     LogWriteBytes(name_string.get(),
     339           0 :                   static_cast<uint32_t>(strlen(name_string.get())) + 1);
     340             :   }
     341           0 :   char padding_bytes[] = "\0\0\0\0\0\0\0\0";
     342             :   LogWriteBytes(padding_bytes, padding);
     343             : }
     344             : 
     345           0 : void PerfJitLogger::LogWriteUnwindingInfo(Code* code) {
     346             :   PerfJitCodeUnwindingInfo unwinding_info_header;
     347           0 :   unwinding_info_header.event_ = PerfJitCodeLoad::kUnwindingInfo;
     348           0 :   unwinding_info_header.time_stamp_ = GetTimestamp();
     349           0 :   unwinding_info_header.eh_frame_hdr_size_ = EhFrameConstants::kEhFrameHdrSize;
     350             : 
     351           0 :   if (code->has_unwinding_info()) {
     352           0 :     unwinding_info_header.unwinding_size_ = code->unwinding_info_size();
     353           0 :     unwinding_info_header.mapped_size_ = unwinding_info_header.unwinding_size_;
     354             :   } else {
     355           0 :     unwinding_info_header.unwinding_size_ = EhFrameConstants::kEhFrameHdrSize;
     356           0 :     unwinding_info_header.mapped_size_ = 0;
     357             :   }
     358             : 
     359             :   int content_size = static_cast<int>(sizeof(unwinding_info_header) +
     360           0 :                                       unwinding_info_header.unwinding_size_);
     361           0 :   int padding_size = RoundUp(content_size, 8) - content_size;
     362           0 :   unwinding_info_header.size_ = content_size + padding_size;
     363             : 
     364             :   LogWriteBytes(reinterpret_cast<const char*>(&unwinding_info_header),
     365             :                 sizeof(unwinding_info_header));
     366             : 
     367           0 :   if (code->has_unwinding_info()) {
     368             :     LogWriteBytes(reinterpret_cast<const char*>(code->unwinding_info_start()),
     369             :                   code->unwinding_info_size());
     370             :   } else {
     371           0 :     OFStream perf_output_stream(perf_output_handle_);
     372           0 :     EhFrameWriter::WriteEmptyEhFrame(perf_output_stream);
     373             :   }
     374             : 
     375           0 :   char padding_bytes[] = "\0\0\0\0\0\0\0\0";
     376             :   DCHECK_LT(padding_size, static_cast<int>(sizeof(padding_bytes)));
     377             :   LogWriteBytes(padding_bytes, static_cast<int>(padding_size));
     378           0 : }
     379             : 
     380           0 : void PerfJitLogger::CodeMoveEvent(AbstractCode* from, Address to) {
     381             :   // Code relocation not supported.
     382           0 :   UNREACHABLE();
     383             : }
     384             : 
     385           0 : void PerfJitLogger::LogWriteBytes(const char* bytes, int size) {
     386           0 :   size_t rv = fwrite(bytes, 1, size, perf_output_handle_);
     387             :   DCHECK(static_cast<size_t>(size) == rv);
     388             :   USE(rv);
     389           0 : }
     390             : 
     391           0 : void PerfJitLogger::LogWriteHeader() {
     392             :   DCHECK(perf_output_handle_ != NULL);
     393             :   PerfJitHeader header;
     394             : 
     395           0 :   header.magic_ = PerfJitHeader::kMagic;
     396           0 :   header.version_ = PerfJitHeader::kVersion;
     397           0 :   header.size_ = sizeof(header);
     398           0 :   header.elf_mach_target_ = GetElfMach();
     399           0 :   header.reserved_ = 0xdeadbeef;
     400           0 :   header.process_id_ = base::OS::GetCurrentProcessId();
     401             :   header.time_stamp_ =
     402           0 :       static_cast<uint64_t>(base::OS::TimeCurrentMillis() * 1000.0);
     403           0 :   header.flags_ = 0;
     404             : 
     405             :   LogWriteBytes(reinterpret_cast<const char*>(&header), sizeof(header));
     406           0 : }
     407             : 
     408             : #endif  // V8_OS_LINUX
     409             : }  // namespace internal
     410             : }  // namespace v8

Generated by: LCOV version 1.10