memory_replay/Threads.cpp

   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
  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
  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
  68 Threads::~Threads() {
  69   if (threads_) {
  70     munmap(threads_, data_size_);
  71     threads_ = nullptr;
  72     data_size_ = 0;
  73   }
  74 }
  75
  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
  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
 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
 123 size_t Threads::GetHashEntry(pid_t tid) {
 124   return tid % max_threads_;
 125 }
 126
 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
 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
 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 }