void run()
{
unsigned s;
unsigned n;
if (waitForWork(s,n))
subsort(s,n);
}
void MessagePumpUI::doRunLoop() {
// IF this was just a simple PeekMessage() loop (servicing all possible work queues), then Windows would try to
// achieve the following order according to MSDN documentation about PeekMessage with no filter):
//
// - Sent messages
// - Posted messages
// - Sent messages (again)
// - WM_PAINT messages
// - WM_TIMER messages
//
// Summary: none of the above classes is starved, and sent messages has twice the chance of being processed (i.e.,
// reduced service time).
for (;;) {
// If we do any work, we may create more messages etc., and more work may possibly be waiting in another task group.
// When we (for example) processNextWindowsMessage(), there is a good chance there are still more messages waiting.
// On the other hand, when any of these methods return having done no work, then it is pretty unlikely that calling
// them again quickly will find any work to do. Finally, if they all say they had no work, then it is a good time
// to consider sleeping (waiting) for more work.
bool moreWorkIsPlausible = processNextWindowsMessage();
if (m_runState->shouldQuit) {
break;
}
moreWorkIsPlausible |= m_runState->delegate->doWork();
if (m_runState->shouldQuit) {
break;
}
moreWorkIsPlausible |= m_runState->delegate->doDelayedWork(&delayed_work_time_);
// If we did not process any delayed work, then we can assume that our
// existing WM_TIMER if any will fire when delayed work should run. We
// don't want to disturb that timer if it is already in flight. However,
// if we did do all remaining delayed work, then lets kill the WM_TIMER.
if (moreWorkIsPlausible && delayed_work_time_.is_null())
KillTimer(m_messageWindow.getHandle(), reinterpret_cast<UINT_PTR>(this));
if (m_runState->shouldQuit)
break;
if (moreWorkIsPlausible)
continue;
moreWorkIsPlausible = m_runState->delegate->doIdleWork();
if (m_runState->shouldQuit)
break;
if (moreWorkIsPlausible)
continue;
// Wait (sleep) until we have work to do again.
waitForWork();
}
}
void KisTileDataSwapper::run()
{
while (1) {
waitForWork();
if (m_d->shouldExitFlag.load())
return;
QThread::msleep(DELAY);
doJob();
}
}
void Client::Connection::recvStart() {
Log::write(INFO, "Connection receiver thread started. <thread id : %ld>, <pid : %d> \n",
(long int)syscall(SYS_gettid), getpid());
while(waitForWork()) {
Log::write(DEBUG, "Got calls in Connection\n");
recvRespond();
}
close();
Log::write(INFO, "Connection receiver thread exits.\n");
}
void subsort(unsigned s, unsigned n)
{
do {
sJobItem *qi;
while (n>PARALLEL_GRANULARITY) {
unsigned r1;
unsigned r2;
partition(s, n, r1, r2);
unsigned n2 = n+s-r2;
if (r1==s) {
n = n2;
s = r2;
}
else {
if (n2!=0) {
qi = new sJobItem;
qi->num = n2;
qi->start = r2;
NonReentrantSpinBlock block(joblock);
jobq.enqueue(qi);
if (waiting) {
jobqsem.signal(waiting);
waiting = 0;
}
}
n = r1-s;
}
}
serialsort(s,n);
NonReentrantSpinBlock block(joblock);
if (waiting==numsubthreads) { // well we are done so are rest
done = true;
jobqsem.signal(waiting);
break;
}
}
while(waitForWork(s,n));
}
err_t X11UIEventLoopImpl::runInternal()
{
int work = 0;
// Sync with server before we get into the event loop.
doXSync();
for (;;)
{
bool didWork = false;
bool more;
// Process 'XEvent's - Highest priority.
do {
more = processNextXEvent();
didWork |= more;
if (_quitting)
goto _End;
} while (more);
// doWork.
didWork |= doWork();
if (_quitting)
goto _End;
if (didWork && work < _workPerLoop)
continue;
work++;
// doDelayedWork.
didWork |= doDelayedWork(&_delayedWorkTime);
if (_quitting)
goto _End;
if (didWork && work < _workPerLoop)
continue;
// doIdleWork.
//
// If quit is received in nestedLoop or through runAllPending(), we will
// quit here, because we don't want to doXSync().
didWork |= doIdleWork();
if (_quitting)
goto _End;
// Call doXSync(), this is round-trip operation and can generate events.
didWork |= doXSync();
if (_quitting)
goto _End;
// Clear work status, this is why it's here...
if (didWork || work < _workPerLoop)
continue;
work = 0;
// Finally wait.
waitForWork();
}
_End:
return ERR_OK;
}
