Changeset 6a44ee4 in mainline for kernel/generic/src/proc

Timestamp:

2011-07-20T15:26:21Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

efcebe1

Parents:

25bef0ff (diff), a701812 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

kernel/generic/src/proc

Files:

• scheduler.c (modified) (8 diffs)
• task.c (modified) (3 diffs)
• thread.c (modified) (6 diffs)

kernel/generic/src/proc/scheduler.c

@@ -237 +237 @@
                  * Take the first thread from the queue.
                  */
-                thread_t *thread =
-                    list_get_instance(CPU->rq[i].rq_head.next, thread_t, rq_link);
+                thread_t *thread = list_get_instance(
+                    list_first(&CPU->rq[i].rq), thread_t, rq_link);
                 list_remove(&thread->rq_link);
                 
@@ -273 +273 @@
 static void relink_rq(int start)
 {
-        link_t head;
-        
-        list_initialize(&head);
+        list_t list;
+        
+        list_initialize(&list);
         irq_spinlock_lock(&CPU->lock, false);
         
@@ -284 +284 @@
                         
                         irq_spinlock_lock(&CPU->rq[i + 1].lock, false);
-                        list_concat(&head, &CPU->rq[i + 1].rq_head);
+                        list_concat(&list, &CPU->rq[i + 1].rq);
                         size_t n = CPU->rq[i + 1].n;
                         CPU->rq[i + 1].n = 0;
@@ -292 +292 @@
                         
                         irq_spinlock_lock(&CPU->rq[i].lock, false);
-                        list_concat(&CPU->rq[i].rq_head, &head);
+                        list_concat(&CPU->rq[i].rq, &list);
                         CPU->rq[i].n += n;
                         irq_spinlock_unlock(&CPU->rq[i].lock, false);
@@ -586 +586 @@
          * Searching least priority queues on all CPU's first and most priority
          * queues on all CPU's last.
-         *
          */
         size_t acpu;
@@ -617 +616 @@
                         
                         /* Search rq from the back */
-                        link_t *link = cpu->rq[rq].rq_head.prev;
-                        
-                        while (link != &(cpu->rq[rq].rq_head)) {
-                                thread = (thread_t *) list_get_instance(link, thread_t, rq_link);
+                        link_t *link = cpu->rq[rq].rq.head.prev;
+                        
+                        while (link != &(cpu->rq[rq].rq.head)) {
+                                thread = (thread_t *) list_get_instance(link,
+                                    thread_t, rq_link);
                                 
                                 /*
-                                 * We don't want to steal CPU-wired threads
-                                 * neither threads already stolen. The latter
-                                 * prevents threads from migrating between CPU's
-                                 * without ever being run. We don't want to
-                                 * steal threads whose FPU context is still in
-                                 * CPU.
-                                 *
+                                 * Do not steal CPU-wired threads, threads
+                                 * already stolen, threads for which migration
+                                 * was temporarily disabled or threads whose
+                                 * FPU context is still in the CPU.
                                  */
                                 irq_spinlock_lock(&thread->lock, false);
                                 
-                                if ((!(thread->flags & (THREAD_FLAG_WIRED | THREAD_FLAG_STOLEN)))
-                                    && (!(thread->fpu_context_engaged))) {
+                                if (!(thread->flags & THREAD_FLAG_WIRED) &&
+                                    !(thread->flags & THREAD_FLAG_STOLEN) &&
+                                    !thread->nomigrate &&
+                                    !thread->fpu_context_engaged) {
                                         /*
                                          * Remove thread from ready queue.
                                          */
-                                        irq_spinlock_unlock(&thread->lock, false);
+                                        irq_spinlock_unlock(&thread->lock,
+                                            false);
                                         
                                         atomic_dec(&cpu->nrdy);
@@ -660 +660 @@
                                  */
                                 
-                                irq_spinlock_pass(&(cpu->rq[rq].lock), &thread->lock);
+                                irq_spinlock_pass(&(cpu->rq[rq].lock),
+                                    &thread->lock);
                                 
 #ifdef KCPULB_VERBOSE
@@ -739 +740 @@
                         
                         printf("\trq[%u]: ", i);
-                        link_t *cur;
-                        for (cur = cpus[cpu].rq[i].rq_head.next;
-                            cur != &(cpus[cpu].rq[i].rq_head);
-                            cur = cur->next) {
-                                thread_t *thread = list_get_instance(cur, thread_t, rq_link);
+                        list_foreach(cpus[cpu].rq[i].rq, cur) {
+                                thread_t *thread = list_get_instance(cur,
+                                    thread_t, rq_link);
                                 printf("%" PRIu64 "(%s) ", thread->tid,
                                     thread_states[thread->state]);

kernel/generic/src/proc/task.c

@@ -155 +155 @@
         mutex_initialize(&task->futexes_lock, MUTEX_PASSIVE);
         
-        list_initialize(&task->th_head);
-        list_initialize(&task->sync_box_head);
+        list_initialize(&task->threads);
+        list_initialize(&task->sync_boxes);
         
         ipc_answerbox_init(&task->answerbox, task);
@@ -435 +435 @@
         
         /* Current values of threads */
-        link_t *cur;
-        for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
+        list_foreach(task->threads, cur) {
                 thread_t *thread = list_get_instance(cur, thread_t, th_link);
                 
@@ -468 +467 @@
          */
         
-        link_t *cur;
-        for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
+        list_foreach(task->threads, cur) {
                 thread_t *thread = list_get_instance(cur, thread_t, th_link);
                 bool sleeping = false;

kernel/generic/src/proc/thread.c

@@ -55 +55 @@
 #include <time/clock.h>
 #include <time/timeout.h>
+#include <time/delay.h>
 #include <config.h>
 #include <arch/interrupt.h>
@@ -259 +260 @@
          */
         
-        list_append(&thread->rq_link, &cpu->rq[i].rq_head);
+        list_append(&thread->rq_link, &cpu->rq[i].rq);
         cpu->rq[i].n++;
         irq_spinlock_unlock(&(cpu->rq[i].lock), true);
@@ -321 +322 @@
         thread->cpu = NULL;
         thread->flags = flags;
+        thread->nomigrate = 0;
         thread->state = Entering;
         
@@ -421 +423 @@
                 atomic_inc(&task->lifecount);
         
-        list_append(&thread->th_link, &task->th_head);
+        list_append(&thread->th_link, &task->threads);
         
         irq_spinlock_pass(&task->lock, &threads_lock);
@@ -481 +483 @@
         /* Not reached */
         while (true);
+}
+
+/** Prevent the current thread from being migrated to another processor. */
+void thread_migration_disable(void)
+{
+        ASSERT(THREAD);
+
+        THREAD->nomigrate++;
+}
+
+/** Allow the current thread to be migrated to another processor. */
+void thread_migration_enable(void)
+{
+        ASSERT(THREAD);
+        ASSERT(THREAD->nomigrate > 0);
+
+        THREAD->nomigrate--;
 }
 
@@ -912 +931 @@
 }
 
+sysarg_t sys_thread_udelay(uint32_t usec)
+{
+        delay(usec);
+        return 0;
+}
+
 /** @}
  */