This file is indexed.

/usr/include/OpenThreads/Thread is in libopenthreads-dev 3.2.0~rc1-4.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
/* -*-c++-*- OpenThreads library, Copyright (C) 2002 - 2007  The Open Thread Group
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * OpenSceneGraph Public License for more details.
*/


//
// Thread - C++ Thread class
// ~~~~~~~~
//

#ifndef _OPENTHREADS_THREAD_
#define _OPENTHREADS_THREAD_

#include <sys/types.h>

#include <OpenThreads/Mutex>

namespace OpenThreads {

/**
 *  Get the number of processors.
 *
 *  Note, systems where no support exists for querrying the number of processors, 1 is returned.
 *
 */
extern OPENTHREAD_EXPORT_DIRECTIVE int GetNumberOfProcessors();

/**
 *  Set the processor affinity of current thread.
 *
 *  Note, systems where no support exists no affinity will be set, and -1 will be returned.
 *
 */
extern OPENTHREAD_EXPORT_DIRECTIVE int SetProcessorAffinityOfCurrentThread(unsigned int cpunum);

/**
 *  @class Thread
 *  @brief  This class provides an object-oriented thread interface.
 */
class OPENTHREAD_EXPORT_DIRECTIVE Thread {

public:

    /**
     *  Set the concurrency level for a running application.  This method
     *  only has effect if the pthreads thread model is being used, and
     *  then only when that model is many-to-one (eg. irix).
     *  in other cases it is ignored.  The concurrency level is only a
     *  *hint* as to the number of execution vehicles to use, the actual
     *  implementation may do anything it wants.  Setting the value
     *  to 0 returns things to their default state.
     *
     *  @return previous concurrency level, -1 indicates no-op.
     */
    static int SetConcurrency(int concurrencyLevel);

    /**
     *  Get the concurrency level for a running application.  In this
     *  case, a return code of 0 means that the application is in default
     *  mode.  A return code of -1 means that the application is incapable
     *  of setting an arbitrary concurrency, because it is a one-to-one
     *  execution model (sprocs, linuxThreads)
     */
    static int GetConcurrency();

    /**
     *  Enumerated Type for thread priority
     */
    enum ThreadPriority {

	THREAD_PRIORITY_MAX,      /**< The maximum possible priority  */
	THREAD_PRIORITY_HIGH,     /**< A high (but not max) setting   */
	THREAD_PRIORITY_NOMINAL,  /**< An average priority            */
	THREAD_PRIORITY_LOW,      /**< A low (but not min) setting    */
	THREAD_PRIORITY_MIN,      /**< The miniumum possible priority */
	THREAD_PRIORITY_DEFAULT   /**< Priority scheduling default    */

    };

    /**
     *  Enumerated Type for thread scheduling policy
     */
    enum ThreadPolicy {

	THREAD_SCHEDULE_FIFO,        /**< First in, First out scheduling         */
	THREAD_SCHEDULE_ROUND_ROBIN, /**< Round-robin scheduling (LINUX_DEFAULT) */
	THREAD_SCHEDULE_TIME_SHARE,  /**< Time-share scheduling (IRIX DEFAULT)   */
	THREAD_SCHEDULE_DEFAULT      /**< Default scheduling                     */

    };

    /**
     *  Constructor
     */
    Thread();

    /**
     *  Destructor
     */
    virtual ~Thread();


    /**
     *  Return a pointer to the current running thread
     */
    static Thread *CurrentThread();


    /**
     *  Initialize Threading in a program.  This method must be called before
     *  you can do any threading in a program.
     */
    static void Init();

    /**
     *  Yield the processor.
     *
     *  @note This method operates on the calling process.  And is
     *  equivalent to calling sched_yield().
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    static int YieldCurrentThread();

    /**
     *  This method will return the ThreadPriority of the master process.
     *  (ie, the one calling the thread->start() methods for the first time)
     *  The method will almost certainly return
     *  Thread::THREAD_PRIORITY_DEFAULT if
     *  Init() has not been called.
     *
     *  @return the Thread::ThreadPriority of the master thread.
     */
    static ThreadPriority GetMasterPriority() {return s_masterThreadPriority;};


    /**
     *  Get a unique thread id.  This id is monotonically increasing.
     *
     *  @return a unique thread identifier
     */
    int getThreadId();

    /**
     *  Get the thread's process id.  This is the pthread_t or pid_t value
     *  depending on the threading model being used.
     *
     *  @return thread process id.
     */
    size_t getProcessId();

    /**
     *  Start the thread.  This method will configure the thread, set
     *  it's priority, and spawn it.
     *
     *  @note if the stack size specified setStackSize is smaller than the
     *  smallest allowable stack size,  the threads stack size will be set to
     *  the minimum allowed, and may be retrieved via the getStackSize()
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    int start();
    int startThread();

    /**
     * Test the cancel state of the thread.  If the thread has been canceled
     * this method will cause the thread to exit now.  This method operates
     * on the calling thread.
     *
     * Returns 0 if normal, -1 if called from a thread other that this.
     */
    int testCancel();


    /**
     *  Cancel the thread.  Equivalent to SIGKILL.
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    virtual int cancel();

    /**
     *  Set the thread's schedule priority.  This is a complex method.
     *  Beware of thread priorities when using a many-to-many kernel
     *  entity implemenation (such as IRIX pthreads).  If one is not carefull
     *  to manage the thread priorities, a priority inversion deadlock can
     *  easily occur (Although the OpenThreads::Mutex & OpenThreads::Barrier
     *  constructs have been designed with this senario in mind).  Unless
     *  you have explicit need to set the schedule pirorites for a given
     *  task, it is best to leave them alone.
     *
     *  @note some implementations (notably LinuxThreads and IRIX Sprocs)
     *  only alow you to decrease thread priorities dynamically.  Thus,
     *  a lower priority thread will not allow it's priority to be raised
     *  on the fly.
     *
     *  @note seting the environment variable OUTPUT_THREADLIB_SCHEDULING_INFO
     *  will output scheduling information for each thread to stdout.
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    int setSchedulePriority(ThreadPriority priority);

    /**
     *  Get the thread's schedule priority (if able)
     *
     *  @note seting the environment variable OUTPUT_THREADLIB_SCHEDULING_INFO
     *  will output scheduling information for each thread to stdout.
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    int getSchedulePriority();

    /**
     *  Set the thread's scheduling policy (if able)
     *
     *  @note On some implementations (notably IRIX Sprocs & LinuxThreads)
     *  The policy may prohibit the use of SCHEDULE_ROUND_ROBIN and
     *  SCHEDULE_FIFO policies - due to their real-time nature, and
     *  the danger of deadlocking the machine when used as super-user.
     *  In such cases, the command is a no-op.
     *
     *  @note seting the environment variable OUTPUT_THREADLIB_SCHEDULING_INFO
     *  will output scheduling information for each thread to stdout.
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    int setSchedulePolicy(ThreadPolicy policy);

    /**
     *  Get the thread's policy (if able)
     *
     *  @note seting the environment variable OUTPUT_THREADLIB_SCHEDULING_INFO
     *  will output scheduling information for each thread to stdout.
     *
     *  @return policy if normal, -1 if errno set, errno code otherwise.
     */
    int getSchedulePolicy();

    /**
     *  Set the thread's desired stack size (in bytes).
     *  This method is an attribute of the thread and must be called
     *  *before* the start() method is invoked.
     *
     *  @note a return code of 13 (EACESS) means that the thread stack
     *  size can no longer be changed.
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    int setStackSize(size_t size);

    /**
     *  Get the thread's desired stack size.
     *
     *  @return the thread's stack size.  0 indicates that the stack size
     *   has either not yet been initialized, or not yet been specified by
     *   the application.
     */
    size_t getStackSize();

    /**
     *  Print the thread's scheduling information to stdout.
     */
    void printSchedulingInfo();

    /**
     *  Detach the thread from the calling process.
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    int detach();

    /**
     *  Join the calling process with the thread
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    int join();

    /**
     *  Disable thread cancelation altogether. Thread::cancel() has no effect.
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    int setCancelModeDisable();

    /**
     *  Mark the thread to cancel aysncronously on Thread::cancel().
     *  (May not be available with process-level implementations).
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    int setCancelModeAsynchronous();

    /**
     *  Mark the thread to cancel at the earliest convenience on
     *  Thread::cancel() (This is the default)
     *
     *  @return 0 if normal, -1 if errno set, errno code otherwise.
     */
    int setCancelModeDeferred();

    /**
     *  Query the thread's running status
     *
     *  @return true if running, false if not.
     */
    bool isRunning();

    /**
     *  Thread's run method.  Must be implemented by derived classes.
     *  This is where the action happens.
     */
    virtual void run() = 0;

    /**
     *  Thread's cancel cleanup routine, called upon cancel(), after the
     *  cancelation has taken place, but before the thread exits completely.
     *  This method should be used to repair parts of the thread's data
     *  that may have been damaged by a pre-mature cancel.  No-op by default.
     */
    virtual void cancelCleanup() {};

    void* getImplementation(){ return _prvData;	};

    /** Thread's processor affinity method.  This binds a thread to a
      * processor whenever possible.   This call must be made before
      * start() or startThread() and has no effect after the thread
      * has been running.  In the pthreads implementation, this is only
      * implemented on sgi, through a pthread extension.  On other pthread
      * platforms this is ignored.  Returns 0 on success, implementation's
      * error on failure, or -1 if ignored.
      */
    int setProcessorAffinity( unsigned int cpunum );

    /** microSleep method, equivilant to the posix usleep(microsec).
      *  This is not strictly thread API but is used
      * so often with threads. It's basically UNIX usleep. Parameter is
      * number of microseconds we current thread to sleep. Returns 0 on
      * succes, non-zero on failure (UNIX errno or GetLastError() will give
      * detailed description.
      */
    static int microSleep( unsigned int microsec);

private:

    /**
     *  The Private Actions class is allowed to operate on private data.
     */
    friend class ThreadPrivateActions;

     /**
      *  Private copy constructor, to prevent tampering.
      */
    Thread(const Thread &/*t*/) {};

    /**
      *  Private copy assignment, to prevent tampering.
      */
    Thread &operator=(const Thread &/*t*/) {return *(this);};

    /**
     *  Implementation-specific data
     */
    void * _prvData;

    /**
     *  Master thread's priority, set by Thread::Init.
     */
    static ThreadPriority s_masterThreadPriority;

    /**
     *  Is initialized flag
     */
    static bool s_isInitialized;
};

}

#endif // !_OPENTHREADS_THREAD_