Changeset 69 for trunk/src

Timestamp:

Jul 4, 2009, 2:31:20 PM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

corelib: OS/2: Ported QThread (#13).

Location:

trunk/src/corelib/thread

Files:

• qthread.cpp (modified) (3 diffs)
• qthread_os2.cpp (copied) (copied from trunk/src/corelib/thread/qthread_win.cpp ) (26 diffs)
• qthread_p.h (modified) (2 diffs)
• thread.pri (modified) (3 diffs)

trunk/src/corelib/thread/qthread.cpp

@@ -154 +154 @@
     terminationEnabled = true;
     terminatePending = false;
+
+
+
+
 #endif
 
@@ -550 +554 @@
     Initializes the QThread system.
 */
-#if defined (Q_OS_WIN)
+#if defined)
 void qt_create_tls();
 #endif
@@ -560 +564 @@
     qt_global_mutexpool = QMutexPool::instance();
 
-#if defined (Q_OS_WIN)
+#if defined)
     qt_create_tls();
 #endif

trunk/src/corelib/thread/qthread_os2.cpp

@@ -3 +3 @@
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 ** Contact: Qt Software Information ([email protected])
+
+
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -40 +42 @@
 ****************************************************************************/
 
-//#define WINVER 0x0500
-#define _WIN32_WINNT 0x0400
-
-
 #include "qthread.h"
 #include "qthread_p.h"
@@ -53 +51 @@
 
 #include <private/qcoreapplication_p.h>
-#include <private/qeventdispatcher_win_p.h>
-
-#include <windows.h>
-
-
-#ifndef Q_OS_WINCE
-#ifndef _MT
-#define _MT
-#endif
-#include <process.h>
-#else
-#include "qfunctions_wince.h"
-#endif
+#include <private/qeventdispatcher_pm_p.h>
+
+#include <qt_os2.h>
 
 #ifndef QT_NO_THREAD
+
 QT_BEGIN_NAMESPACE
 
-void qt_watch_adopted_thread(const HANDLE adoptedThreadHandle, QThread *qthread);
-void qt_adopted_thread_watcher_function(void *);
-
-static DWORD qt_current_thread_data_tls_index = TLS_OUT_OF_INDEXES;
-void qt_create_tls()
-{
-    if (qt_current_thread_data_tls_index != TLS_OUT_OF_INDEXES)
+static void qt_watch_adopted_thread(const TID adoptedTID, QThread *qthread);
+static void qt_adopted_thread_watcher_function(void *);
+
+static QThreadData **qt_tls = NULL;
+
+static void qt_create_tls()
+{
+    if (qt_tls != NULL)
         return;
     static QMutex mutex;
     QMutexLocker locker(&mutex);
-    qt_current_thread_data_tls_index = TlsAlloc();
+    APIRET rc = DosAllocThreadLocalMemory((sizeof(QThreadData *) + 3)/4,
+                                          (PULONG *)&qt_tls);
+    if (rc != NO_ERROR)
+        qWarning("qt_create_tls: DosAllocThreadLocalMemory returned %lu", rc);
 }
 
 static void qt_free_tls()
 {
-    if (qt_current_thread_data_tls_index != TLS_OUT_OF_INDEXES) {
-        TlsFree(qt_current_thread_data_tls_index);
-        qt_current_thread_data_tls_index = TLS_OUT_OF_INDEXES;
-    }
-}
-Q_DESTRUCTOR_FUNCTION(qt_free_tls)
+    if (qt_tls != NULL) {
+        DosFreeThreadLocalMemory((PULONG)qt_tls);
+        qt_tls = NULL;
+    }
+}
+
+static Q_DESTRUCTOR_FUNCTION(qt_free_tls)
 
 /*
@@ -98 +92 @@
 {
     qt_create_tls();
-    QThreadData *threadData = reinterpret_cast<QThreadData *>(TlsGetValue(qt_current_thread_data_tls_index));
+    QThreadData *threadData = ;
     if (!threadData) {
         QThread *adopted = 0;
@@ -104 +98 @@
             Q_ASSERT(adopted);
             threadData = QThreadData::get2(adopted);
-            TlsSetValue(qt_current_thread_data_tls_index, threadData);
+            ;
             adopted->d_func()->running = true;
             adopted->d_func()->finished = false;
@@ -112 +106 @@
             // This needs to be called prior to new AdoptedThread() to
             // avoid recursion.
-            TlsSetValue(qt_current_thread_data_tls_index, threadData);
+            ;
             threadData->thread = new QAdoptedThread(threadData);
             threadData->deref();
@@ -120 +114 @@
             QCoreApplicationPrivate::theMainThread = threadData->thread;
         } else {
-            HANDLE realHandle = INVALID_HANDLE_VALUE;
-#if !defined(Q_OS_WINCE) || (defined(_WIN32_WCE) && (_WIN32_WCE>=0x600))
-            DuplicateHandle(GetCurrentProcess(),
-                    GetCurrentThread(),
-                    GetCurrentProcess(),
-                    &realHandle,
-                    0,
-                    FALSE,
-                    DUPLICATE_SAME_ACCESS);
-#else
-                        realHandle = (HANDLE)GetCurrentThreadId();
-#endif
-            qt_watch_adopted_thread(realHandle, threadData->thread);
+            PTIB ptib;
+            DosGetInfoBlocks(&ptib, NULL);
+            qt_watch_adopted_thread(ptib->tib_ptib2->tib2_ultid, threadData->thread);
         }
     }
@@ -140 +124 @@
 void QAdoptedThread::init()
 {
-    d_func()->handle = GetCurrentThread();
-    d_func()->id = GetCurrentThreadId();
-}
-
-static QVector<HANDLE> qt_adopted_thread_handles;
+    PTIB ptib;
+    DosGetInfoBlocks(&ptib, NULL);
+    d_func()->tid = ptib->tib_ptib2->tib2_ultid;
+}
+
+static QVector<TID> qt_adopted_thread_tids;
 static QVector<QThread *> qt_adopted_qthreads;
 static QMutex qt_adopted_thread_watcher_mutex;
-static HANDLE qt_adopted_thread_watcher_handle = 0;
-static HANDLE qt_adopted_thread_wakeup = 0;
+static  = 0;
+static H;
 
 /*! \internal
@@ -155 +140 @@
     thread if necessary.
 */
-void qt_watch_adopted_thread(const HANDLE adoptedThreadHandle, QThread *qthread)
+, QThread *qthread)
 {
     QMutexLocker lock(&qt_adopted_thread_watcher_mutex);
-    qt_adopted_thread_handles.append(adoptedThreadHandle);
+    qt_adopted_thread_);
     qt_adopted_qthreads.append(qthread);
 
     // Start watcher thread if it is not already running.
-    if (qt_adopted_thread_watcher_handle == 0) {
-        if (qt_adopted_thread_wakeup == 0) {
-            qt_adopted_thread_wakeup = QT_WA_INLINE(CreateEventW(0, false, false, 0),
-                                                    CreateEventA(0, false, false, 0));
-            qt_adopted_thread_handles.prepend(qt_adopted_thread_wakeup);
+    if (qt_adopted_thread_watcher_tid == 0) {
+        APIRET rc = DosCreateEventSem(NULL, &qt_adopted_thread_wakeup,
+                                      DCE_AUTORESET, FALSE);
+        if (rc != NO_ERROR) {
+            qWarning("qt_watch_adopted_thread: DosCreateEventSem returned %lu", rc);
+            return;
         }
 
-        qt_adopted_thread_watcher_handle =
-            (HANDLE)_beginthread(qt_adopted_thread_watcher_function, 0, NULL);
+        int tid =
+            (TID)_beginthread(qt_adopted_thread_watcher_function, NULL, 0, NULL);
+        if (tid == -1)
+            qErrnoWarning(errno, "qt_watch_adopted_thread: _beginthread failed");
+        else
+            qt_adopted_thread_watcher_tid = (TID) tid;
     } else {
-        SetEvent(qt_adopted_thread_wakeup);
+        (qt_adopted_thread_wakeup);
     }
 }
@@ -181 +171 @@
     to make sure it gets cleaned up properly.
 */
-void qt_adopted_thread_watcher_function(void *)
+void qt_adopted_thread_watcher_function(void *)
 {
     forever {
         qt_adopted_thread_watcher_mutex.lock();
 
-        if (qt_adopted_thread_handles.count() == 1) {
-            qt_adopted_thread_watcher_handle = 0;
+        if (qt_adopted_thread_tids.isEmpty()) {
+            // our service is no longer necessary
+            qt_adopted_thread_watcher_tid = 0;
+            DosCloseEventSem(qt_adopted_thread_wakeup);
+            qt_adopted_thread_wakeup = NULLHANDLE;
             qt_adopted_thread_watcher_mutex.unlock();
             break;
         }
 
-        QVector<HANDLE> handlesCopy = qt_adopted_thread_handles;
+        APIRET rc;
+        TID tid;
+
+        for (int i = 0; i < qt_adopted_thread_tids.size();) {
+            tid = qt_adopted_thread_tids.at(i);
+            rc = DosWaitThread(&tid, DCWW_NOWAIT);
+            if (rc != ERROR_THREAD_NOT_TERMINATED) {
+                if (rc == NO_ERROR || rc == ERROR_INVALID_THREADID) {
+                    QThreadData::get2(qt_adopted_qthreads.at(i))->deref();
+                    QMutexLocker lock(&qt_adopted_thread_watcher_mutex);
+                    qt_adopted_thread_tids.remove(i);
+                    qt_adopted_qthreads.remove(i);
+                    continue;
+                }
+                qWarning("qt_adopted_thread_watcher_function: DosWaitThread returned %lu", rc);
+            }
+            ++i;
+        }
+
         qt_adopted_thread_watcher_mutex.unlock();
 
-        DWORD ret = WAIT_TIMEOUT;
-        int loops = (handlesCopy.count() / MAXIMUM_WAIT_OBJECTS) + 1, offset, count;
-        if (loops == 1) {
-            // no need to loop, no timeout
-            offset = 0;
-            count = handlesCopy.count();
-            ret = WaitForMultipleObjects(handlesCopy.count(), handlesCopy.constData(), false, INFINITE);
-        } else {
-            int loop = 0;
-            do {
-                offset = loop * MAXIMUM_WAIT_OBJECTS;
-                count = qMin(handlesCopy.count() - offset, MAXIMUM_WAIT_OBJECTS);
-                ret = WaitForMultipleObjects(count, handlesCopy.constData() + offset, false, 100);
-                loop = (loop + 1) % loops;
-            } while (ret == WAIT_TIMEOUT);
+        rc = DosWaitEventSem(qt_adopted_thread_wakeup, 300);
+        if (rc != NO_ERROR && rc != ERROR_TIMEOUT) {
+            qWarning("qt_adopted_thread_watcher_function: DosWaitEventSem returned %lu", rc);
         }
-
-        if (ret == WAIT_FAILED || !(ret >= WAIT_OBJECT_0 && ret < WAIT_OBJECT_0 + uint(count))) {
-            qWarning("QThread internal error while waiting for adopted threads: %d", int(GetLastError()));
-            continue;
-        }
-
-        const int handleIndex = offset + ret - WAIT_OBJECT_0;
-        if (handleIndex == 0){
-            // New handle to watch was added.
-            continue;
-        } else {
-//             printf("(qt) - qt_adopted_thread_watcher_function... called\n");
-            const int qthreadIndex = handleIndex - 1;
-            QThreadData::get2(qt_adopted_qthreads.at(qthreadIndex))->deref();
-#if !defined(Q_OS_WINCE) || (defined(_WIN32_WCE) && (_WIN32_WCE>=0x600))
-            CloseHandle(qt_adopted_thread_handles.at(handleIndex));
-#endif
-            QMutexLocker lock(&qt_adopted_thread_watcher_mutex);
-            qt_adopted_thread_handles.remove(handleIndex);
-            qt_adopted_qthreads.remove(qthreadIndex);
-        }
-    }
-}
-
-#if !defined(QT_NO_DEBUG) && defined(Q_CC_MSVC) && !defined(Q_OS_WINCE)
-
-#ifndef Q_OS_WIN64
-#  define ULONG_PTR DWORD
-#endif
-
-typedef struct tagTHREADNAME_INFO
-{
-    DWORD dwType;      // must be 0x1000
-    LPCSTR szName;     // pointer to name (in user addr space)
-    HANDLE dwThreadID; // thread ID (-1=caller thread)
-    DWORD dwFlags;     // reserved for future use, must be zero
-} THREADNAME_INFO;
-
-void qt_set_thread_name(HANDLE threadId, LPCSTR threadName)
-{
-    THREADNAME_INFO info;
-    info.dwType = 0x1000;
-    info.szName = threadName;
-    info.dwThreadID = threadId;
-    info.dwFlags = 0;
-
-    __try
-    {
-        RaiseException(0x406D1388, 0, sizeof(info)/sizeof(DWORD), (const ULONG_PTR*)&info);
-    }
-    __except (EXCEPTION_CONTINUE_EXECUTION)
-    {
-    }
-}
-#endif // !QT_NO_DEBUG && Q_CC_MSVC && !Q_OS_WINCE
+    }
+}
 
 /**************************************************************************
@@ -275 +221 @@
 void QThreadPrivate::createEventDispatcher(QThreadData *data)
 {
-    data->eventDispatcher = new QEventDispatcherWin32;
+    data->eventDispatcher = new QEventDispatcher;
     data->eventDispatcher->startingUp();
 }
@@ -281 +227 @@
 #ifndef QT_NO_THREAD
 
-unsigned int __stdcall QThreadPrivate::start(void *arg)
+// static
+void QThreadPrivate::start(void *arg)
 {
     QThread *thr = reinterpret_cast<QThread *>(arg);
@@ -287 +234 @@
 
     qt_create_tls();
-    TlsSetValue(qt_current_thread_data_tls_index, data);
+    ;
 
     QThread::setTerminationEnabled(false);
@@ -296 +243 @@
         createEventDispatcher(data);
 
-#if !defined(QT_NO_DEBUG) && defined(Q_CC_MSVC) && !defined(Q_OS_WINCE)
-    // sets the name of the current thread.
-    QByteArray objectName = thr->objectName().toLocal8Bit();
-    qt_set_thread_name((HANDLE)-1,
-                       objectName.isEmpty() ?
-                       thr->metaObject()->className() : objectName.constData());
-#endif
-
     emit thr->started();
     QThread::setTerminationEnabled(true);
@@ -309 +248 @@
 
     finish(arg);
-    return 0;
-}
-
+}
+
+// static
 void QThreadPrivate::finish(void *arg, bool lockAnyway)
 {
@@ -336 +275 @@
     QThreadStorageData::finish(reinterpret_cast<void **>(&d->data->tls));
 
-    if (!d->waiters) {
-        CloseHandle(d->handle);
-        d->handle = 0;
-    }
-
-    d->id = 0;
+    d->tid = 0;
 
     if (lockAnyway)
@@ -353 +287 @@
 Qt::HANDLE QThread::currentThreadId()
 {
-    return (Qt::HANDLE)GetCurrentThreadId();
+    PTIB ptib;
+    DosGetInfoBlocks(&ptib, NULL);
+    return (Qt::HANDLE)ptib->tib_ptib2->tib2_ultid;
 }
 
 int QThread::idealThreadCount()
 {
-    SYSTEM_INFO sysinfo;
-    GetSystemInfo(&sysinfo);
-    return sysinfo.dwNumberOfProcessors;
+    ULONG cpuCnt = 1;
+    APIRET rc = DosQuerySysInfo(QSV_NUMPROCESSORS, QSV_NUMPROCESSORS,
+                                &cpuCnt, sizeof(cpuCnt));
+    if (rc != NO_ERROR || cpuCnt == 0)
+        cpuCnt = 1;
+    return (int) cpuCnt;
 }
 
 void QThread::yieldCurrentThread()
 {
-#ifndef Q_OS_WINCE
-    if (QSysInfo::WindowsVersion & QSysInfo::WV_NT_based)
-        SwitchToThread();
-    else
-#endif
-        ::Sleep(0);
+    DosSleep(0);
 }
 
 void QThread::sleep(unsigned long secs)
 {
-    ::Sleep(secs * 1000);
+    Sleep(secs * 1000);
 }
 
 void QThread::msleep(unsigned long msecs)
 {
-    ::Sleep(msecs);
+    Sleep(msecs);
 }
 
 void QThread::usleep(unsigned long usecs)
 {
-    ::Sleep((usecs / 1000) + 1);
-}
-
+    DosSleep((usecs / 1000) + 1);
+}
 
 void QThread::start(Priority priority)
@@ -401 +334 @@
     d->terminated = false;
 
-    /*
-      NOTE: we create the thread in the suspended state, set the
-      priority and then resume the thread.
-
-      since threads are created with normal priority by default, we
-      could get into a case where a thread (with priority less than
-      NormalPriority) tries to create a new thread (also with priority
-      less than NormalPriority), but the newly created thread preempts
-      its 'parent' and runs at normal priority.
-    */
-    d->handle = (Qt::HANDLE) _beginthreadex(NULL, d->stackSize, QThreadPrivate::start,
-                                            this, CREATE_SUSPENDED, &(d->id));
-
-    if (!d->handle) {
+    int tid = _beginthread(QThreadPrivate::start, NULL, d->stackSize, this);
+    d->tid = tid != -1 ? (TID) tid : 0;
+
+    if (tid == -1) {
         qErrnoWarning(errno, "QThread::start: Failed to create thread");
         d->running = false;
@@ -421 +344 @@
     }
 
-    // Since Win 9x will have problems if the priority is idle or time critical
-    // we have to use the closest one instead
-    int prio;
-    d->priority = priority;
-    switch (d->priority) {
-    case IdlePriority:
-        if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
-            prio = THREAD_PRIORITY_LOWEST;
-        } else {
-            prio = THREAD_PRIORITY_IDLE;
-        }
-        break;
-
-    case LowestPriority:
-        prio = THREAD_PRIORITY_LOWEST;
-        break;
-
-    case LowPriority:
-        prio = THREAD_PRIORITY_BELOW_NORMAL;
-        break;
-
-    case NormalPriority:
-        prio = THREAD_PRIORITY_NORMAL;
-        break;
-
-    case HighPriority:
-        prio = THREAD_PRIORITY_ABOVE_NORMAL;
-        break;
-
-    case HighestPriority:
-        prio = THREAD_PRIORITY_HIGHEST;
-        break;
-
-    case TimeCriticalPriority:
-        if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
-            prio = THREAD_PRIORITY_HIGHEST;
-        } else {
-            prio = THREAD_PRIORITY_TIME_CRITICAL;
-        }
-        break;
-
-    case InheritPriority:
-    default:
-        prio = GetThreadPriority(GetCurrentThread());
-        break;
-    }
-
-    if (!SetThreadPriority(d->handle, prio)) {
-        qErrnoWarning("QThread::start: Failed to set thread priority");
-    }
-
-    if (ResumeThread(d->handle) == (DWORD) -1) {
-        qErrnoWarning("QThread::start: Failed to resume new thread");
-    }
+    setPriority(priority);
 }
 
@@ -481 +351 @@
     Q_D(QThread);
     QMutexLocker locker(&d->mutex);
+
+
+
+
     if (!d->running)
         return;
@@ -487 +361 @@
         return;
     }
-    TerminateThread(d->handle, 0);
+    );
     d->terminated = true;
     QThreadPrivate::finish(this, false);
@@ -497 +371 @@
     QMutexLocker locker(&d->mutex);
 
-    if (d->id == GetCurrentThreadId()) {
+    if (d->urrentThreadId()) {
         qWarning("QThread::wait: Thread tried to wait on itself");
         return false;
@@ -504 +378 @@
         return true;
 
-    ++d->waiters;
     locker.mutex()->unlock();
 
-    bool ret = false;
-    switch (WaitForSingleObject(d->handle, time)) {
-    case WAIT_OBJECT_0:
-        ret = true;
-        break;
-    case WAIT_FAILED:
-        qErrnoWarning("QThread::wait: Thread wait failure");
-        break;
-    case WAIT_ABANDONED:
-    case WAIT_TIMEOUT:
-    default:
-        break;
+    bool ret = true;
+    TID tid = d->tid;
+    APIRET rc = NO_ERROR;
+    if (time == ULONG_MAX) {
+        rc = DosWaitThread(&tid, DCWW_WAIT);
+    } else {
+        ULONG sleep;
+        do {
+            // OS/2 doesn't support specifying a maximum time to wait for a
+            // thread to end other than infininty, so we run a loop of small
+            // wait intervals (in ms)
+            enum { THREAD_WAIT_INTERVAL = 1000 };
+            sleep = time > THREAD_WAIT_INTERVAL ? THREAD_WAIT_INTERVAL : time;
+            DosSleep(sleep);
+            rc = DosWaitThread(&tid, DCWW_NOWAIT);
+            if (rc != ERROR_THREAD_NOT_TERMINATED)
+                break;
+            if (d->finished || !d->running) {
+                rc = 0;
+                break;
+            }
+            time -= sleep;
+        } while (time);
+    }
+    if (rc != NO_ERROR && rc != ERROR_INVALID_THREADID) {
+        if (rc != ERROR_THREAD_NOT_TERMINATED)
+            qWarning("QThread::wait: DosWaitThread returned %lu", rc);
+        ret = false;
     }
 
     locker.mutex()->lock();
-    --d->waiters;
 
     if (ret && !d->finished) {
@@ -528 +416 @@
         d->terminated = true;
         QThreadPrivate::finish(this, false);
-    }
-
-    if (d->finished && !d->waiters) {
-        CloseHandle(d->handle);
-        d->handle = 0;
     }
 
@@ -550 +433 @@
         QThreadPrivate::finish(thr, false);
         locker.unlock(); // don't leave the mutex locked!
-        _endthreadex(0);
+        _endthread);
     }
 }
@@ -563 +446 @@
     }
 
-    // copied from start() with a few modifications:
-
-    // Since Win 9x will have problems if the priority is idle or time critical
-    // we have to use the closest one instead
-    int prio;
     d->priority = priority;
-    switch (d->priority) {
-    case IdlePriority:
-        if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
-            prio = THREAD_PRIORITY_LOWEST;
-        } else {
-            prio = THREAD_PRIORITY_IDLE;
-        }
-        break;
-
-    case LowestPriority:
-        prio = THREAD_PRIORITY_LOWEST;
-        break;
-
-    case LowPriority:
-        prio = THREAD_PRIORITY_BELOW_NORMAL;
-        break;
-
-    case NormalPriority:
-        prio = THREAD_PRIORITY_NORMAL;
-        break;
-
-    case HighPriority:
-        prio = THREAD_PRIORITY_ABOVE_NORMAL;
-        break;
-
-    case HighestPriority:
-        prio = THREAD_PRIORITY_HIGHEST;
-        break;
-
-    case TimeCriticalPriority:
-        if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
-            prio = THREAD_PRIORITY_HIGHEST;
-        } else {
-            prio = THREAD_PRIORITY_TIME_CRITICAL;
-        }
-        break;
-
-    case InheritPriority:
-    default:
-        qWarning("QThread::setPriority: Argument cannot be InheritPriority");
-        return;
-    }
-
-    if (!SetThreadPriority(d->handle, prio)) {
-        qErrnoWarning("QThread::setPriority: Failed to set thread priority");
-    }
+
+    ULONG prioClass = 0;
+    LONG prioDelta = 0;
+    switch (priority) {
+        case IdlePriority:
+            prioClass = PRTYC_IDLETIME;
+            prioDelta = PRTYD_MINIMUM;
+        break;
+
+        case LowestPriority:
+            prioClass = PRTYC_IDLETIME;
+            break;
+
+        case LowPriority:
+            prioClass = PRTYC_IDLETIME;
+            prioDelta = PRTYD_MAXIMUM;
+            break;
+
+        case NormalPriority:
+                prioClass = PRTYC_REGULAR;
+                break;
+
+        case HighPriority:
+            prioClass = PRTYC_REGULAR;
+            prioDelta = PRTYD_MAXIMUM;
+            break;
+
+        case HighestPriority:
+                prioClass = PRTYC_TIMECRITICAL;
+                break;
+
+        case TimeCriticalPriority:
+            prioClass = PRTYC_TIMECRITICAL;
+            prioDelta = PRTYD_MAXIMUM;
+            break;
+
+        case InheritPriority:
+        default:
+            PTIB ptib;
+            DosGetInfoBlocks( &ptib, NULL );
+            prioClass = (ptib->tib_ptib2->tib2_ulpri >> 8) & 0xFF;
+            prioDelta = (ptib->tib_ptib2->tib2_ulpri) & 0xFF;
+            break;
+    }
+
+    APIRET rc = DosSetPriority(PRTYS_THREAD, prioClass, prioDelta, d->tid);
+    if (rc != NO_ERROR)
+        qWarning("QThread::setPriority: DosSetPriority returned %lu", rc);
 }
 
 QT_END_NAMESPACE
+
 #endif // QT_NO_THREAD

trunk/src/corelib/thread/qthread_p.h

@@ -62 +62 @@
 #include "QtCore/qmap.h"
 #include "private/qobject_p.h"
+
+
+
+
 
 QT_BEGIN_NAMESPACE
@@ -172 +176 @@
 #endif // Q_OS_WIN32
 
+
+
+
+
+
+
+
+
     QThreadData *data;
 

trunk/src/corelib/thread/thread.pri

@@ -9 +9 @@
            thread/qwaitcondition.h \
            thread/qatomic.h
-        
+
 # private headers
 HEADERS += thread/qmutex_p.h \
@@ -23 +23 @@
            thread/qsemaphore.cpp \
            thread/qthread.cpp \
-           thread/qthreadstorage.cpp 
+           thread/qthreadstorage.cpp
 
 unix:SOURCES += thread/qmutex_unix.cpp \
@@ -32 +32 @@
                  thread/qthread_win.cpp \
                  thread/qwaitcondition_win.cpp
+
+
+
+