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
|
/* This file is part of the Spring engine (GPL v2 or later), see LICENSE.html */
#ifndef _THREADING_H_
#define _THREADING_H_
#include <string>
#ifndef WIN32
#include <pthread.h>
#include "System/Platform/Linux/ThreadSupport.h"
#include <semaphore.h>
#endif
#ifdef __APPLE__
#include <libkern/OSAtomic.h> // OSAtomicIncrement64
#endif
#include "System/Platform/Win/win32.h"
#include "System/Threading/SpringThreading.h"
#include <functional>
#include <atomic>
#include <cinttypes>
namespace Threading {
class ThreadControls;
extern thread_local std::shared_ptr<Threading::ThreadControls> threadCtls;
/**
* Generic types & functions to handle OS native threads
*/
#ifdef WIN32
typedef DWORD NativeThreadId;
typedef HANDLE NativeThreadHandle;
#else
typedef pthread_t NativeThreadId;
typedef pthread_t NativeThreadHandle;
#endif
NativeThreadHandle GetCurrentThread();
NativeThreadId GetCurrentThreadId();
/**
* Used to indicate the result of a suspend or resume operation.
*/
enum SuspendResult {
THREADERR_NONE,
THREADERR_NOT_RUNNING,
THREADERR_MISC
};
/**
* Creates a new spring::thread whose entry function is wrapped by some boilerplate code that allows for suspend/resume.
* These suspend/resume controls are exposed via the ThreadControls object that is provided by the caller and initialized by the thread.
* The thread is guaranteed to be in a running and initialized state when this function returns.
*
* The ppThreadCtls object is an optional return parameter that gives access to the Suspend/Resume controls under Linux.
*
*/
spring::thread CreateNewThread(std::function<void()> taskFunc, std::shared_ptr<Threading::ThreadControls>* ppThreadCtls = nullptr);
/**
* Retrieves a shared pointer to the current ThreadControls for the calling thread.
*/
std::shared_ptr<ThreadControls> GetCurrentThreadControls();
#ifndef WIN32
void SetCurrentThreadControls(bool);
#else
static inline void SetCurrentThreadControls(bool) {}
#endif
/**
* @brief Provides suspend/resume functionality for worker threads.
*/
class ThreadControls {
public:
ThreadControls();
/* These are implemented in System/Platform/<platform>/ThreadSupport.cpp */
SuspendResult Suspend();
SuspendResult Resume();
NativeThreadHandle handle;
std::atomic<bool> running;
#ifndef WIN32
spring::mutex mutSuspend;
spring::condition_variable condInitialized;
ucontext_t ucontext;
pid_t thread_id;
#endif
};
inline bool NativeThreadIdsEqual(const NativeThreadId thID1, const NativeThreadId thID2);
/**
* Sets the affinity of the current thread
*
* Interpret <cores_bitmask> as a bit-mask indicating on which of the
* available system CPU's (which are numbered logically from 1 to N) we
* want to run. Note that this approach will fail when N > 32.
*/
void DetectCores();
std::uint32_t GetAffinity();
std::uint32_t SetAffinity(std::uint32_t cores_bitmask, bool hard = true);
void SetAffinityHelper(const char* threadName, std::uint32_t affinity);
std::uint32_t GetAvailableCoresMask();
/**
* returns count of cpu cores/ hyperthreadings cores
*/
int GetPhysicalCpuCores(); /// physical cores only (excluding hyperthreading)
int GetLogicalCpuCores(); /// physical + hyperthreading
bool HasHyperThreading();
/**
* Inform the OS kernel that we are a cpu-intensive task
*/
void SetThreadScheduler();
/**
* Used to detect the main-thread which runs SDL, GL, Input, Sim, ...
*/
void SetMainThread();
void SetGameLoadThread();
void SetAudioThread();
void SetWatchDogThread();
bool IsMainThread();
bool IsMainThread(NativeThreadId threadID);
bool IsGameLoadThread();
bool IsGameLoadThread(NativeThreadId threadID);
bool IsAudioThread();
bool IsAudioThread(NativeThreadId threadID);
bool IsWatchDogThread();
bool IsWatchDogThread(NativeThreadId threadID);
/**
* Give the current thread a name (posix-only)
*/
void SetThreadName(const std::string& newname);
/**
* Used to raise errors in the main-thread issued by worker-threads
*/
struct Error {
Error() : flags(0) {}
Error(const std::string& _caption, const std::string& _message, const unsigned int _flags) : caption(_caption), message(_message), flags(_flags) {}
bool Empty() const { return (caption.empty() && message.empty() && flags == 0); }
std::string caption;
std::string message;
unsigned int flags;
};
void SetThreadError(const Error& err);
Error* GetThreadError();
}
//
// Inlined Definitions
//
namespace Threading {
bool NativeThreadIdsEqual(const NativeThreadId thID1, const NativeThreadId thID2)
{
#ifdef __APPLE__
// quote from the pthread_equal manpage:
// Implementations may choose to define a thread ID as a structure.
// This allows additional flexibility and robustness over using an int.
//
// -> Linux implementation seems always to be done as integer type.
// Only Windows & MacOSX use structs afaik. But for Windows we use their native thread funcs.
// So only MacOSX is left.
{
return pthread_equal(thID1, thID2);
}
#endif
return (thID1 == thID2);
}
}
#endif // _THREADING_H_
|
