context: clean up

This patch does the following:
- changes fctx to ctx/p_ctx if "fctx" is not fcontext specific.
- fixes up white spaces.
- updates comments that mention fcontext.

Author: shintaro-iwasaki

src/arch/abtd_thread.c

@@ -12,13 +12,13 @@ static inline void ABTD_thread_terminate_sched(ABTI_local *p_local,
 
 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
@@ -29,13 +29,13 @@ 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
@@ -61,9 +61,9 @@ static inline void ABTDI_thread_terminate(ABTI_local *p_local,
                                           ABTI_thread *p_thread,
                                           ABT_bool is_sched)
 {
-    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;
@@ -112,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) {
@@ -174,21 +174,21 @@ 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. */
-    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);
         }
     }
@@ -198,7 +198,7 @@ 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;
-    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);
     fflush(p_os);

src/include/Makefile.mk

@@ -9,10 +9,10 @@ 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/abtd_context.h \
 	include/abti.h \
 	include/abti_barrier.h \
 	include/abti_cond.h \

src/include/abtd_context.h

@@ -13,15 +13,14 @@
 #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 */
+    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 fctx */
+    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

src/include/abtd_fcontext.h

@@ -6,6 +6,8 @@
 #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
@@ -25,29 +27,29 @@ static inline
 void ABTD_thread_context_make(ABTD_thread_context *p_ctx, void *sp, size_t size,
                               void (*thread_func)(void *))
 {
-    p_ctx->fctx = make_fcontext(sp, size, thread_func);
+    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->fctx, p_new->fctx, 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->fctx, p_new->fctx, 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->fctx);
+    init_and_call_fcontext(arg, thread_func, sp, &p_ctx->p_ctx);
 }
 #endif
 

src/include/abtd_thread.h

@@ -28,7 +28,7 @@ int ABTDI_thread_context_create(ABTD_thread_context *p_link,
     int abt_errno = ABT_SUCCESS;
     void *p_stacktop;
 
-    /* fcontext uses the top address of stack.
+    /* ABTD_thread_context_make uses the top address of stack.
        Note that the parameter, p_stack, points to the bottom of stack. */
     p_stacktop = (void *)(((char *)p_stack) + stacksize);
 
@@ -67,11 +67,11 @@ int ABTD_thread_context_invalidate(ABTD_thread_context *p_newctx)
 {
     int abt_errno = ABT_SUCCESS;
 #if ABT_CONFIG_THREAD_TYPE == ABT_THREAD_TYPE_DYNAMIC_PROMOTION
-    /* fctx is used to check whether the context requires dynamic promotion is
+    /* p_ctx is used to check whether the context requires dynamic promotion is
      * necessary or not, so this value must not be NULL. */
-    p_newctx->fctx = (void *)((intptr_t)0x1);
+    p_newctx->p_ctx = (void *)((intptr_t)0x1);
 #else
-    p_newctx->fctx = NULL;
+    p_newctx->p_ctx = NULL;
 #endif
     p_newctx->f_thread = NULL;
     p_newctx->p_arg = NULL;
@@ -86,7 +86,7 @@ int ABTD_thread_context_init(ABTD_thread_context *p_link,
                              ABTD_thread_context *p_newctx)
 {
     int abt_errno = ABT_SUCCESS;
-    p_newctx->fctx = NULL;
+    p_newctx->p_ctx = NULL;
     p_newctx->f_thread = f_thread;
     p_newctx->p_arg = p_arg;
     p_newctx->p_link = p_link;
@@ -100,9 +100,9 @@ int ABTD_thread_context_arm_thread(size_t stacksize, void *p_stack,
     /* This function *arms* the dynamic promotion thread (initialized by
      * ABTD_thread_context_init) as if it were created by
      * ABTD_thread_context_create; this function fully creates the context
-     * so that the thread can be run by jump_fcontext. */
+     * so that the thread can be run by ABTD_thread_context_jump. */
     int abt_errno = ABT_SUCCESS;
-    /* fcontext uses the top address of stack.
+    /* ABTD_thread_context_make uses the top address of stack.
        Note that the parameter, p_stack, points to the bottom of stack. */
     void *p_stacktop = (void *)(((char *)p_stack) + stacksize);
     ABTD_thread_context_make(p_newctx, p_stacktop, stacksize,
@@ -142,7 +142,7 @@ ABT_bool ABTD_thread_context_is_dynamic_promoted(ABTD_thread_context *p_ctx)
 {
     /* Check if the ULT has been dynamically promoted; internally, it checks if
      * the context is NULL. */
-    return p_ctx->fctx ? ABT_TRUE : ABT_FALSE;
+    return p_ctx->p_ctx ? ABT_TRUE : ABT_FALSE;
 }
 
 static inline

src/include/abtd_ucontext.h

@@ -28,7 +28,7 @@ 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;
+    p_ctx->p_ctx = &p_ctx->uctx;
 
     /* uc_link is not used. */
     p_ctx->uctx.uc_link = NULL;

src/include/abti_thread.h

@@ -222,9 +222,9 @@ void ABTI_thread_context_switch_sched_to_thread_internal(ABTI_local *p_local,
             ABTI_ASSERT(p_prev == p_new);
             /* See ABTDI_thread_terminate for details.
              * TODO: avoid making a copy of the code. */
-            ABTD_thread_context *p_fctx = &p_prev->ctx;
+            ABTD_thread_context *p_ctx = &p_prev->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. */
@@ -246,7 +246,7 @@ void ABTI_thread_context_switch_sched_to_thread_internal(ABTI_local *p_local,
                      */
                     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);
                 }