Changeset 846 for trunk/src/corelib/thread/qthread_unix.cpp

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/corelib/thread/qthread_unix.cpp (modified) (18 diffs)

trunk/src/corelib/thread/qthread_unix.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
@@ -93 +93 @@
 #endif
 
+
+
+
+
+
+
+
+
+
+
 QT_BEGIN_NAMESPACE
 
 #ifndef QT_NO_THREAD
+
+
 
 static pthread_once_t current_thread_data_once = PTHREAD_ONCE_INIT;
@@ -130 +142 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 QThreadData *QThreadData::current()
 {
-    pthread_once(&current_thread_data_once, create_current_thread_data_key);
-
-    QThreadData *data = reinterpret_cast<QThreadData *>(pthread_getspecific(current_thread_data_key));
+    QThreadData *data = get_thread_data();
     if (!data) {
         void *a;
@@ -141 +204 @@
             Q_ASSERT(adopted);
             data = QThreadData::get2(adopted);
-            pthread_setspecific(current_thread_data_key, data);
+            data);
             adopted->d_func()->running = true;
             adopted->d_func()->finished = false;
@@ -147 +210 @@
         } else {
             data = new QThreadData;
-            pthread_setspecific(current_thread_data_key, data);
             QT_TRY {
+
                 data->thread = new QAdoptedThread(data);
             } QT_CATCH(...) {
-                pthread_setspecific(current_thread_data_key, 0);
+                );
                 data->deref();
                 data = 0;
@@ -170 +233 @@
     d->thread_id = pthread_self();
 #ifdef Q_OS_SYMBIAN
-    d->data->symbian_thread_handle = RThread();
-    TThreadId threadId = d->data->symbian_thread_handle.Id();
-    d->data->symbian_thread_handle.Open(threadId);
+    init_symbian_thread_handle(d->data->symbian_thread_handle);
 #endif
 }
@@ -222 +283 @@
     QThreadData *data = QThreadData::get2(thr);
 
+
+
+
+
+
 #ifdef Q_OS_SYMBIAN
     // Because Symbian Open C does not provide a way to convert between
@@ -227 +293 @@
     // handle when creating a thread, until we are running in the new thread.
     // Here, we pick up the current thread and assign that to the handle.
-    data->symbian_thread_handle = RThread();
-    TThreadId threadId = data->symbian_thread_handle.Id();
-    data->symbian_thread_handle.Open(threadId);
-#endif
-
-    pthread_once(&current_thread_data_once, create_current_thread_data_key);
-    pthread_setspecific(current_thread_data_key, data);
+    init_symbian_thread_handle(data->symbian_thread_handle);
+
+    // On symbian, threads other than the main thread are non critical by default
+    // This means a worker thread can crash without crashing the application - to
+    // use this feature, we would need to use RThread::Logon in the main thread
+    // to catch abnormal thread exit and emit the finished signal.
+    // For the sake of cross platform consistency, we set the thread as process critical
+    // - advanced users who want the symbian behaviour can change the critical
+    // attribute of the thread again once the app gains control in run()
+    User::SetCritical(User::EProcessCritical);
+#endif
+
+    set_thread_data(data);
 
     data->ref();
@@ -437 +509 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 void QThread::start(Priority priority)
 {
@@ -447 +552 @@
     d->finished = false;
     d->terminated = false;
+
+
 
     pthread_attr_t attr;
@@ -454 +561 @@
     d->priority = priority;
 
-#if defined(Q_OS_DARWIN) || !defined(Q_OS_OPENBSD) && !defined(Q_OS_SYMBIAN) && defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING-0 >= 0)
+#if defined(Q)
 // ### Need to implement thread sheduling and priorities for symbian os. Implementation removed for now
     switch (priority) {
@@ -473 +580 @@
             }
 
-            int prio_min = sched_get_priority_min(sched_policy);
-            int prio_max = sched_get_priority_max(sched_policy);
-            if (prio_min == -1 || prio_max == -1) {
+            int prio;
+            if (!calculateUnixPriority(priority, &sched_policy, &prio)) {
                 // failed to get the scheduling parameters, don't
                 // bother setting the priority
@@ -482 +588 @@
             }
 
-            int prio;
-            switch (priority) {
-            case IdlePriority:
-                prio = prio_min;
-                break;
-
-            case TimeCriticalPriority:
-                prio = prio_max;
-                break;
-
-            default:
-                // crudely scale our priority enum values to the prio_min/prio_max
-                prio = (priority * (prio_max - prio_min) / TimeCriticalPriority) + prio_min;
-                prio = qMax(prio_min, qMin(prio_max, prio));
-                break;
-            }
-
             sched_param sp;
             sp.sched_priority = prio;
@@ -506 +595 @@
                 || pthread_attr_setschedparam(&attr, &sp) != 0) {
                 // could not set scheduling hints, fallback to inheriting them
+
                 pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
+
             }
             break;
         }
     }
-#endif // _POSIX_THREAD_PRIORITY_SCHEDULING
+#endif // _THREAD_PRIORITY_SCHEDULING
 
 #ifdef Q_OS_SYMBIAN
@@ -617 +708 @@
 
     while (d->running) {
+
+
+
+
+
+
+
+
+
+
+
+
         if (!d->thread_done.wait(locker.mutex(), time))
             return false;
@@ -662 +765 @@
     // copied from start() with a few modifications:
 
-#if defined(Q_OS_DARWIN) || !defined(Q_OS_OPENBSD) && defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING-0 >= 0)
+#if
     int sched_policy;
     sched_param param;
@@ -673 +776 @@
     }
 
-    int prio_min = sched_get_priority_min(sched_policy);
-    int prio_max = sched_get_priority_max(sched_policy);
-    if (prio_min == -1 || prio_max == -1) {
+    int prio;
+    if (!calculateUnixPriority(priority, &sched_policy, &prio)) {
         // failed to get the scheduling parameters, don't
         // bother setting the priority
@@ -682 +784 @@
     }
 
-    int prio;
-    switch (priority) {
-    case InheritPriority:
-        qWarning("QThread::setPriority: Argument cannot be InheritPriority");
-        return;
-
-    case IdlePriority:
-        prio = prio_min;
-        break;
-
-    case TimeCriticalPriority:
-        prio = prio_max;
-        break;
-
-    default:
-        // crudely scale our priority enum values to the prio_min/prio_max
-        prio = (priority * (prio_max - prio_min) / TimeCriticalPriority) + prio_min;
-        prio = qMax(prio_min, qMin(prio_max, prio));
-        break;
-    }
-
     param.sched_priority = prio;
-    pthread_setschedparam(d->thread_id, sched_policy, &param);
+    int status = pthread_setschedparam(d->thread_id, sched_policy, &param);
+
+# ifdef SCHED_IDLE
+    // were we trying to set to idle priority and failed?
+    if (status == -1 && sched_policy == SCHED_IDLE && errno == EINVAL) {
+        // reset to lowest priority possible
+        pthread_getschedparam(d->thread_id, &sched_policy, &param);
+        param.sched_priority = sched_get_priority_min(sched_policy);
+        pthread_setschedparam(d->thread_id, sched_policy, &param);
+    }
+# else
+    Q_UNUSED(status);
+# endif // SCHED_IDLE
 #endif
 }