Fixed the threading to work as I wanted it:

We only execute one thread at a time, and we do this by using a mytex that
the executing thread locks. sleep() returns the mutex, sleep and then gets
it again, yeild() makes the same as sleep but immediately.
This makes threading in the simulator behave closer to how it works on target
and it makes it necessary to use yield() or sleep() for other threads to
get to execute.


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@1002 a1c6a512-1295-4272-9138-f99709370657

1 files changed, 30 insertions, 7 deletions

diff --git a/uisimulator/x11/thread.c b/uisimulator/x11/thread.c
index b4a4ea13e7..ddaae313ae 100644
--- a/uisimulator/x11/thread.c
+++ b/uisimulator/x11/thread.c
@@ -20,6 +20,10 @@
 #include <stdio.h>
 #include <pthread.h>
 
+#include "kernel.h"
+#include <poll.h>
+
+
 /*
  * We emulate the target threads by using pthreads. We have a mutex that only
  * allows one thread at a time to execute. It forces each thread to yield()
@@ -31,6 +35,9 @@ pthread_mutex_t mp;
 void init_threads(void)
 {  
   pthread_mutex_init(&mp, NULL);
+  /* get mutex to only allow one thread running at a time */
+  pthread_mutex_lock(&mp);
+
 }
 /* 
    int pthread_create(pthread_t *new_thread_ID,
@@ -38,12 +45,19 @@ void init_threads(void)
    void * (*start_func)(void *), void *arg);
 */
 
-void yield(void)
+void (yield)(void)
 {
   pthread_mutex_unlock(&mp); /* return */
   pthread_mutex_lock(&mp); /* get it again */
 }
 
+void newfunc(void (*func)(void))
+{
+  yield();
+  func();
+}
+
+
 int create_thread(void* fp, void* sp, int stk_size)
 {
   pthread_t tid;
@@ -54,16 +68,25 @@ int create_thread(void* fp, void* sp, int stk_size)
   (void)sp;
   (void)stk_size;
   error = pthread_create(&tid,
-                         NULL, /* default attributes please */
-                         fp,   /* function to start */
-                         NULL  /* start argument */);
+                         NULL,   /* default attributes please */
+                         (void *(*)(void *)) newfunc,   /* function to start */
+                         fp      /* start argument */);
   if(0 != error)
     fprintf(stderr, "Couldn't run thread number %d, errno %d\n", i, error);
   else 
-    fprintf(stderr, "Thread %ld is running\n", tid);
+    fprintf(stderr, "Thread %ld is running\n", (long)tid);
 
-  /* get mutex to only allow one thread running at a time */
-  pthread_mutex_lock(&mp);
+  yield();
 
   return error;
 }
+
+/* ticks is HZ per second */
+void x11_sleep(int ticks)
+{
+    pthread_mutex_unlock(&mp); /* return */
+    /* portable subsecond "sleep" */
+    poll((void *)0, 0, ticks * 1000/HZ);
+
+    pthread_mutex_lock(&mp); /* get it again */
+}