Changes in / [b9c7425:bc7d44c] in mainline

Files:

• kernel/generic/include/ipc/sysipc.h (modified) (1 diff)
• kernel/generic/include/synch/waitq.h (modified) (1 diff)
• kernel/generic/include/syscall/syscall.h (modified) (1 diff)
• kernel/generic/src/ipc/sysipc.c (modified) (2 diffs)
• kernel/generic/src/synch/waitq.c (modified) (1 diff)
• kernel/generic/src/syscall/syscall.c (modified) (1 diff)
• uspace/app/trace/syscalls.c (modified) (1 diff)
• uspace/lib/libc/generic/async.c (modified) (3 diffs)
• uspace/lib/libc/generic/fibril_sync.c (modified) (5 diffs)
• uspace/lib/libc/generic/ipc.c (modified) (1 diff)
• uspace/lib/libc/include/async.h (modified) (1 diff)
• uspace/lib/libc/include/ipc/ipc.h (modified) (1 diff)

kernel/generic/include/ipc/sysipc.h

@@ -52 +52 @@
 unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
     int nonblocking);
+unative_t sys_ipc_poke(void);
 unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
     unative_t method, unative_t arg1, unative_t arg2, int mode);

kernel/generic/include/synch/waitq.h

@@ -68 +68 @@
 struct thread;
 
-extern void waitq_initialize(waitq_t *wq);
-extern int waitq_sleep_timeout(waitq_t *wq, uint32_t usec, int flags);
-extern ipl_t waitq_sleep_prepare(waitq_t *wq);
-extern int waitq_sleep_timeout_unsafe(waitq_t *wq, uint32_t usec, int flags);
-extern void waitq_sleep_finish(waitq_t *wq, int rc, ipl_t ipl);
-extern void waitq_wakeup(waitq_t *wq, wakeup_mode_t mode);
-extern void _waitq_wakeup_unsafe(waitq_t *wq, wakeup_mode_t mode);
-extern void waitq_interrupt_sleep(struct thread *t);
+extern void waitq_initialize(waitq_t *);
+extern int waitq_sleep_timeout(waitq_t *, uint32_t, int);
+extern ipl_t waitq_sleep_prepare(waitq_t *);
+extern int waitq_sleep_timeout_unsafe(waitq_t *, uint32_t, int);
+extern void waitq_sleep_finish(waitq_t *, int, ipl_t);
+extern void waitq_wakeup(waitq_t *, wakeup_mode_t);
+extern void _waitq_wakeup_unsafe(waitq_t *, wakeup_mode_t);
+extern void waitq_interrupt_sleep(struct thread *);
+extern void waitq_unsleep(waitq_t *);
 
 #endif

kernel/generic/include/syscall/syscall.h

@@ -66 +66 @@
         SYS_IPC_FORWARD_SLOW,
         SYS_IPC_WAIT,
+        SYS_IPC_POKE,
         SYS_IPC_HANGUP,
         SYS_IPC_REGISTER_IRQ,

kernel/generic/src/ipc/sysipc.c

@@ -44 +44 @@
 #include <ipc/ipcrsc.h>
 #include <ipc/kbox.h>
+#include <synch/waitq.h>
 #include <udebug/udebug_ipc.h>
 #include <arch/interrupt.h>
@@ -1051 +1052 @@
 }
 
+/** Interrupt one thread from sys_ipc_wait_for_call(). */
+unative_t sys_ipc_poke(void)
+{
+        waitq_unsleep(&TASK->answerbox.wq);     
+        return EOK;
+}
+
 /** Connect an IRQ handler to a task.
  *

kernel/generic/src/synch/waitq.c

@@ -171 +171 @@
 out:
         spinlock_unlock(&threads_lock);
+        interrupts_restore(ipl);
+}
+
+/** Interrupt the first thread sleeping in the wait queue.
+ *
+ * Note that the caller somehow needs to know that the thread to be interrupted
+ * is sleeping interruptibly.
+ *
+ * @param wq            Pointer to wait queue.
+ */
+void waitq_unsleep(waitq_t *wq)
+{
+        ipl_t ipl;
+
+        ipl = interrupts_disable();
+        spinlock_lock(&wq->lock);
+
+        if (!list_empty(&wq->head)) {
+                thread_t *t;
+                
+                t = list_get_instance(wq->head.next, thread_t, wq_link);
+                spinlock_lock(&t->lock);
+                ASSERT(t->sleep_interruptible);
+                if (t->timeout_pending && timeout_unregister(&t->sleep_timeout))
+                        t->timeout_pending = false;
+                list_remove(&t->wq_link);
+                t->saved_context = t->sleep_interruption_context;
+                t->sleep_queue = NULL;
+                spinlock_unlock(&t->lock);
+                thread_ready(t);
+        }
+
+        spinlock_unlock(&wq->lock);
         interrupts_restore(ipl);
 }

kernel/generic/src/syscall/syscall.c

@@ -137 +137 @@
         (syshandler_t) sys_ipc_forward_slow,
         (syshandler_t) sys_ipc_wait_for_call,
+        (syshandler_t) sys_ipc_poke,
         (syshandler_t) sys_ipc_hangup,
         (syshandler_t) sys_ipc_register_irq,

uspace/app/trace/syscalls.c

@@ -62 +62 @@
     [SYS_IPC_FORWARD_SLOW] = { "ipc_forward_slow",      3,      V_ERRNO },
     [SYS_IPC_WAIT] = { "ipc_wait_for_call",             3,      V_HASH },
+    [SYS_IPC_POKE] = { "ipc_poke",                      0,      V_ERRNO },
     [SYS_IPC_HANGUP] = { "ipc_hangup",                  1,      V_ERRNO },
     [SYS_IPC_REGISTER_IRQ] = { "ipc_register_irq",      4,      V_ERRNO },

uspace/lib/libc/generic/async.c

@@ -106 +106 @@
 
 atomic_t async_futex = FUTEX_INITIALIZER;
+
+/** Number of threads waiting for IPC in the kernel. */
+atomic_t threads_in_ipc_wait = { 0 };
 
 /** Structures of this type represent a waiting fibril. */
@@ -683 +686 @@
                 
                 futex_up(&async_futex);
+
+                atomic_inc(&threads_in_ipc_wait);
                 
                 ipc_call_t call;
@@ -688 +693 @@
                     SYNCH_FLAGS_NONE);
                 
+                atomic_dec(&threads_in_ipc_wait);
+
                 if (!callid) {
                         handle_expired_timeouts();

uspace/lib/libc/generic/fibril_sync.c

@@ -40 +40 @@
 #include <assert.h>
 
+static void optimize_execution_power(void)
+{
+        /*
+         * When waking up a worker fibril previously blocked in fibril
+         * synchronization, chances are that there is an idle manager fibril
+         * waiting for IPC, that could start executing the awakened worker
+         * fibril right away. We try to detect this and bring the manager
+         * fibril back to fruitful work.
+         */
+        if (atomic_get(&threads_in_ipc_wait) > 0)
+                ipc_poke();
+}
+
 void fibril_mutex_initialize(fibril_mutex_t *fm)
 {
@@ -84 +97 @@
                 list_remove(&f->link);
                 fibril_add_ready((fid_t) f);
+                optimize_execution_power();
         }
 }
@@ -152 +166 @@
                         fibril_add_ready((fid_t) f);
                         frw->writers++;
+                        optimize_execution_power();
                         break;
                 } else {
@@ -157 +172 @@
                         fibril_add_ready((fid_t) f);
                         frw->readers++;
+                        optimize_execution_power();
                 }
         }
@@ -200 +216 @@
                 list_remove(&f->link);
                 fibril_add_ready((fid_t) f);
+                optimize_execution_power();
                 if (once)
                         break;

uspace/lib/libc/generic/ipc.c

@@ -565 +565 @@
 }
 
+/** Interrupt one thread of this task from waiting for IPC. */
+void ipc_poke(void)
+{
+        __SYSCALL0(SYS_IPC_POKE);
+}
+
 /** Ask destination to do a callback connection.
  *

uspace/lib/libc/include/async.h

@@ -47 +47 @@
 extern atomic_t async_futex;
 
+extern atomic_t threads_in_ipc_wait;
+
 extern int __async_init(void);
 extern ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs);

uspace/lib/libc/include/ipc/ipc.h

@@ -192 +192 @@
 extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, uint32_t, int);
 extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, uint32_t);
+extern void ipc_poke(void);
 
 static inline ipc_callid_t ipc_wait_for_call(ipc_call_t *data)