Changeset 0f4f1b2 in mainline for kernel/test


Ignore:
Timestamp:
2024-01-15T17:10:27Z (18 months ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
master
Children:
e82879c
Parents:
a064d4f
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2024-01-15 16:37:22)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2024-01-15 17:10:27)
Message:

Add (and use) functions thread_start() and thread_detach()

Mostly cosmetic, with thread_start() replacing calls to thread_ready(),
but not consuming the passed reference, and thread_detach() being
synonym for thread_put(). Makes the code's function more obvious.

Also modify some threaded tests to use thread_join() for waiting,
instead of counting threads with atomics or semaphores.

Location:
kernel/test
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • kernel/test/mm/falloc2.c

    ra064d4f r0f4f1b2  
    4343#define THREADS      8
    4444
    45 static atomic_size_t thread_cnt;
    4645static atomic_size_t thread_fail;
    4746
    … …  
    5655                    "Unable to allocate frames\n", THREAD->tid, CPU->id);
    5756                atomic_inc(&thread_fail);
    58                 atomic_dec(&thread_cnt);
    5957                return;
    6058        }
    … …  
    108106        TPRINTF("Thread #%" PRIu64 " (cpu%u): Exiting\n",
    109107            THREAD->tid, CPU->id);
    110         atomic_dec(&thread_cnt);
    111108}
    112109
    113110const char *test_falloc2(void)
    114111{
    115         atomic_store(&thread_cnt, THREADS);
    116112        atomic_store(&thread_fail, 0);
     113
     114        thread_t *threads[THREADS] = { };
    117115
    118116        for (unsigned int i = 0; i < THREADS; i++) {
    … …  
    123121                        break;
    124122                }
    125                 thread_ready(thrd);
     123                thread_start(thrd);
     124                threads[i] = thrd;
    126125        }
    127126
    128         while (atomic_load(&thread_cnt) > 0) {
    129                 TPRINTF("Threads left: %zu\n",
    130                     atomic_load(&thread_cnt));
    131                 thread_sleep(1);
     127        for (unsigned int i = 0; i < THREADS; i++) {
     128                if (threads[i] != NULL)
     129                        thread_join(threads[i]);
     130
     131                TPRINTF("Threads left: %u\n", THREADS - i - 1);
    132132        }
    133133

  • kernel/test/mm/slab1.c

    ra064d4f r0f4f1b2  
    121121static void *thr_data[THREADS][THR_MEM_COUNT];
    122122static slab_cache_t *thr_cache;
    123 static semaphore_t thr_sem;
    124123
    125124static void slabtest(void *data)
    … …  
    142141
    143142        TPRINTF("Thread #%" PRIu64 " finished\n", THREAD->tid);
    144 
    145         semaphore_up(&thr_sem);
    146143}
    147144
    148145static void testthreads(void)
    149146{
    150         thread_t *t;
    151         int i;
    152 
    153147        thr_cache = slab_cache_create("thread_cache", THR_MEM_SIZE, 0, NULL, NULL,
    154148            SLAB_CACHE_NOMAGAZINE);
    155149
    156         semaphore_initialize(&thr_sem, 0);
    157         for (i = 0; i < THREADS; i++) {
    158                 if (!(t = thread_create(slabtest, (void *) (sysarg_t) i, TASK, THREAD_FLAG_NONE, "slabtest"))) {
     150        thread_t *threads[THREADS] = { };
     151
     152        for (int i = 0; i < THREADS; i++) {
     153                threads[i] = thread_create(slabtest, (void *) (sysarg_t) i,
     154                    TASK, THREAD_FLAG_NONE, "slabtest");
     155                if (threads[i]) {
     156                        thread_start(threads[i]);
     157                } else {
    159158                        TPRINTF("Could not create thread %d\n", i);
    160                 } else
    161                         thread_ready(t);
     159                }
    162160        }
    163161
    164         for (i = 0; i < THREADS; i++)
    165                 semaphore_down(&thr_sem);
     162        for (int i = 0; i < THREADS; i++) {
     163                if (threads[i] != NULL)
     164                        thread_join(threads[i]);
     165        }
    166166
    167167        slab_cache_destroy(thr_cache);

  • kernel/test/mm/slab2.c

    ra064d4f r0f4f1b2  
    127127
    128128static slab_cache_t *thr_cache;
    129 static semaphore_t thr_sem;
    130129static condvar_t thread_starter;
    131130static mutex_t starter_mutex;
    … …  
    188187        if (!test_quiet)
    189188                slab_print_list();
    190 
    191         semaphore_up(&thr_sem);
    192189}
    193190
    … …  
    198195         * then release everything, then again allocate, then release
    199196         */
    200         thread_t *t;
    201         int i;
    202197
    203198        TPRINTF("Running stress test with size %d\n", size);
    … …  
    207202
    208203        thr_cache = slab_cache_create("thread_cache", size, 0, NULL, NULL, 0);
    209         semaphore_initialize(&thr_sem, 0);
    210         for (i = 0; i < THREADS; i++) {
    211                 if (!(t = thread_create(slabtest, NULL, TASK, THREAD_FLAG_NONE, "slabtest"))) {
     204
     205        thread_t *threads[THREADS] = { };
     206
     207        for (int i = 0; i < THREADS; i++) {
     208                threads[i] = thread_create(slabtest, NULL,
     209                    TASK, THREAD_FLAG_NONE, "slabtest");
     210                if (threads[i]) {
     211                        thread_start(threads[i]);
     212                } else {
    212213                        TPRINTF("Could not create thread %d\n", i);
    213                 } else
    214                         thread_ready(t);
    215         }
     214                }
     215        }
     216
    216217        thread_sleep(1);
    217218        condvar_broadcast(&thread_starter);
    218219
    219         for (i = 0; i < THREADS; i++)
    220                 semaphore_down(&thr_sem);
     220        for (int i = 0; i < THREADS; i++) {
     221                if (threads[i] != NULL)
     222                        thread_join(threads[i]);
     223        }
    221224
    222225        slab_cache_destroy(thr_cache);

  • kernel/test/synch/semaphore1.c

    ra064d4f r0f4f1b2  
    8989                                thrd = thread_create(consumer, NULL, TASK,
    9090                                    THREAD_FLAG_NONE, "consumer");
    91                                 if (thrd)
    92                                         thread_ready(thrd);
    93                                 else
     91                                if (thrd) {
     92                                        thread_start(thrd);
     93                                        thread_detach(thrd);
     94                                } else {
    9495                                        TPRINTF("could not create consumer %d\n", i);
     96                                }
    9597                        }
    9698                        for (k = 0; k < (4 - i); k++) {
    9799                                thrd = thread_create(producer, NULL, TASK,
    98100                                    THREAD_FLAG_NONE, "producer");
    99                                 if (thrd)
    100                                         thread_ready(thrd);
    101                                 else
     101                                if (thrd) {
     102                                        thread_start(thrd);
     103                                        thread_detach(thrd);
     104                                } else {
    102105                                        TPRINTF("could not create producer %d\n", i);
     106                                }
    103107                        }
    104108                }

  • kernel/test/synch/semaphore2.c

    ra064d4f r0f4f1b2  
    9292                thrd = thread_create(consumer, NULL, TASK,
    9393                    THREAD_FLAG_NONE, "consumer");
    94                 if (thrd)
    95                         thread_ready(thrd);
    96                 else
     94                if (thrd) {
     95                        thread_start(thrd);
     96                        thread_detach(thrd);
     97                } else {
    9798                        TPRINTF("Error creating thread\n");
     99                }
    98100        }
    99101

  • kernel/test/thread/thread1.c

    ra064d4f r0f4f1b2  
    3838
    3939static atomic_bool finish;
    40 static atomic_size_t threads_finished;
    4140
    4241static void threadtest(void *data)
    … …  
    4645                thread_usleep(100000);
    4746        }
    48         atomic_inc(&threads_finished);
    4947}
    5048
    5149const char *test_thread1(void)
    5250{
    53         unsigned int i;
    54         size_t total = 0;
     51        atomic_store(&finish, true);
    5552
    56         atomic_store(&finish, true);
    57         atomic_store(&threads_finished, 0);
     53        thread_t *threads[THREADS] = { };
    5854
    59         for (i = 0; i < THREADS; i++) {
    60                 thread_t *t;
    61                 if (!(t = thread_create(threadtest, NULL, TASK,
    62                     THREAD_FLAG_NONE, "threadtest"))) {
     55        for (int i = 0; i < THREADS; i++) {
     56                threads[i] = thread_create(threadtest, NULL,
     57                    TASK, THREAD_FLAG_NONE, "threadtest");
     58
     59                if (threads[i]) {
     60                        thread_start(threads[i]);
     61                } else {
    6362                        TPRINTF("Could not create thread %d\n", i);
    6463                        break;
    6564                }
    66                 thread_ready(t);
    67                 total++;
    6865        }
    6966
    … …  
    7269
    7370        atomic_store(&finish, false);
    74         while (atomic_load(&threads_finished) < total) {
    75                 TPRINTF("Threads left: %zu\n", total - atomic_load(&threads_finished));
    76                 thread_sleep(1);
     71
     72        for (int i = 0; i < THREADS; i++) {
     73                if (threads[i] != NULL)
     74                        thread_join(threads[i]);
     75
     76                TPRINTF("Threads left: %d\n", THREADS - i - 1);
    7777        }
    7878
Note: See TracChangeset for help on using the changeset viewer.