context: support ucontext

This patch implements a ucontext wrapper.  Most of the logic is the same as the
previous (partial) ucontext implementation.

Author: shintaro-iwasaki

src/include/Makefile.mk

@@ -11,6 +11,7 @@ noinst_HEADERS = \
 	include/abtd_atomic.h \
 	include/abtd_fcontext.h \
 	include/abtd_thread.h \
+	include/abtd_ucontext.h \
 	include/abtd_context.h \
 	include/abti.h \
 	include/abti_barrier.h \

src/include/abtd_context.h

@@ -8,13 +8,23 @@
 
 #include "abt_config.h"
 
+#ifndef ABT_CONFIG_USE_FCONTEXT
+#define _XOPEN_SOURCE
+#include <ucontext.h>
+#endif
+
 typedef void *  fcontext_t;
 
 typedef struct ABTD_thread_context {
     fcontext_t             fctx;    /* actual context */
     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 fctx */
+    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,
@@ -32,6 +42,10 @@ static void ABTD_thread_context_init_and_call(ABTD_thread_context *p_ctx,
 
 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_ucontext.h

@@ -0,0 +1,73 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ * See COPYRIGHT in top-level directory.
+ */
+
+#ifndef ABTD_UCONTEXT_H_INCLUDED
+#define ABTD_UCONTEXT_H_INCLUDED
+
+static void ABTD_ucontext_wrapper(int arg1, int arg2)
+{
+    ABTD_thread_context *p_self;
+    if (sizeof(void *) == 8) {
+        p_self = (ABTD_thread_context *)(((uintptr_t)((uint32_t)arg1) << 32) |
+                                         ((uintptr_t)((uint32_t)arg2)));
+    } else if (sizeof(void *) == 4) {
+        p_self = (ABTD_thread_context *)((uintptr_t)arg1);
+    } else {
+        ABTI_ASSERT(0);
+    }
+    p_self->f_uctx_thread(p_self->p_uctx_arg);
+    /* ABTD_thread_context_jump or take must be called at the end of
+     * f_uctx_thread, */
+    ABTI_ASSERT(0);
+}
+
+static inline
+void ABTD_thread_context_make(ABTD_thread_context *p_ctx, void *sp, size_t size,
+                              void (*thread_func)(void *))
+{
+    getcontext(&p_ctx->uctx);
+    p_ctx->fctx = &p_ctx->uctx;
+
+    /* uc_link is not used. */
+    p_ctx->uctx.uc_link = NULL;
+    p_ctx->uctx.uc_stack.ss_sp = (void *)(((char *)sp) - size);
+    p_ctx->uctx.uc_stack.ss_size = size;
+    p_ctx->f_uctx_thread = thread_func;
+
+    if (sizeof(void *) == 8) {
+        int arg_upper = (int)(((uintptr_t)p_ctx) >> 32);
+        int arg_lower = (int)(((uintptr_t)p_ctx) >> 0);
+        makecontext(&p_ctx->uctx, (void (*)())ABTD_ucontext_wrapper, 2,
+                    arg_upper, arg_lower);
+    } else if (sizeof(void *) == 4) {
+        int arg = (int)((uintptr_t)p_ctx);
+        makecontext(&p_ctx->uctx, (void (*)())ABTD_ucontext_wrapper, 1, arg);
+    } else {
+        ABTI_ASSERT(0);
+    }
+}
+
+static inline
+void ABTD_thread_context_jump(ABTD_thread_context *p_old,
+                              ABTD_thread_context *p_new, void *arg)
+{
+    p_new->p_uctx_arg = arg;
+    swapcontext(&p_old->uctx, &p_new->uctx);
+}
+
+static inline
+void ABTD_thread_context_take(ABTD_thread_context *p_old,
+                              ABTD_thread_context *p_new, void *arg)
+{
+    p_new->p_uctx_arg = arg;
+    setcontext(&p_new->uctx);
+    /* Unreachable. */
+}
+
+#if ABT_CONFIG_THREAD_TYPE == ABT_THREAD_TYPE_DYNAMIC_PROMOTION
+#error "ABTD_thread_context_make_and_call is not implemented."
+#endif
+
+#endif /* ABTD_UCONTEXT_H_INCLUDED */