2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
23 #include "opthelpers.h"
26 #include <system_error>
30 #define WIN32_LEAN_AND_MEAN
35 void althrd_setname(const char *name)
37 #if defined(_MSC_VER) && !defined(_M_ARM)
39 #define MS_VC_EXCEPTION 0x406D1388
42 DWORD dwType; // Must be 0x1000.
43 LPCSTR szName; // Pointer to name (in user addr space).
44 DWORD dwThreadID; // Thread ID (-1=caller thread).
45 DWORD dwFlags; // Reserved for future use, must be zero.
50 info.dwThreadID = ~DWORD{0};
54 RaiseException(MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info);
56 __except(EXCEPTION_CONTINUE_EXECUTION) {
58 #undef MS_VC_EXCEPTION
68 semaphore::semaphore(unsigned int initial)
70 if(initial > static_cast<unsigned int>(std::numeric_limits<int>::max()))
71 throw std::system_error(std::make_error_code(std::errc::value_too_large));
72 mSem = CreateSemaphore(nullptr, initial, std::numeric_limits<int>::max(), nullptr);
74 throw std::system_error(std::make_error_code(std::errc::resource_unavailable_try_again));
77 semaphore::~semaphore()
78 { CloseHandle(mSem); }
80 void semaphore::post()
82 if(!ReleaseSemaphore(static_cast<HANDLE>(mSem), 1, nullptr))
83 throw std::system_error(std::make_error_code(std::errc::value_too_large));
86 void semaphore::wait() noexcept
87 { WaitForSingleObject(static_cast<HANDLE>(mSem), INFINITE); }
89 bool semaphore::try_wait() noexcept
90 { return WaitForSingleObject(static_cast<HANDLE>(mSem), 0) == WAIT_OBJECT_0; }
97 #ifdef HAVE_PTHREAD_NP_H
98 #include <pthread_np.h>
104 using setname_t1 = int(*)(const char*);
105 using setname_t2 = int(*)(pthread_t, const char*);
106 using setname_t3 = void(*)(pthread_t, const char*);
107 using setname_t4 = int(*)(pthread_t, const char*, void*);
109 void setname_caller(setname_t1 func, const char *name)
112 void setname_caller(setname_t2 func, const char *name)
113 { func(pthread_self(), name); }
115 void setname_caller(setname_t3 func, const char *name)
116 { func(pthread_self(), name); }
118 void setname_caller(setname_t4 func, const char *name)
119 { func(pthread_self(), "%s", static_cast<void*>(const_cast<char*>(name))); }
123 void althrd_setname(const char *name)
125 #if defined(HAVE_PTHREAD_SET_NAME_NP)
126 setname_caller(pthread_set_name_np, name);
127 #elif defined(HAVE_PTHREAD_SETNAME_NP)
128 setname_caller(pthread_setname_np, name);
130 /* Avoid unused function/parameter warnings. */
132 std::ignore = static_cast<void(*)(setname_t1,const char*)>(&setname_caller);
133 std::ignore = static_cast<void(*)(setname_t2,const char*)>(&setname_caller);
134 std::ignore = static_cast<void(*)(setname_t3,const char*)>(&setname_caller);
135 std::ignore = static_cast<void(*)(setname_t4,const char*)>(&setname_caller);
142 semaphore::semaphore(unsigned int initial)
144 mSem = dispatch_semaphore_create(initial);
146 throw std::system_error(std::make_error_code(std::errc::resource_unavailable_try_again));
149 semaphore::~semaphore()
150 { dispatch_release(mSem); }
152 void semaphore::post()
153 { dispatch_semaphore_signal(mSem); }
155 void semaphore::wait() noexcept
156 { dispatch_semaphore_wait(mSem, DISPATCH_TIME_FOREVER); }
158 bool semaphore::try_wait() noexcept
159 { return dispatch_semaphore_wait(mSem, DISPATCH_TIME_NOW) == 0; }
163 #else /* !__APPLE__ */
169 semaphore::semaphore(unsigned int initial)
171 if(sem_init(&mSem, 0, initial) != 0)
172 throw std::system_error(std::make_error_code(std::errc::resource_unavailable_try_again));
175 semaphore::~semaphore()
176 { sem_destroy(&mSem); }
178 void semaphore::post()
180 if(sem_post(&mSem) != 0)
181 throw std::system_error(std::make_error_code(std::errc::value_too_large));
184 void semaphore::wait() noexcept
186 while(sem_wait(&mSem) == -1 && errno == EINTR) {
190 bool semaphore::try_wait() noexcept
191 { return sem_trywait(&mSem) == 0; }
195 #endif /* __APPLE__ */