info.c

Go to the documentation of this file.

/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
 * See COPYRIGHT in top-level directory.
 */
 
#include "abti.h"
 
ABTU_ret_err static int info_print_thread_stacks_in_pool(ABTI_global *p_global,
                                                         FILE *fp,
                                                         ABTI_pool *p_pool);
static void info_trigger_print_all_thread_stacks(
    FILE *fp, double timeout, void (*cb_func)(ABT_bool, void *), void *arg);
 
int ABT_info_query_config(ABT_info_query_kind query_kind, void *val)
{
    ABTI_UB_ASSERT(val);
 
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x always requires an init check. */
    ABTI_SETUP_GLOBAL(NULL);
#endif
    switch (query_kind) {
        case ABT_INFO_QUERY_KIND_ENABLED_DEBUG: {
            ABTI_global *p_global = ABTI_global_get_global_or_null();
            if (p_global) {
                *((ABT_bool *)val) = p_global->use_debug;
            } else {
                *((ABT_bool *)val) = ABTD_env_get_use_debug();
            }
        } break;
        case ABT_INFO_QUERY_KIND_ENABLED_PRINT_ERRNO:
#ifdef ABT_CONFIG_PRINT_ABT_ERRNO
            *((ABT_bool *)val) = ABT_TRUE;
#else
            *((ABT_bool *)val) = ABT_FALSE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_LOG: {
            ABTI_global *p_global = ABTI_global_get_global_or_null();
            if (p_global) {
                *((ABT_bool *)val) = p_global->use_logging;
            } else {
                *((ABT_bool *)val) = ABTD_env_get_use_logging();
            }
        } break;
        case ABT_INFO_QUERY_KIND_ENABLED_VALGRIND:
#ifdef HAVE_VALGRIND_SUPPORT
            *((ABT_bool *)val) = ABT_TRUE;
#else
            *((ABT_bool *)val) = ABT_FALSE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_CHECK_ERROR:
#ifndef ABT_CONFIG_DISABLE_ERROR_CHECK
            *((ABT_bool *)val) = ABT_TRUE;
#else
            *((ABT_bool *)val) = ABT_FALSE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_CHECK_POOL_PRODUCER:
            *((ABT_bool *)val) = ABT_FALSE;
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_CHECK_POOL_CONSUMER:
            *((ABT_bool *)val) = ABT_FALSE;
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_PRESERVE_FPU:
#if !defined(ABTD_FCONTEXT_PRESERVE_FPU) && defined(ABT_CONFIG_USE_FCONTEXT)
            *((ABT_bool *)val) = ABT_FALSE;
#else
            /* If ucontext is used, FPU is preserved. */
            *((ABT_bool *)val) = ABT_TRUE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_THREAD_CANCEL:
#ifndef ABT_CONFIG_DISABLE_CANCELLATION
            *((ABT_bool *)val) = ABT_TRUE;
#else
            *((ABT_bool *)val) = ABT_FALSE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_TASK_CANCEL:
#ifndef ABT_CONFIG_DISABLE_CANCELLATION
            *((ABT_bool *)val) = ABT_TRUE;
#else
            *((ABT_bool *)val) = ABT_FALSE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_MIGRATION:
#ifndef ABT_CONFIG_DISABLE_MIGRATION
            *((ABT_bool *)val) = ABT_TRUE;
#else
            *((ABT_bool *)val) = ABT_FALSE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_STACKABLE_SCHED:
            *((ABT_bool *)val) = ABT_TRUE;
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_EXTERNAL_THREAD:
#ifndef ABT_CONFIG_DISABLE_EXT_THREAD
            *((ABT_bool *)val) = ABT_TRUE;
#else
            *((ABT_bool *)val) = ABT_FALSE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_SCHED_SLEEP:
#ifdef ABT_CONFIG_USE_SCHED_SLEEP
            *((ABT_bool *)val) = ABT_TRUE;
#else
            *((ABT_bool *)val) = ABT_FALSE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_PRINT_CONFIG: {
            ABTI_global *p_global = ABTI_global_get_global_or_null();
            if (p_global) {
                *((ABT_bool *)val) = p_global->print_config;
            } else {
                *((ABT_bool *)val) = ABTD_env_get_print_config();
            }
        } break;
        case ABT_INFO_QUERY_KIND_ENABLED_AFFINITY: {
            ABTI_global *p_global;
            /* This check needs runtime check in ABT_init(). */
            ABTI_SETUP_GLOBAL(&p_global);
            *((ABT_bool *)val) = p_global->set_affinity;
        } break;
        case ABT_INFO_QUERY_KIND_MAX_NUM_XSTREAMS: {
            ABTI_global *p_global = ABTI_global_get_global_or_null();
            if (p_global) {
                *((unsigned int *)val) = p_global->max_xstreams;
            } else {
                *((unsigned int *)val) = ABTD_env_get_max_xstreams();
            }
        } break;
        case ABT_INFO_QUERY_KIND_DEFAULT_THREAD_STACKSIZE: {
            ABTI_global *p_global = ABTI_global_get_global_or_null();
            if (p_global) {
                *((size_t *)val) = p_global->thread_stacksize;
            } else {
                *((size_t *)val) = ABTD_env_get_thread_stacksize();
            }
        } break;
        case ABT_INFO_QUERY_KIND_DEFAULT_SCHED_STACKSIZE: {
            ABTI_global *p_global = ABTI_global_get_global_or_null();
            if (p_global) {
                *((size_t *)val) = p_global->sched_stacksize;
            } else {
                *((size_t *)val) = ABTD_env_get_sched_stacksize();
            }
        } break;
        case ABT_INFO_QUERY_KIND_DEFAULT_SCHED_EVENT_FREQ: {
            ABTI_global *p_global = ABTI_global_get_global_or_null();
            if (p_global) {
                *((uint64_t *)val) = p_global->sched_event_freq;
            } else {
                *((uint64_t *)val) = ABTD_env_get_sched_event_freq();
            }
        } break;
        case ABT_INFO_QUERY_KIND_DEFAULT_SCHED_SLEEP_NSEC: {
            ABTI_global *p_global = ABTI_global_get_global_or_null();
            if (p_global) {
                *((uint64_t *)val) = p_global->sched_sleep_nsec;
            } else {
                *((uint64_t *)val) = ABTD_env_get_sched_sleep_nsec();
            }
        } break;
        case ABT_INFO_QUERY_KIND_ENABLED_TOOL:
#ifndef ABT_CONFIG_DISABLE_TOOL_INTERFACE
            *((ABT_bool *)val) = ABT_TRUE;
#else
            *((ABT_bool *)val) = ABT_FALSE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_FCONTEXT:
#ifdef ABT_CONFIG_USE_FCONTEXT
            *((ABT_bool *)val) = ABT_TRUE;
#else
            *((ABT_bool *)val) = ABT_FALSE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_DYNAMIC_PROMOTION:
            *((ABT_bool *)val) = ABT_FALSE;
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_STACK_UNWIND:
#ifdef ABT_CONFIG_ENABLE_STACK_UNWIND
            *((ABT_bool *)val) = ABT_TRUE;
#else
            *((ABT_bool *)val) = ABT_FALSE;
#endif
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_STACK_OVERFLOW_CHECK: {
            ABTI_global *p_global = ABTI_global_get_global_or_null();
            if (p_global) {
                if (p_global->stack_guard_kind == ABTI_STACK_GUARD_MPROTECT) {
                    *((int *)val) = 2;
                } else if (p_global->stack_guard_kind ==
                           ABTI_STACK_GUARD_MPROTECT_STRICT) {
                    *((int *)val) = 3;
                } else {
#if ABT_CONFIG_STACK_CHECK_TYPE == ABTI_STACK_CHECK_TYPE_CANARY
                    *((int *)val) = 1;
#else
                    *((int *)val) = 0;
#endif
                }
            } else {
                ABT_bool is_strict;
                if (ABTD_env_get_stack_guard_mprotect(&is_strict)) {
                    if (is_strict) {
                        *((int *)val) = 3;
                    } else {
                        *((int *)val) = 2;
                    }
                } else {
#if ABT_CONFIG_STACK_CHECK_TYPE == ABTI_STACK_CHECK_TYPE_CANARY
                    *((int *)val) = 1;
#else
                    *((int *)val) = 0;
#endif
                }
            }
        } break;
        case ABT_INFO_QUERY_KIND_WAIT_POLICY:
#if ABT_CONFIG_ACTIVE_WAIT_POLICY
            *((int *)val) = 1;
#else
            *((int *)val) = 0;
#endif
            break;
        case ABT_INFO_QUERY_KIND_ENABLED_LAZY_STACK_ALLOC:
#ifdef ABT_CONFIG_DISABLE_LAZY_STACK_ALLOC
            *((ABT_bool *)val) = ABT_FALSE;
#else
            *((ABT_bool *)val) = ABT_TRUE;
#endif
            break;
        default:
            ABTI_HANDLE_ERROR(ABT_ERR_INV_QUERY_KIND);
    }
    return ABT_SUCCESS;
}
 
int ABT_info_print_config(FILE *fp)
{
    ABTI_UB_ASSERT(fp);
 
    ABTI_global *p_global;
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x always requires an init check. */
    ABTI_SETUP_GLOBAL(&p_global);
#else
    p_global = ABTI_global_get_global_or_null();
    if (!p_global) {
        fprintf(fp, "Argobots is not initialized.\n");
        fflush(fp);
        return ABT_SUCCESS;
    }
#endif
    ABTI_info_print_config(p_global, fp);
    return ABT_SUCCESS;
}
 
int ABT_info_print_all_xstreams(FILE *fp)
{
    ABTI_UB_ASSERT(fp);
 
    ABTI_global *p_global;
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x always requires an init check. */
    ABTI_SETUP_GLOBAL(&p_global);
#else
    p_global = ABTI_global_get_global_or_null();
    if (!p_global) {
        fprintf(fp, "Argobots is not initialized.\n");
        fflush(fp);
        return ABT_SUCCESS;
    }
#endif
 
    ABTD_spinlock_acquire(&p_global->xstream_list_lock);
 
    fprintf(fp, "# of created ESs: %d\n", p_global->num_xstreams);
 
    ABTI_xstream *p_xstream = p_global->p_xstream_head;
    while (p_xstream) {
        ABTI_xstream_print(p_xstream, fp, 0, ABT_FALSE);
        p_xstream = p_xstream->p_next;
    }
 
    ABTD_spinlock_release(&p_global->xstream_list_lock);
 
    fflush(fp);
    return ABT_SUCCESS;
}
 
int ABT_info_print_xstream(FILE *fp, ABT_xstream xstream)
{
    ABTI_UB_ASSERT(fp);
 
    ABTI_xstream *p_xstream = ABTI_xstream_get_ptr(xstream);
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x requires a NULL-handle check. */
    ABTI_CHECK_NULL_XSTREAM_PTR(p_xstream);
#endif
    ABTI_xstream_print(p_xstream, fp, 0, ABT_FALSE);
    return ABT_SUCCESS;
}
 
int ABT_info_print_sched(FILE *fp, ABT_sched sched)
{
    ABTI_UB_ASSERT(fp);
 
    ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x requires a NULL-handle check. */
    ABTI_CHECK_NULL_SCHED_PTR(p_sched);
#endif
    ABTI_sched_print(p_sched, fp, 0, ABT_TRUE);
    return ABT_SUCCESS;
}
 
int ABT_info_print_pool(FILE *fp, ABT_pool pool)
{
    ABTI_UB_ASSERT(fp);
 
    ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x requires a NULL-handle check. */
    ABTI_CHECK_NULL_POOL_PTR(p_pool);
#endif
    ABTI_pool_print(p_pool, fp, 0);
    return ABT_SUCCESS;
}
 
int ABT_info_print_thread(FILE *fp, ABT_thread thread)
{
    ABTI_UB_ASSERT(fp);
 
    ABTI_thread *p_thread = ABTI_thread_get_ptr(thread);
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x requires a NULL-handle check. */
    ABTI_CHECK_NULL_THREAD_PTR(p_thread);
#endif
    ABTI_thread_print(p_thread, fp, 0);
    return ABT_SUCCESS;
}
 
int ABT_info_print_thread_attr(FILE *fp, ABT_thread_attr attr)
{
    ABTI_UB_ASSERT(fp);
 
    ABTI_thread_attr *p_attr = ABTI_thread_attr_get_ptr(attr);
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x requires a NULL-handle check. */
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);
#endif
    ABTI_thread_attr_print(p_attr, fp, 0);
    return ABT_SUCCESS;
}
 
int ABT_info_print_task(FILE *fp, ABT_task task)
{
    ABTI_UB_ASSERT(fp);
 
    ABTI_thread *p_thread = ABTI_thread_get_ptr(task);
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x requires a NULL-handle check. */
    ABTI_CHECK_NULL_TASK_PTR(p_thread);
#endif
    ABTI_thread_print(p_thread, fp, 0);
    return ABT_SUCCESS;
}
 
int ABT_info_print_thread_stack(FILE *fp, ABT_thread thread)
{
    ABTI_UB_ASSERT(fp);
    /* We can check if thread is running or not in ABTI_UB_ASSERT(), but as this
     * info function is basically used for debugging, printing a corrupted stack
     * or even crashing a program would be fine. */
 
    ABTI_thread *p_thread = ABTI_thread_get_ptr(thread);
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x requires a NULL-handle check. */
    ABTI_CHECK_NULL_THREAD_PTR(p_thread);
#endif
    if (!p_thread) {
        fprintf(fp, "no stack\n");
        fflush(0);
    } else {
        if (p_thread->type & ABTI_THREAD_TYPE_YIELDABLE) {
            ABTI_global *p_global = ABTI_global_get_global_or_null();
            if (!p_global) {
                fprintf(fp, "Argobots is not initialized.\n");
                fflush(0);
            } else {
                ABTI_ythread *p_ythread = ABTI_thread_get_ythread(p_thread);
                ABTI_ythread_print_stack(p_global, p_ythread, fp);
            }
        } else {
            fprintf(fp, "no stack\n");
            fflush(0);
        }
    }
    return ABT_SUCCESS;
}
 
int ABT_info_print_thread_stacks_in_pool(FILE *fp, ABT_pool pool)
{
    ABTI_UB_ASSERT(fp);
 
    ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x requires a NULL-handle check. */
    ABTI_CHECK_NULL_POOL_PTR(p_pool);
#endif
    ABTI_global *p_global = ABTI_global_get_global_or_null();
    if (!p_global) {
        fprintf(fp, "Argobots is not initialized.\n");
        fflush(0);
    } else {
        int abt_errno = info_print_thread_stacks_in_pool(p_global, fp, p_pool);
        ABTI_CHECK_ERROR(abt_errno);
    }
    return ABT_SUCCESS;
}
 
int ABT_info_trigger_print_all_thread_stacks(FILE *fp, double timeout,
                                             void (*cb_func)(ABT_bool, void *),
                                             void *arg)
{
    /* assert() is not signal safe, so we cannot validate variables. */
    info_trigger_print_all_thread_stacks(fp, timeout, cb_func, arg);
    return ABT_SUCCESS;
}
 
/*****************************************************************************/
/* Private APIs                                                              */
/*****************************************************************************/
 
ABTU_ret_err static int print_all_thread_stacks(ABTI_global *p_global,
                                                FILE *fp);
 
#define PRINT_STACK_FLAG_UNSET 0
#define PRINT_STACK_FLAG_INITIALIZE 1
#define PRINT_STACK_FLAG_WAIT 2
#define PRINT_STACK_FLAG_FINALIZE 3
 
static ABTD_atomic_int print_stack_flag =
    ABTD_ATOMIC_INT_STATIC_INITIALIZER(PRINT_STACK_FLAG_UNSET);
static FILE *print_stack_fp = NULL;
static double print_stack_timeout = 0.0;
static void (*print_cb_func)(ABT_bool, void *) = NULL;
static void *print_arg = NULL;
static ABTD_atomic_int print_stack_barrier =
    ABTD_ATOMIC_INT_STATIC_INITIALIZER(0);
 
void ABTI_info_check_print_all_thread_stacks(void)
{
    if (ABTD_atomic_acquire_load_int(&print_stack_flag) !=
        PRINT_STACK_FLAG_WAIT)
        return;
 
    /* Wait for the other execution streams using a barrier mechanism. */
    int self_value = ABTD_atomic_fetch_add_int(&print_stack_barrier, 1);
    if (self_value == 0) {
        ABTI_global *p_global = ABTI_global_get_global();
        /* This ES becomes the main ES. */
        double start_time = ABTI_get_wtime();
        ABT_bool force_print = ABT_FALSE;
 
        /* xstreams_lock is acquired to avoid dynamic ES creation while
         * printing data. */
        ABTD_spinlock_acquire(&p_global->xstream_list_lock);
        while (1) {
            if (ABTD_atomic_acquire_load_int(&print_stack_barrier) >=
                p_global->num_xstreams) {
                break;
            }
            if (print_stack_timeout >= 0.0 &&
                (ABTI_get_wtime() - start_time) >= print_stack_timeout) {
                force_print = ABT_TRUE;
                break;
            }
            ABTD_spinlock_release(&p_global->xstream_list_lock);
            ABTD_atomic_pause();
            ABTD_spinlock_acquire(&p_global->xstream_list_lock);
        }
        /* All the available ESs are (supposed to be) stopped. We *assume* that
         * no ES is calling and will call Argobots functions except this
         * function while printing stack information. */
        if (force_print) {
            fprintf(print_stack_fp,
                    "ABT_info_trigger_print_all_thread_stacks: "
                    "timeout (only %d ESs stop)\n",
                    ABTD_atomic_acquire_load_int(&print_stack_barrier));
        }
        int abt_errno = print_all_thread_stacks(p_global, print_stack_fp);
        if (ABTI_IS_ERROR_CHECK_ENABLED && abt_errno != ABT_SUCCESS) {
            fprintf(print_stack_fp, "ABT_info_trigger_print_all_thread_stacks: "
                                    "failed because of an internal error.\n");
        }
        fflush(print_stack_fp);
        /* Release the lock that protects ES data. */
        ABTD_spinlock_release(&p_global->xstream_list_lock);
        if (print_cb_func)
            print_cb_func(force_print, print_arg);
        /* Update print_stack_flag to 3. */
        ABTD_atomic_release_store_int(&print_stack_flag,
                                      PRINT_STACK_FLAG_FINALIZE);
    } else {
        /* Wait for the main ES's work. */
        while (ABTD_atomic_acquire_load_int(&print_stack_flag) !=
               PRINT_STACK_FLAG_FINALIZE)
            ABTD_atomic_pause();
    }
    ABTI_ASSERT(ABTD_atomic_acquire_load_int(&print_stack_flag) ==
                PRINT_STACK_FLAG_FINALIZE);
 
    /* Decrement the barrier value. */
    int dec_value = ABTD_atomic_fetch_sub_int(&print_stack_barrier, 1);
    if (dec_value == 0) {
        /* The last execution stream resets the flag. */
        ABTD_atomic_release_store_int(&print_stack_flag,
                                      PRINT_STACK_FLAG_UNSET);
    }
}
 
void ABTI_info_print_config(ABTI_global *p_global, FILE *fp)
{
    fprintf(fp, "Argobots Configuration:\n");
    fprintf(fp, " - version: " ABT_VERSION "\n");
    fprintf(fp, " - # of cores: %d\n", p_global->num_cores);
    fprintf(fp, " - cache line size: %u B\n", ABT_CONFIG_STATIC_CACHELINE_SIZE);
    fprintf(fp, " - huge page size: %zu B\n", p_global->huge_page_size);
    fprintf(fp, " - max. # of ESs: %d\n", p_global->max_xstreams);
    fprintf(fp, " - cur. # of ESs: %d\n", p_global->num_xstreams);
    fprintf(fp, " - ES affinity: %s\n",
            (p_global->set_affinity == ABT_TRUE) ? "on" : "off");
    fprintf(fp, " - logging: %s\n",
            (p_global->use_logging == ABT_TRUE) ? "on" : "off");
    fprintf(fp, " - debug output: %s\n",
            (p_global->use_debug == ABT_TRUE) ? "on" : "off");
    fprintf(fp, " - print errno: "
#ifdef ABT_CONFIG_PRINT_ABT_ERRNO
                "on"
#else
                "off"
#endif
                "\n");
    fprintf(fp, " - valgrind support: "
#ifdef HAVE_VALGRIND_SUPPORT
                "yes"
#else
                "no"
#endif
                "\n");
    fprintf(fp, " - thread cancellation: "
#ifndef ABT_CONFIG_DISABLE_CANCELLATION
                "enabled"
#else
                "disabled"
#endif
                "\n");
    fprintf(fp, " - thread migration: "
#ifndef ABT_CONFIG_DISABLE_MIGRATION
                "enabled"
#else
                "disabled"
#endif
                "\n");
    fprintf(fp, " - external thread: "
#ifndef ABT_CONFIG_DISABLE_EXT_THREAD
                "enabled"
#else
                "disabled"
#endif
                "\n");
    fprintf(fp, " - error check: "
#ifndef ABT_CONFIG_DISABLE_ERROR_CHECK
                "enabled"
#else
                "disable"
#endif
                "\n");
    fprintf(fp, " - tool interface: "
#ifndef ABT_CONFIG_DISABLE_TOOL_INTERFACE
                "yes"
#else
                "no"
#endif
                "\n");
    fprintf(fp, " - wait policy: "
#ifdef ABT_CONFIG_ACTIVE_WAIT_POLICY
                "active"
#else
                "passive"
#endif
                "\n");
    fprintf(fp, " - context-switch: "
#ifdef ABT_CONFIG_USE_FCONTEXT
                "fcontext"
#ifndef ABTD_FCONTEXT_PRESERVE_FPU
                " (no FPU save)"
#endif
#else  /* ABT_CONFIG_USE_FCONTEXT */
                "ucontext"
#endif /* !ABT_CONFIG_USE_FCONTEXT */
                "\n");
 
    fprintf(fp, " - key table entries: %" PRIu32 "\n",
            p_global->key_table_size);
    fprintf(fp, " - default ULT stack size: %zu KB\n",
            p_global->thread_stacksize / 1024);
    fprintf(fp, " - default scheduler stack size: %zu KB\n",
            p_global->sched_stacksize / 1024);
    fprintf(fp, " - default scheduler event check frequency: %u\n",
            p_global->sched_event_freq);
    fprintf(fp, " - default scheduler sleep: "
#ifdef ABT_CONFIG_USE_SCHED_SLEEP
                "on"
#else
                "off"
#endif
                "\n");
    fprintf(fp, " - default scheduler sleep duration : %" PRIu64 " [ns]\n",
            p_global->sched_sleep_nsec);
 
    fprintf(fp, " - timer function: "
#if defined(ABT_CONFIG_USE_CLOCK_GETTIME)
                "clock_gettime"
#elif defined(ABT_CONFIG_USE_MACH_ABSOLUTE_TIME)
                "mach_absolute_time"
#elif defined(ABT_CONFIG_USE_GETTIMEOFDAY)
                "gettimeofday"
#endif
                "\n");
 
#ifdef ABT_CONFIG_USE_MEM_POOL
    fprintf(fp, "Memory Pool:\n");
    fprintf(fp, " - page size for allocation: %zu KB\n",
            p_global->mem_page_size / 1024);
    fprintf(fp, " - stack page size: %zu KB\n", p_global->mem_sp_size / 1024);
    fprintf(fp, " - max. # of stacks per ES: %u\n", p_global->mem_max_stacks);
    fprintf(fp, " - max. # of descs per ES: %u\n", p_global->mem_max_descs);
    switch (p_global->mem_lp_alloc) {
        case ABTI_MEM_LP_MALLOC:
            fprintf(fp, " - large page allocation: malloc\n");
            break;
        case ABTI_MEM_LP_MMAP_RP:
            fprintf(fp, " - large page allocation: mmap regular pages\n");
            break;
        case ABTI_MEM_LP_MMAP_HP_RP:
            fprintf(fp, " - large page allocation: mmap huge pages + "
                        "regular pages\n");
            break;
        case ABTI_MEM_LP_MMAP_HP_THP:
            fprintf(fp, " - large page allocation: mmap huge pages + THPs\n");
            break;
        case ABTI_MEM_LP_THP:
            fprintf(fp, " - large page allocation: THPs\n");
            break;
    }
#endif /* ABT_CONFIG_USE_MEM_POOL */
 
    fflush(fp);
}
 
/*****************************************************************************/
/* Internal static functions                                                 */
/*****************************************************************************/
 
struct info_print_unit_arg_t {
    ABTI_global *p_global;
    FILE *fp;
};
 
struct info_pool_set_t {
    ABT_pool *pools;
    size_t num;
    size_t len;
};
 
static void info_print_unit(void *arg, ABT_thread thread)
{
    /* This function may not have any side effect on unit because it is passed
     * to p_print_all. */
    struct info_print_unit_arg_t *p_arg;
    p_arg = (struct info_print_unit_arg_t *)arg;
    FILE *fp = p_arg->fp;
    ABTI_thread *p_thread = ABTI_thread_get_ptr(thread);
 
    if (!p_thread) {
        fprintf(fp, "=== unknown (%p) ===\n", (void *)thread);
    } else if (p_thread->type & ABTI_THREAD_TYPE_YIELDABLE) {
        fprintf(fp, "=== ULT (%p) ===\n", (void *)thread);
        ABTI_ythread *p_ythread = ABTI_thread_get_ythread(p_thread);
        ABT_unit_id thread_id = ABTI_thread_get_id(&p_ythread->thread);
        fprintf(fp,
                "id        : %" PRIu64 "\n"
                "ctx       : %p\n",
                (uint64_t)thread_id, (void *)&p_ythread->ctx);
        ABTI_ythread_print_stack(p_arg->p_global, p_ythread, fp);
    } else {
        fprintf(fp, "=== tasklet (%p) ===\n", (void *)thread);
    }
}
 
ABTU_ret_err static int info_print_thread_stacks_in_pool(ABTI_global *p_global,
                                                         FILE *fp,
                                                         ABTI_pool *p_pool)
{
    if (p_pool == NULL) {
        fprintf(fp, "== NULL pool ==\n");
        fflush(fp);
        return ABT_SUCCESS;
    }
    ABTI_CHECK_TRUE(p_pool->optional_def.p_print_all, ABT_ERR_POOL);
 
    ABT_pool pool = ABTI_pool_get_handle(p_pool);
 
    fprintf(fp, "== pool (%p) ==\n", (void *)p_pool);
    struct info_print_unit_arg_t arg;
    arg.p_global = p_global;
    arg.fp = fp;
    p_pool->optional_def.p_print_all(pool, &arg, info_print_unit);
    fflush(fp);
    return ABT_SUCCESS;
}
 
ABTU_ret_err static inline int
info_initialize_pool_set(struct info_pool_set_t *p_set)
{
    size_t default_len = 16;
    int abt_errno =
        ABTU_malloc(sizeof(ABT_pool) * default_len, (void **)&p_set->pools);
    ABTI_CHECK_ERROR(abt_errno);
    p_set->num = 0;
    p_set->len = default_len;
    return ABT_SUCCESS;
}
 
static inline void info_finalize_pool_set(struct info_pool_set_t *p_set)
{
    ABTU_free(p_set->pools);
}
 
ABTU_ret_err static inline int info_add_pool_set(ABT_pool pool,
                                                 struct info_pool_set_t *p_set)
{
    size_t i;
    for (i = 0; i < p_set->num; i++) {
        if (p_set->pools[i] == pool)
            return ABT_SUCCESS;
    }
    /* Add pool to p_set. */
    if (p_set->num == p_set->len) {
        size_t new_len = p_set->len * 2;
        int abt_errno =
            ABTU_realloc(sizeof(ABT_pool) * p_set->len,
                         sizeof(ABT_pool) * new_len, (void **)&p_set->pools);
        ABTI_CHECK_ERROR(abt_errno);
        p_set->len = new_len;
    }
    p_set->pools[p_set->num++] = pool;
    return ABT_SUCCESS;
}
 
static void info_trigger_print_all_thread_stacks(
    FILE *fp, double timeout, void (*cb_func)(ABT_bool, void *), void *arg)
{
    /* This function is signal-safe, so it may not call other functions unless
     * you really know what the called functions do. */
    if (ABTD_atomic_acquire_load_int(&print_stack_flag) ==
        PRINT_STACK_FLAG_UNSET) {
        if (ABTD_atomic_bool_cas_strong_int(&print_stack_flag,
                                            PRINT_STACK_FLAG_UNSET,
                                            PRINT_STACK_FLAG_INITIALIZE)) {
            /* Save fp and timeout. */
            print_stack_fp = fp;
            print_stack_timeout = timeout;
            print_cb_func = cb_func;
            print_arg = arg;
            /* Here print_stack_barrier must be 0. */
            ABTI_ASSERT(ABTD_atomic_acquire_load_int(&print_stack_barrier) ==
                        0);
            ABTD_atomic_release_store_int(&print_stack_flag,
                                          PRINT_STACK_FLAG_WAIT);
        }
    }
}
 
ABTU_ret_err static int print_all_thread_stacks(ABTI_global *p_global, FILE *fp)
{
    size_t i;
    int abt_errno;
    struct info_pool_set_t pool_set;
    struct tm *tm = NULL;
    time_t seconds;
 
    abt_errno = info_initialize_pool_set(&pool_set);
    ABTI_CHECK_ERROR(abt_errno);
    ABTI_xstream *p_xstream = p_global->p_xstream_head;
 
    seconds = (time_t)ABT_get_wtime();
    tm = localtime(&seconds);
    ABTI_ASSERT(tm != NULL);
    fprintf(fp, "Start of ULT stacks dump %04d/%02d/%02d-%02d:%02d:%02d\n",
            tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour,
            tm->tm_min, tm->tm_sec);
 
    while (p_xstream) {
        ABTI_sched *p_main_sched = p_xstream->p_main_sched;
        fprintf(fp, "= xstream[%d] (%p) =\n", p_xstream->rank,
                (void *)p_xstream);
        fprintf(fp, "main_sched : %p\n", (void *)p_main_sched);
        if (!p_main_sched)
            continue;
        for (i = 0; i < p_main_sched->num_pools; i++) {
            ABT_pool pool = p_main_sched->pools[i];
            ABTI_ASSERT(pool != ABT_POOL_NULL);
            fprintf(fp, "  pools[%zu] : %p\n", i,
                    (void *)ABTI_pool_get_ptr(pool));
            abt_errno = info_add_pool_set(pool, &pool_set);
            if (ABTI_IS_ERROR_CHECK_ENABLED && abt_errno != ABT_SUCCESS) {
                info_finalize_pool_set(&pool_set);
                ABTI_HANDLE_ERROR(abt_errno);
            }
        }
        p_xstream = p_xstream->p_next;
    }
    for (i = 0; i < pool_set.num; i++) {
        ABT_pool pool = pool_set.pools[i];
        ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
        abt_errno = info_print_thread_stacks_in_pool(p_global, fp, p_pool);
        if (abt_errno != ABT_SUCCESS)
            fprintf(fp, "  Failed to print (errno = %d).\n", abt_errno);
    }
 
    seconds = (time_t)ABT_get_wtime();
    tm = localtime(&seconds);
    ABTI_ASSERT(tm != NULL);
    fprintf(fp, "End of ULT stacks dump %04d/%02d/%02d-%02d:%02d:%02d\n",
            tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour,
            tm->tm_min, tm->tm_sec);
 
    info_finalize_pool_set(&pool_set);
    return ABT_SUCCESS;
}