uisimulator/sdl/thread-sdl.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 Dan Everton
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include <stdbool.h>
  21 #include <time.h>
  22 #include <SDL.h>
  23 #include <SDL_thread.h>
  24 #include <stdlib.h>
  25 #include <memory.h>
  26 #include <setjmp.h>
  27 #include "thread-sdl.h"
  28 #include "kernel.h"
  29 #include "thread.h"
  30 #include "debug.h"
  31
  32 /* Define this as 1 to show informational messages that are not errors. */
  33 #define THREAD_SDL_DEBUGF_ENABLED 0
  34
  35 #if THREAD_SDL_DEBUGF_ENABLED
  36 #define THREAD_SDL_DEBUGF(...) DEBUGF(__VA_ARGS__)
  37 static char __name[32];
  38 #define THREAD_SDL_GET_NAME(thread) \
  39     ({ thread_get_name(__name, sizeof(__name)/sizeof(__name[0]), thread); __name; })
  40 #else
  41 #define THREAD_SDL_DEBUGF(...)
  42 #define THREAD_SDL_GET_NAME(thread)
  43 #endif
  44
  45 #define THREAD_PANICF(str...) \
  46     ({ fprintf(stderr, str); exit(-1); })
  47
  48 /* Thread entries as in core */
  49 struct thread_entry threads[MAXTHREADS];
  50 /* Jump buffers for graceful exit - kernel threads don't stay neatly
  51  * in their start routines responding to messages so this is the only
  52  * way to get them back in there so they may exit */
  53 static jmp_buf thread_jmpbufs[MAXTHREADS];
  54 static SDL_mutex *m;
  55 static struct thread_entry *running;
  56 static bool threads_exit = false;
  57
  58 extern long start_tick;
  59
  60 void thread_sdl_shutdown(void)
  61 {
  62     int i;
  63     /* Take control */
  64     SDL_LockMutex(m);
  65
  66     /* Tell all threads jump back to their start routines, unlock and exit
  67        gracefully - we'll check each one in turn for it's status. Threads
  68        _could_ terminate via remove_thread or multiple threads could exit
  69        on each unlock but that is safe. */
  70     threads_exit = true;
  71
  72     for (i = 0; i < MAXTHREADS; i++)
  73     {
  74         struct thread_entry *thread = &threads[i];
  75         if (thread->context.t != NULL)
  76         {
  77             /* Signal thread on delay or block */
  78             SDL_Thread *t = thread->context.t;
  79             SDL_CondSignal(thread->context.c);
  80             SDL_UnlockMutex(m);
  81             /* Wait for it to finish */
  82             SDL_WaitThread(t, NULL);
  83             /* Relock for next thread signal */
  84             SDL_LockMutex(m);
  85         }
  86     }
  87
  88     SDL_UnlockMutex(m);
  89     SDL_DestroyMutex(m);
  90 }
  91
  92 /* Do main thread creation in this file scope to avoid the need to double-
  93    return to a prior call-level which would be unaware of the fact setjmp
  94    was used */
  95 extern void app_main(void *param);
  96 static int thread_sdl_app_main(void *param)
  97 {
  98     SDL_LockMutex(m);
  99     running = &threads[0];
 100
 101     /* Set the jump address for return */
 102     if (setjmp(thread_jmpbufs[0]) == 0)
 103     {
 104         app_main(param);
 105         /* should not ever be reached but... */
 106         THREAD_PANICF("app_main returned!\n");
 107     }
 108
 109     /* Unlock and exit */
 110     SDL_UnlockMutex(m);
 111     return 0;
 112 }
 113
 114 /* Initialize SDL threading */
 115 bool thread_sdl_init(void *param)
 116 {
 117     memset(threads, 0, sizeof(threads));
 118
 119     m = SDL_CreateMutex();
 120
 121     if (SDL_LockMutex(m) == -1)
 122     {
 123         fprintf(stderr, "Couldn't lock mutex\n");
 124         return false;
 125     }
 126
 127     /* Slot 0 is reserved for the main thread - initialize it here and
 128        then create the SDL thread - it is possible to have a quick, early
 129        shutdown try to access the structure. */
 130     running = &threads[0];
 131     running->stack = "       ";
 132     running->stack_size = 8;
 133     running->name = "main";
 134     running->statearg = STATE_RUNNING;
 135     running->context.c = SDL_CreateCond();
 136
 137     if (running->context.c == NULL)
 138     {
 139         fprintf(stderr, "Failed to create main condition variable\n");
 140         return false;
 141     }
 142
 143     running->context.t = SDL_CreateThread(thread_sdl_app_main, param);
 144
 145     if (running->context.t == NULL)
 146     {
 147         fprintf(stderr, "Failed to create main thread\n");
 148         return false;
 149     }
 150
 151     THREAD_SDL_DEBUGF("Main thread: %p\n", running);
 152
 153     SDL_UnlockMutex(m);
 154     return true;
 155 }
 156
 157 static int find_empty_thread_slot(void)
 158 {
 159     int n;
 160
 161     for (n = 0; n < MAXTHREADS; n++)
 162     {
 163         if (threads[n].name == NULL)
 164             break;
 165     }
 166
 167     return n;
 168 }
 169
 170 static void add_to_list(struct thread_entry **list,
 171                         struct thread_entry *thread)
 172 {
 173     if (*list == NULL)
 174     {
 175         /* Insert into unoccupied list */
 176         thread->next = thread;
 177         thread->prev = thread;
 178         *list = thread;
 179     }
 180     else
 181     {
 182         /* Insert last */
 183         thread->next = *list;
 184         thread->prev = (*list)->prev;
 185         thread->prev->next = thread;
 186         (*list)->prev = thread;
 187     }
 188 }
 189
 190 static void remove_from_list(struct thread_entry **list,
 191                              struct thread_entry *thread)
 192 {
 193     if (thread == thread->next)
 194     {
 195         /* The only item */
 196         *list = NULL;
 197         return;
 198     }
 199
 200     if (thread == *list)
 201     {
 202         /* List becomes next item */
 203         *list = thread->next;
 204     }
 205
 206     /* Fix links to jump over the removed entry. */
 207     thread->prev->next = thread->next;
 208     thread->next->prev = thread->prev;
 209 }
 210
 211 struct thread_entry *thread_get_current(void)
 212 {
 213     return running;
 214 }
 215
 216 void thread_sdl_lock(void)
 217 {
 218     SDL_LockMutex(m);
 219 }
 220
 221 void thread_sdl_unlock(void)
 222 {
 223     SDL_UnlockMutex(m);
 224 }
 225
 226 void switch_thread(bool save_context, struct thread_entry **blocked_list)
 227 {
 228     struct thread_entry *current = running;
 229
 230     SDL_UnlockMutex(m);
 231     /* Any other thread waiting already will get it first */
 232     SDL_LockMutex(m);
 233     running = current;
 234
 235     if (threads_exit)
 236         remove_thread(NULL);
 237
 238     (void)save_context; (void)blocked_list;
 239 }
 240
 241 void sleep_thread(int ticks)
 242 {
 243     struct thread_entry *current;
 244     int rem;
 245
 246     current = running;
 247     current->statearg = STATE_SLEEPING;
 248
 249     rem = (SDL_GetTicks() - start_tick) % (1000/HZ);
 250     if (rem < 0)
 251         rem = 0;
 252
 253     rem = (1000/HZ) * ticks + ((1000/HZ)-1) - rem;
 254
 255     if (rem == 0)
 256     {
 257         /* Unlock and give up rest of quantum */
 258         SDL_UnlockMutex(m);
 259         SDL_Delay(0);
 260         SDL_LockMutex(m);
 261     }
 262     else
 263     {
 264         /* These sleeps must be signalable for thread exit */
 265         SDL_CondWaitTimeout(current->context.c, m, rem);
 266     }
 267
 268     running = current;
 269
 270     current->statearg = STATE_RUNNING;
 271
 272     if (threads_exit)
 273         remove_thread(NULL);
 274 }
 275
 276 int runthread(void *data)
 277 {
 278     struct thread_entry *current;
 279     jmp_buf *current_jmpbuf;
 280
 281     /* Cannot access thread variables before locking the mutex as the
 282        data structures may not be filled-in yet. */
 283     SDL_LockMutex(m);
 284     running = (struct thread_entry *)data;
 285     current = running;
 286     current_jmpbuf = &thread_jmpbufs[running - threads];
 287
 288     /* Setup jump for exit */
 289     if (setjmp(*current_jmpbuf) == 0)
 290     {
 291         /* Run the thread routine */
 292         current->context.start();
 293         THREAD_SDL_DEBUGF("Thread Done: %d (%s)\n",
 294                           current - threads, THREAD_SDL_GET_NAME(current));
 295         /* Thread routine returned - suicide */
 296         remove_thread(NULL);
 297     }
 298     else
 299     {
 300         /* Unlock and exit */
 301         SDL_UnlockMutex(m);
 302     }
 303
 304     return 0;
 305 }
 306
 307 struct thread_entry*
 308     create_thread(void (*function)(void), void* stack, int stack_size,
 309                   const char *name)
 310 {
 311     /** Avoid compiler warnings */
 312     SDL_Thread* t;
 313     SDL_cond *cond;
 314     int slot;
 315
 316     THREAD_SDL_DEBUGF("Creating thread: (%s)\n", name ? name : "");
 317
 318     slot = find_empty_thread_slot();
 319     if (slot >= MAXTHREADS)
 320     {
 321         DEBUGF("Failed to find thread slot\n");
 322         return NULL;
 323     }
 324
 325     cond = SDL_CreateCond();
 326     if (cond == NULL)
 327     {
 328         DEBUGF("Failed to create condition variable\n");
 329         return NULL;
 330     }
 331
 332     t = SDL_CreateThread(runthread, &threads[slot]);
 333     if (t == NULL)
 334     {
 335         DEBUGF("Failed to create SDL thread\n");
 336         SDL_DestroyCond(cond);
 337         return NULL;
 338     }
 339
 340     threads[slot].stack = stack;
 341     threads[slot].stack_size = stack_size;
 342     threads[slot].name = name;
 343     threads[slot].statearg = STATE_RUNNING;
 344     threads[slot].context.start = function;
 345     threads[slot].context.t = t;
 346     threads[slot].context.c = cond;
 347
 348     THREAD_SDL_DEBUGF("New Thread: %d (%s)\n",
 349                       slot, THREAD_SDL_GET_NAME(&threads[slot]));
 350
 351     return &threads[slot];
 352 }
 353
 354 void block_thread(struct thread_entry **list)
 355 {
 356     struct thread_entry *thread = running;
 357
 358     thread->statearg = STATE_BLOCKED;
 359     add_to_list(list, thread);
 360
 361     SDL_CondWait(thread->context.c, m);
 362     running = thread;
 363
 364     if (threads_exit)
 365         remove_thread(NULL);
 366 }
 367
 368 void block_thread_w_tmo(struct thread_entry **list, int ticks)
 369 {
 370     struct thread_entry *thread = running;
 371
 372     thread->statearg = STATE_BLOCKED_W_TMO;
 373     add_to_list(list, thread);
 374
 375     SDL_CondWaitTimeout(thread->context.c, m, (1000/HZ) * ticks);
 376     running = thread;
 377
 378     if (thread->statearg == STATE_BLOCKED_W_TMO)
 379     {
 380         /* Timed out */
 381         remove_from_list(list, thread);
 382         thread->statearg = STATE_RUNNING;
 383     }
 384
 385     if (threads_exit)
 386         remove_thread(NULL);
 387 }
 388
 389 void wakeup_thread(struct thread_entry **list)
 390 {
 391     struct thread_entry *thread = *list;
 392
 393     if (thread == NULL)
 394     {
 395         return;
 396     }
 397
 398     switch (thread->statearg)
 399     {
 400     case STATE_BLOCKED:
 401     case STATE_BLOCKED_W_TMO:
 402         remove_from_list(list, thread);
 403         thread->statearg = STATE_RUNNING;
 404         SDL_CondSignal(thread->context.c);
 405         break;
 406     }
 407 }
 408
 409 void init_threads(void)
 410 {
 411     /* Main thread is already initialized */
 412     if (running != &threads[0])
 413     {
 414         THREAD_PANICF("Wrong main thread in init_threads: %p\n", running);
 415     }
 416
 417     THREAD_SDL_DEBUGF("First Thread: %d (%s)\n",
 418             0, THREAD_SDL_GET_NAME(&threads[0]));
 419 }
 420
 421 void remove_thread(struct thread_entry *thread)
 422 {
 423     struct thread_entry *current = running;
 424     SDL_Thread *t;
 425     SDL_cond *c;
 426
 427     if (thread == NULL)
 428     {
 429         thread = current;
 430     }
 431
 432     t = thread->context.t;
 433     c = thread->context.c;
 434     thread->context.t = NULL;
 435
 436     if (thread != current)
 437         SDL_CondSignal(c);
 438
 439     THREAD_SDL_DEBUGF("Removing thread: %d (%s)\n",
 440         thread - threads, THREAD_SDL_GET_NAME(thread));
 441
 442     thread->name = NULL;
 443
 444     SDL_DestroyCond(c);
 445
 446     if (thread == current)
 447     {
 448         /* Do a graceful exit - perform the longjmp back into the thread
 449            function to return */
 450         longjmp(thread_jmpbufs[current - threads], 1);
 451     }
 452
 453     SDL_KillThread(t);
 454 }
 455
 456 int thread_stack_usage(const struct thread_entry *thread)
 457 {
 458     return 50;
 459     (void)thread;
 460 }
 461
 462 int thread_get_status(const struct thread_entry *thread)
 463 {
 464     return thread->statearg;
 465 }
 466
 467 /* Return name if one or ID if none */
 468 void thread_get_name(char *buffer, int size,
 469                      struct thread_entry *thread)
 470 {
 471     if (size <= 0)
 472         return;
 473
 474     *buffer = '\0';
 475
 476     if (thread)
 477     {
 478         /* Display thread name if one or ID if none */
 479         bool named = thread->name && *thread->name;
 480         const char *fmt = named ? "%s" : "%08lX";
 481         intptr_t name = named ?
 482             (intptr_t)thread->name : (intptr_t)thread;
 483         snprintf(buffer, size, fmt, name);
 484     }
 485 }