Changeset 518dd43 in mainline

Timestamp:

2012-07-06T13:06:44Z (12 years ago)

Author:

Adam Hraska <adam.hraska+hos@…>

Branches:

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

Children:

8a64e81e

Parents:

46a5b37

Message:

thread: thread_ready() new prefers cpus where thread last ran. Added thread_interrupt().

Location:

kernel/generic

Files:

• include/proc/thread.h (modified) (1 diff)
• src/proc/thread.c (modified) (2 diffs)

kernel/generic/include/proc/thread.h

@@ -217 +217 @@
 extern void thread_ready(thread_t *);
 extern void thread_exit(void) __attribute__((noreturn));
+extern void thread_interrupt(thread_t *);
+extern bool thread_interrupted(thread_t *);
 
 #ifndef thread_create_arch

kernel/generic/src/proc/thread.c

@@ -272 +272 @@
         
         ASSERT(thread->state != Ready);
-        
+
         int i = (thread->priority < RQ_COUNT - 1) ?
             ++thread->priority : thread->priority;
-        
-        cpu_t *cpu;
-        if (thread->wired || thread->nomigrate || thread->fpu_context_engaged) {
-                ASSERT(thread->cpu != NULL);
-                cpu = thread->cpu;
-        } else
+
+        /* Check that thread->cpu is set whenever it needs to be. */
+        ASSERT(thread->cpu != NULL || 
+                (!thread->wired && !thread->nomigrate && !thread->fpu_context_engaged));
+
+        /* 
+         * Prefer to run on the same cpu as the last time. Used by wired 
+         * threads as well as threads with disabled migration.
+         */
+        cpu_t *cpu = thread->cpu;
+        if (cpu == NULL) 
                 cpu = CPU;
         
@@ -518 +523 @@
         /* Not reached */
         while (true);
+}
+
+/** Interrupts an existing thread so that it may exit as soon as possible.
+ * 
+ * Threads that are blocked waiting for a synchronization primitive 
+ * are woken up with a return code of ESYNCH_INTERRUPTED if the
+ * blocking call was interruptable. See waitq_sleep_timeout().
+ * 
+ * The caller must guarantee the thread object is valid during the entire
+ * function, eg by holding the threads_lock lock.
+ * 
+ * Interrupted threads automatically exit when returning back to user space.
+ * 
+ * @param thread A valid thread object. The caller must guarantee it
+ *               will remain valid until thread_interrupt() exits.
+ */
+void thread_interrupt(thread_t *thread)
+{
+        ASSERT(thread != NULL);
+        
+        irq_spinlock_lock(&thread->lock, true);
+        
+        thread->interrupted = true;
+        bool sleeping = (thread->state == Sleeping);
+        
+        irq_spinlock_unlock(&thread->lock, true);
+        
+        if (sleeping)
+                waitq_interrupt_sleep(thread);
+}
+
+/** Returns true if the thread was interrupted.
+ * 
+ * @param thread A valid thread object. User must guarantee it will
+ *               be alive during the entire call.
+ * @return true if the thread was already interrupted via thread_interrupt().
+ */
+bool thread_interrupted(thread_t *thread)
+{
+        ASSERT(thread != NULL);
+        
+        bool interrupted;
+        
+        irq_spinlock_lock(&thread->lock, true);
+        interrupted = thread->interrupted;
+        irq_spinlock_unlock(&thread->lock, true);
+        
+        return interrupted;
 }