Changeset 38d8849 in mainline for uspace/app

Timestamp:

2018-07-16T15:58:51Z (7 years ago)

Author:

Jiří Zárevúcky <jiri.zarevucky@…>

Branches:

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

Children:

db51219f

Parents:

c124c985

git-author:

Jiří Zárevúcky <jiri.zarevucky@…> (2018-07-14 16:53:46)

git-committer:

Jiří Zárevúcky <jiri.zarevucky@…> (2018-07-16 15:58:51)

Message:

Privatize <thread.h>.

Location:

uspace/app

Files:

• rcubench/rcubench.c (modified) (4 diffs)
• rcutest/rcutest.c (modified) (2 diffs)
• tester/float/float1.c (modified) (5 diffs)
• tester/thread/thread1.c (modified) (4 diffs)

uspace/app/rcubench/rcubench.c

@@ -40 +40 @@
 #include <mem.h>
 #include <errno.h>
-#include <thread.h>
 #include <assert.h>
 #include <async.h>
@@ -105 +104 @@
 }
 
-static void thread_func(void *arg)
+static errno_t thread_func(void *arg)
 {
         bench_t *bench = (bench_t *)arg;
@@ -113 +112 @@
         /* Signal another thread completed. */
         futex_up(&bench->done_threads);
+        return EOK;
 }
 
@@ -123 +123 @@
         }
 
+        fibril_test_spawn_runners(bench->nthreads - 1);
+
         /* Create and run the first nthreads - 1 threads.*/
         for (size_t k = 1; k < bench->nthreads; ++k) {
-                thread_id_t tid;
-                /* Also sets up a fibril for the thread. */
-                errno_t ret = thread_create(thread_func, bench, "rcubench-t", &tid);
-                if (ret != EOK) {
+                fid_t f = fibril_create(thread_func, bench);
+                if (!f) {
                         printf("Error: Failed to create benchmark thread.\n");
                         abort();
                 }
-                thread_detach(tid);
+                fibril_detach(f);
+                fibril_add_ready(f);
         }
 

uspace/app/rcutest/rcutest.c

@@ -41 +41 @@
 #include <mem.h>
 #include <errno.h>
-#include <thread.h>
 #include <assert.h>
 #include <async.h>
@@ -759 +758 @@
 /*--------------------------------------------------------------------*/
 
-static FIBRIL_MUTEX_INITIALIZE(blocking_mtx);
-
-static void dummy_fibril(void *arg)
-{
-        /* Block on an already locked mutex - enters the fibril manager. */
-        fibril_mutex_lock(&blocking_mtx);
-        assert(false);
-}
-
 static bool create_threads(size_t cnt)
 {
         /* Sanity check. */
         assert(cnt < 1024);
-
-        /* Keep this mutex locked so that dummy fibrils never exit. */
-        bool success = fibril_mutex_trylock(&blocking_mtx);
-        assert(success);
-
-        for (size_t k = 0; k < cnt; ++k) {
-                thread_id_t tid;
-
-                errno_t ret = thread_create(dummy_fibril, NULL, "urcu-test-worker", &tid);
-                if (EOK != ret) {
-                        printf("Failed to create thread '%zu' (error: %s)\n", k + 1, str_error_name(ret));
-                        return false;
-                }
-        }
-
+        fibril_test_spawn_runners(cnt);
         return true;
 }

uspace/app/tester/float/float1.c

@@ -33 +33 @@
 #include <stddef.h>
 #include <atomic.h>
-#include <thread.h>
+#include <fibril.h>
+#include <fibril_synch.h>
 #include <inttypes.h>
 #include "../tester.h"
@@ -43 +44 @@
 #define PRECISION  100000000
 
-static atomic_t threads_finished;
+static FIBRIL_SEMAPHORE_INITIALIZE(threads_finished, 0);
 static atomic_t threads_fault;
 
-static void e(void *data)
+static errno_t e(void *data)
 {
         for (unsigned int i = 0; i < ATTEMPTS; i++) {
@@ -64 +65 @@
         }
 
-        atomic_inc(&threads_finished);
+        fibril_semaphore_up(&threads_finished);
+        return EOK;
 }
 
@@ -71 +73 @@
         atomic_count_t total = 0;
 
-        atomic_set(&threads_finished, 0);
         atomic_set(&threads_fault, 0);
+        fibril_test_spawn_runners(THREADS);
 
         TPRINTF("Creating threads");
         for (unsigned int i = 0; i < THREADS; i++) {
-                if (thread_create(e, NULL, "e", NULL) != EOK) {
+                fid_t f = fibril_create(e, NULL);
+                if (!f) {
                         TPRINTF("\nCould not create thread %u\n", i);
                         break;
                 }
+                fibril_detach(f);
+                fibril_add_ready(f);
 
                 TPRINTF(".");
@@ -87 +92 @@
         TPRINTF("\n");
 
-        while (atomic_get(&threads_finished) < total) {
-                TPRINTF("Threads left: %" PRIua "\n",
-                    total - atomic_get(&threads_finished));
-                thread_sleep(1);
+        for (unsigned int i = 0; i < total; i++) {
+                TPRINTF("Threads left: %" PRIua "\n", total - i);
+                fibril_semaphore_down(&threads_finished);
         }
 

uspace/app/tester/thread/thread1.c

@@ -33 +33 @@
 #include <atomic.h>
 #include <errno.h>
-#include <thread.h>
+#include <fibril.h>
+#include <fibril_synch.h>
 #include <stdio.h>
 #include <stddef.h>
@@ -40 +41 @@
 
 static atomic_t finish;
-static atomic_t threads_finished;
 
-static void threadtest(void *data)
+static FIBRIL_SEMAPHORE_INITIALIZE(threads_finished, 0);
+
+static errno_t threadtest(void *data)
 {
-        thread_detach(thread_get_id());
+        fibril_detach(fibril_get_id());
 
         while (atomic_get(&finish))
-                thread_usleep(100000);
+                fibril_usleep(100000);
 
-        atomic_inc(&threads_finished);
+        fibril_semaphore_up(&threads_finished);
+        return EOK;
 }
 
@@ -58 +61 @@
 
         atomic_set(&finish, 1);
-        atomic_set(&threads_finished, 0);
+
+        fibril_test_spawn_runners(THREADS);
 
         TPRINTF("Creating threads");
         for (i = 0; i < THREADS; i++) {
-                if (thread_create(threadtest, NULL, "threadtest", NULL) != EOK) {
+                fid_t f = fibril_create(threadtest, NULL);
+                if (!f) {
                         TPRINTF("\nCould not create thread %u\n", i);
                         break;
                 }
+                fibril_add_ready(f);
                 TPRINTF(".");
                 total++;
@@ -71 +77 @@
 
         TPRINTF("\nRunning threads for %u seconds...", DELAY);
-        thread_sleep(DELAY);
+        fibril_sleep(DELAY);
         TPRINTF("\n");
 
         atomic_set(&finish, 0);
-        while (atomic_get(&threads_finished) < total) {
+        for (i = 0; i < total; i++) {
                 TPRINTF("Threads left: %" PRIua "\n",
-                    total - atomic_get(&threads_finished));
-                thread_sleep(1);
+                    total - i);
+                fibril_semaphore_down(&threads_finished);
         }