Florian Mayer | c7255fd | 2018-01-25 10:29:24 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2018 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 | |
Lalit Maganti | bfc3d3e | 2018-03-22 20:28:38 +0000 | [diff] [blame] | 17 | #include <pthread.h> |
| 18 | #include <stdlib.h> |
| 19 | #include <sys/syscall.h> |
| 20 | #include <sys/types.h> |
| 21 | #include <unistd.h> |
| 22 | |
| 23 | #include <condition_variable> |
Florian Mayer | c7255fd | 2018-01-25 10:29:24 +0000 | [diff] [blame] | 24 | #include <thread> |
| 25 | |
Lalit Maganti | bfc3d3e | 2018-03-22 20:28:38 +0000 | [diff] [blame] | 26 | #include "perfetto/base/file_utils.h" |
| 27 | #include "perfetto/base/string_splitter.h" |
| 28 | #include "perfetto/base/time.h" |
Florian Mayer | c7255fd | 2018-01-25 10:29:24 +0000 | [diff] [blame] | 29 | #include "test/task_runner_thread.h" |
| 30 | |
| 31 | namespace perfetto { |
| 32 | |
Lalit Maganti | bfc3d3e | 2018-03-22 20:28:38 +0000 | [diff] [blame] | 33 | TaskRunnerThread::TaskRunnerThread(const char* name) : name_(name) {} |
Florian Mayer | c7255fd | 2018-01-25 10:29:24 +0000 | [diff] [blame] | 34 | TaskRunnerThread::~TaskRunnerThread() { |
Lalit Maganti | bfc3d3e | 2018-03-22 20:28:38 +0000 | [diff] [blame] | 35 | Stop(); |
Florian Mayer | c7255fd | 2018-01-25 10:29:24 +0000 | [diff] [blame] | 36 | } |
| 37 | |
| 38 | void TaskRunnerThread::Start(std::unique_ptr<ThreadDelegate> delegate) { |
| 39 | // Begin holding the lock for the condition variable. |
| 40 | std::unique_lock<std::mutex> lock(mutex_); |
| 41 | |
| 42 | // Start the thread. |
| 43 | PERFETTO_DCHECK(!runner_); |
| 44 | thread_ = std::thread(&TaskRunnerThread::Run, this, std::move(delegate)); |
| 45 | |
| 46 | // Wait for runner to be ready. |
| 47 | ready_.wait_for(lock, std::chrono::seconds(10), |
| 48 | [this]() { return runner_ != nullptr; }); |
| 49 | } |
| 50 | |
Lalit Maganti | bfc3d3e | 2018-03-22 20:28:38 +0000 | [diff] [blame] | 51 | void TaskRunnerThread::Stop() { |
| 52 | { |
| 53 | std::unique_lock<std::mutex> lock(mutex_); |
| 54 | if (runner_) |
| 55 | runner_->Quit(); |
| 56 | } |
| 57 | |
| 58 | if (thread_.joinable()) |
| 59 | thread_.join(); |
| 60 | } |
| 61 | |
| 62 | uint64_t TaskRunnerThread::GetThreadCPUTimeNs() { |
| 63 | std::condition_variable cv; |
| 64 | std::unique_lock<std::mutex> lock(mutex_); |
| 65 | uint64_t thread_time_ns = 0; |
| 66 | |
| 67 | if (!runner_) |
| 68 | return 0; |
| 69 | |
| 70 | runner_->PostTask([this, &thread_time_ns, &cv] { |
| 71 | std::unique_lock<std::mutex> inner_lock(mutex_); |
Primiano Tucci | 3cbb10a | 2018-04-10 17:52:40 +0100 | [diff] [blame] | 72 | thread_time_ns = static_cast<uint64_t>(base::GetThreadCPUTimeNs().count()); |
Lalit Maganti | bfc3d3e | 2018-03-22 20:28:38 +0000 | [diff] [blame] | 73 | cv.notify_one(); |
| 74 | }); |
| 75 | |
| 76 | cv.wait(lock, [&thread_time_ns] { return thread_time_ns != 0; }); |
| 77 | return thread_time_ns; |
| 78 | } |
| 79 | |
Florian Mayer | c7255fd | 2018-01-25 10:29:24 +0000 | [diff] [blame] | 80 | void TaskRunnerThread::Run(std::unique_ptr<ThreadDelegate> delegate) { |
Primiano Tucci | 808d6df | 2018-03-31 13:24:18 +0100 | [diff] [blame] | 81 | #if PERFETTO_BUILDFLAG(PERFETTO_OS_MACOSX) |
| 82 | pthread_setname_np(name_); |
| 83 | #else |
Lalit Maganti | bfc3d3e | 2018-03-22 20:28:38 +0000 | [diff] [blame] | 84 | pthread_setname_np(pthread_self(), name_); |
Primiano Tucci | 808d6df | 2018-03-31 13:24:18 +0100 | [diff] [blame] | 85 | #endif |
Lalit Maganti | bfc3d3e | 2018-03-22 20:28:38 +0000 | [diff] [blame] | 86 | |
Florian Mayer | c7255fd | 2018-01-25 10:29:24 +0000 | [diff] [blame] | 87 | // Create the task runner and execute the specicalised code. |
| 88 | base::PlatformTaskRunner task_runner; |
| 89 | delegate->Initialize(&task_runner); |
| 90 | |
| 91 | // Pass the runner back to the main thread. |
| 92 | { |
| 93 | std::unique_lock<std::mutex> lock(mutex_); |
| 94 | runner_ = &task_runner; |
| 95 | } |
| 96 | |
| 97 | // Notify the main thread that the runner is ready. |
| 98 | ready_.notify_one(); |
| 99 | |
| 100 | // Spin the loop. |
| 101 | task_runner.Run(); |
| 102 | |
| 103 | // Ensure we clear out the delegate before runner goes out |
| 104 | // of scope. |
| 105 | delegate.reset(); |
| 106 | |
| 107 | // Cleanup the runner. |
| 108 | { |
| 109 | std::unique_lock<std::mutex> lock(mutex_); |
| 110 | runner_ = nullptr; |
| 111 | } |
| 112 | } |
| 113 | |
Primiano Tucci | 3cbb10a | 2018-04-10 17:52:40 +0100 | [diff] [blame] | 114 | ThreadDelegate::~ThreadDelegate() = default; |
| 115 | |
Florian Mayer | c7255fd | 2018-01-25 10:29:24 +0000 | [diff] [blame] | 116 | } // namespace perfetto |