gclib/gclib/GThreads.cpp

/*
Copyright (c) 2010 Marcus Geelnard
(with minor modifications by Geo Pertea)
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

    1. The origin of this software must not be misrepresented; you must not
    claim that you wrote the original software. If you use this software
    in a product, an acknowledgment in the product documentation would be
    appreciated but is not required.

    2. Altered source versions must be plainly marked as such, and must not be
    misrepresented as being the original software.

    3. This notice may not be removed or altered from any source
    distribution.
*/

#include "GThreads.h"

#if defined(_GTHREADS_POSIX_)
  #include <unistd.h>
//  #include <map>
#elif defined(_GTHREADS_WIN32_)
  #include <process.h>
#endif


//namespace tthread {

//------------------------------------------------------------------------------
// condition_variable
//------------------------------------------------------------------------------
// NOTE 1: The Win32 implementation of the condition_variable class is based on
// the corresponding implementation in GLFW, which in turn is based on a
// description by Douglas C. Schmidt and Irfan Pyarali:
// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
//
// NOTE 2: Windows Vista actually has native support for condition variables
// (InitializeConditionVariable, WakeConditionVariable, etc), but we want to
// be portable with pre-Vista Windows versions, so TinyThread++ does not use
// Vista condition variables.
//------------------------------------------------------------------------------

#if defined(_GTHREADS_WIN32_)
  #define _CONDITION_EVENT_ONE 0
  #define _CONDITION_EVENT_ALL 1
#endif


int GThread::tcounter=0;
int GThread::num_created=0;

#if defined(_GTHREADS_WIN32_)
GConditionVar::GConditionVar() : mWaitersCount(0)
{
  mEvents[_CONDITION_EVENT_ONE] = CreateEvent(NULL, FALSE, FALSE, NULL);
  mEvents[_CONDITION_EVENT_ALL] = CreateEvent(NULL, TRUE, FALSE, NULL);
  InitializeCriticalSection(&mWaitersCountLock);
}
#endif

#if defined(_GTHREADS_WIN32_)
GConditionVar::~GConditionVar()
{
  CloseHandle(mEvents[_CONDITION_EVENT_ONE]);
  CloseHandle(mEvents[_CONDITION_EVENT_ALL]);
  DeleteCriticalSection(&mWaitersCountLock);
}
#endif

#if defined(_GTHREADS_WIN32_)
void GConditionVar::_wait()
{
  // Wait for either event to become signaled due to notify_one() or
  // notify_all() being called
  int result = WaitForMultipleObjects(2, mEvents, FALSE, INFINITE);

  // Check if we are the last waiter
  EnterCriticalSection(&mWaitersCountLock);
  -- mWaitersCount;
  bool lastWaiter = (result == (WAIT_OBJECT_0 + _CONDITION_EVENT_ALL)) &&
                    (mWaitersCount == 0);
  LeaveCriticalSection(&mWaitersCountLock);

  // If we are the last waiter to be notified to stop waiting, reset the event
  if(lastWaiter)
    ResetEvent(mEvents[_CONDITION_EVENT_ALL]);
}
#endif

#if defined(_GTHREADS_WIN32_)
void GConditionVar::notify_one()
{
  // Are there any waiters?
  EnterCriticalSection(&mWaitersCountLock);
  bool haveWaiters = (mWaitersCount > 0);
  LeaveCriticalSection(&mWaitersCountLock);

  // If we have any waiting threads, send them a signal
  if(haveWaiters)
    SetEvent(mEvents[_CONDITION_EVENT_ONE]);
}
#endif

#if defined(_GTHREADS_WIN32_)
void GConditionVar::notify_all()
{
  // Are there any waiters?
  EnterCriticalSection(&mWaitersCountLock);
  bool haveWaiters = (mWaitersCount > 0);
  LeaveCriticalSection(&mWaitersCountLock);

  // If we have any waiting threads, send them a signal
  if(haveWaiters)
    SetEvent(mEvents[_CONDITION_EVENT_ALL]);
}
#endif


//------------------------------------------------------------------------------
// POSIX pthread_t to unique thread::id mapping logic.
// Note: Here we use a global thread safe std::map to convert instances of
// pthread_t to small thread identifier numbers (unique within one process).
// This method should be portable across different POSIX implementations.
//------------------------------------------------------------------------------
/*

#if defined(_GTHREADS_POSIX_)
static thread::id _pthread_t_to_ID(const pthread_t &aHandle)
{
  static mutex idMapLock;
  static std::map<pthread_t, unsigned long int> idMap;
  static unsigned long int idCount(1);

  lock_guard<mutex> guard(idMapLock);
  if(idMap.find(aHandle) == idMap.end())
    idMap[aHandle] = idCount ++;
  return thread::id(idMap[aHandle]);
}
#endif // _GTHREADS_POSIX_
*/

void GThread::update_counter(int inc, GThread* t_update) {
  static GMutex counterLock;
  GLockGuard<GMutex> guard(counterLock);
  if (inc==1) { //joinable thread creation
          GThread::num_created++;
          t_update->mId = GThread::num_created;
     }
  GThread::tcounter+=inc;
  if (t_update!=NULL && inc<0)
          t_update->mId=0; // thread terminated

 }
 

//------------------------------------------------------------------------------
// thread
//------------------------------------------------------------------------------

/// Information to pass to the new thread (what to run).
struct _thread_start_info {
  void (*mFunction)(void *, GThread*); ///< Pointer to the function to be executed.
  void * mArg;               ///< Function argument for the thread function.
  GThread * mThread;          ///< Pointer to the thread object.
};

// Thread wrapper function.
#if defined(_GTHREADS_WIN32_)
unsigned WINAPI GThread::wrapper_function(void * aArg)
#elif defined(_GTHREADS_POSIX_)
void * GThread::wrapper_function(void * aArg)
#endif
{
  // Get thread startup information
  _thread_start_info * ti = (_thread_start_info *) aArg;

/*
  try
  {
    // Call the actual client thread function
    ti->mFunction(ti->mArg, ti->mThread);
  }
  catch(...)
  {
    // Uncaught exceptions will terminate the application (default behavior
    // according to the C++0x draft)
    std::terminate();
  }
*/
  ti->mFunction(ti->mArg, ti->mThread);
  
  // The thread is no longer executing
  GLockGuard<GMutex> guard(ti->mThread->mDataMutex);
  ti->mThread->mNotAThread = true;
  GThread::update_counter(-1, ti->mThread);
  // The thread is responsible for freeing the startup information
  delete ti;

  return 0;
}

GThread::GThread(void (*aFunction)(void *, GThread*), void * aArg)
{
  // Serialize access to this thread structure
  GLockGuard<GMutex> guard(mDataMutex);

  // Fill out the thread startup information (passed to the thread wrapper,
  // which will eventually free it)
  _thread_start_info * ti = new _thread_start_info;
  ti->mFunction = aFunction;
  ti->mArg = aArg;
  ti->mThread = this;

  // The thread is now alive
  mNotAThread = false;

  // Create the thread
#if defined(_GTHREADS_WIN32_)
  mHandle = (HANDLE) _beginthreadex(0, 0, wrapper_function, (void *) ti, 0, &mWin32ThreadID);
#elif defined(_GTHREADS_POSIX_)
  if(pthread_create(&mHandle, NULL, wrapper_function, (void *) ti) != 0)
    mHandle = 0;
#endif

  // Did we fail to create the thread?
  if(!mHandle)
  {
    mNotAThread = true;
    delete ti;
  }
   else GThread::update_counter(1, this);
}

GThread::~GThread()
{
  if(joinable()) {
    //std::terminate();
    GThread::update_counter(-1, this);
    }
}

void GThread::join()
{
  if(joinable())
  {
#if defined(_GTHREADS_WIN32_)
    WaitForSingleObject(mHandle, INFINITE);
#elif defined(_GTHREADS_POSIX_)
    pthread_join(mHandle, NULL);
#endif
  }
}

void GThread::wait_all() {
  while (GThread::num_running()>0)
        this_thread::sleep_for(chrono::milliseconds(2));
}


bool GThread::joinable() const
{
  mDataMutex.lock();
  bool result = !mNotAThread;
  mDataMutex.unlock();
  return result;
}

int GThread::get_id() const
{
  if(!joinable())
    //return id();
    return 0; //FIXME
   else
     return mId;
/*      
#if defined(_GTHREADS_WIN32_)
  return id((unsigned long int) mWin32ThreadID);
#elif defined(_GTHREADS_POSIX_)
  return _pthread_t_to_ID(mHandle);
#endif
*/
}

unsigned GThread::hardware_concurrency()
{
#if defined(_GTHREADS_WIN32_)
  SYSTEM_INFO si;
  GetSystemInfo(&si);
  return (int) si.dwNumberOfProcessors;
#elif defined(_SC_NPROCESSORS_ONLN)
  return (int) sysconf(_SC_NPROCESSORS_ONLN);
#elif defined(_SC_NPROC_ONLN)
  return (int) sysconf(_SC_NPROC_ONLN);
#else
  // The standard requires this function to return zero if the number of
  // hardware cores could not be determined.
  return 0;
#endif
}


//------------------------------------------------------------------------------
// this_thread
//------------------------------------------------------------------------------
/*
int this_thread::get_id()
{
#if defined(_GTHREADS_WIN32_)
  return thread::id((unsigned long int) GetCurrentThreadId());
#elif defined(_GTHREADS_POSIX_)
  return _pthread_t_to_ID(pthread_self());
#endif
}
*/
Revision:	156
Committed:	Fri Jan 27 18:29:55 2012 UTC (12 years, 7 months ago) by gpertea
File size:	8998 byte(s)
Log Message:	adding refactored TinyThread++ code
Line	File contents
1	/*
2	Copyright (c) 2010 Marcus Geelnard
3	(with minor modifications by Geo Pertea)
4	This software is provided 'as-is', without any express or implied
5	warranty. In no event will the authors be held liable for any damages
6	arising from the use of this software.
7
8	Permission is granted to anyone to use this software for any purpose,
9	including commercial applications, and to alter it and redistribute it
10	freely, subject to the following restrictions:
11
12	1. The origin of this software must not be misrepresented; you must not
13	claim that you wrote the original software. If you use this software
14	in a product, an acknowledgment in the product documentation would be
15	appreciated but is not required.
16
17	2. Altered source versions must be plainly marked as such, and must not be
18	misrepresented as being the original software.
19
20	3. This notice may not be removed or altered from any source
21	distribution.
22	*/
23
24	#include "GThreads.h"
25
26	#if defined(_GTHREADS_POSIX_)
27	#include <unistd.h>
28	// #include <map>
29	#elif defined(_GTHREADS_WIN32_)
30	#include <process.h>
31	#endif
32
33
34	//namespace tthread {
35
36	//------------------------------------------------------------------------------
37	// condition_variable
38	//------------------------------------------------------------------------------
39	// NOTE 1: The Win32 implementation of the condition_variable class is based on
40	// the corresponding implementation in GLFW, which in turn is based on a
41	// description by Douglas C. Schmidt and Irfan Pyarali:
42	// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
43	//
44	// NOTE 2: Windows Vista actually has native support for condition variables
45	// (InitializeConditionVariable, WakeConditionVariable, etc), but we want to
46	// be portable with pre-Vista Windows versions, so TinyThread++ does not use
47	// Vista condition variables.
48	//------------------------------------------------------------------------------
49
50	#if defined(_GTHREADS_WIN32_)
51	#define _CONDITION_EVENT_ONE 0
52	#define _CONDITION_EVENT_ALL 1
53	#endif
54
55
56	int GThread::tcounter=0;
57	int GThread::num_created=0;
58
59	#if defined(_GTHREADS_WIN32_)
60	GConditionVar::GConditionVar() : mWaitersCount(0)
61	{
62	mEvents[_CONDITION_EVENT_ONE] = CreateEvent(NULL, FALSE, FALSE, NULL);
63	mEvents[_CONDITION_EVENT_ALL] = CreateEvent(NULL, TRUE, FALSE, NULL);
64	InitializeCriticalSection(&mWaitersCountLock);
65	}
66	#endif
67
68	#if defined(_GTHREADS_WIN32_)
69	GConditionVar::~GConditionVar()
70	{
71	CloseHandle(mEvents[_CONDITION_EVENT_ONE]);
72	CloseHandle(mEvents[_CONDITION_EVENT_ALL]);
73	DeleteCriticalSection(&mWaitersCountLock);
74	}
75	#endif
76
77	#if defined(_GTHREADS_WIN32_)
78	void GConditionVar::_wait()
79	{
80	// Wait for either event to become signaled due to notify_one() or
81	// notify_all() being called
82	int result = WaitForMultipleObjects(2, mEvents, FALSE, INFINITE);
83
84	// Check if we are the last waiter
85	EnterCriticalSection(&mWaitersCountLock);
86	-- mWaitersCount;
87	bool lastWaiter = (result == (WAIT_OBJECT_0 + _CONDITION_EVENT_ALL)) &&
88	(mWaitersCount == 0);
89	LeaveCriticalSection(&mWaitersCountLock);
90
91	// If we are the last waiter to be notified to stop waiting, reset the event
92	if(lastWaiter)
93	ResetEvent(mEvents[_CONDITION_EVENT_ALL]);
94	}
95	#endif
96
97	#if defined(_GTHREADS_WIN32_)
98	void GConditionVar::notify_one()
99	{
100	// Are there any waiters?
101	EnterCriticalSection(&mWaitersCountLock);
102	bool haveWaiters = (mWaitersCount > 0);
103	LeaveCriticalSection(&mWaitersCountLock);
104
105	// If we have any waiting threads, send them a signal
106	if(haveWaiters)
107	SetEvent(mEvents[_CONDITION_EVENT_ONE]);
108	}
109	#endif
110
111	#if defined(_GTHREADS_WIN32_)
112	void GConditionVar::notify_all()
113	{
114	// Are there any waiters?
115	EnterCriticalSection(&mWaitersCountLock);
116	bool haveWaiters = (mWaitersCount > 0);
117	LeaveCriticalSection(&mWaitersCountLock);
118
119	// If we have any waiting threads, send them a signal
120	if(haveWaiters)
121	SetEvent(mEvents[_CONDITION_EVENT_ALL]);
122	}
123	#endif
124
125
126	//------------------------------------------------------------------------------
127	// POSIX pthread_t to unique thread::id mapping logic.
128	// Note: Here we use a global thread safe std::map to convert instances of
129	// pthread_t to small thread identifier numbers (unique within one process).
130	// This method should be portable across different POSIX implementations.
131	//------------------------------------------------------------------------------
132	/*
133
134	#if defined(_GTHREADS_POSIX_)
135	static thread::id _pthread_t_to_ID(const pthread_t &aHandle)
136	{
137	static mutex idMapLock;
138	static std::map<pthread_t, unsigned long int> idMap;
139	static unsigned long int idCount(1);
140
141	lock_guard<mutex> guard(idMapLock);
142	if(idMap.find(aHandle) == idMap.end())
143	idMap[aHandle] = idCount ++;
144	return thread::id(idMap[aHandle]);
145	}
146	#endif // _GTHREADS_POSIX_
147	*/
148
149	void GThread::update_counter(int inc, GThread* t_update) {
150	static GMutex counterLock;
151	GLockGuard<GMutex> guard(counterLock);
152	if (inc==1) { //joinable thread creation
153	GThread::num_created++;
154	t_update->mId = GThread::num_created;
155	}
156	GThread::tcounter+=inc;
157	if (t_update!=NULL && inc<0)
158	t_update->mId=0; // thread terminated
159
160	}
161
162
163	//------------------------------------------------------------------------------
164	// thread
165	//------------------------------------------------------------------------------
166
167	/// Information to pass to the new thread (what to run).
168	struct _thread_start_info {
169	void (mFunction)(void , GThread*); ///< Pointer to the function to be executed.
170	void * mArg; ///< Function argument for the thread function.
171	GThread * mThread; ///< Pointer to the thread object.
172	};
173
174	// Thread wrapper function.
175	#if defined(_GTHREADS_WIN32_)
176	unsigned WINAPI GThread::wrapper_function(void * aArg)
177	#elif defined(_GTHREADS_POSIX_)
178	void * GThread::wrapper_function(void * aArg)
179	#endif
180	{
181	// Get thread startup information
182	_thread_start_info * ti = (_thread_start_info *) aArg;
183
184	/*
185	try
186	{
187	// Call the actual client thread function
188	ti->mFunction(ti->mArg, ti->mThread);
189	}
190	catch(...)
191	{
192	// Uncaught exceptions will terminate the application (default behavior
193	// according to the C++0x draft)
194	std::terminate();
195	}
196	*/
197	ti->mFunction(ti->mArg, ti->mThread);
198
199	// The thread is no longer executing
200	GLockGuard<GMutex> guard(ti->mThread->mDataMutex);
201	ti->mThread->mNotAThread = true;
202	GThread::update_counter(-1, ti->mThread);
203	// The thread is responsible for freeing the startup information
204	delete ti;
205
206	return 0;
207	}
208
209	GThread::GThread(void (aFunction)(void , GThread), void aArg)
210	{
211	// Serialize access to this thread structure
212	GLockGuard<GMutex> guard(mDataMutex);
213
214	// Fill out the thread startup information (passed to the thread wrapper,
215	// which will eventually free it)
216	_thread_start_info * ti = new _thread_start_info;
217	ti->mFunction = aFunction;
218	ti->mArg = aArg;
219	ti->mThread = this;
220
221	// The thread is now alive
222	mNotAThread = false;
223
224	// Create the thread
225	#if defined(_GTHREADS_WIN32_)
226	mHandle = (HANDLE) _beginthreadex(0, 0, wrapper_function, (void *) ti, 0, &mWin32ThreadID);
227	#elif defined(_GTHREADS_POSIX_)
228	if(pthread_create(&mHandle, NULL, wrapper_function, (void *) ti) != 0)
229	mHandle = 0;
230	#endif
231
232	// Did we fail to create the thread?
233	if(!mHandle)
234	{
235	mNotAThread = true;
236	delete ti;
237	}
238	else GThread::update_counter(1, this);
239	}
240
241	GThread::~GThread()
242	{
243	if(joinable()) {
244	//std::terminate();
245	GThread::update_counter(-1, this);
246	}
247	}
248
249	void GThread::join()
250	{
251	if(joinable())
252	{
253	#if defined(_GTHREADS_WIN32_)
254	WaitForSingleObject(mHandle, INFINITE);
255	#elif defined(_GTHREADS_POSIX_)
256	pthread_join(mHandle, NULL);
257	#endif
258	}
259	}
260
261	void GThread::wait_all() {
262	while (GThread::num_running()>0)
263	this_thread::sleep_for(chrono::milliseconds(2));
264	}
265
266
267	bool GThread::joinable() const
268	{
269	mDataMutex.lock();
270	bool result = !mNotAThread;
271	mDataMutex.unlock();
272	return result;
273	}
274
275	int GThread::get_id() const
276	{
277	if(!joinable())
278	//return id();
279	return 0; //FIXME
280	else
281	return mId;
282	/*
283	#if defined(_GTHREADS_WIN32_)
284	return id((unsigned long int) mWin32ThreadID);
285	#elif defined(_GTHREADS_POSIX_)
286	return _pthread_t_to_ID(mHandle);
287	#endif
288	*/
289	}
290
291	unsigned GThread::hardware_concurrency()
292	{
293	#if defined(_GTHREADS_WIN32_)
294	SYSTEM_INFO si;
295	GetSystemInfo(&si);
296	return (int) si.dwNumberOfProcessors;
297	#elif defined(_SC_NPROCESSORS_ONLN)
298	return (int) sysconf(_SC_NPROCESSORS_ONLN);
299	#elif defined(_SC_NPROC_ONLN)
300	return (int) sysconf(_SC_NPROC_ONLN);
301	#else
302	// The standard requires this function to return zero if the number of
303	// hardware cores could not be determined.
304	return 0;
305	#endif
306	}
307
308
309	//------------------------------------------------------------------------------
310	// this_thread
311	//------------------------------------------------------------------------------
312	/*
313	int this_thread::get_id()
314	{
315	#if defined(_GTHREADS_WIN32_)
316	return thread::id((unsigned long int) GetCurrentThreadId());
317	#elif defined(_GTHREADS_POSIX_)
318	return _pthread_t_to_ID(pthread_self());
319	#endif
320	}
321	*/