Thread portable class Gate portable class Timer class Pool class Terimber 2.0 About C++

Downloads Products & Services Support Clients Open Source About Home / Open source / Terimber 2.0 primitives.cpp Go to the documentation of this file. /* * The Software License * ================================================================================= * Copyright (c) 2003-.The Terimber Corporation. All rights reserved. * ================================================================================= * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * The end-user documentation included with the redistribution, if any, * must include the following acknowledgment: * "This product includes software developed by the Terimber Corporation." * ================================================================================= * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE TERIMBER CORPORATION OR ITS CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ================================================================================ */ #include "base/primitives.h" BEGIN_TERIMBER_NAMESPACE #pragma pack(4) #if OS_TYPE != OS_WIN32 static void calculate_absolute_time_by_timeout(size_t tm_relative, timespec& tm_absolute) { // sets timeout timeval now_; gettimeofday(&now_, 0); tm_absolute.tv_sec = now_.tv_sec + (unsigned long)tm_relative / 1000; tm_absolute.tv_nsec = now_.tv_usec * 1000 + ((unsigned long)tm_relative % 1000) * 1000000; if (tm_absolute.tv_nsec >= 1000000000) { ++tm_absolute.tv_sec; tm_absolute.tv_nsec -= 1000000000; } } #endif // constructor mutex::mutex() { #if OS_TYPE == OS_WIN32 InitializeCriticalSection(&_handle); #else pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&_handle, &attr); #endif } // destructor mutex::~mutex() { #if OS_TYPE == OS_WIN32 DeleteCriticalSection(&_handle); #else pthread_mutex_destroy(&_handle); #endif } // NB!!! can be used in the const member function bool mutex::lock() const { #if OS_TYPE == OS_WIN32 EnterCriticalSection(&_handle); return true; #else return !pthread_mutex_lock(&_handle); #endif } // unlocks mutex // NB!!! can be used in the const member function void mutex::unlock() const { #if OS_TYPE == OS_WIN32 LeaveCriticalSection(&_handle); #else pthread_mutex_unlock(&_handle); #endif } // NB!!! can be used in the const member function bool mutex::trylock() const { #if OS_TYPE == OS_WIN32 return TRUE == TryEnterCriticalSection(&_handle); #else return !pthread_mutex_trylock(&_handle); #endif } // constructor creates event event::event(bool manual_reset, bool init_state) { #if OS_TYPE == OS_WIN32 // creates event _handle = CreateEvent(0, manual_reset, init_state, 0); #else _handle._cond = (pthread_cond_t*)malloc(sizeof(pthread_cond_t)); // inits condition thread pthread_cond_init(_handle._cond, 0); // set initial setting _handle._manual_reset = manual_reset; _handle._signaled = init_state; #endif } // destructor event::~event() { #if OS_TYPE == OS_WIN32 // close event handle CloseHandle(_handle); #else // destroys condition thread pthread_cond_destroy(_handle._cond); free(_handle._cond); #endif } // signal event // NB!!! can be used in the const member function void event::signal() const { #if OS_TYPE == OS_WIN32 // sets event to the signal state SetEvent(_handle); #else // locks mutex mutex_keeper keeper(_handle._mtx); _handle._manual_reset ? // manual reset pthread_cond_broadcast(_handle._cond) : // Unblock everyone waiting pthread_cond_signal(_handle._cond); // Unblock just one waiter // sets state, if any _handle._signaled = true; #endif } // nonsignal event // NB!!! can be used in the const member function void event::nonsignal() const { #if OS_TYPE == OS_WIN32 // sets event to the non signal state ResetEvent(_handle); #else mutex_keeper keeper(_handle._mtx); _handle._signaled = false; #endif } // waits for signal state // NB!!! can be used in the const member function size_t event::wait(size_t timeout) const { #if OS_TYPE == OS_WIN32 // waits for signal return WaitForSingleObject(_handle, (DWORD)timeout); #else // If the event is not in the signaled state, we will have to wait mutex_keeper keeper(_handle._mtx); size_t ret = 0; // If we don't do anything it's because it's free already if (!_handle._signaled) // if already in a signal state just return { if (!timeout) // no time for waiting return WAIT_TIMEOUT; else { timespec timeout_; if (INFINITE != timeout) { // sets timeout calculate_absolute_time_by_timeout(timeout, timeout_); } // waits until condition thread returns control do { ret = (INFINITE == timeout ? pthread_cond_wait(_handle._cond, _handle._mtx) : pthread_cond_timedwait(_handle._cond, _handle._mtx, &timeout_)); } while (!ret && !_handle._signaled); } } // adjusts signaled member switch (ret) { case 0: // success if (!_handle._manual_reset) _handle._signaled = false; return WAIT_OBJECT_0; case ETIMEDOUT: default: return WAIT_TIMEOUT; } #endif } // constructor create semaphore semaphore::semaphore(size_t initial_count, size_t max_count) { // checks reasonable params assert(max_count != 0); assert(initial_count <= max_count); #if OS_TYPE == OS_WIN32 // creates semaphore _handle = CreateSemaphore(0, (LONG)initial_count, (LONG)max_count, 0); #else _handle._cond = (pthread_cond_t*)malloc(sizeof(pthread_cond_t)); // creates condition thread pthread_cond_init(_handle._cond, 0); _handle._max_count = max_count; _handle._init_count = initial_count; #endif } // destructor semaphore::~semaphore() { #if OS_TYPE == OS_WIN32 // closes semaphore handle CloseHandle(_handle); #else // destroys condition thread pthread_cond_destroy(_handle._cond); free(_handle._cond); #endif } // releases semaphore // NB!!! can be used in the const member function bool semaphore::release(size_t count) const { if (!count) // nothing to do return false; #if OS_TYPE == OS_WIN32 // releases semaphore return TRUE == ReleaseSemaphore(_handle, (LONG)count, 0); #else // locks mutex mutex_keeper keeper(_handle._mtx); if (_handle._init_count >= _handle._max_count) return false; // increment semaphore counter if (_handle._init_count + count > _handle._max_count) _handle._init_count = _handle._max_count; else _handle._init_count += count; // sets condition thread count == 1 ? pthread_cond_signal(_handle._cond) : pthread_cond_broadcast(_handle._cond); return true; #endif } // waits for signal state // NB!!! can be used in the const member function size_t semaphore::wait(size_t timeout) const { #if OS_TYPE == OS_WIN32 // waits for semaphore event return WaitForSingleObject(_handle, (DWORD)timeout); #else mutex_keeper keeper(_handle._mtx); size_t ret = 0; // If we don't do anything it's because it's available already if (!_handle._init_count) // if we can acquire resource { if (!timeout) return WAIT_TIMEOUT; else { timespec timeout_; if (INFINITE != timeout) { // sets timeout calculate_absolute_time_by_timeout(timeout, timeout_); } // waits until condition thread returns control do { ret = (INFINITE == timeout ? pthread_cond_wait(_handle._cond, _handle._mtx) : pthread_cond_timedwait(_handle._cond, _handle._mtx, &timeout_)); } while (!ret && !_handle._init_count); } } // adjusts count member switch (ret) { case 0: // success --_handle._init_count; return WAIT_OBJECT_0; case ETIMEDOUT: default: return WAIT_TIMEOUT; } #endif } #pragma pack() END_TERIMBER_NAMESPACE

© Copyright Terimber 2003-.