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
ThreadA(ThreadArg * thread_arg)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
GetClockDiff(int64_t * clock_diff_in_ns)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
InitPerfClock()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
GetPerfClock()166 uint64_t GetPerfClock() {
167 CHECK(perf_clock_initialized);
168 return GetSystemClock() + perf_clock_and_system_clock_diff_in_ns;
169 }
170