1 /*
2 * Copyright (C) 2015 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 <err.h>
18 #include <errno.h>
19 #include <pthread.h>
20 #include <stdint.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <sys/mman.h>
25 #include <unistd.h>
26
27 #include <new>
28
29 #include "Action.h"
30 #include "Thread.h"
31 #include "Threads.h"
32
ThreadRunner(void * data)33 void* ThreadRunner(void* data) {
34 Thread* thread = reinterpret_cast<Thread*>(data);
35 while (true) {
36 thread->WaitForPending();
37 Action* action = thread->GetAction();
38 thread->AddTimeNsecs(action->Execute(thread->pointers()));
39 bool end_thread = action->EndThread();
40 thread->ClearPending();
41 if (end_thread) {
42 break;
43 }
44 }
45 return nullptr;
46 }
47
Threads(Pointers * pointers,size_t max_threads)48 Threads::Threads(Pointers* pointers, size_t max_threads)
49 : pointers_(pointers), max_threads_(max_threads) {
50 size_t pagesize = getpagesize();
51 data_size_ = (max_threads_ * sizeof(Thread) + pagesize - 1) & ~(pagesize - 1);
52 max_threads_ = data_size_ / sizeof(Thread);
53
54 void* memory = mmap(nullptr, data_size_, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
55 if (memory == MAP_FAILED) {
56 err(1, "Failed to map in memory for Threads: map size %zu, max threads %zu\n",
57 data_size_, max_threads_);
58 }
59
60 if (Thread::ACTION_SIZE < Action::MaxActionSize()) {
61 err(1, "Thread action size is too small: ACTION_SIZE %zu, max size %zu\n",
62 Thread::ACTION_SIZE, Action::MaxActionSize());
63 }
64
65 threads_ = new (memory) Thread[max_threads_];
66 }
67
~Threads()68 Threads::~Threads() {
69 if (threads_) {
70 munmap(threads_, data_size_);
71 threads_ = nullptr;
72 data_size_ = 0;
73 }
74 }
75
CreateThread(pid_t tid)76 Thread* Threads::CreateThread(pid_t tid) {
77 if (num_threads_ == max_threads_) {
78 err(1, "Too many threads created, current max %zu.\n", num_threads_);
79 }
80 Thread* thread = FindEmptyEntry(tid);
81 if (thread == nullptr) {
82 err(1, "No empty entries found, current max %zu, num threads %zu\n",
83 max_threads_, num_threads_);
84 }
85 thread->tid_ = tid;
86 thread->pointers_ = pointers_;
87 thread->total_time_nsecs_ = 0;
88 if (pthread_create(&thread->thread_id_, nullptr, ThreadRunner, thread) == -1) {
89 err(1, "Failed to create thread %d: %s\n", tid, strerror(errno));
90 }
91
92 num_threads_++;
93 return thread;
94 }
95
FindThread(pid_t tid)96 Thread* Threads::FindThread(pid_t tid) {
97 size_t index = GetHashEntry(tid);
98 for (size_t entries = num_threads_; entries != 0; ) {
99 pid_t cur_tid = threads_[index].tid_;
100 if (cur_tid == tid) {
101 return threads_ + index;
102 }
103 if (cur_tid != 0) {
104 entries--;
105 }
106 if (++index == max_threads_) {
107 index = 0;
108 }
109 }
110 return nullptr;
111 }
112
WaitForAllToQuiesce()113 void Threads::WaitForAllToQuiesce() {
114 for (size_t i = 0, threads = 0; threads < num_threads_; i++) {
115 pid_t cur_tid = threads_[i].tid_;
116 if (cur_tid != 0) {
117 threads++;
118 threads_[i].WaitForReady();
119 }
120 }
121 }
122
GetHashEntry(pid_t tid)123 size_t Threads::GetHashEntry(pid_t tid) {
124 return tid % max_threads_;
125 }
126
FindEmptyEntry(pid_t tid)127 Thread* Threads::FindEmptyEntry(pid_t tid) {
128 size_t index = GetHashEntry(tid);
129 for (size_t entries = 0; entries < max_threads_; entries++) {
130 if (threads_[index].tid_ == 0) {
131 return threads_ + index;
132 }
133 if (++index == max_threads_) {
134 index = 0;
135 }
136 }
137 return nullptr;
138 }
139
Finish(Thread * thread)140 void Threads::Finish(Thread* thread) {
141 int ret = pthread_join(thread->thread_id_, nullptr);
142 if (ret != 0) {
143 fprintf(stderr, "pthread_join failed: %s\n", strerror(ret));
144 exit(1);
145 }
146 total_time_nsecs_ += thread->total_time_nsecs_;
147 thread->tid_ = 0;
148 num_threads_--;
149 }
150
FinishAll()151 void Threads::FinishAll() {
152 for (size_t i = 0; i < max_threads_; i++) {
153 if (threads_[i].tid_ != 0) {
154 threads_[i].CreateAction(0, "thread_done", nullptr);
155 threads_[i].SetPending();
156 Finish(threads_ + i);
157 }
158 }
159 }
160