gold/workqueue-threads.cc

   1 // workqueue-threads.cc -- the threaded workqueue for gold
   2
   3 // Copyright (C) 2007-2023 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@google.com>.
   5
   6 // This file is part of gold.
   7
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 3 of the License, or
  11 // (at your option) any later version.
  12
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21 // MA 02110-1301, USA.
  22
  23 // This file holds the workqueue implementation which may be used when
  24 // using threads.
  25
  26 #include "gold.h"
  27
  28 #ifdef ENABLE_THREADS
  29
  30 #include <cstring>
  31 #include <pthread.h>
  32
  33 #include "debug.h"
  34 #include "gold-threads.h"
  35 #include "workqueue.h"
  36 #include "workqueue-internal.h"
  37
  38 namespace gold
  39 {
  40
  41 // Class Workqueue_thread represents a single thread.  Creating an
  42 // instance of this spawns a new thread.
  43
  44 class Workqueue_thread
  45 {
  46  public:
  47   Workqueue_thread(Workqueue_threader_threadpool*, int thread_number);
  48
  49   ~Workqueue_thread();
  50
  51  private:
  52   // This class can not be copied.
  53   Workqueue_thread(const Workqueue_thread&);
  54   Workqueue_thread& operator=(const Workqueue_thread&);
  55
  56   // Check for error from a pthread function.
  57   void
  58   check(const char* function, int err) const;
  59
  60   // A function to pass to pthread_create.  This is called with a
  61   // pointer to an instance of this object.
  62   static void*
  63   thread_body(void*);
  64
  65   // A pointer to the threadpool that this thread is part of.
  66   Workqueue_threader_threadpool* threadpool_;
  67   // The thread number.
  68   int thread_number_;
  69   // The thread ID.
  70   pthread_t tid_;
  71 };
  72
  73 // Create the thread in the constructor.
  74
  75 Workqueue_thread::Workqueue_thread(Workqueue_threader_threadpool* threadpool,
  76                                    int thread_number)
  77   : threadpool_(threadpool), thread_number_(thread_number)
  78 {
  79   pthread_attr_t attr;
  80   int err = pthread_attr_init(&attr);
  81   this->check("pthread_attr_init", err);
  82
  83   err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  84   this->check("pthread_attr_setdetachstate", err);
  85
  86   err = pthread_create(&this->tid_, &attr, &Workqueue_thread::thread_body,
  87                        reinterpret_cast<void*>(this));
  88   this->check("pthread_create", err);
  89
  90   err = pthread_attr_destroy(&attr);
  91   this->check("pthread_attr_destroy", err);
  92 }
  93
  94 // The destructor will be called when the thread is exiting.
  95
  96 Workqueue_thread::~Workqueue_thread()
  97 {
  98 }
  99
 100 // Check for an error.
 101
 102 void
 103 Workqueue_thread::check(const char* function, int err) const
 104 {
 105   if (err != 0)
 106     gold_fatal(_("%s failed: %s"), function, strerror(err));
 107 }
 108
 109 // Passed to pthread_create.
 110
 111 extern "C"
 112 void*
 113 Workqueue_thread::thread_body(void* arg)
 114 {
 115   Workqueue_thread* pwt = reinterpret_cast<Workqueue_thread*>(arg);
 116
 117   pwt->threadpool_->process(pwt->thread_number_);
 118
 119   // Delete the thread object as we exit.
 120   delete pwt;
 121
 122   return NULL;
 123 }
 124
 125 // Class Workqueue_threader_threadpool.
 126
 127 // Constructor.
 128
 129 Workqueue_threader_threadpool::Workqueue_threader_threadpool(
 130     Workqueue* workqueue)
 131   : Workqueue_threader(workqueue),
 132     check_thread_count_(0),
 133     lock_(),
 134     desired_thread_count_(1),
 135     threads_(1)
 136 {
 137 }
 138
 139 // Destructor.
 140
 141 Workqueue_threader_threadpool::~Workqueue_threader_threadpool()
 142 {
 143   // Tell the threads to exit.
 144   this->get_workqueue()->set_thread_count(0);
 145 }
 146
 147 // Set the thread count.
 148
 149 void
 150 Workqueue_threader_threadpool::set_thread_count(int thread_count)
 151 {
 152   int create;
 153   {
 154     Hold_lock hl(this->lock_);
 155
 156     this->desired_thread_count_ = thread_count;
 157     create = this->desired_thread_count_ - this->threads_;
 158     if (create < 0)
 159       this->check_thread_count_ = 1;
 160   }
 161
 162   if (create > 0)
 163     {
 164       for (int i = 0; i < create; ++i)
 165         {
 166           // Note that threads delete themselves when they exit, so we
 167           // don't keep pointers to them.
 168           new Workqueue_thread(this, this->threads_);
 169           ++this->threads_;
 170         }
 171     }
 172 }
 173
 174 // Return whether the current thread should be cancelled.
 175
 176 bool
 177 Workqueue_threader_threadpool::should_cancel_thread(int thread_number)
 178 {
 179   // Fast exit without taking a lock.
 180   if (!this->check_thread_count_)
 181     return false;
 182
 183   {
 184     Hold_lock hl(this->lock_);
 185     if (thread_number > this->desired_thread_count_)
 186       {
 187         --this->threads_;
 188         if (this->threads_ <= this->desired_thread_count_)
 189           this->check_thread_count_ = 0;
 190         return true;
 191       }
 192   }
 193
 194   return false;
 195 }
 196
 197 } // End namespace gold.
 198
 199 #endif // defined(ENABLE_THREADS)