void SocketService::update(unsigned char flag)
{
#ifndef WIN32
if(::write(iosync[1], (char *)&flag, 1) < 1) {
#ifdef CCXX_EXCEPTIONS
switch(Thread::getException()) {
case throwObject:
throw(this);
return;
#ifdef COMMON_STD_EXCEPTION
case throwException:
throw(ThrException("update failed"));
return;
#endif
default:
return;
}
#else
return;
#endif
}
#else
sync->update(flag);
#endif
}
SocketService::SocketService(int pri, size_t stack, const char *id) :
Thread(pri, stack), Mutex(id)
{
first = last = NULL;
count = 0;
#ifndef WIN32
FD_ZERO(&connect);
long opt;
if(::pipe(iosync)) {
#ifdef CCXX_EXCEPTIONS
switch(Thread::getException()) {
case throwObject:
throw(this);
return;
#ifdef COMMON_STD_EXCEPTION
case throwException:
throw(ThrException("no service pipe"));
return;
#endif
default:
return;
}
#else
return;
#endif
}
hiwater = iosync[0] + 1;
#ifndef USE_POLL
FD_SET(iosync[0], &connect);
#endif
opt = fcntl(iosync[0], F_GETFL);
fcntl(iosync[0], F_SETFL, opt | O_NDELAY);
#else
sync = new Sync();
#endif
}
Thread::Thread(int pri, size_t stack):
_cancel(cancelDefault), _start(NULL), priv(new ThreadImpl(threadTypeNormal))
{
#ifdef WIN32
if(!_main)
{
_self.setKey(NULL);
_main = this;
setName("main()");
}
else
#ifdef WIN32
_name[0] = 0;
#else
snprintf(_name, sizeof(_name), "%d", getId());
#endif
_parent = Thread::get();
if(_parent)
priv->_throw = _parent->priv->_throw;
else
_parent = this;
priv->_cancellation = CreateEvent(NULL, TRUE, FALSE, NULL);
if(!priv->_cancellation)
THROW(this);
if(stack <= _autostack)
priv->_stack = 0;
else
priv->_stack = stack;
if(pri > 2)
pri = 2;
if(pri < -2)
pri = -2;
if(Process::isRealtime() && pri < 0)
pri = 0;
switch(pri)
{
case 1:
priv->_priority = THREAD_PRIORITY_ABOVE_NORMAL;
break;
case -1:
priv->_priority = THREAD_PRIORITY_BELOW_NORMAL;
break;
case 2:
priv->_priority = THREAD_PRIORITY_HIGHEST;
break;
case -2:
priv->_priority = THREAD_PRIORITY_LOWEST;
break;
default:
priv->_priority = THREAD_PRIORITY_NORMAL;
}
#else
int salign;
pthread_attr_init(&priv->_attr);
pthread_attr_setdetachstate(&priv->_attr, PTHREAD_CREATE_JOINABLE);
#ifdef PTHREAD_STACK_MIN
if(stack && stack <= _autostack)
pthread_attr_setstacksize(&priv->_attr, _autostack);
else if(stack > _autostack)
{
if(stack < PTHREAD_STACK_MIN)
stack = PTHREAD_STACK_MIN;
else // align to nearest min boundry
{
salign = stack / PTHREAD_STACK_MIN;
if(stack % PTHREAD_STACK_MIN)
++salign;
stack = salign * PTHREAD_STACK_MIN;
}
if(stack && pthread_attr_setstacksize(&priv->_attr, stack))
{
#ifdef CCXX_EXCEPTIONS
switch(Thread::getException())
{
case throwObject:
throw(this);
return;
#ifdef COMMON_STD_EXCEPTION
case throwException:
throw(ThrException("no stack space"));
return;
#endif
default:
return;
}
#else
return;
#endif
}
}
#endif
#ifndef __FreeBSD__
#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
#ifdef HAVE_SCHED_GETSCHEDULER
#define __HAS_PRIORITY_SCHEDULING__
if(pri < 0 && Process::isRealtime())
pri = 0;
if(pri)
{
struct sched_param sched;
int policy;
policy = sched_getscheduler(0);
if(policy < 0)
{
#ifdef CCXX_EXCEPTIONS
switch(Thread::getException())
{
case throwObject:
throw(this);
return;
#ifdef COMMON_STD_EXCEPTION
case throwException:
throw(ThrException("invalid scheduler"));
return;
#endif
default:
return;
}
#else
return;
#endif
}
sched_getparam(0, &sched);
pri = sched.sched_priority - pri;
if(pri > sched_get_priority_max(policy))
pri = sched_get_priority_max(policy);
if(pri < sched_get_priority_min(policy))
pri = sched_get_priority_min(policy);
sched.sched_priority = pri;
pthread_attr_setschedpolicy(&priv->_attr, policy);
pthread_attr_setschedparam(&priv->_attr, &sched);
}
#endif // ifdef HAVE_SCHED_GETSCHEDULER
#endif // ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
#endif // ifndef __FreeBSD__
#ifdef __HAS_PRIORITY_SCHEDULING__
if(!pri)
pthread_attr_setinheritsched(&priv->_attr, PTHREAD_INHERIT_SCHED);
#else
pthread_attr_setinheritsched(&priv->_attr, PTHREAD_INHERIT_SCHED);
#endif
_parent = getThread();
priv->_throw = _parent->priv->_throw;
_cancel = cancelInitial;
#endif // WIN32
}
