1 // gold-threads.h -- thread support for gold -*- C++ -*-
3 // Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
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.
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.
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.
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
29 // A simple lock class.
31 #ifndef GOLD_THREADS_H
32 #define GOLD_THREADS_H
38 class Initialize_lock_once
;
40 // The interface for the implementation of a Lock.
59 // A simple lock class.
71 { this->lock_
->acquire(); }
76 { this->lock_
->release(); }
79 // This class can not be copied.
81 Lock
& operator=(const Lock
&);
86 { return this->lock_
; }
98 { this->lock_
.acquire(); }
101 { this->lock_
.release(); }
104 // This class can not be copied.
105 Hold_lock(const Hold_lock
&);
106 Hold_lock
& operator=(const Hold_lock
&);
111 class Hold_optional_lock
114 Hold_optional_lock(Lock
* lock
)
117 if (this->lock_
!= NULL
)
118 this->lock_
->acquire();
121 ~Hold_optional_lock()
123 if (this->lock_
!= NULL
)
124 this->lock_
->release();
128 Hold_optional_lock(const Hold_optional_lock
&);
129 Hold_optional_lock
& operator=(const Hold_optional_lock
&);
134 // The interface for the implementation of a condition variable.
147 wait(Lock_impl
*) = 0;
156 // A simple condition variable class. It is always associated with a
165 // Wait for the condition variable to be signalled. This should
166 // only be called when the lock is held.
169 { this->condvar_
->wait(this->lock_
.get_impl()); }
171 // Signal the condition variable--wake up at least one thread
172 // waiting on the condition variable. This should only be called
173 // when the lock is held.
176 { this->condvar_
->signal(); }
178 // Broadcast the condition variable--wake up all threads waiting on
179 // the condition variable. This should only be called when the lock
183 { this->condvar_
->broadcast(); }
186 // This class can not be copied.
187 Condvar(const Condvar
&);
188 Condvar
& operator=(const Condvar
&);
191 Condvar_impl
* condvar_
;
194 // A class used to initialize a lock exactly once, after the options
195 // have been read. This is needed because the implementation of locks
196 // depends on whether we've seen the --threads option. Before the
197 // options have been read, we know we are single-threaded, so we can
198 // get by without using a lock. This class should be an instance
199 // variable of the class which has a lock which needs to be
202 class Initialize_lock
205 // The class which uses this will have a pointer to a lock. This
206 // must be constructed with a pointer to that pointer.
207 Initialize_lock(Lock
** pplock
);
209 // Initialize the lock. Return true if the lock is now initialized,
210 // false if it is not (because the options have not yet been read).
215 // A pointer to the lock pointer which must be initialized.
216 Lock
** const pplock_
;
217 // If needed, a pointer to a pthread_once_t structure.
218 Initialize_lock_once
* once_
;
221 } // End namespace gold.
223 #endif // !defined(GOLD_THREADS_H)
This page took 0.034215 seconds and 4 git commands to generate.