posix/thread.hh Go to the documentation of this file. // // $Id: thread.hh,v 1.5 2003/10/30 15:05:13 cholm Exp $ // // threadmm::posix::thread // Copyright (C) 2002 Christian Holm Christensen <cholm@nbi.dk> // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public License // as published by the Free Software Foundation; either version 2.1 // of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free // Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA // 02111-1307 USA // #ifndef THREADMM_posix_thread #define THREADMM_posix_thread #ifndef THREADMM_thread # error Do not include threadmm/posix/thread.hh directly #endif #ifndef __PTHREAD_H__ #include <pthread.h> #endif #ifndef __STDEXCEPT__ #include <stdexcept> #endif #ifndef __CERRNO__ #include <cerrno> #endif #ifndef __CASSERT__ #include <cassert> #endif #ifndef THREADMM_thread_specific # include <threadmm/thread_specific.hh> #endif namespace threadmm { namespace posix { template <class C> struct thread_create { C* on_null() volatile { pthread_t pth = pthread_self(); C* self = new C; self->_thread = pth; self->_is_running = true; #if HAVE_DECL_PTHREAD_GETATTR_NP > 0 pthread_attr_t attr; pthread_getattr_np(pth, &attr); self->_attr = attr; #endif return self; } }; template <typename C> struct thread_cleanup { static void on_cleanup(C*) {} }; template <typename Client> class thread { private: template <typename C> friend struct thread_create; #if 0 template <class C> struct create { C* on_null() volatile { pthread_t pth = pthread_self(); C* self = new C; self->_thread = pth; self->_is_running = true; #if HAVE_DECL_PTHREAD_GETATTR_NP > 0 pthread_attr_t attr; pthread_getattr_np(pth, &attr); self->_attr = attr; #endif return self; } }; template <typename C> struct cleanup { static void on_cleanup(C*) {} }; #endif public: typedef Client client_type; typedef ::threadmm::thread_specific<client_type, thread_create, thread_cleanup> pool_type; private: pthread_t _thread; pthread_attr_t _attr; bool _is_running; static pool_type _pool; static void* dispatch(void* arg); void init_kind(int flags); void init_guard_size(size_t n); void init_stack(void* address, size_t& n); protected: thread() : _is_running(false) {} void run(client_type* client); public: thread(int flags, int policy=regular, int priority=0, int gsize=-1, void* address=0, size_t ssize=0); virtual ~thread(); // virtual void* operator()() = 0; int kind() const; void* stack(size_t& n) const; size_t guard_size() const; int scheduling(int flag, int priority); int scheduling(int& flag) const; void cancel(); void detach(); bool equal(const client_type& other); void* join(); static void exit(void* retval); static void kill_others(); static int cancellation(int type); static int concurrency(); static int concurrency(int c); static bool disable_cancellation(); static bool enable_cancellation(); static client_type& self(); static void test_cancel(); static void yield(); static bool at_fork(void (*prep)(), void (*par)(), void (*chi)()); }; //________________________________________________________________ template <typename Client> typename thread<Client>::pool_type thread<Client>::_pool; //________________________________________________________________ template <typename Client> inline void* thread<Client>::dispatch(void* arg) { // Having entered the thread, and registered the object in // thread specific memory, we can execute the object. void* ret = 0; client_type* t = static_cast<client_type*>(arg); assert(static_cast<void*>(t) == arg); try { // First thing to do, inside this function, is to register in // thread specific memory, the object that executed this // thread. In that way, we can simply use the thread specific // memory to retrive the object in the member function self. // Much easier and safer than using some // static (shudder) list of all threads. I go the inspiration // from the implamenation from the CThreads library. // pthread_once(&_once, dispatcher_init); _pool.assign(t); assert(_pool.ptr() == t); if (!t) throw std::invalid_argument("No thread"); ret = t->operator()(); } catch (std::exception& e) { // Let user-derived class handle the exception. if (t) { t->on_exception(e); t->_is_running = false; } return ret; // Or let terminate do it's job // else throw; } catch (...) { // Let user-derived class handle the exception. if (t) { t->on_exception(); t->_is_running = false; } // Let terminate do it's job throw; } t->_is_running = false; return ret; } //________________________________________________________________ template <typename Client> inline thread<Client>::thread(int flags, int policy, int priority, int gsize, void* address, size_t ssize) : _is_running(false) { pthread_attr_init(&_attr); this->scheduling(policy, priority); this->init_kind(flags); if (gsize >= 0) this->init_guard_size(size_t(gsize)); if (address) this->init_stack(address, ssize); } //________________________________________________________________ template <typename Client> inline thread<Client>::~thread() { pthread_attr_destroy(&_attr); _pool.assign(0); if (_is_running) thread<Client>::exit(0); } //________________________________________________________________ template <typename Client> inline void thread<Client>::init_kind(int flags) { int ret = 0; if (flags & detached) ret = pthread_attr_setdetachstate(&_attr, PTHREAD_CREATE_DETACHED); else ret = pthread_attr_setdetachstate(&_attr, PTHREAD_CREATE_JOINABLE); if (flags & inherit) ret = pthread_attr_setinheritsched(&_attr, PTHREAD_INHERIT_SCHED); else ret = pthread_attr_setinheritsched(&_attr, PTHREAD_EXPLICIT_SCHED); if (flags & process) ret = pthread_attr_setscope(&_attr, PTHREAD_SCOPE_PROCESS); else ret = pthread_attr_setscope(&_attr, PTHREAD_SCOPE_SYSTEM); if (ret == ENOTSUP) throw std::runtime_error("scope not supported"); } //________________________________________________________________ template <typename Client> inline int thread<Client>::kind() const { int flag = 0; int detach; pthread_attr_getdetachstate(&_attr, &detach); switch (detach){ case PTHREAD_CREATE_DETACHED: flag |= detached; break; case PTHREAD_CREATE_JOINABLE: flag |= joinable; break; } int inher; pthread_attr_getinheritsched(&_attr, &inher); switch(inher) { case PTHREAD_INHERIT_SCHED: flag |= inherit; break; case PTHREAD_EXPLICIT_SCHED: flag |= own; break; } int scope; pthread_attr_getscope(&_attr, &scope); switch (scope) { case PTHREAD_SCOPE_PROCESS: flag |= process; break; case PTHREAD_SCOPE_SYSTEM: flag |= system; break; } return flag; } //________________________________________________________________ template <typename Client> inline void thread<Client>::init_stack(void* address, size_t &n) { int ret = 0; void* a = address; #if HAVE_DECL_PTHREAD_ATTR_SETSTACK > 0 ret = pthread_attr_setstack(&_attr, a, n); #else # if HAVE_DECL_PTHREAD_ATTR_SETSTACKADDR > 0 ret = pthread_attr_setstackaddr(&_attr, a); # else a = 0; # endif if (!ret) pthread_attr_setstacksize(&_attr, n); #endif if (ret == EINVAL) throw std::invalid_argument("invalid stack address and/or size"); } //________________________________________________________________ template <typename Client> inline void* thread<Client>::stack(size_t& n) const { void* address = 0; #if HAVE_DECL_PTHREAD_ATTR_GETSTACK > 0 pthread_attr_getstack(&_attr, &address, &n); #else # if HAVE_DECL_PTHREAD_ATTR_GETSTACKADDR > 0 pthread_attr_getstackaddr(&_attr, &address); #endif pthread_attr_getstacksize(&_attr, &n); #endif return address; } //________________________________________________________________ template <typename Client> inline void thread<Client>::init_guard_size(size_t n) { int ret = 0; #if HAVE_DECL_PTHREAD_ATTR_SETGUARDSIZE > 0 ret = pthread_attr_setguardsize(&_attr, n); #else n = 0; #endif if (ret == EINVAL) throw std::invalid_argument("invalid stack address and/or size"); } //________________________________________________________________ template <typename Client> inline size_t thread<Client>::guard_size() const { size_t n = 0; #if HAVE_DECL_PTHREAD_ATTR_GETGUARDSIZE > 0 pthread_attr_getguardsize(&_attr, &n); #endif return n; } //________________________________________________________________ template <typename Client> inline int thread<Client>::scheduling(int flag, int priority) { struct sched_param sp; int ret = 0; int policy = 0; sp.sched_priority = priority; if (flag & fifo) policy = SCHED_FIFO; else if (flag & round_robin) policy = SCHED_RR; else policy = SCHED_OTHER; if (!_is_running) { ret = pthread_attr_setschedpolicy(&_attr, policy); ret = pthread_attr_setschedparam(&_attr, &sp); } else ret = pthread_setschedparam(_thread, policy, &sp); switch (ret) { case EINVAL: throw std::invalid_argument("invalid policy"); break; case EPERM: throw std::runtime_error("permission denied"); break; case ESRCH: throw std::invalid_argument("thread not running"); break; case EFAULT: throw std::runtime_error("memory out of bounds"); break; } return sp.sched_priority; } //________________________________________________________________ template <typename Client> inline int thread<Client>::scheduling(int& policy) const { struct sched_param sp; int ret = 0; if (!_is_running) { ret = pthread_attr_getschedpolicy(&_attr, &policy); ret = pthread_attr_getschedparam(&_attr, &sp); } else pthread_getschedparam(_thread, &policy, &sp); switch (policy) { case SCHED_FIFO: policy = fifo; break; case SCHED_RR: policy = round_robin; break; case SCHED_OTHER: policy = regular; break; } switch (ret) { case ESRCH: throw std::invalid_argument("thread not running"); break; case EFAULT: throw std::runtime_error("invalid memory"); break; } return sp.sched_priority; } //________________________________________________________________ template <typename Client> inline void thread<Client>::cancel() { int ret = pthread_cancel(_thread); switch (ret) { case ESRCH: throw std::runtime_error("no such thread"); } } //________________________________________________________________ template <typename Client> inline void thread<Client>::detach() { int ret = pthread_detach(_thread); switch (ret) { case ESRCH: throw std::runtime_error("no such thread"); case EINVAL: throw std::runtime_error("thread is already detached"); } } //________________________________________________________________ template <typename Client> inline void thread<Client>::run(client_type* client) { if (_is_running) return; #if 0 std::cout << "Client: " << std::hex << client << " Self: " << this << std::endl; #endif int ret= pthread_create(&_thread, &_attr, dispatch, static_cast<void*>(client)); switch (ret) { case EPERM: throw std::runtime_error("permission denied"); case EAGAIN: throw std::runtime_error("out of resources"); } _is_running = true; } //________________________________________________________________ template <typename Client> inline bool thread<Client>::equal(const client_type& other) { return pthread_equal(_thread, other._thread) == 0 ? false : true; } //________________________________________________________________ template <typename Client> inline int thread<Client>::cancellation(int type) { int old = 0; switch (type) { case deferred: pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,&old); break; case asynchronous: pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,&old); break; default: throw std::invalid_argument("unknown cancellation type"); } switch(old) { case PTHREAD_CANCEL_DEFERRED: return deferred; case PTHREAD_CANCEL_ASYNCHRONOUS: return asynchronous; } return 0; } //________________________________________________________________ template <typename Client> inline int thread<Client>::concurrency() { #if HAVE_DECL_PTHREAD_GETCONCURRENCY > 0 return pthread_getconcurrency(); #else return 0; #endif } //________________________________________________________________ template <typename Client> inline int thread<Client>::concurrency(int c) { #if HAVE_DECL_PTHREAD_SETCONCURRENCY > 0 pthread_setconcurrency(c); return c; #else return 0; #endif } //________________________________________________________________ template <typename Client> inline bool thread<Client>::disable_cancellation() { int old = 0; pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old); switch (old) { case PTHREAD_CANCEL_ENABLE: return true; case PTHREAD_CANCEL_DISABLE: return false; } return true; } //________________________________________________________________ template <typename Client> inline bool thread<Client>::enable_cancellation() { int old = 0; pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old); switch (old) { case PTHREAD_CANCEL_ENABLE: return true; case PTHREAD_CANCEL_DISABLE: return false; } return true; } //________________________________________________________________ template <typename Client> inline void thread<Client>::exit(void* retval) { self()._is_running = false; // For some odd reason, this will cause `std::terminate()' to be // called, if optimistion is turned on pthread_exit(retval); } //________________________________________________________________ template <typename Client> inline void* thread<Client>::join() { assert(!equal(self())); if (equal(self())) throw std::runtime_error("cannot join to self, would deadlock"); void* retval; int ret = pthread_join(_thread, &retval); switch (ret) { case ESRCH: throw std::invalid_argument("no such thread"); case EINVAL: throw std::invalid_argument("thread detached or joined"); case EDEADLK: throw std::runtime_error("would deadlock"); } return retval; } //________________________________________________________________ template <typename Client> inline void thread<Client>::kill_others() { #if HAVE_DECL_PTHREAD_KILL_OTHER_THREADS_NP > 0 pthread_kill_other_threads_np(); #endif } //________________________________________________________________ template <typename Client> inline typename thread<Client>::client_type& thread<Client>::self() { client_type* s = _pool.ptr(); return *s; } //________________________________________________________________ template <typename Client> inline void thread<Client>::test_cancel() { pthread_testcancel(); } //________________________________________________________________ template <typename Client> inline void thread<Client>::yield() { #if HAVE_DECL_PTHREAD_YIELD > 0 pthread_yield(); #else struct timespec request = { 0, 1000 }; nanosleep(&request, NULL); #endif } //________________________________________________________________ template <typename Client> inline bool thread<Client>::at_fork(void(*prep)(), void(*par)(), void(*chi)()) { #if HAVE_DECL_PTHREAD_ATFORK > 0 int ret = pthread_atfork(prep, par, chi); return ret == 0 ? true : false; #else void (*f1)() = prep; // Smak warnings void (*f2)() = par; // Smak warnings void (*f3)() = chi; // Smak warnings f1 = f2 = f3 = 0; return false; #endif } } } #endif //____________________________________________________________________ // // EOF //