Changes in uspace/lib/c/generic/fibril.c [6aeca0d:eceff5f] in mainline

File:

• uspace/lib/c/generic/fibril.c (modified) (13 diffs)

uspace/lib/c/generic/fibril.c

@@ -50 +50 @@
 #include <async.h>
 
-#ifdef FUTEX_UPGRADABLE
-#include <rcu.h>
-#endif
-
 /**
  * This futex serializes access to ready_list,
- * manager_list and fibril_list.
- */
-static futex_t fibril_futex = FUTEX_INITIALIZER;
+ * serialized_list and manager_list.
+ */
+static atomic_t fibril_futex = FUTEX_INITIALIZER;
 
 static LIST_INITIALIZE(ready_list);
+static LIST_INITIALIZE(serialized_list);
 static LIST_INITIALIZE(manager_list);
-static LIST_INITIALIZE(fibril_list);
+
+/** Number of threads that are executing a manager fibril. */
+static int threads_in_manager;
+
+/**
+ * Number of threads that are executing a manager fibril
+ * and are serialized. Protected by async_futex.
+ */
+static int serialized_threads;
+
+/** Fibril-local count of serialization. If > 0, we must not preempt */
+static fibril_local int serialization_count;
 
 /** Function that spans the whole life-cycle of a fibril.
@@ -74 +82 @@
 {
         fibril_t *fibril = __tcb_get()->fibril_data;
-
-#ifdef FUTEX_UPGRADABLE
-        rcu_register_fibril();
-#endif
         
         /* Call the implementing function. */
         fibril->retval = fibril->func(fibril->arg);
         
-        futex_down(&async_futex);
         fibril_switch(FIBRIL_FROM_DEAD);
         /* Not reached */
@@ -113 +116 @@
         
         fibril->waits_for = NULL;
-
-        fibril->switches = 0;
-
-        /*
-         * We are called before __tcb_set(), so we need to use
-         * futex_down/up() instead of futex_lock/unlock() that
-         * may attempt to access TLS.
-         */
-        futex_down(&fibril_futex);
-        list_append(&fibril->all_link, &fibril_list);
-        futex_up(&fibril_futex);
         
         return fibril;
 }
 
-void fibril_teardown(fibril_t *fibril, bool locked)
-{       
-        if (!locked)
-                futex_lock(&fibril_futex);
-        list_remove(&fibril->all_link);
-        if (!locked)
-                futex_unlock(&fibril_futex);
+void fibril_teardown(fibril_t *fibril)
+{
         tls_free(fibril->tcb);
         free(fibril);
@@ -141 +128 @@
 /** Switch from the current fibril.
  *
- * If stype is FIBRIL_TO_MANAGER or FIBRIL_FROM_DEAD, the async_futex must
- * be held.
+ * If calling with FIBRIL_TO_MANAGER parameter, the async_futex should be
+ * held.
  *
  * @param stype Switch type. One of FIBRIL_PREEMPT, FIBRIL_TO_MANAGER,
@@ -154 +141 @@
 int fibril_switch(fibril_switch_type_t stype)
 {
-        futex_lock(&fibril_futex);
-
-        switch (stype) {
-        case FIBRIL_PREEMPT:
-        case FIBRIL_FROM_MANAGER:
-                if (list_empty(&ready_list)) {
-                        futex_unlock(&fibril_futex);
-                        return 0;
-                }
-                break;
-        case FIBRIL_TO_MANAGER:
-        case FIBRIL_FROM_DEAD:
-                /* Make sure the async_futex is held. */
-                assert((atomic_signed_t) async_futex.val.count <= 0);
-
-                /* If we are going to manager and none exists, create it */
+        int retval = 0;
+        
+        futex_down(&fibril_futex);
+        
+        if (stype == FIBRIL_PREEMPT && list_empty(&ready_list))
+                goto ret_0;
+        
+        if (stype == FIBRIL_FROM_MANAGER) {
+                if ((list_empty(&ready_list)) && (list_empty(&serialized_list)))
+                        goto ret_0;
+                
+                /*
+                 * Do not preempt if there is not enough threads to run the
+                 * ready fibrils which are not serialized.
+                 */
+                if ((list_empty(&serialized_list)) &&
+                    (threads_in_manager <= serialized_threads)) {
+                        goto ret_0;
+                }
+        }
+        
+        /* If we are going to manager and none exists, create it */
+        if ((stype == FIBRIL_TO_MANAGER) || (stype == FIBRIL_FROM_DEAD)) {
                 while (list_empty(&manager_list)) {
-                        futex_unlock(&fibril_futex);
+                        futex_up(&fibril_futex);
                         async_create_manager();
-                        futex_lock(&fibril_futex);
-                }
-                break;
+                        futex_down(&fibril_futex);
+                }
         }
         
@@ -183 +176 @@
                 /* Save current state */
                 if (!context_save(&srcf->ctx)) {
+                        if (serialization_count)
+                                srcf->flags &= ~FIBRIL_SERIALIZED;
+                        
                         if (srcf->clean_after_me) {
                                 /*
@@ -200 +196 @@
                                         as_area_destroy(stack);
                                 }
-                                fibril_teardown(srcf->clean_after_me, true);
+                                fibril_teardown(srcf->clean_after_me);
                                 srcf->clean_after_me = NULL;
                         }
                         
-                        return 1;       /* futex_unlock already done here */
+                        return 1;       /* futex_up already done here */
                 }
                 
-                /* Put the current fibril into the correct run list */
-                switch (stype) {
-                case FIBRIL_PREEMPT:
+                /* Save myself to the correct run list */
+                if (stype == FIBRIL_PREEMPT)
                         list_append(&srcf->link, &ready_list);
-                        break;
-                case FIBRIL_FROM_MANAGER:
+                else if (stype == FIBRIL_FROM_MANAGER) {
                         list_append(&srcf->link, &manager_list);
-                        break;
-                default:
-                        assert(stype == FIBRIL_TO_MANAGER);
-
-                        srcf->switches++;
-
+                        threads_in_manager--;
+                } else {
                         /*
-                         * Don't put the current fibril into any list, it should
-                         * already be somewhere, or it will be lost.
+                         * If stype == FIBRIL_TO_MANAGER, don't put ourselves to
+                         * any list, we should already be somewhere, or we will
+                         * be lost.
                          */
-                        break;
-                }
-        }
-        
+                }
+        }
+        
+        /* Choose a new fibril to run */
         fibril_t *dstf;
-
-        /* Choose a new fibril to run */
-        switch (stype) {
-        case FIBRIL_TO_MANAGER:
-        case FIBRIL_FROM_DEAD:
+        if ((stype == FIBRIL_TO_MANAGER) || (stype == FIBRIL_FROM_DEAD)) {
                 dstf = list_get_instance(list_first(&manager_list), fibril_t,
                     link);
+                if (serialization_count && stype == FIBRIL_TO_MANAGER) {
+                        serialized_threads++;
+                        srcf->flags |= FIBRIL_SERIALIZED;
+                }
+                threads_in_manager++;
                 
                 if (stype == FIBRIL_FROM_DEAD) 
                         dstf->clean_after_me = srcf;
-                break;
-        default:
-                dstf = list_get_instance(list_first(&ready_list), fibril_t,
-                    link);
-                break;
-        }
-
+        } else {
+                if (!list_empty(&serialized_list)) {
+                        dstf = list_get_instance(list_first(&serialized_list),
+                            fibril_t, link);
+                        serialized_threads--;
+                } else {
+                        dstf = list_get_instance(list_first(&ready_list),
+                            fibril_t, link);
+                }
+        }
         list_remove(&dstf->link);
         
-        futex_unlock(&fibril_futex);
-        
-#ifdef FUTEX_UPGRADABLE
-        if (stype == FIBRIL_FROM_DEAD) {
-                rcu_deregister_fibril();
-        }
-#endif
-        
+        futex_up(&fibril_futex);
         context_restore(&dstf->ctx);
         /* not reached */
+        
+ret_0:
+        futex_up(&fibril_futex);
+        return retval;
 }
 
@@ -279 +271 @@
         size_t stack_size = (stksz == FIBRIL_DFLT_STK_SIZE) ?
             stack_size_get() : stksz;
-        fibril->stack = as_area_create(AS_AREA_ANY, stack_size,
+        fibril->stack = as_area_create((void *) -1, stack_size,
             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |
-            AS_AREA_LATE_RESERVE, AS_AREA_UNPAGED);
+            AS_AREA_LATE_RESERVE);
         if (fibril->stack == (void *) -1) {
-                fibril_teardown(fibril, false);
+                fibril_teardown(fibril);
                 return 0;
         }
@@ -310 +302 @@
         
         as_area_destroy(fibril->stack);
-        fibril_teardown(fibril, false);
+        fibril_teardown(fibril);
 }
 
@@ -323 +315 @@
         fibril_t *fibril = (fibril_t *) fid;
         
-        futex_lock(&fibril_futex);
-        list_append(&fibril->link, &ready_list);
-        futex_unlock(&fibril_futex);
+        futex_down(&fibril_futex);
+        
+        if ((fibril->flags & FIBRIL_SERIALIZED))
+                list_append(&fibril->link, &serialized_list);
+        else
+                list_append(&fibril->link, &ready_list);
+        
+        futex_up(&fibril_futex);
 }
 
@@ -338 +335 @@
         fibril_t *fibril = (fibril_t *) fid;
         
-        futex_lock(&fibril_futex);
+        futex_down(&fibril_futex);
         list_append(&fibril->link, &manager_list);
-        futex_unlock(&fibril_futex);
+        futex_up(&fibril_futex);
 }
 
@@ -346 +343 @@
 void fibril_remove_manager(void)
 {
-        futex_lock(&fibril_futex);
+        futex_down(&fibril_futex);
+        
         if (!list_empty(&manager_list))
                 list_remove(list_first(&manager_list));
-        futex_unlock(&fibril_futex);
+        
+        futex_up(&fibril_futex);
 }
 
@@ -362 +361 @@
 }
 
+/** Disable preemption
+ *
+ * If the fibril wants to send several message in a row and does not want to be
+ * preempted, it should start async_serialize_start() in the beginning of
+ * communication and async_serialize_end() in the end. If it is a true
+ * multithreaded application, it should protect the communication channel by a
+ * futex as well.
+ *
+ */
+void fibril_inc_sercount(void)
+{
+        serialization_count++;
+}
+
+/** Restore the preemption counter to the previous state. */
+void fibril_dec_sercount(void)
+{
+        serialization_count--;
+}
+
+int fibril_get_sercount(void)
+{
+        return serialization_count;
+}
+
 /** @}
  */