simpleperf/perf_clock.cpp

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "perf_clock.h"
  18
  19 #include <sys/mman.h>
  20 #include <sys/syscall.h>
  21
  22 #include <atomic>
  23 #include <chrono>
  24 #include <thread>
  25
  26 #include <android-base/logging.h>
  27
  28 #include "environment.h"
  29 #include "event_attr.h"
  30 #include "event_fd.h"
  31 #include "event_type.h"
  32 #include "record.h"
  33
  34 static bool perf_clock_initialized = false;
  35 static int64_t perf_clock_and_system_clock_diff_in_ns = 0;
  36
  37 struct ThreadArg {
  38   std::atomic<pid_t> thread_a_tid;
  39   std::atomic<bool> start_mmap;
  40   std::atomic<uint64_t> mmap_start_addr;
  41   uint64_t system_time_in_ns;
  42   std::atomic<bool> has_error;
  43 };
  44
  45 static void ThreadA(ThreadArg* thread_arg) {
  46   thread_arg->thread_a_tid = syscall(SYS_gettid);
  47   while (!thread_arg->start_mmap) {
  48     usleep(1000);
  49   }
  50
  51   size_t TRY_MMAP_COUNT = 10;
  52
  53   struct TryMmap {
  54     void* mmap_start_addr;
  55     uint64_t start_system_time_in_ns;
  56     uint64_t end_system_time_in_ns;
  57   };
  58   TryMmap array[TRY_MMAP_COUNT];
  59
  60   // In case current thread is preempted by other threads, we run mmap()
  61   // multiple times and use the one with the smallest time interval.
  62   for (size_t i = 0; i < TRY_MMAP_COUNT; ++i) {
  63     array[i].start_system_time_in_ns = GetSystemClock();
  64     array[i].mmap_start_addr =
  65         mmap(NULL, 4096, PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
  66     if (array[i].mmap_start_addr == MAP_FAILED) {
  67       PLOG(ERROR) << "mmap() failed";
  68       thread_arg->has_error = true;
  69       return;
  70     }
  71
  72     array[i].end_system_time_in_ns = GetSystemClock();
  73   }
  74   size_t best_index = 0;
  75   uint64_t min_duration_in_ns = UINT64_MAX;
  76   for (size_t i = 0; i < TRY_MMAP_COUNT; ++i) {
  77     uint64_t d =
  78         array[i].end_system_time_in_ns - array[i].start_system_time_in_ns;
  79     if (min_duration_in_ns > d) {
  80       min_duration_in_ns = d;
  81       best_index = i;
  82     }
  83     munmap(array[i].mmap_start_addr, 4096);
  84   }
  85   thread_arg->mmap_start_addr =
  86       reinterpret_cast<uint64_t>(array[best_index].mmap_start_addr);
  87   // Perf time is generated at the end of mmap() syscall, which is close to
  88   // the end time instead of the start time.
  89   thread_arg->system_time_in_ns = array[best_index].end_system_time_in_ns;
  90 }
  91
  92 static bool GetClockDiff(int64_t* clock_diff_in_ns) {
  93   ThreadArg thread_arg;
  94   thread_arg.thread_a_tid = 0;
  95   thread_arg.start_mmap = false;
  96   thread_arg.has_error = false;
  97   std::thread thread_a(ThreadA, &thread_arg);
  98   while (thread_arg.thread_a_tid == 0) {
  99     usleep(1000);
 100   }
 101   std::unique_ptr<EventTypeAndModifier> event_type =
 102       ParseEventType("cpu-clock");
 103   if (event_type == nullptr) {
 104     return false;
 105   }
 106   perf_event_attr attr = CreateDefaultPerfEventAttr(event_type->event_type);
 107   attr.comm = 0;
 108   attr.mmap_data = 1;
 109   attr.mmap = 0;
 110   attr.inherit = 0;
 111   attr.sample_id_all = 1;
 112   attr.freq = 0;
 113   attr.sample_period = 1ULL << 62;  // Sample records are not needed.
 114   std::unique_ptr<EventFd> event_fd =
 115       EventFd::OpenEventFile(attr, thread_arg.thread_a_tid, -1, nullptr);
 116   if (event_fd == nullptr) {
 117     return false;
 118   }
 119   if (!event_fd->CreateMappedBuffer(4, true)) {
 120     return false;
 121   }
 122
 123   thread_arg.start_mmap = true;
 124   thread_a.join();
 125
 126   if (thread_arg.has_error) {
 127     return false;
 128   }
 129
 130   std::vector<char> buffer;
 131   size_t buffer_pos = 0;
 132   size_t size = event_fd->GetAvailableMmapData(buffer, buffer_pos);
 133   std::vector<std::unique_ptr<Record>> records =
 134       ReadRecordsFromBuffer(attr, buffer.data(), size);
 135   uint64_t perf_time_in_ns = 0;
 136   for (auto& r : records) {
 137     if (r->type() == PERF_RECORD_MMAP) {
 138       auto& record = *static_cast<MmapRecord*>(r.get());
 139       if (record.data->addr == thread_arg.mmap_start_addr) {
 140         perf_time_in_ns = record.Timestamp();
 141       }
 142     }
 143   }
 144   if (perf_time_in_ns == 0) {
 145     LOG(ERROR) << "GetPerfClockAndSystemClockDiff: can't get perf time.";
 146     return false;
 147   }
 148
 149   *clock_diff_in_ns = perf_time_in_ns - thread_arg.system_time_in_ns;
 150   LOG(VERBOSE) << "perf_time is " << perf_time_in_ns << " ns, system_time is "
 151                << thread_arg.system_time_in_ns << " ns , clock_diff is "
 152                << *clock_diff_in_ns << " ns.";
 153   return true;
 154 }
 155
 156 bool InitPerfClock() {
 157   if (!perf_clock_initialized) {
 158     if (!GetClockDiff(&perf_clock_and_system_clock_diff_in_ns)) {
 159       return false;
 160     }
 161     perf_clock_initialized = true;
 162   }
 163   return true;
 164 }
 165
 166 uint64_t GetPerfClock() {
 167   CHECK(perf_clock_initialized);
 168   return GetSystemClock() + perf_clock_and_system_clock_diff_in_ns;
 169 }