poco/Foundation/include/Poco/Thread_POSIX.h
Aleksandar Fabijanic 86a4f0045e
Fix/posix sleep (#3705)
* fix(Thread_POSIX): sleep() poor performance #3703

* chore(vscode): add file associations

* fix(TaskManager): waits for all threads in the ThreadPool #3704

* fix(Thread): call std::this_thread::sleep_for() to sleep #3703

* fix(PollSet): wakeup fd is never read #3708

* feat(Thread): Add Thread::set/getAffinity() #3709

* doc(Thread): Thread::trySleep() assertion #3710

* fix(PollSet): wakeup fd is never read (windows portion and some other optimizations) #3708

* feat(SocketReactor): improvements #3713

* chore(ThreadTest): add missing include

* fix(PollSet): wakeup fd is never read #3708

* fix(Any): #3682 #3683 #3692 #3712

* fix(mingw): lowercase winsock2 and iphlpapi to allow cross compile #3711

* feat(Thread): Add Thread::set/getAffinity() #3709

* chore(SocketReactor): one-liners inlined, removed redundant try/catch in dospatch, remove unused onBusy()

* feat(SocketReactor): add socket to ErrorNotification

* fix(SocketReactor): pollTimeout assignment and ConnectorTest leak
2022-07-26 06:54:56 -05:00

208 lines
4.2 KiB
C++

//
// Thread_POSIX.h
//
// Library: Foundation
// Package: Threading
// Module: Thread
//
// Definition of the ThreadImpl class for POSIX Threads.
//
// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Thread_POSIX_INCLUDED
#define Foundation_Thread_POSIX_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Runnable.h"
#include "Poco/SignalHandler.h"
#include "Poco/Event.h"
#include "Poco/RefCountedObject.h"
#include "Poco/AutoPtr.h"
#include "Poco/SharedPtr.h"
#include <pthread.h>
// must be limits.h (not <climits>) for PTHREAD_STACK_MIN on Solaris
#include <limits.h>
#if !defined(POCO_NO_SYS_SELECT_H)
#include <sys/select.h>
#endif
#include <errno.h>
#if defined(POCO_VXWORKS)
#include <cstring>
#endif
namespace Poco {
class Foundation_API ThreadImpl
{
public:
typedef pthread_t TIDImpl;
typedef void (*Callable)(void*);
enum Priority
{
PRIO_LOWEST_IMPL,
PRIO_LOW_IMPL,
PRIO_NORMAL_IMPL,
PRIO_HIGH_IMPL,
PRIO_HIGHEST_IMPL
};
enum Policy
{
POLICY_DEFAULT_IMPL = SCHED_OTHER
};
ThreadImpl();
~ThreadImpl();
TIDImpl tidImpl() const;
void setNameImpl(const std::string& threadName);
std::string getNameImpl() const;
std::string getOSThreadNameImpl();
/// Returns the thread's name, expressed as an operating system
/// specific name value. Return empty string if thread is not running.
/// For test used only.
void setPriorityImpl(int prio);
int getPriorityImpl() const;
void setOSPriorityImpl(int prio, int policy = SCHED_OTHER);
int getOSPriorityImpl() const;
static int getMinOSPriorityImpl(int policy);
static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size);
int getStackSizeImpl() const;
void startImpl(SharedPtr<Runnable> pTarget);
void joinImpl();
bool joinImpl(long milliseconds);
bool isRunningImpl() const;
static void yieldImpl();
static ThreadImpl* currentImpl();
static TIDImpl currentTidImpl();
static long currentOsTidImpl();
bool setAffinityImpl(int coreID);
int getAffinityImpl() const;
protected:
static void* runnableEntry(void* pThread);
static int mapPrio(int prio, int policy = SCHED_OTHER);
static int reverseMapPrio(int osPrio, int policy = SCHED_OTHER);
private:
class CurrentThreadHolder
{
public:
CurrentThreadHolder()
{
if (pthread_key_create(&_key, NULL))
throw SystemException("cannot allocate thread context key");
}
~CurrentThreadHolder()
{
pthread_key_delete(_key);
}
ThreadImpl* get() const
{
return reinterpret_cast<ThreadImpl*>(pthread_getspecific(_key));
}
void set(ThreadImpl* pThread)
{
pthread_setspecific(_key, pThread);
}
private:
pthread_key_t _key;
};
struct ThreadData: public RefCountedObject
{
ThreadData():
thread(0),
prio(PRIO_NORMAL_IMPL),
osPrio(),
policy(SCHED_OTHER),
done(false),
stackSize(POCO_THREAD_STACK_SIZE),
started(false),
joined(false)
{
#if defined(POCO_VXWORKS)
// This workaround is for VxWorks 5.x where
// pthread_init() won't properly initialize the thread.
std::memset(&thread, 0, sizeof(thread));
#endif
}
SharedPtr<Runnable> pRunnableTarget;
pthread_t thread;
int prio;
int osPrio;
int policy;
Event done;
std::size_t stackSize;
bool started;
bool joined;
std::string name;
int affinity;
mutable FastMutex mutex;
};
AutoPtr<ThreadData> _pData;
static CurrentThreadHolder _currentThreadHolder;
#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
SignalHandler::JumpBufferVec _jumpBufferVec;
friend class SignalHandler;
#endif
};
//
// inlines
//
inline int ThreadImpl::getPriorityImpl() const
{
return _pData->prio;
}
inline int ThreadImpl::getOSPriorityImpl() const
{
return _pData->osPrio;
}
inline bool ThreadImpl::isRunningImpl() const
{
FastMutex::ScopedLock l(_pData->mutex);
return !_pData->pRunnableTarget.isNull();
}
inline void ThreadImpl::yieldImpl()
{
sched_yield();
}
inline int ThreadImpl::getStackSizeImpl() const
{
return static_cast<int>(_pData->stackSize);
}
inline ThreadImpl::TIDImpl ThreadImpl::tidImpl() const
{
return _pData->thread;
}
} // namespace Poco
#endif // Foundation_Thread_POSIX_INCLUDED