gold/gold-threads.h

   1 // gold-threads.h -- thread support for gold  -*- C++ -*-
   2
   3 // Copyright (C) 2006-2019 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 // gold can be configured to support threads.  If threads are
  24 // supported, the user can specify at runtime whether or not to
  25 // support them.  This provides an interface to manage locking
  26 // accordingly.
  27
  28 // Lock
  29 //   A simple lock class.
  30
  31 #ifndef GOLD_THREADS_H
  32 #define GOLD_THREADS_H
  33
  34 namespace gold
  35 {
  36
  37 class Condvar;
  38 class Once_initialize;
  39 class Initialize_lock_once;
  40
  41 // The interface for the implementation of a Lock.
  42
  43 class Lock_impl
  44 {
  45  public:
  46   Lock_impl()
  47   { }
  48
  49   virtual
  50   ~Lock_impl()
  51   { }
  52
  53   virtual void
  54   acquire() = 0;
  55
  56   virtual void
  57   release() = 0;
  58 };
  59
  60 // A simple lock class.
  61
  62 class Lock
  63 {
  64  public:
  65   Lock();
  66
  67   ~Lock();
  68
  69   // Acquire the lock.
  70   void
  71   acquire()
  72   { this->lock_->acquire(); }
  73
  74   // Release the lock.
  75   void
  76   release()
  77   { this->lock_->release(); }
  78
  79  private:
  80   // This class can not be copied.
  81   Lock(const Lock&);
  82   Lock& operator=(const Lock&);
  83
  84   friend class Condvar;
  85   Lock_impl*
  86   get_impl() const
  87   { return this->lock_; }
  88
  89   Lock_impl* lock_;
  90 };
  91
  92 // RAII for Lock.
  93
  94 class Hold_lock
  95 {
  96  public:
  97   Hold_lock(Lock& lock)
  98     : lock_(lock)
  99   { this->lock_.acquire(); }
 100
 101   ~Hold_lock()
 102   { this->lock_.release(); }
 103
 104  private:
 105   // This class can not be copied.
 106   Hold_lock(const Hold_lock&);
 107   Hold_lock& operator=(const Hold_lock&);
 108
 109   Lock& lock_;
 110 };
 111
 112 class Hold_optional_lock
 113 {
 114  public:
 115   Hold_optional_lock(Lock* lock)
 116     : lock_(lock)
 117   {
 118     if (this->lock_ != NULL)
 119       this->lock_->acquire();
 120   }
 121
 122   ~Hold_optional_lock()
 123   {
 124     if (this->lock_ != NULL)
 125       this->lock_->release();
 126   }
 127
 128  private:
 129   Hold_optional_lock(const Hold_optional_lock&);
 130   Hold_optional_lock& operator=(const Hold_optional_lock&);
 131
 132   Lock* lock_;
 133 };
 134
 135 // The interface for the implementation of a condition variable.
 136
 137 class Condvar_impl
 138 {
 139  public:
 140   Condvar_impl()
 141   { }
 142
 143   virtual
 144   ~Condvar_impl()
 145   { }
 146
 147   virtual void
 148   wait(Lock_impl*) = 0;
 149
 150   virtual void
 151   signal() = 0;
 152
 153   virtual void
 154   broadcast() = 0;
 155 };
 156
 157 // A simple condition variable class.  It is always associated with a
 158 // specific lock.
 159
 160 class Condvar
 161 {
 162  public:
 163   Condvar(Lock& lock);
 164   ~Condvar();
 165
 166   // Wait for the condition variable to be signalled.  This should
 167   // only be called when the lock is held.
 168   void
 169   wait()
 170   { this->condvar_->wait(this->lock_.get_impl()); }
 171
 172   // Signal the condition variable--wake up at least one thread
 173   // waiting on the condition variable.  This should only be called
 174   // when the lock is held.
 175   void
 176   signal()
 177   { this->condvar_->signal(); }
 178
 179   // Broadcast the condition variable--wake up all threads waiting on
 180   // the condition variable.  This should only be called when the lock
 181   // is held.
 182   void
 183   broadcast()
 184   { this->condvar_->broadcast(); }
 185
 186  private:
 187   // This class can not be copied.
 188   Condvar(const Condvar&);
 189   Condvar& operator=(const Condvar&);
 190
 191   Lock& lock_;
 192   Condvar_impl* condvar_;
 193 };
 194
 195 // A class used to do something once.  This is an abstract parent
 196 // class; any actual use will involve a child of this.
 197
 198 class Once
 199 {
 200  public:
 201   Once();
 202
 203   virtual
 204   ~Once()
 205   { }
 206
 207   // Call this function to do whatever it is.  We pass an argument
 208   // even though you have to use a child class because in some uses
 209   // setting the argument would itself require a Once class.
 210   void
 211   run_once(void* arg);
 212
 213   // This is an internal function, which must be public because it is
 214   // run by an extern "C" function called via pthread_once.
 215   void
 216   internal_run(void* arg);
 217
 218  protected:
 219   // This must be implemented by the child class.
 220   virtual void
 221   do_run_once(void* arg) = 0;
 222
 223  private:
 224   // True if we have already run the function.
 225   bool was_run_;
 226 #if defined(ENABLE_THREADS) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
 227   // Internal compare-and-swap lock on was_run_;
 228   uint32_t was_run_lock_;
 229 #endif
 230   // The lock to run the function only once.
 231   Once_initialize* once_;
 232 };
 233
 234 // A class used to initialize a lock exactly once, after the options
 235 // have been read.  This is needed because the implementation of locks
 236 // depends on whether we've seen the --threads option.  Before the
 237 // options have been read, we know we are single-threaded, so we can
 238 // get by without using a lock.  This class should be an instance
 239 // variable of the class which has a lock which needs to be
 240 // initialized.
 241
 242 class Initialize_lock : public Once
 243 {
 244  public:
 245   // The class which uses this will have a pointer to a lock.  This
 246   // must be constructed with a pointer to that pointer.
 247   Initialize_lock(Lock** pplock)
 248     : pplock_(pplock)
 249   { }
 250
 251   // Initialize the lock.  Return true if the lock is now initialized,
 252   // false if it is not (because the options have not yet been read).
 253   bool
 254   initialize();
 255
 256  protected:
 257   void
 258   do_run_once(void*);
 259
 260  private:
 261   // A pointer to the lock pointer which must be initialized.
 262   Lock** const pplock_;
 263 };
 264
 265 } // End namespace gold.
 266
 267 #endif // !defined(GOLD_THREADS_H)