Merge pull request #100 from shintaro-iwasaki/SupportUcontext

Support ucontext

Author: shintaro-iwasaki

src/arch/abtd_thread.c

@@ -10,16 +10,15 @@ static inline void ABTD_thread_terminate_thread(ABTI_local *p_local,
 static inline void ABTD_thread_terminate_sched(ABTI_local *p_local,
                                                ABTI_thread *p_thread);
 
-#if defined(ABT_CONFIG_USE_FCONTEXT)
 void ABTD_thread_func_wrapper_thread(void *p_arg)
 {
-    ABTD_thread_context *p_fctx = (ABTD_thread_context *)p_arg;
-    void (*thread_func)(void *) = p_fctx->f_thread;
+    ABTD_thread_context *p_ctx = (ABTD_thread_context *)p_arg;
+    void (*thread_func)(void *) = p_ctx->f_thread;
 
-    thread_func(p_fctx->p_arg);
+    thread_func(p_ctx->p_arg);
 
     /* NOTE: ctx is located in the beginning of ABTI_thread */
-    ABTI_thread *p_thread = (ABTI_thread *)p_fctx;
+    ABTI_thread *p_thread = (ABTI_thread *)p_ctx;
 #ifndef ABT_CONFIG_DISABLE_STACKABLE_SCHED
     ABTI_ASSERT(p_thread->is_sched == NULL);
 #endif
@@ -30,56 +29,20 @@ void ABTD_thread_func_wrapper_thread(void *p_arg)
 
 void ABTD_thread_func_wrapper_sched(void *p_arg)
 {
-    ABTD_thread_context *p_fctx = (ABTD_thread_context *)p_arg;
-    void (*thread_func)(void *) = p_fctx->f_thread;
+    ABTD_thread_context *p_ctx = (ABTD_thread_context *)p_arg;
+    void (*thread_func)(void *) = p_ctx->f_thread;
 
-    thread_func(p_fctx->p_arg);
+    thread_func(p_ctx->p_arg);
 
     /* NOTE: ctx is located in the beginning of ABTI_thread */
-    ABTI_thread *p_thread = (ABTI_thread *)p_fctx;
+    ABTI_thread *p_thread = (ABTI_thread *)p_ctx;
 #ifndef ABT_CONFIG_DISABLE_STACKABLE_SCHED
     ABTI_ASSERT(p_thread->is_sched != NULL);
 #endif
 
     ABTI_local *p_local = ABTI_local_get_local();
     ABTD_thread_terminate_sched(p_local, p_thread);
 }
-#else
-void ABTD_thread_func_wrapper(int func_upper, int func_lower,
-                              int arg_upper, int arg_lower)
-{
-    ABTI_local *p_local = ABTI_local_get_local();
-    void (*thread_func)(void *);
-    void *p_arg;
-    size_t ptr_size, int_size;
-
-    ptr_size = sizeof(void *);
-    int_size = sizeof(int);
-    if (ptr_size == int_size) {
-        thread_func = (void (*)(void *))(uintptr_t)func_lower;
-        p_arg = (void *)(uintptr_t)arg_lower;
-    } else if (ptr_size == int_size * 2) {
-        uintptr_t shift_bits = CHAR_BIT * int_size;
-        uintptr_t mask = ((uintptr_t)1 << shift_bits) - 1;
-        thread_func = (void (*)(void *))(
-                ((uintptr_t)func_upper << shift_bits) |
-                ((uintptr_t)func_lower & mask));
-        p_arg = (void *)(
-                ((uintptr_t)arg_upper << shift_bits) |
-                ((uintptr_t)arg_lower & mask));
-    } else {
-        ABTI_ASSERT(0);
-    }
-
-    thread_func(p_arg);
-
-    /* Now, the ULT has finished its job. Terminate the ULT.
-     * We don't need to use the atomic operation here because the ULT will be
-     * terminated regardless of other requests. */
-    ABTI_thread *p_thread = p_local->p_thread;
-    p_thread->request |= ABTI_THREAD_REQ_TERMINATE;
-}
-#endif
 
 void ABTD_thread_exit(ABTI_local *p_local, ABTI_thread *p_thread)
 {
@@ -98,10 +61,9 @@ static inline void ABTDI_thread_terminate(ABTI_local *p_local,
                                           ABTI_thread *p_thread,
                                           ABT_bool is_sched)
 {
-#if defined(ABT_CONFIG_USE_FCONTEXT)
-    ABTD_thread_context *p_fctx = &p_thread->ctx;
+    ABTD_thread_context *p_ctx = &p_thread->ctx;
     ABTD_thread_context *p_link = (ABTD_thread_context *)
-        ABTD_atomic_load_ptr((void **)&p_fctx->p_link);
+        ABTD_atomic_load_ptr((void **)&p_ctx->p_link);
     if (p_link) {
         /* If p_link is set, it means that other ULT has called the join. */
         ABTI_thread *p_joiner = (ABTI_thread *)p_link;
@@ -150,15 +112,15 @@ static inline void ABTDI_thread_terminate(ABTI_local *p_local,
              * blocked.  We have to wake up the joiner ULT. */
             do {
                 p_link = (ABTD_thread_context *)
-                    ABTD_atomic_load_ptr((void **)&p_fctx->p_link);
+                    ABTD_atomic_load_ptr((void **)&p_ctx->p_link);
             } while (!p_link);
             ABTI_thread_set_ready(p_local, (ABTI_thread *)p_link);
         }
     }
 
-    /* No other ULT is waiting or blocked for this ULT. Since fcontext does
-     * not switch to other fcontext when it finishes, we need to explicitly
-     * switch to the scheduler. */
+    /* No other ULT is waiting or blocked for this ULT. Since a context does not
+     * switch to another context when it finishes, we need to explicitly switch
+     * to the scheduler. */
     ABTI_sched *p_sched;
 #ifndef ABT_CONFIG_DISABLE_STACKABLE_SCHED
     if (p_thread->is_sched) {
@@ -180,9 +142,6 @@ static inline void ABTDI_thread_terminate(ABTI_local *p_local,
 #ifndef ABT_CONFIG_DISABLE_STACKABLE_SCHED
     }
 #endif
-#else
-#error "Not implemented yet"
-#endif
 }
 
 static inline void ABTD_thread_terminate_thread(ABTI_local *p_local,
@@ -215,62 +174,33 @@ void ABTD_thread_cancel(ABTI_local *p_local, ABTI_thread *p_thread)
      * ULT has finished its execution and calls ABTD_thread_terminate/exit,
      * this function is called by the scheduler.  Therefore, we should not
      * context switch to the joiner ULT and need to always wake it up. */
-#if defined(ABT_CONFIG_USE_FCONTEXT)
-    ABTD_thread_context *p_fctx = &p_thread->ctx;
+    ABTD_thread_context *p_ctx = &p_thread->ctx;
 
     /* acquire load is not needed here. */
-    if (p_fctx->p_link) {
+    if (p_ctx->p_link) {
         /* If p_link is set, it means that other ULT has called the join. */
-        ABTI_thread *p_joiner = (ABTI_thread *)p_fctx->p_link;
+        ABTI_thread *p_joiner = (ABTI_thread *)p_ctx->p_link;
         ABTI_thread_set_ready(p_local, p_joiner);
     } else {
         uint32_t req = ABTD_atomic_fetch_or_uint32(&p_thread->request,
                 ABTI_THREAD_REQ_JOIN | ABTI_THREAD_REQ_TERMINATE);
         if (req & ABTI_THREAD_REQ_JOIN) {
             /* This case means there has been a join request and the joiner has
              * blocked.  We have to wake up the joiner ULT. */
-            while (ABTD_atomic_load_ptr((void **)&p_fctx->p_link) == NULL);
-            ABTI_thread *p_joiner = (ABTI_thread *)p_fctx->p_link;
+            while (ABTD_atomic_load_ptr((void **)&p_ctx->p_link) == NULL);
+            ABTI_thread *p_joiner = (ABTI_thread *)p_ctx->p_link;
             ABTI_thread_set_ready(p_local, p_joiner);
         }
     }
-#else
-#error "Not implemented yet"
-#endif
 }
 
-#if !defined(ABT_CONFIG_USE_FCONTEXT)
-static inline
-void print_bytes(size_t size, void *p_val, FILE *p_os) {
-    size_t i;
-    for (i = 0; i < size; i++) {
-        uint8_t val = ((uint8_t *)p_val)[i];
-        fprintf(p_os, "%02" PRIx8, val);
-    }
-}
-#endif
-
 void ABTD_thread_print_context(ABTI_thread *p_thread, FILE *p_os, int indent)
 {
     char *prefix = ABTU_get_indent_str(indent);
     ABTD_thread_context *p_ctx = &p_thread->ctx;
-#if defined(ABT_CONFIG_USE_FCONTEXT)
-    fprintf(p_os, "%sfctx     : %p\n", prefix, (void *)p_ctx->fctx);
+    fprintf(p_os, "%sp_ctx    : %p\n", prefix, p_ctx->p_ctx);
     fprintf(p_os, "%sp_arg    : %p\n", prefix, p_ctx->p_arg);
     fprintf(p_os, "%sp_link   : %p\n", prefix, (void *)p_ctx->p_link);
-#else
-    /* TODO: print information in more detail. */
-    fprintf(p_os, "%suc_link     : %p\n", prefix, p_ctx->uc_link);
-    fprintf(p_os, "%suc_sigmask  : ", prefix);
-    print_bytes(sizeof(sigset_t), &p_ctx->uc_sigmask, p_os);
-    fprintf(p_os, "\n");
-    fprintf(p_os, "%suc_stack    : ", prefix);
-    print_bytes(sizeof(stack_t), &p_ctx->uc_stack, p_os);
-    fprintf(p_os, "\n");
-    fprintf(p_os, "%suc_mcontext : ", prefix);
-    print_bytes(sizeof(mcontext_t), &p_ctx->uc_mcontext, p_os);
-    fprintf(p_os, "\n");
-#endif
     fflush(p_os);
     ABTU_free(prefix);
 }

src/include/Makefile.mk

@@ -9,6 +9,8 @@ noinst_HEADERS = \
 	include/abt_config.h \
 	include/abtd.h \
 	include/abtd_atomic.h \
+	include/abtd_context.h \
+	include/abtd_fcontext.h \
 	include/abtd_thread.h \
 	include/abtd_ucontext.h \
 	include/abti.h \

src/include/abtd.h

@@ -8,7 +8,7 @@
 
 #define __USE_GNU
 #include <pthread.h>
-#include "abtd_ucontext.h"
+#include "abtd_context.h"
 
 /* Atomic Functions */
 #include "abtd_atomic.h"
@@ -21,7 +21,6 @@ typedef pthread_barrier_t   ABTD_xstream_barrier;
 #else
 typedef void *              ABTD_xstream_barrier;
 #endif
-typedef abt_ucontext_t      ABTD_thread_context;
 
 /* ES Storage Qualifier */
 #define ABTD_XSTREAM_LOCAL  __thread

src/include/abtd_context.h

@@ -0,0 +1,50 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ * See COPYRIGHT in top-level directory.
+ */
+
+#ifndef ABTD_CONTEXT_H_INCLUDED
+#define ABTD_CONTEXT_H_INCLUDED
+
+#include "abt_config.h"
+
+#ifndef ABT_CONFIG_USE_FCONTEXT
+#define _XOPEN_SOURCE
+#include <ucontext.h>
+#endif
+
+typedef struct ABTD_thread_context {
+    void *                 p_ctx;        /* actual context of fcontext, or a
+                                          * pointer to uctx */
+    void (*f_thread)(void *);            /* ULT function */
+    void *                 p_arg;        /* ULT function argument */
+    struct ABTD_thread_context *p_link;  /* pointer to scheduler context */
+#ifndef ABT_CONFIG_USE_FCONTEXT
+    ucontext_t             uctx;         /* ucontext entity pointed by p_ctx */
+    void (*f_uctx_thread)(void *);       /* root function called by ucontext */
+    void *                 p_uctx_arg;   /* argument for root function */
+#endif
+} ABTD_thread_context;
+
+static void ABTD_thread_context_make(ABTD_thread_context *p_ctx, void *sp,
+                                     size_t size, void (*thread_func)(void *));
+static void ABTD_thread_context_jump(ABTD_thread_context *p_old,
+                                     ABTD_thread_context *p_new, void *arg);
+static void ABTD_thread_context_take(ABTD_thread_context *p_old,
+                                     ABTD_thread_context *p_new, void *arg);
+#if ABT_CONFIG_THREAD_TYPE == ABT_THREAD_TYPE_DYNAMIC_PROMOTION
+static void ABTD_thread_context_init_and_call(ABTD_thread_context *p_ctx,
+                                              void *sp,
+                                              void (*thread_func)(void *),
+                                              void *arg);
+#endif
+
+void ABTD_thread_print_context(ABTI_thread *p_thread, FILE *p_os, int indent);
+
+#ifdef ABT_CONFIG_USE_FCONTEXT
+#include "abtd_fcontext.h"
+#else
+#include "abtd_ucontext.h"
+#endif
+
+#endif /* ABTD_CONTEXT_H_INCLUDED */

src/include/abtd_fcontext.h

@@ -0,0 +1,56 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ * See COPYRIGHT in top-level directory.
+ */
+
+#ifndef ABTD_FCONTEXT_H_INCLUDED
+#define ABTD_FCONTEXT_H_INCLUDED
+
+typedef void *fcontext_t;
+
+#if defined(ABT_C_HAVE_VISIBILITY)
+#define ABT_API_PRIVATE     __attribute__((visibility ("hidden")))
+#else
+#define ABT_API_PRIVATE
+#endif
+
+fcontext_t make_fcontext(void *sp, size_t size, void (*thread_func)(void *))
+                         ABT_API_PRIVATE;
+void *jump_fcontext(fcontext_t *old, fcontext_t new, void *arg) ABT_API_PRIVATE;
+void *take_fcontext(fcontext_t *old, fcontext_t new, void *arg) ABT_API_PRIVATE;
+#if ABT_CONFIG_THREAD_TYPE == ABT_THREAD_TYPE_DYNAMIC_PROMOTION
+void init_and_call_fcontext(void *p_arg, void (*f_thread)(void *),
+                            void *p_stacktop, fcontext_t *old);
+#endif
+
+static inline
+void ABTD_thread_context_make(ABTD_thread_context *p_ctx, void *sp, size_t size,
+                              void (*thread_func)(void *))
+{
+    p_ctx->p_ctx = make_fcontext(sp, size, thread_func);
+}
+
+static inline
+void ABTD_thread_context_jump(ABTD_thread_context *p_old,
+                              ABTD_thread_context *p_new, void *arg)
+{
+    jump_fcontext(&p_old->p_ctx, p_new->p_ctx, arg);
+}
+
+static inline
+void ABTD_thread_context_take(ABTD_thread_context *p_old,
+                              ABTD_thread_context *p_new, void *arg)
+{
+    take_fcontext(&p_old->p_ctx, p_new->p_ctx, arg);
+}
+
+#if ABT_CONFIG_THREAD_TYPE == ABT_THREAD_TYPE_DYNAMIC_PROMOTION
+static inline
+void ABTD_thread_context_init_and_call(ABTD_thread_context *p_ctx, void *sp,
+                                       void (*thread_func)(void *), void *arg)
+{
+    init_and_call_fcontext(arg, thread_func, sp, &p_ctx->p_ctx);
+}
+#endif
+
+#endif /* ABTD_FCONTEXT_H_INCLUDED */