Cosmetic changes, biggest being current_thread renamed to current_uthread
authorKevin Klues <klueska@cs.berkeley.edu>
Thu, 3 Mar 2011 04:24:07 +0000 (20:24 -0800)
committerKevin Klues <klueska@cs.berkeley.edu>
Thu, 3 Nov 2011 00:35:59 +0000 (17:35 -0700)
tests/c3po/Makefrag
tests/c3po/c3po_test.c
tests/mhello.c
user/parlib/include/rassert.h
user/parlib/include/vcore.h
user/parlib/vcore.c
user/pthread/pthread.c

index e8e3e31..a656f72 100644 (file)
@@ -5,7 +5,7 @@ C3PO_TESTS_CFLAGS += $(TESTS_CFLAGS) \
 
 ALL_C3PO_TEST_FILES = $(shell ls $(C3PO_TESTS_DIR)/*.c)
 
-C3PO_TESTS_LDLIBS := -lc3po -lparlib -lm
+C3PO_TESTS_LDLIBS := -lpthread -lparlib -lm
 
 C3PO_TESTS_SRCS := $(ALL_C3PO_TEST_FILES)
 
index 7c50189..4b9e164 100644 (file)
@@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include <parlib.h>
 #include <unistd.h>
+#include <vcore.h>
 
 pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 #define printf_safe(...) {}
@@ -24,17 +25,17 @@ __thread int my_id;
 void *yield_thread(void* arg)
 {      
        for (int i = 0; i < 100; i++) {
-               printf_safe("[A] pthread %d on vcore %d\n", pthread_self(), vcore_id());
+               printf_safe("[A] pthread %p on vcore %d, itr: %d\n", pthread_self(), vcore_id(), i);
                pthread_yield();
-               printf_safe("[A] pthread %d returned from yield on vcore %d\n",
-                           pthread_self(), vcore_id());
+               printf_safe("[A] pthread %p returned from yield on vcore %d, itr: %d\n",
+                           pthread_self(), vcore_id(), i);
        }
        return (void*)(pthread_self());
 }
 
 void *hello_thread(void* arg)
 {      
-       printf_safe("[A] pthread %d on vcore %d\n", pthread_self(), vcore_id());
+       printf_safe("[A] pthread %p on vcore %d\n", pthread_self(), vcore_id());
        return (void*)(pthread_self());
 }
 
@@ -72,14 +73,15 @@ int main(int argc, char** argv)
        printf_safe("[A] Successfully joined on thread 3 (retval: %p)\n", retval3);
 
        /* create and join on hellos */
-       for (int i = 1; i < NUM_TEST_THREADS; i++) {
+       for (int i = 0; i < NUM_TEST_THREADS; i++) {
                printf_safe("[A] About to create thread %d\n", i);
                pthread_create(&my_threads[i], NULL, &yield_thread, NULL);
        }
-       for (int i = 1; i < NUM_TEST_THREADS; i++) {
+       for (int i = 0; i < NUM_TEST_THREADS; i++) {
                printf_safe("[A] About to join on thread %d\n", i);
                pthread_join(my_threads[i], &my_retvals[i]);
                printf_safe("[A] Successfully joined on thread %d (retval: %p)\n", i,
                            my_retvals[i]);
        }
+       printf("Exiting cleanly!\n");
 } 
index 3c9b5dc..029805e 100644 (file)
@@ -154,7 +154,7 @@ void ghetto_vcore_entry(void)
        assert(in_vcore_context());
 
        /* old logic was moved to parlib code */
-       if (current_thread) {
+       if (current_uthread) {
                assert(vcoreid == 0);
                run_current_uthread();
        }
index a774883..7e249d9 100644 (file)
@@ -4,6 +4,7 @@
 #define ROS_INC_ASSERT_H
 
 #include <assert.h>
+#include <vcore.h>
 #undef assert
 
 void _warn(const char*, int, const char*, ...);
@@ -13,7 +14,7 @@ void _panic(const char*, int, const char*, ...) __attribute__((noreturn));
 #define panic(...) _panic(__FILE__, __LINE__, __VA_ARGS__)
 
 #define assert(x)              \
-       do { if (!(x)) panic("assertion failed: %s", #x); } while (0)
+       do { if (!(x)) panic("assertion failed - vcore %d: %s", vcore_id(), #x); } while (0)
 
 // static_assert(x) will generate a compile-time error if 'x' is false.
 #define static_assert(x)       switch (x) case 0: case (x):
index 99ff4af..f3e2ff8 100644 (file)
@@ -34,6 +34,7 @@ extern __thread bool __vcore_context;
 
 /* Utility Functions */
 void *allocate_tls(void);
+void free_tls(void *tcb);
 
 /* Vcore API functions */
 static inline size_t max_vcores(void);
@@ -58,7 +59,7 @@ struct uthread {
        /* whether or not the scheduler can migrate you from your vcore */
        bool dont_migrate;
 };
-extern __thread struct uthread *current_thread;
+extern __thread struct uthread *current_uthread;
 
 /* 2L-Scheduler operations.  Can be 0.  Examples in pthread.c. */
 struct schedule_ops {
index 7d34bb3..547643c 100644 (file)
@@ -24,7 +24,7 @@ struct schedule_ops *sched_ops __attribute__((weak)) = &default_2ls_ops;
 
 extern void** vcore_thread_control_blocks;
 
-__thread struct uthread *current_thread = 0;
+__thread struct uthread *current_uthread = 0;
 
 /* Get a TLS, returns 0 on failure.  Vcores have their own TLS, and any thread
  * created by a user-level scheduler needs to create a TLS as well. */
@@ -44,13 +44,20 @@ void *allocate_tls(void)
        return tcb;
 }
 
+/* Free a previously allocated TLS region */
+void free_tls(void *tcb)
+{
+       extern void _dl_deallocate_tls (void *tcb, bool dealloc_tcb) internal_function;
+       assert(tcb);
+       _dl_deallocate_tls(tcb, TRUE);
+}
+
 /* TODO: probably don't want to dealloc.  Considering caching */
 static void free_transition_tls(int id)
 {
-       extern void _dl_deallocate_tls (void *tcb, bool dealloc_tcb) internal_function;
        if(vcore_thread_control_blocks[id])
        {
-               _dl_deallocate_tls(vcore_thread_control_blocks[id],true);
+               free_tls(vcore_thread_control_blocks[id]);
                vcore_thread_control_blocks[id] = NULL;
        }
 }
@@ -123,16 +130,16 @@ int vcore_init()
        /* Save a pointer to thread0's tls region (the glibc one) into its tcb */
        uthread->tls_desc = get_tls_desc(0);
        /* Save a pointer to the uthread in its own TLS */
-       current_thread = uthread;
+       current_uthread = uthread;
 
        /* Change temporarily to vcore0s tls region so we can save the newly created
-        * tcb into its current_thread variable and then restore it.  One minor
+        * tcb into its current_uthread variable and then restore it.  One minor
         * issue is that vcore0's transition-TLS isn't TLS_INITed yet.  Until it is
         * (right before vcore_entry(), don't try and take the address of any of
         * its TLS vars. */
        extern void** vcore_thread_control_blocks;
        set_tls_desc(vcore_thread_control_blocks[0], 0);
-       current_thread = uthread;
+       current_uthread = uthread;
        set_tls_desc(uthread->tls_desc, 0);
        assert(!in_vcore_context());
 
@@ -276,7 +283,7 @@ struct uthread *uthread_create(void (*func)(void), void *udata)
        /* Get a TLS */
        assert(!__uthread_allocate_tls(new_thread));
        /* Switch into the new guys TLS and let it know who it is */
-       struct uthread *caller = current_thread;
+       struct uthread *caller = current_uthread;
        assert(caller);
        /* Don't migrate this thread to another vcore, since it depends on being on
         * the same vcore throughout. */
@@ -286,7 +293,7 @@ struct uthread *uthread_create(void (*func)(void), void *udata)
        uint32_t vcoreid = vcore_id();
        /* Save the new_thread to the new uthread in that uthread's TLS */
        set_tls_desc(new_thread->tls_desc, vcoreid);
-       current_thread = new_thread;
+       current_uthread = new_thread;
        /* Switch back to the caller */
        set_tls_desc(caller->tls_desc, vcoreid);
        /* Okay to migrate now. */
@@ -350,7 +357,7 @@ __uthread_yield(struct uthread *uthread)
         * probably have a generic function for all sorts of waiting. */
        sched_ops->thread_yield(uthread);
        /* Leave the current vcore completely */
-       current_thread = NULL; // this might be okay, even with a migration
+       current_uthread = NULL; // this might be okay, even with a migration
        /* Go back to the entry point, where we can handle notifications or
         * reschedule someone. */
        vcore_entry();
@@ -360,7 +367,7 @@ __uthread_yield(struct uthread *uthread)
  * like this to ease the transition to the 2LS-ops */
 void uthread_yield(void)
 {
-       struct uthread *uthread = current_thread;
+       struct uthread *uthread = current_uthread;
        volatile bool yielding = TRUE; /* signal to short circuit when restarting */
        /* TODO: (HSS) Save silly state */
        // save_fp_state(&t->as);
@@ -386,13 +393,13 @@ void uthread_yield(void)
        /* Change to the transition context (both TLS and stack). */
        extern void** vcore_thread_control_blocks;
        set_tls_desc(vcore_thread_control_blocks[vcoreid], vcoreid);
-       assert(current_thread == uthread);      
+       assert(current_uthread == uthread);     
        assert(in_vcore_context());     /* technically, we aren't fully in vcore context */
        /* After this, make sure you don't use local variables.  Note the warning in
         * pthread_exit() */
        set_stack_pointer((void*)vcpd->transition_stack);
        /* Finish exiting in another function. */
-       __uthread_yield(current_thread);
+       __uthread_yield(current_uthread);
        /* Should never get here */
        assert(0);
        /* Will jump here when the pthread's trapframe is restarted/popped. */
@@ -412,7 +419,7 @@ __uthread_exit(struct uthread *uthread)
        /* 2LS specific cleanup */
        assert(sched_ops->thread_exit);
        sched_ops->thread_exit(uthread);
-       current_thread = NULL;
+       current_uthread = NULL;
        /* Go back to the entry point, where we can handle notifications or
         * reschedule someone. */
        vcore_entry();
@@ -422,7 +429,7 @@ __uthread_exit(struct uthread *uthread)
 void uthread_exit(void)
 {
        assert(!in_vcore_context());
-       struct uthread *uthread = current_thread;
+       struct uthread *uthread = current_uthread;
        /* Don't migrate this thread to anothe vcore, since it depends on being on
         * the same vcore throughout. */
        uthread->dont_migrate = TRUE; // won't set to false later, since he is dying
@@ -436,7 +443,7 @@ void uthread_exit(void)
        /* Change to the transition context (both TLS and stack). */
        extern void** vcore_thread_control_blocks;
        set_tls_desc(vcore_thread_control_blocks[vcoreid], vcoreid);
-       assert(current_thread == uthread);      
+       assert(current_uthread == uthread);     
        /* After this, make sure you don't use local variables.  Also, make sure the
         * compiler doesn't use them without telling you (TODO).
         *
@@ -446,18 +453,18 @@ void uthread_exit(void)
         * walk up the stack a bit when calling a noreturn function. */
        set_stack_pointer((void*)vcpd->transition_stack);
        /* Finish exiting in another function.  Ugh. */
-       __uthread_exit(current_thread);
+       __uthread_exit(current_uthread);
 }
 
-/* Runs whatever thread is vcore's current_thread */
+/* Runs whatever thread is vcore's current_uthread */
 void run_current_uthread(void)
 {
        uint32_t vcoreid = vcore_id();
        struct preempt_data *vcpd = &__procdata.vcore_preempt_data[vcoreid];
-       assert(current_thread);
+       assert(current_uthread);
        printd("[U] Vcore %d is restarting uthread %d\n", vcoreid, uthread->id);
        clear_notif_pending(vcoreid);
-       set_tls_desc(current_thread->tls_desc, vcoreid);
+       set_tls_desc(current_uthread->tls_desc, vcoreid);
        /* Pop the user trap frame */
        pop_ros_tf(&vcpd->notif_tf, vcoreid);
        assert(0);
@@ -470,7 +477,7 @@ void run_uthread(struct uthread *uthread)
        uint32_t vcoreid = vcore_id();
        struct preempt_data *vcpd = &__procdata.vcore_preempt_data[vcoreid];
        printd("[U] Vcore %d is starting uthread %d\n", vcoreid, uthread->id);
-       current_thread = uthread;
+       current_uthread = uthread;
        clear_notif_pending(vcoreid);
        set_tls_desc(uthread->tls_desc, vcoreid);
        /* Load silly state (Floating point) too.  For real */
index 34dc8be..c6ea458 100644 (file)
@@ -85,7 +85,7 @@ struct uthread *pth_init(void)
  * event.c (table of function pointers, stuff like that). */
 void pth_sched_entry(void)
 {
-       if (current_thread) {
+       if (current_uthread) {
                run_current_uthread();
                assert(0);
        }
@@ -449,7 +449,7 @@ int pthread_condattr_getpshared(pthread_condattr_t *a, int *s)
 
 pthread_t pthread_self()
 {
-  return (struct pthread_tcb*)current_thread;
+  return (struct pthread_tcb*)current_uthread;
 }
 
 int pthread_equal(pthread_t t1, pthread_t t2)