13 #if defined(__SYMBIAN32__)
44 ~NPT_PosixMutex()
override;
52 pthread_mutex_t m_Mutex;
58 NPT_PosixMutex::NPT_PosixMutex()
61 pthread_mutexattr_t attr;
62 pthread_mutexattr_init(&attr);
63 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
65 pthread_mutex_init(&m_Mutex, &attr);
71 NPT_PosixMutex::~NPT_PosixMutex()
73 pthread_mutex_destroy(&m_Mutex);
80 NPT_PosixMutex::Lock()
82 pthread_mutex_lock(&m_Mutex);
90 NPT_PosixMutex::Unlock()
92 pthread_mutex_unlock(&m_Mutex);
101 m_Delegate =
new NPT_PosixMutex();
111 NPT_PosixSharedVariable(
int value);
112 ~NPT_PosixSharedVariable()
override;
120 volatile int m_Value;
121 pthread_mutex_t m_Mutex;
122 pthread_cond_t m_Condition;
128 NPT_PosixSharedVariable::NPT_PosixSharedVariable(
int value) :
131 pthread_mutex_init(&m_Mutex,
NULL);
132 pthread_cond_init(&m_Condition,
NULL);
138 NPT_PosixSharedVariable::~NPT_PosixSharedVariable()
140 pthread_cond_destroy(&m_Condition);
141 pthread_mutex_destroy(&m_Mutex);
148 NPT_PosixSharedVariable::SetValue(
int value)
150 pthread_mutex_lock(&m_Mutex);
152 pthread_cond_broadcast(&m_Condition);
153 pthread_mutex_unlock(&m_Mutex);
160 NPT_PosixSharedVariable::GetValue()
173 struct timespec timed;
178 if (gettimeofday(&now,
NULL)) {
182 now.tv_usec += timeout * 1000;
183 if (now.tv_usec >= 1000000) {
184 now.tv_sec += now.tv_usec / 1000000;
185 now.tv_usec = now.tv_usec % 1000000;
189 timed.tv_sec = now.tv_sec;
190 timed.tv_nsec = now.tv_usec * 1000;
193 pthread_mutex_lock(&m_Mutex);
194 while (value != m_Value) {
196 pthread_cond_wait(&m_Condition, &m_Mutex);
198 int wait_res = pthread_cond_timedwait(&m_Condition, &m_Mutex, &timed);
199 if (wait_res == ETIMEDOUT) {
205 pthread_mutex_unlock(&m_Mutex);
214 NPT_PosixSharedVariable::WaitWhileEquals(
int value,
NPT_Timeout timeout)
217 struct timespec timed;
222 if (gettimeofday(&now,
NULL)) {
226 now.tv_usec += timeout * 1000;
227 if (now.tv_usec >= 1000000) {
228 now.tv_sec += now.tv_usec / 1000000;
229 now.tv_usec = now.tv_usec % 1000000;
233 timed.tv_sec = now.tv_sec;
234 timed.tv_nsec = now.tv_usec * 1000;
237 pthread_mutex_lock(&m_Mutex);
238 while (value == m_Value) {
240 pthread_cond_wait(&m_Condition, &m_Mutex);
242 int wait_res = pthread_cond_timedwait(&m_Condition, &m_Mutex, &timed);
243 if (wait_res == ETIMEDOUT) {
249 pthread_mutex_unlock(&m_Mutex);
259 m_Delegate =
new NPT_PosixSharedVariable(value);
269 NPT_PosixAtomicVariable(
int value);
270 ~NPT_PosixAtomicVariable()
override;
278 volatile int m_Value;
279 pthread_mutex_t m_Mutex;
285 NPT_PosixAtomicVariable::NPT_PosixAtomicVariable(
int value) :
288 pthread_mutex_init(&m_Mutex,
NULL);
294 NPT_PosixAtomicVariable::~NPT_PosixAtomicVariable()
296 pthread_mutex_destroy(&m_Mutex);
303 NPT_PosixAtomicVariable::Increment()
307 pthread_mutex_lock(&m_Mutex);
309 pthread_mutex_unlock(&m_Mutex);
318 NPT_PosixAtomicVariable::Decrement()
322 pthread_mutex_lock(&m_Mutex);
324 pthread_mutex_unlock(&m_Mutex);
333 NPT_PosixAtomicVariable::GetValue()
343 NPT_PosixAtomicVariable::SetValue(
int value)
345 pthread_mutex_lock(&m_Mutex);
347 pthread_mutex_unlock(&m_Mutex);
355 m_Delegate =
new NPT_PosixAtomicVariable(value);
368 ~NPT_PosixThread()
override;
380 static void* EntryPoint(
void*
argument);
392 pthread_t m_ThreadId;
394 NPT_PosixMutex m_JoinLock;
401 NPT_PosixThread::NPT_PosixThread(
NPT_Thread* delegator,
404 m_Delegator(delegator),
406 m_Detached(detached),
417 NPT_PosixThread::~NPT_PosixThread()
434 pthread_t pid = pthread_self();
460 NPT_PosixThread::EntryPoint(
void*
argument)
462 NPT_PosixThread* thread =
reinterpret_cast<NPT_PosixThread*
>(
argument);
464 NPT_LOG_FINER(
"NPT_PosixThread::EntryPoint - in =======================");
466 #if defined(NPT_CONFIG_HAVE_AUTORELEASE_POOL)
473 thread->m_ThreadId = pthread_self();
488 if (thread->m_Detached) {
489 delete thread->m_Delegator;
492 thread->m_Done.SetValue(1);
503 NPT_PosixThread::Start()
512 pthread_attr_t *attributes =
NULL;
514 #if defined(NPT_CONFIG_THREAD_STACK_SIZE)
515 pthread_attr_t stack_size_attributes;
516 pthread_attr_init(&stack_size_attributes);
518 attributes = &stack_size_attributes;
524 bool detached = m_Detached;
528 int result = pthread_create(&thread_id, attributes, EntryPoint,
529 static_cast<NPT_PosixThread*>(
this));
538 pthread_detach(thread_id);
543 m_ThreadId = thread_id;
553 NPT_PosixThread::Run()
572 if (m_ThreadId == 0 || m_Detached) {
582 if (
NPT_FAILED(m_Done.WaitUntilEquals(1, timeout))) {
588 result = pthread_join(m_ThreadId, &return_value);
605 NPT_PosixThread::SetPriority(
int priority)
608 if (m_ThreadId == 0) {
622 if (thread_id == 0) {
627 struct sched_param sp;
629 int result = pthread_getschedparam((pthread_t)thread_id, &policy, &sp);
631 NPT_LOG_FINER_3(
"Current thread policy: %d, priority: %d, new priority: %d",
632 policy, sp.sched_priority, priority);
634 min(SCHED_OTHER): %d, min(SCHED_RR): %d",
635 sched_get_priority_max(SCHED_OTHER),
636 sched_get_priority_max(SCHED_RR),
637 sched_get_priority_min(SCHED_OTHER),
638 sched_get_priority_min(SCHED_RR));
640 sp.sched_priority = priority;
650 result = pthread_setschedparam((pthread_t)thread_id, policy, &sp);
659 NPT_PosixThread::GetPriority(
int& priority)
662 if (m_ThreadId == 0) {
676 if (thread_id == 0) {
680 struct sched_param sp;
683 int result = pthread_getschedparam((pthread_t)thread_id, &policy, &sp);
686 priority = sp.sched_priority;
695 m_Delegate =
new NPT_PosixThread(
this, *
this, detached);
703 m_Delegate =
new NPT_PosixThread(
this, target, detached);
virtual NPT_Result WaitWhileEquals(int value, NPT_Timeout timeout=NPT_TIMEOUT_INFINITE)=0
#define NPT_SUCCESS
Result indicating that the operation or call succeeded.
#define NPT_LOG_FINER_2(_msg, _arg1, _arg2)
#define NPT_ERROR_NOT_IMPLEMENTED
virtual void SetValue(int value)=0
#define NPT_SET_LOCAL_LOGGER(_name)
#define NPT_FAILURE
Result indicating an unspecified failure condition.
static NPT_Result SetRandomSeed(unsigned int seed)
static NPT_Result GetCurrentTimeStamp(NPT_TimeStamp &now)
const int NPT_TIMEOUT_INFINITE
#define NPT_LOG_FINER(_msg)
#define NPT_LOG_FINER_4(_msg, _arg1, _arg2, _arg3, _arg4)
NPT_AtomicVariable(int value=0)
#define NPT_FAILED(result)
virtual NPT_Result Start()=0
virtual void SetValue(int value)=0
virtual NPT_Result GetPriority(int &priority)=0
static NPT_Result SetCurrentThreadPriority(int priority)
#define NPT_ERROR_TIMEOUT
#define NPT_LOG_FINER_1(_msg, _arg1)
const char * argument(const unsigned int nb, const int argc, const char *const *const argv, const unsigned int nb_singles=0,...)
#define NPT_CONFIG_THREAD_STACK_SIZE
#define NPT_ERROR_ERRNO(e)
static NPT_Result GetCurrentThreadPriority(int &priority)
virtual NPT_Result SetPriority(int)
virtual int Decrement()=0
#define NPT_LOG_FINER_3(_msg, _arg1, _arg2, _arg3)
static ThreadId GetCurrentThreadId()
NPT_Int64 ToNanos() const
virtual NPT_Result Wait(NPT_Timeout timeout=NPT_TIMEOUT_INFINITE)=0
virtual NPT_Result Interrupt()=0
virtual NPT_Result WaitUntilEquals(int value, NPT_Timeout timeout=NPT_TIMEOUT_INFINITE)=0
NPT_SharedVariable(int value=0)
NPT_Thread(bool detached=false)
virtual int Increment()=0
#define NPT_LOG_FINE(_msg)