abt.h

Go to the documentation of this file.

/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
 * See COPYRIGHT in top-level directory.
 */
 
#ifndef ABT_H_INCLUDED
#define ABT_H_INCLUDED
 
/* user include file for ARGOBOTS programs */
 
#if defined(ABT_C_HAVE_VISIBILITY)
#define ABT_API_PUBLIC  __attribute__((visibility ("default")))
#else
#define ABT_API_PUBLIC
#endif
 
/* Keep C++ compilers from getting confused */
#if defined(__cplusplus)
extern "C" {
#endif
 
#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <sys/time.h>
 
#define ABT_VERSION "1.1"
 
#define ABT_NUMVERSION 10100300
 
#define ABT_RELEASE_TYPE_ALPHA  0
#define ABT_RELEASE_TYPE_BETA   1
#define ABT_RELEASE_TYPE_RC     2
#define ABT_RELEASE_TYPE_PATCH  3
 
#define ABT_CALC_VERSION(MAJOR, MINOR, REVISION, TYPE, PATCH) \
    (((MAJOR) * 10000000) + ((MINOR) * 100000) + ((REVISION) * 1000) + ((TYPE) * 100) + (PATCH))
 
#define ABT_DEPRECATED __attribute__((deprecated))
 
#define ABT_ENABLE_VER_20_API_VAL 0
#undef ABT_ENABLE_VER_20_API
#if ABT_ENABLE_VER_20_API_VAL
#define ABT_ENABLE_VER_20_API 1
#endif
 
#define ABT_SUCCESS                 0
 
#define ABT_ERR_UNINITIALIZED       1
 
#define ABT_ERR_MEM                 2
 
#define ABT_ERR_OTHER               3
 
#define ABT_ERR_INV_XSTREAM         4
 
#define ABT_ERR_INV_XSTREAM_RANK    5
 
#define ABT_ERR_INV_XSTREAM_BARRIER 6
 
#define ABT_ERR_INV_SCHED           7
 
#define ABT_ERR_INV_SCHED_KIND      8
 
#define ABT_ERR_INV_SCHED_PREDEF    9
 
#define ABT_ERR_INV_SCHED_TYPE     10
 
#define ABT_ERR_INV_SCHED_CONFIG   11
 
#define ABT_ERR_INV_POOL           12
 
#define ABT_ERR_INV_POOL_KIND      13
 
#define ABT_ERR_INV_POOL_ACCESS    14
 
#define ABT_ERR_INV_POOL_CONFIG    56
 
#define ABT_ERR_INV_POOL_USER_DEF  57
 
#define ABT_ERR_INV_UNIT           15
 
#define ABT_ERR_INV_THREAD         16
 
#define ABT_ERR_INV_THREAD_ATTR    17
 
#define ABT_ERR_INV_TASK           18
 
#define ABT_ERR_INV_KEY            19
 
#define ABT_ERR_INV_MUTEX          20
 
#define ABT_ERR_INV_MUTEX_ATTR     21
 
#define ABT_ERR_INV_COND           22
 
#define ABT_ERR_INV_RWLOCK         23
 
#define ABT_ERR_INV_EVENTUAL       24
 
#define ABT_ERR_INV_FUTURE         25
 
#define ABT_ERR_INV_BARRIER        26
 
#define ABT_ERR_INV_TIMER          27
 
#define ABT_ERR_INV_QUERY_KIND     28
 
#define ABT_ERR_INV_TOOL_CONTEXT   52
 
#define ABT_ERR_INV_ARG            53
 
#define ABT_ERR_XSTREAM            29
 
#define ABT_ERR_XSTREAM_STATE      30
 
#define ABT_ERR_XSTREAM_BARRIER    31
 
#define ABT_ERR_SCHED              32
 
#define ABT_ERR_SCHED_CONFIG       33
 
#define ABT_ERR_POOL               34
 
#define ABT_ERR_UNIT               35
 
#define ABT_ERR_THREAD             36
 
#define ABT_ERR_TASK               37
 
#define ABT_ERR_KEY                38
 
#define ABT_ERR_MUTEX              39
 
#define ABT_ERR_MUTEX_LOCKED       40
 
#define ABT_ERR_COND               41
 
#define ABT_ERR_COND_TIMEDOUT      42
 
#define ABT_ERR_RWLOCK             43
 
#define ABT_ERR_EVENTUAL           44
 
#define ABT_ERR_FUTURE             45
 
#define ABT_ERR_BARRIER            46
 
#define ABT_ERR_TIMER              47
 
#define ABT_ERR_MIGRATION_TARGET   48
 
#define ABT_ERR_MIGRATION_NA       49
 
#define ABT_ERR_MISSING_JOIN       50
 
#define ABT_ERR_FEATURE_NA         51
 
#define ABT_ERR_SYS                54
 
#define ABT_ERR_CPUID              55
 
enum ABT_xstream_state {
    ABT_XSTREAM_STATE_RUNNING,
    ABT_XSTREAM_STATE_TERMINATED
};
 
enum ABT_thread_state {
    ABT_THREAD_STATE_READY,
    ABT_THREAD_STATE_RUNNING,
    ABT_THREAD_STATE_BLOCKED,
    ABT_THREAD_STATE_TERMINATED
};
 
enum ABT_task_state {
    ABT_TASK_STATE_READY,
    ABT_TASK_STATE_RUNNING,
    ABT_TASK_STATE_TERMINATED
};
 
enum ABT_sched_state {
    ABT_SCHED_STATE_READY,
    ABT_SCHED_STATE_RUNNING,
    ABT_SCHED_STATE_STOPPED,
    ABT_SCHED_STATE_TERMINATED
};
 
enum ABT_sched_predef {
    ABT_SCHED_DEFAULT,
    ABT_SCHED_BASIC,
    ABT_SCHED_PRIO,
    ABT_SCHED_RANDWS,
    ABT_SCHED_BASIC_WAIT,
};
 
enum ABT_sched_type {
    ABT_SCHED_TYPE_ULT,
    ABT_SCHED_TYPE_TASK
};
 
enum ABT_pool_kind {
    ABT_POOL_FIFO,
    ABT_POOL_FIFO_WAIT,
    ABT_POOL_RANDWS
};
 
enum ABT_pool_access {
    ABT_POOL_ACCESS_PRIV,
    ABT_POOL_ACCESS_SPSC,
    ABT_POOL_ACCESS_MPSC,
    ABT_POOL_ACCESS_SPMC,
    ABT_POOL_ACCESS_MPMC
};
 
enum ABT_unit_type {
    ABT_UNIT_TYPE_THREAD,
    ABT_UNIT_TYPE_TASK,
    ABT_UNIT_TYPE_XSTREAM,
    ABT_UNIT_TYPE_EXT
};
 
enum ABT_info_query_kind {
    ABT_INFO_QUERY_KIND_ENABLED_DEBUG,
    ABT_INFO_QUERY_KIND_ENABLED_PRINT_ERRNO,
    ABT_INFO_QUERY_KIND_ENABLED_LOG,
    ABT_INFO_QUERY_KIND_ENABLED_VALGRIND,
    ABT_INFO_QUERY_KIND_ENABLED_CHECK_ERROR,
    ABT_INFO_QUERY_KIND_ENABLED_CHECK_POOL_PRODUCER,
    ABT_INFO_QUERY_KIND_ENABLED_CHECK_POOL_CONSUMER,
    ABT_INFO_QUERY_KIND_ENABLED_PRESERVE_FPU,
    ABT_INFO_QUERY_KIND_ENABLED_THREAD_CANCEL,
    ABT_INFO_QUERY_KIND_ENABLED_TASK_CANCEL,
    ABT_INFO_QUERY_KIND_ENABLED_MIGRATION,
    ABT_INFO_QUERY_KIND_ENABLED_STACKABLE_SCHED,
    ABT_INFO_QUERY_KIND_ENABLED_EXTERNAL_THREAD,
    ABT_INFO_QUERY_KIND_ENABLED_SCHED_SLEEP,
    ABT_INFO_QUERY_KIND_ENABLED_PRINT_CONFIG,
    ABT_INFO_QUERY_KIND_ENABLED_AFFINITY,
    ABT_INFO_QUERY_KIND_MAX_NUM_XSTREAMS,
    ABT_INFO_QUERY_KIND_DEFAULT_THREAD_STACKSIZE,
    ABT_INFO_QUERY_KIND_DEFAULT_SCHED_STACKSIZE,
    ABT_INFO_QUERY_KIND_DEFAULT_SCHED_EVENT_FREQ,
    ABT_INFO_QUERY_KIND_DEFAULT_SCHED_SLEEP_NSEC,
    ABT_INFO_QUERY_KIND_ENABLED_TOOL,
    ABT_INFO_QUERY_KIND_FCONTEXT,
    ABT_INFO_QUERY_KIND_DYNAMIC_PROMOTION,
    ABT_INFO_QUERY_KIND_ENABLED_STACK_UNWIND,
    ABT_INFO_QUERY_KIND_ENABLED_STACK_OVERFLOW_CHECK,
    ABT_INFO_QUERY_KIND_WAIT_POLICY,
    ABT_INFO_QUERY_KIND_ENABLED_LAZY_STACK_ALLOC,
};
 
enum ABT_tool_query_kind {
    ABT_TOOL_QUERY_KIND_POOL,
    ABT_TOOL_QUERY_KIND_STACK_DEPTH,
    ABT_TOOL_QUERY_KIND_CALLER_TYPE,
    ABT_TOOL_QUERY_KIND_CALLER_HANDLE,
    ABT_TOOL_QUERY_KIND_SYNC_OBJECT_TYPE,
    ABT_TOOL_QUERY_KIND_SYNC_OBJECT_HANDLE,
};
 
enum ABT_exec_entity_type {
    ABT_EXEC_ENTITY_TYPE_EXT,
    ABT_EXEC_ENTITY_TYPE_THREAD,
};
 
enum ABT_sync_event_type {
    ABT_SYNC_EVENT_TYPE_UNKNOWN = 0,
    ABT_SYNC_EVENT_TYPE_USER,
    ABT_SYNC_EVENT_TYPE_OTHER,
    ABT_SYNC_EVENT_TYPE_XSTREAM_JOIN,
    ABT_SYNC_EVENT_TYPE_THREAD_JOIN,
    ABT_SYNC_EVENT_TYPE_MUTEX,
    ABT_SYNC_EVENT_TYPE_COND,
    ABT_SYNC_EVENT_TYPE_RWLOCK,
    ABT_SYNC_EVENT_TYPE_EVENTUAL,
    ABT_SYNC_EVENT_TYPE_FUTURE,
    ABT_SYNC_EVENT_TYPE_BARRIER,
};
 
#define ABT_TOOL_EVENT_THREAD_NONE    (0)
 
#define ABT_TOOL_EVENT_THREAD_CREATE  (1 << 0)
 
#define ABT_TOOL_EVENT_THREAD_JOIN    (1 << 1)
 
#define ABT_TOOL_EVENT_THREAD_FREE    (1 << 2)
 
#define ABT_TOOL_EVENT_THREAD_REVIVE  (1 << 3)
 
#define ABT_TOOL_EVENT_THREAD_RUN     (1 << 4)
 
#define ABT_TOOL_EVENT_THREAD_FINISH  (1 << 5)
 
#define ABT_TOOL_EVENT_THREAD_CANCEL  (1 << 6)
 
#define ABT_TOOL_EVENT_THREAD_YIELD   (1 << 7)
 
#define ABT_TOOL_EVENT_THREAD_SUSPEND (1 << 8)
 
#define ABT_TOOL_EVENT_THREAD_RESUME  (1 << 9)
 
#define ABT_TOOL_EVENT_THREAD_ALL     ((uint64_t)((1 << 12) - 1))
 
 
#define ABT_TRUE  1
 
#define ABT_FALSE 0
 
#define ABT_XSTREAM_ANY_RANK    -1
 
/* Data Types */
struct ABT_xstream_opaque;
struct ABT_xstream_barrier_opaque;
struct ABT_sched_opaque;
struct ABT_sched_config_opaque;
struct ABT_pool_opaque;
struct ABT_pool_config_opaque;
struct ABT_pool_def;
struct ABT_unit_opaque;
struct ABT_thread_opaque;
struct ABT_thread_attr_opaque;
struct ABT_task_opaque;
struct ABT_key_opaque;
struct ABT_mutex_opaque;
struct ABT_mutex_attr_opaque;
struct ABT_cond_opaque;
struct ABT_rwlock_opaque;
struct ABT_eventual_opaque;
struct ABT_future_opaque;
struct ABT_barrier_opaque;
struct ABT_timer_opaque;
struct ABT_tool_context_opaque;
 
typedef struct ABT_xstream_opaque *         ABT_xstream;
typedef enum ABT_xstream_state              ABT_xstream_state;
typedef struct ABT_xstream_barrier_opaque * ABT_xstream_barrier;
typedef struct ABT_sched_opaque *           ABT_sched;
typedef struct ABT_sched_config_opaque *    ABT_sched_config;
typedef enum ABT_sched_predef               ABT_sched_predef;
typedef enum ABT_sched_state                ABT_sched_state;
typedef enum ABT_sched_type                 ABT_sched_type;
typedef struct ABT_pool_opaque *            ABT_pool;
typedef struct ABT_pool_config_opaque *     ABT_pool_config;
typedef enum ABT_pool_kind                  ABT_pool_kind;
typedef enum ABT_pool_access                ABT_pool_access;
typedef struct ABT_pool_def *               ABT_pool_user_def;
typedef struct ABT_unit_opaque *            ABT_unit;
typedef enum ABT_unit_type                  ABT_unit_type;
typedef uint64_t                            ABT_unit_id;
typedef struct ABT_thread_opaque *          ABT_thread;
typedef struct ABT_thread_attr_opaque *     ABT_thread_attr;
typedef enum ABT_thread_state               ABT_thread_state;
typedef enum ABT_task_state                 ABT_task_state;
typedef ABT_unit_id                         ABT_thread_id;
typedef struct ABT_thread_opaque *          ABT_task;
typedef struct ABT_key_opaque *             ABT_key;
typedef struct ABT_mutex_opaque *           ABT_mutex;
typedef struct ABT_mutex_attr_opaque *      ABT_mutex_attr;
typedef struct ABT_cond_opaque *            ABT_cond;
typedef struct ABT_rwlock_opaque *          ABT_rwlock;
typedef struct ABT_eventual_opaque *        ABT_eventual;
typedef struct ABT_future_opaque *          ABT_future;
typedef struct ABT_barrier_opaque *         ABT_barrier;
typedef struct ABT_timer_opaque *           ABT_timer;
typedef int                                 ABT_bool;
typedef enum ABT_info_query_kind            ABT_info_query_kind;
typedef struct ABT_tool_context_opaque *    ABT_tool_context;
typedef enum ABT_tool_query_kind            ABT_tool_query_kind;
typedef enum ABT_exec_entity_type           ABT_exec_entity_type;
typedef enum ABT_sync_event_type            ABT_sync_event_type;
 
 
/* Null Object Handles */
#define ABT_NULL 0
#if ABT_NULL == 1
#define ABT_XSTREAM_NULL         ((ABT_xstream)        NULL)
#define ABT_XSTREAM_BARRIER_NULL ((ABT_xstream_barrier)NULL)
#define ABT_SCHED_NULL           ((ABT_sched)          NULL)
#define ABT_SCHED_CONFIG_NULL    ((ABT_sched_config)   NULL)
#define ABT_POOL_NULL            ((ABT_pool)           NULL)
#define ABT_POOL_CONFIG_NULL     ((ABT_pool_config)    NULL)
#define ABT_UNIT_NULL            ((ABT_unit)           NULL)
#define ABT_THREAD_NULL          ((ABT_thread)         NULL)
#define ABT_THREAD_ATTR_NULL     ((ABT_thread_attr)    NULL)
#define ABT_TASK_NULL            ((ABT_task)           NULL)
#define ABT_KEY_NULL             ((ABT_key)            NULL)
#define ABT_MUTEX_NULL           ((ABT_mutex)          NULL)
#define ABT_MUTEX_ATTR_NULL      ((ABT_mutex_attr)     NULL)
#define ABT_COND_NULL            ((ABT_cond)           NULL)
#define ABT_RWLOCK_NULL          ((ABT_rwlock)         NULL)
#define ABT_EVENTUAL_NULL        ((ABT_eventual)       NULL)
#define ABT_FUTURE_NULL          ((ABT_future)         NULL)
#define ABT_BARRIER_NULL         ((ABT_barrier)        NULL)
#define ABT_TIMER_NULL           ((ABT_timer)          NULL)
#define ABT_TOOL_CONTEXT_NULL    ((ABT_tool_context)   NULL)
#define ABT_POOL_USER_DEF_NULL   ((ABT_pool_user_def)  NULL)
#else
#define ABT_XSTREAM_NULL         ((ABT_xstream)        (0x01))
#define ABT_XSTREAM_BARRIER_NULL ((ABT_xstream_barrier)(0x02))
#define ABT_SCHED_NULL           ((ABT_sched)          (0x03))
#define ABT_SCHED_CONFIG_NULL    ((ABT_sched_config)   (0x04))
#define ABT_POOL_NULL            ((ABT_pool)           (0x05))
#define ABT_POOL_CONFIG_NULL     ((ABT_pool_config)    (0x06))
#define ABT_UNIT_NULL            ((ABT_unit)           (0x07))
#define ABT_THREAD_NULL          ((ABT_thread)         (0x08))
#define ABT_THREAD_ATTR_NULL     ((ABT_thread_attr)    (0x09))
#define ABT_TASK_NULL            ((ABT_task)           (0x0a))
#define ABT_KEY_NULL             ((ABT_key)            (0x0b))
#define ABT_MUTEX_NULL           ((ABT_mutex)          (0x0c))
#define ABT_MUTEX_ATTR_NULL      ((ABT_mutex_attr)     (0x0d))
#define ABT_COND_NULL            ((ABT_cond)           (0x0e))
#define ABT_RWLOCK_NULL          ((ABT_rwlock)         (0x0f))
#define ABT_EVENTUAL_NULL        ((ABT_eventual)       (0x10))
#define ABT_FUTURE_NULL          ((ABT_future)         (0x11))
#define ABT_BARRIER_NULL         ((ABT_barrier)        (0x12))
#define ABT_TIMER_NULL           ((ABT_timer)          (0x13))
#define ABT_TOOL_CONTEXT_NULL    ((ABT_tool_context)   (0x14))
#define ABT_POOL_USER_DEF_NULL   ((ABT_pool_user_def)  (0x15))
#endif
 
typedef struct {
    int dummy[16];
} ABT_mutex_memory;
 
#define ABT_MUTEX_INITIALIZER                                                  \
    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
 
#define ABT_RECURSIVE_MUTEX_INITIALIZER                                        \
    { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
 
#define ABT_MUTEX_MEMORY_GET_HANDLE(p_mutex_memory)                            \
    ((ABT_mutex)p_mutex_memory)
 
typedef struct {
    int dummy[16];
} ABT_cond_memory;
 
#define ABT_COND_INITIALIZER                                                   \
    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
 
#define ABT_COND_MEMORY_GET_HANDLE(p_cond_memory)                              \
    ((ABT_cond)p_cond_memory)
 
typedef struct {
    int dummy[16];
} ABT_eventual_memory;
 
#define ABT_EVENTUAL_INITIALIZER                                               \
    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
 
#define ABT_EVENTUAL_MEMORY_GET_HANDLE(p_eventual_memory)                      \
    ((ABT_eventual)p_eventual_memory)
 
typedef enum {
    ABT_SCHED_CONFIG_INT    = 0,
    ABT_SCHED_CONFIG_DOUBLE = 1,
    ABT_SCHED_CONFIG_PTR    = 2,
} ABT_sched_config_type;
 
typedef struct {
    int idx;
    ABT_sched_config_type type;
} ABT_sched_config_var;
 
extern ABT_sched_config_var ABT_sched_config_var_end ABT_API_PUBLIC;
extern ABT_sched_config_var ABT_sched_basic_freq ABT_API_PUBLIC;
extern ABT_sched_config_var ABT_sched_config_access ABT_API_PUBLIC;
extern ABT_sched_config_var ABT_sched_config_automatic ABT_API_PUBLIC;
 
/* Scheduler Functions */
typedef int      (*ABT_sched_init_fn)(ABT_sched, ABT_sched_config);
typedef void     (*ABT_sched_run_fn)(ABT_sched);
typedef int      (*ABT_sched_free_fn)(ABT_sched);
/* To get a pool ready for receiving a migration */
typedef ABT_pool (*ABT_sched_get_migr_pool_fn)(ABT_sched);
 
typedef struct {
    ABT_sched_type type;
    ABT_sched_init_fn          init;
    ABT_sched_run_fn           run;
    ABT_sched_free_fn          free;
    ABT_sched_get_migr_pool_fn get_migr_pool;
} ABT_sched_def;
 
typedef enum {
    ABT_POOL_CONFIG_INT    = 0,
    ABT_POOL_CONFIG_DOUBLE = 1,
    ABT_POOL_CONFIG_PTR    = 2,
} ABT_pool_config_type;
 
typedef struct {
    int key;
    ABT_pool_config_type type;
} ABT_pool_config_var;
 
extern const ABT_pool_config_var ABT_pool_config_automatic ABT_API_PUBLIC;
 
typedef uint64_t ABT_pool_context;
#define ABT_POOL_CONTEXT_PRIO_DEFAULT_PRIO ((ABT_pool_context)0x0)
 
#define ABT_POOL_CONTEXT_PRIO_HIGH_PRIO ((ABT_pool_context)0x1)
 
#define ABT_POOL_CONTEXT_PRIO_LOW_PRIO ((ABT_pool_context)0x2)
 
#define ABT_POOL_CONTEXT_OWNER_DEFAULT ((ABT_pool_context)0x0)
 
#define ABT_POOL_CONTEXT_OWNER_PRIMARY ((ABT_pool_context)0x100)
 
#define ABT_POOL_CONTEXT_OWNER_SECONDARY ((ABT_pool_context)0x200)
 
#define ABT_POOL_CONTEXT_OP_POOL_OTHER ((ABT_pool_context)0x0)
 
#define ABT_POOL_CONTEXT_OP_THREAD_CREATE ((ABT_pool_context)0x1000)
 
#define ABT_POOL_CONTEXT_OP_THREAD_CREATE_TO ((ABT_pool_context)0x2000)
 
#define ABT_POOL_CONTEXT_OP_THREAD_REVIVE ((ABT_pool_context)0x4000)
 
#define ABT_POOL_CONTEXT_OP_THREAD_REVIVE_TO ((ABT_pool_context)0x8000)
 
#define ABT_POOL_CONTEXT_OP_THREAD_YIELD ((ABT_pool_context)0x10000)
 
#define ABT_POOL_CONTEXT_OP_THREAD_YIELD_TO ((ABT_pool_context)0x20000)
 
#define ABT_POOL_CONTEXT_OP_THREAD_RESUME_YIELD_TO ((ABT_pool_context)0x40000)
 
#define ABT_POOL_CONTEXT_OP_THREAD_YIELD_LOOP ((ABT_pool_context)0x80000)
 
#define ABT_POOL_CONTEXT_OP_THREAD_RESUME ((ABT_pool_context)0x100000)
 
#define ABT_POOL_CONTEXT_OP_THREAD_MIGRATE ((ABT_pool_context)0x200000)
 
/* Pool Functions */
typedef ABT_unit (*ABT_pool_user_create_unit_fn)(ABT_pool, ABT_thread);
typedef void (*ABT_pool_user_free_unit_fn)(ABT_pool, ABT_unit);
typedef ABT_bool (*ABT_pool_user_is_empty_fn)(ABT_pool);
typedef ABT_thread (*ABT_pool_user_pop_fn)(ABT_pool, ABT_pool_context);
typedef void (*ABT_pool_user_push_fn)(ABT_pool, ABT_unit, ABT_pool_context);
typedef int (*ABT_pool_user_init_fn)(ABT_pool, ABT_pool_config);
typedef void (*ABT_pool_user_free_fn)(ABT_pool);
typedef size_t (*ABT_pool_user_get_size_fn)(ABT_pool);
typedef ABT_thread (*ABT_pool_user_pop_wait_fn)(ABT_pool, double,
                                                ABT_pool_context);
typedef void (*ABT_pool_user_pop_many_fn)(ABT_pool, ABT_thread *, size_t,
                                          size_t *, ABT_pool_context);
typedef void (*ABT_pool_user_push_many_fn)(ABT_pool, const ABT_unit *, size_t,
                                           ABT_pool_context);
typedef void (*ABT_pool_user_print_all_fn)(ABT_pool, void *arg,
                                           void (*)(void *, ABT_thread));
 
/* Pool Functions */
typedef ABT_unit_type (*ABT_unit_get_type_fn)(ABT_unit);
typedef ABT_thread    (*ABT_unit_get_thread_fn)(ABT_unit);
typedef ABT_task      (*ABT_unit_get_task_fn)(ABT_unit);
typedef ABT_bool      (*ABT_unit_is_in_pool_fn)(ABT_unit);
typedef ABT_unit      (*ABT_unit_create_from_thread_fn)(ABT_thread);
typedef ABT_unit      (*ABT_unit_create_from_task_fn)(ABT_task);
typedef void          (*ABT_unit_free_fn)(ABT_unit *);
typedef int           (*ABT_pool_init_fn)(ABT_pool, ABT_pool_config);
typedef size_t        (*ABT_pool_get_size_fn)(ABT_pool);
typedef void          (*ABT_pool_push_fn)(ABT_pool, ABT_unit);
typedef ABT_unit      (*ABT_pool_pop_fn)(ABT_pool);
typedef ABT_unit      (*ABT_pool_pop_wait_fn)(ABT_pool, double);
typedef ABT_unit      (*ABT_pool_pop_timedwait_fn)(ABT_pool, double); /* Deprecated .*/
typedef int           (*ABT_pool_remove_fn)(ABT_pool, ABT_unit);
typedef int           (*ABT_pool_free_fn)(ABT_pool);
typedef int           (*ABT_pool_print_all_fn)(ABT_pool, void *arg,
                                               void (*)(void*, ABT_unit));
 
struct ABT_pool_def {
    ABT_pool_access access;
    ABT_unit_get_type_fn           u_get_type;
    ABT_unit_get_thread_fn         u_get_thread;
    ABT_unit_get_task_fn           u_get_task;
    ABT_unit_is_in_pool_fn         u_is_in_pool;
    ABT_unit_create_from_thread_fn u_create_from_thread;
    ABT_unit_create_from_task_fn   u_create_from_task;
    ABT_unit_free_fn               u_free;
    ABT_pool_init_fn          p_init;
    ABT_pool_get_size_fn      p_get_size;
    ABT_pool_push_fn          p_push;
    ABT_pool_pop_fn           p_pop;
#ifdef ABT_ENABLE_VER_20_API
 
    ABT_pool_pop_wait_fn      p_pop_wait;
#endif
 
    ABT_pool_pop_timedwait_fn p_pop_timedwait;
    ABT_pool_remove_fn        p_remove;
    ABT_pool_free_fn          p_free;
    ABT_pool_print_all_fn     p_print_all;
};
typedef struct ABT_pool_def ABT_pool_def;
 
/* Tool callback type. */
typedef void (*ABT_tool_thread_callback_fn)(ABT_thread, ABT_xstream, uint64_t event,
                                            ABT_tool_context context, void *user_arg);
typedef void (*ABT_tool_task_callback_fn)(ABT_task, ABT_xstream, uint64_t event,
                                          ABT_tool_context context, void *user_arg);
 
/* Init & Finalize */
int ABT_init(int argc, char **argv) ABT_API_PUBLIC;
int ABT_finalize(void) ABT_API_PUBLIC;
int ABT_initialized(void) ABT_API_PUBLIC;
 
/* Execution Stream (ES) */
int ABT_xstream_create(ABT_sched sched, ABT_xstream *newxstream) ABT_API_PUBLIC;
int ABT_xstream_create_basic(ABT_sched_predef predef, int num_pools,
                             ABT_pool *pools, ABT_sched_config config,
                             ABT_xstream *newxstream) ABT_API_PUBLIC;
int ABT_xstream_create_with_rank(ABT_sched sched, int rank,
                                 ABT_xstream *newxstream) ABT_API_PUBLIC;
int ABT_xstream_free(ABT_xstream *xstream) ABT_API_PUBLIC;
int ABT_xstream_join(ABT_xstream xstream) ABT_API_PUBLIC;
int ABT_xstream_revive(ABT_xstream xstream) ABT_API_PUBLIC;
int ABT_xstream_exit(void) ABT_API_PUBLIC;
int ABT_xstream_cancel(ABT_xstream xstream) ABT_API_PUBLIC;
int ABT_xstream_self(ABT_xstream *xstream) ABT_API_PUBLIC;
int ABT_xstream_self_rank(int *rank) ABT_API_PUBLIC;
int ABT_xstream_set_rank(ABT_xstream xstream, int rank) ABT_API_PUBLIC;
int ABT_xstream_get_rank(ABT_xstream xstream, int *rank) ABT_API_PUBLIC;
int ABT_xstream_set_main_sched(ABT_xstream xstream, ABT_sched sched) ABT_API_PUBLIC;
int ABT_xstream_set_main_sched_basic(ABT_xstream xstream,
                                     ABT_sched_predef predef,
                                     int num_pools, ABT_pool *pools) ABT_API_PUBLIC;
int ABT_xstream_get_main_sched(ABT_xstream xstream, ABT_sched *sched) ABT_API_PUBLIC;
int ABT_xstream_get_main_pools(ABT_xstream xstream, int max_pools,
                               ABT_pool *pools) ABT_API_PUBLIC;
int ABT_xstream_get_state(ABT_xstream xstream, ABT_xstream_state *state) ABT_API_PUBLIC;
int ABT_xstream_equal(ABT_xstream xstream1, ABT_xstream xstream2,
                      ABT_bool *result) ABT_API_PUBLIC;
int ABT_xstream_get_num(int *num_xstreams) ABT_API_PUBLIC;
int ABT_xstream_is_primary(ABT_xstream xstream, ABT_bool *is_primary) ABT_API_PUBLIC;
int ABT_xstream_run_unit(ABT_unit unit, ABT_pool pool) ABT_API_PUBLIC;
int ABT_xstream_check_events(ABT_sched sched) ABT_API_PUBLIC;
int ABT_xstream_set_cpubind(ABT_xstream xstream, int cpuid) ABT_API_PUBLIC;
int ABT_xstream_get_cpubind(ABT_xstream xstream, int *cpuid) ABT_API_PUBLIC;
int ABT_xstream_set_affinity(ABT_xstream xstream, int num_cpuids, int *cpuids)
                             ABT_API_PUBLIC;
int ABT_xstream_get_affinity(ABT_xstream xstream, int max_cpuids, int *cpuids,
                             int *num_cpuids) ABT_API_PUBLIC;
 
/* ES Barrier */
int ABT_xstream_barrier_create(uint32_t num_waiters, ABT_xstream_barrier *newbarrier)
                               ABT_API_PUBLIC;
int ABT_xstream_barrier_free(ABT_xstream_barrier *barrier) ABT_API_PUBLIC;
int ABT_xstream_barrier_wait(ABT_xstream_barrier barrier) ABT_API_PUBLIC;
 
/* Scheduler */
int ABT_sched_create(ABT_sched_def *def, int num_pools, ABT_pool *pools,
                     ABT_sched_config config, ABT_sched *newsched) ABT_API_PUBLIC;
int ABT_sched_create_basic(ABT_sched_predef predef, int num_pools,
                           ABT_pool *pools, ABT_sched_config config,
                           ABT_sched *newsched) ABT_API_PUBLIC;
int ABT_sched_free(ABT_sched *sched) ABT_API_PUBLIC;
int ABT_sched_set_data(ABT_sched sched, void *data) ABT_API_PUBLIC;
int ABT_sched_get_data(ABT_sched sched, void **data) ABT_API_PUBLIC;
int ABT_sched_get_num_pools(ABT_sched sched, int *num_pools) ABT_API_PUBLIC;
int ABT_sched_get_pools(ABT_sched sched, int max_pools, int idx,
                        ABT_pool *pools) ABT_API_PUBLIC;
int ABT_sched_get_size(ABT_sched sched, size_t *size) ABT_API_PUBLIC;
int ABT_sched_get_total_size(ABT_sched sched, size_t *size) ABT_API_PUBLIC;
int ABT_sched_finish(ABT_sched sched) ABT_API_PUBLIC;
int ABT_sched_exit(ABT_sched sched) ABT_API_PUBLIC;
int ABT_sched_has_to_stop(ABT_sched sched, ABT_bool *stop) ABT_API_PUBLIC;
 
/* Scheduler config */
int ABT_sched_config_create(ABT_sched_config *config, ...) ABT_API_PUBLIC;
int ABT_sched_config_read(ABT_sched_config config, int num_vars, ...) ABT_API_PUBLIC;
int ABT_sched_config_free(ABT_sched_config *config) ABT_API_PUBLIC;
int ABT_sched_config_set(ABT_sched_config config, int idx,
                         ABT_sched_config_type type, const void *val) ABT_API_PUBLIC;
int ABT_sched_config_get(ABT_sched_config config, int idx,
                         ABT_sched_config_type *p_type, void *val) ABT_API_PUBLIC;
 
/* Pool */
int ABT_pool_create(ABT_pool_user_def def, ABT_pool_config config,
                    ABT_pool *newpool) ABT_API_PUBLIC;
int ABT_pool_create_basic(ABT_pool_kind kind, ABT_pool_access access,
                          ABT_bool automatic, ABT_pool *newpool) ABT_API_PUBLIC;
int ABT_pool_free(ABT_pool *pool) ABT_API_PUBLIC;
int ABT_pool_get_access(ABT_pool pool, ABT_pool_access *access) ABT_API_PUBLIC;
int ABT_pool_is_empty(ABT_pool pool, ABT_bool *is_empty) ABT_API_PUBLIC;
int ABT_pool_get_size(ABT_pool pool, size_t *size) ABT_API_PUBLIC;
int ABT_pool_get_total_size(ABT_pool pool, size_t *size) ABT_API_PUBLIC;
int ABT_pool_pop_thread(ABT_pool pool, ABT_thread *thread) ABT_API_PUBLIC;
int ABT_pool_pop_thread_ex(ABT_pool pool, ABT_thread *thread,
                           ABT_pool_context pool_ctx) ABT_API_PUBLIC;
int ABT_pool_pop_threads(ABT_pool pool, ABT_thread *threads, size_t len,
                         size_t *num) ABT_API_PUBLIC;
int ABT_pool_pop_threads_ex(ABT_pool pool, ABT_thread *threads, size_t len,
                            size_t *num, ABT_pool_context pool_ctx) ABT_API_PUBLIC;
int ABT_pool_push_thread(ABT_pool pool, ABT_thread thread) ABT_API_PUBLIC;
int ABT_pool_push_thread_ex(ABT_pool pool, ABT_thread thread,
                            ABT_pool_context pool_ctx) ABT_API_PUBLIC;
int ABT_pool_push_threads(ABT_pool pool, const ABT_thread *threads,
                          size_t num) ABT_API_PUBLIC;
int ABT_pool_push_threads_ex(ABT_pool pool, const ABT_thread *threads,
                             size_t num, ABT_pool_context pool_ctx) ABT_API_PUBLIC;
int ABT_pool_pop_wait_thread(ABT_pool pool, ABT_thread *thread,
                             double time_secs) ABT_API_PUBLIC;
int ABT_pool_pop_wait_thread_ex(ABT_pool pool, ABT_thread *thread,
                                double time_secs,
                                ABT_pool_context pool_ctx) ABT_API_PUBLIC;
int ABT_pool_print_all_threads(ABT_pool pool, void *arg,
                               void (*print_fn)(void *arg, ABT_thread)) ABT_API_PUBLIC;
int ABT_pool_set_data(ABT_pool pool, void *data) ABT_API_PUBLIC;
int ABT_pool_get_data(ABT_pool pool, void **data) ABT_API_PUBLIC;
int ABT_pool_add_sched(ABT_pool pool, ABT_sched sched) ABT_API_PUBLIC;
int ABT_pool_get_id(ABT_pool pool, int *id) ABT_API_PUBLIC;
 
/* Old Pool API.  Use ABT_pool_xxx_thread() instead. */
int ABT_pool_pop(ABT_pool pool, ABT_unit *unit) ABT_API_PUBLIC;
int ABT_pool_pop_wait(ABT_pool pool, ABT_unit *unit, double time_secs) ABT_API_PUBLIC;
int ABT_pool_pop_timedwait(ABT_pool pool, ABT_unit *unit, double abstime_secs)
                           ABT_DEPRECATED ABT_API_PUBLIC;
int ABT_pool_remove(ABT_pool pool, ABT_unit unit) ABT_API_PUBLIC;
int ABT_pool_push(ABT_pool pool, ABT_unit unit) ABT_API_PUBLIC;
int ABT_pool_print_all(ABT_pool pool, void *arg,
                       void (*print_fn)(void *arg, ABT_unit)) ABT_API_PUBLIC;
 
/* Pool config */
int ABT_pool_config_create(ABT_pool_config *config) ABT_API_PUBLIC;
int ABT_pool_config_free(ABT_pool_config *config) ABT_API_PUBLIC;
int ABT_pool_config_set(ABT_pool_config config, int key, ABT_pool_config_type type,
                        const void *val) ABT_API_PUBLIC;
int ABT_pool_config_get(ABT_pool_config config, int key,
                        ABT_pool_config_type *p_type, void *val) ABT_API_PUBLIC;
 
/* Pool definition */
int ABT_pool_user_def_create(ABT_pool_user_create_unit_fn p_create_unit,
                             ABT_pool_user_free_unit_fn p_free_unit,
                             ABT_pool_user_is_empty_fn p_is_empty,
                             ABT_pool_user_pop_fn p_pop,
                             ABT_pool_user_push_fn p_push,
                             ABT_pool_user_def *newdef) ABT_API_PUBLIC;
int ABT_pool_user_def_free(ABT_pool_user_def *def) ABT_API_PUBLIC;
int ABT_pool_user_def_set_init(ABT_pool_user_def def,
                               ABT_pool_user_init_fn p_init) ABT_API_PUBLIC;
int ABT_pool_user_def_set_free(ABT_pool_user_def def,
                               ABT_pool_user_free_fn p_free) ABT_API_PUBLIC;
int ABT_pool_user_def_set_get_size(ABT_pool_user_def def,
                                   ABT_pool_user_get_size_fn p_get_size) ABT_API_PUBLIC;
int ABT_pool_user_def_set_pop_wait(ABT_pool_user_def def,
                                   ABT_pool_user_pop_wait_fn p_pop_wait) ABT_API_PUBLIC;
int ABT_pool_user_def_set_pop_many(ABT_pool_user_def def,
                                   ABT_pool_user_pop_many_fn p_pop_many) ABT_API_PUBLIC;
int ABT_pool_user_def_set_push_many(ABT_pool_user_def def,
                                    ABT_pool_user_push_many_fn p_push_many) ABT_API_PUBLIC;
int ABT_pool_user_def_set_print_all(ABT_pool_user_def def,
                                    ABT_pool_user_print_all_fn p_print_all) ABT_API_PUBLIC;
 
/* Work Unit */
int ABT_unit_get_thread(ABT_unit unit, ABT_thread *thread) ABT_API_PUBLIC;
int ABT_unit_set_associated_pool(ABT_unit unit, ABT_pool pool) ABT_API_PUBLIC;
 
/* User-level Thread (ULT) */
int ABT_thread_create(ABT_pool pool, void (*thread_func)(void *), void *arg,
                      ABT_thread_attr attr, ABT_thread *newthread) ABT_API_PUBLIC;
int ABT_thread_create_to(ABT_pool pool, void (*thread_func)(void *), void *arg,
                         ABT_thread_attr attr, ABT_thread *newthread) ABT_API_PUBLIC;
int ABT_thread_create_on_xstream(ABT_xstream xstream,
                      void (*thread_func)(void *), void *arg,
                      ABT_thread_attr attr, ABT_thread *newthread) ABT_API_PUBLIC;
int ABT_thread_create_many(int num_threads, ABT_pool *pool_list,
                      void (**thread_func_list)(void *), void **arg_list,
                      ABT_thread_attr attr, ABT_thread *newthread_list)
                      ABT_API_PUBLIC;
int ABT_thread_revive(ABT_pool pool, void(*thread_func)(void *), void *arg,
                      ABT_thread *thread) ABT_API_PUBLIC;
int ABT_thread_revive_to(ABT_pool pool, void (*thread_func)(void *), void *arg,
                         ABT_thread *thread) ABT_API_PUBLIC;
int ABT_thread_free(ABT_thread *thread) ABT_API_PUBLIC;
int ABT_thread_free_many(int num_threads, ABT_thread *thread_list) ABT_API_PUBLIC;
int ABT_thread_join(ABT_thread thread) ABT_API_PUBLIC;
int ABT_thread_join_many(int num_threads, ABT_thread *thread_list) ABT_API_PUBLIC;
int ABT_thread_exit(void) ABT_API_PUBLIC;
int ABT_thread_cancel(ABT_thread thread) ABT_API_PUBLIC;
int ABT_thread_self(ABT_thread *thread) ABT_API_PUBLIC;
int ABT_thread_self_id(ABT_unit_id *id) ABT_API_PUBLIC;
int ABT_thread_get_last_xstream(ABT_thread thread, ABT_xstream *xstream) ABT_API_PUBLIC;
int ABT_thread_get_state(ABT_thread thread, ABT_thread_state *state) ABT_API_PUBLIC;
int ABT_thread_get_last_pool(ABT_thread thread, ABT_pool *pool) ABT_API_PUBLIC;
int ABT_thread_get_last_pool_id(ABT_thread thread, int *id) ABT_API_PUBLIC;
int ABT_thread_get_unit(ABT_thread thread, ABT_unit *unit) ABT_API_PUBLIC;
int ABT_thread_set_associated_pool(ABT_thread thread, ABT_pool pool) ABT_API_PUBLIC;
int ABT_thread_yield_to(ABT_thread thread) ABT_API_PUBLIC;
int ABT_thread_yield(void) ABT_API_PUBLIC;
int ABT_thread_resume(ABT_thread thread) ABT_API_PUBLIC;
int ABT_thread_migrate_to_xstream(ABT_thread thread, ABT_xstream xstream) ABT_API_PUBLIC;
int ABT_thread_migrate_to_sched(ABT_thread thread, ABT_sched sched) ABT_API_PUBLIC;
int ABT_thread_migrate_to_pool(ABT_thread thread, ABT_pool pool) ABT_API_PUBLIC;
int ABT_thread_migrate(ABT_thread thread) ABT_API_PUBLIC;
int ABT_thread_set_callback(ABT_thread thread,
        void(*cb_func)(ABT_thread thread, void *cb_arg), void *cb_arg) ABT_API_PUBLIC;
int ABT_thread_set_migratable(ABT_thread thread, ABT_bool migratable) ABT_API_PUBLIC;
int ABT_thread_is_migratable(ABT_thread thread, ABT_bool *is_migratable) ABT_API_PUBLIC;
int ABT_thread_is_primary(ABT_thread thread, ABT_bool *is_primary) ABT_API_PUBLIC;
int ABT_thread_is_unnamed(ABT_thread thread, ABT_bool *is_unnamed) ABT_API_PUBLIC;
int ABT_thread_equal(ABT_thread thread1, ABT_thread thread2, ABT_bool *result)
                     ABT_API_PUBLIC;
int ABT_thread_get_stacksize(ABT_thread thread, size_t *stacksize) ABT_API_PUBLIC;
int ABT_thread_get_id(ABT_thread thread, ABT_unit_id *thread_id) ABT_API_PUBLIC;
int ABT_thread_set_arg(ABT_thread thread, void *arg) ABT_API_PUBLIC;
int ABT_thread_get_arg(ABT_thread thread, void **arg) ABT_API_PUBLIC;
int ABT_thread_get_thread_func(ABT_thread thread, void (**thread_func)(void *)) ABT_API_PUBLIC;
int ABT_thread_set_specific(ABT_thread thread, ABT_key key, void *value) ABT_API_PUBLIC;
int ABT_thread_get_specific(ABT_thread thread, ABT_key key, void **value) ABT_API_PUBLIC;
int ABT_thread_get_attr(ABT_thread thread, ABT_thread_attr *attr) ABT_API_PUBLIC;
 
/* ULT Attributes */
int ABT_thread_attr_create(ABT_thread_attr *newattr) ABT_API_PUBLIC;
int ABT_thread_attr_free(ABT_thread_attr *attr) ABT_API_PUBLIC;
int ABT_thread_attr_set_stack(ABT_thread_attr attr, void *stackaddr,
                              size_t stacksize) ABT_API_PUBLIC;
int ABT_thread_attr_get_stack(ABT_thread_attr attr, void **stackaddr,
                              size_t *stacksize) ABT_API_PUBLIC;
int ABT_thread_attr_set_stacksize(ABT_thread_attr attr, size_t stacksize) ABT_API_PUBLIC;
int ABT_thread_attr_get_stacksize(ABT_thread_attr attr, size_t *stacksize) ABT_API_PUBLIC;
int ABT_thread_attr_set_callback(ABT_thread_attr attr,
        void(*cb_func)(ABT_thread thread, void *cb_arg), void *cb_arg) ABT_API_PUBLIC;
int ABT_thread_attr_set_migratable(ABT_thread_attr attr, ABT_bool is_migratable) ABT_API_PUBLIC;
 
/* Tasklet */
int ABT_task_create(ABT_pool pool, void (*task_func)(void *), void *arg,
                    ABT_task *newtask) ABT_API_PUBLIC;
int ABT_task_create_on_xstream(ABT_xstream xstream, void (*task_func)(void *),
                    void *arg, ABT_task *newtask) ABT_API_PUBLIC;
int ABT_task_revive(ABT_pool pool, void (*task_func)(void *), void *arg,
                    ABT_task *task) ABT_API_PUBLIC;
int ABT_task_free(ABT_task *task) ABT_API_PUBLIC;
int ABT_task_join(ABT_task task) ABT_API_PUBLIC;
int ABT_task_cancel(ABT_task task) ABT_API_PUBLIC;
int ABT_task_self(ABT_task *task) ABT_API_PUBLIC;
int ABT_task_self_id(uint64_t *id) ABT_API_PUBLIC;
int ABT_task_get_xstream(ABT_task task, ABT_xstream *xstream) ABT_API_PUBLIC;
int ABT_task_get_state(ABT_task task, ABT_task_state *state) ABT_API_PUBLIC;
int ABT_task_get_last_pool(ABT_task task, ABT_pool *pool) ABT_API_PUBLIC;
int ABT_task_get_last_pool_id(ABT_task task, int *id) ABT_API_PUBLIC;
int ABT_task_set_migratable(ABT_task task, ABT_bool flag) ABT_API_PUBLIC;
int ABT_task_is_migratable(ABT_task task, ABT_bool *flag) ABT_API_PUBLIC;
int ABT_task_equal(ABT_task task1, ABT_task task2, ABT_bool *result) ABT_API_PUBLIC;
int ABT_task_get_id(ABT_task task, uint64_t *task_id) ABT_API_PUBLIC;
int ABT_task_get_arg(ABT_task task, void **arg) ABT_API_PUBLIC;
#define ABT_task_is_unnamed       ABT_thread_is_unnamed
#define ABT_task_set_specific     ABT_thread_set_specific
#define ABT_task_get_specific     ABT_thread_get_specific
 
/* Self */
int ABT_self_get_xstream(ABT_xstream *xstream) ABT_API_PUBLIC;
int ABT_self_get_xstream_rank(int *rank) ABT_API_PUBLIC;
int ABT_self_get_thread(ABT_thread *thread) ABT_API_PUBLIC;
int ABT_self_get_thread_id(ABT_unit_id *id) ABT_API_PUBLIC;
int ABT_self_set_specific(ABT_key key, void *value) ABT_API_PUBLIC;
int ABT_self_get_specific(ABT_key key, void **value) ABT_API_PUBLIC;
#define ABT_self_get_task       ABT_self_get_thread
#define ABT_self_get_task_id    ABT_self_get_thread_id
int ABT_self_get_type(ABT_unit_type *type) ABT_API_PUBLIC;
int ABT_self_is_primary(ABT_bool *is_primary) ABT_API_PUBLIC;
int ABT_self_on_primary_xstream(ABT_bool *on_primary) ABT_API_PUBLIC;
int ABT_self_is_unnamed(ABT_bool *is_unnamed) ABT_API_PUBLIC;
int ABT_self_get_last_pool(ABT_pool *pool) ABT_API_PUBLIC;
int ABT_self_get_last_pool_id(int *pool_id) ABT_API_PUBLIC;
int ABT_self_set_associated_pool(ABT_pool pool) ABT_API_PUBLIC;
int ABT_self_get_unit(ABT_unit *unit) ABT_API_PUBLIC;
int ABT_self_yield(void) ABT_API_PUBLIC;
int ABT_self_yield_to(ABT_thread thread) ABT_API_PUBLIC;
int ABT_self_resume_yield_to(ABT_thread thread) ABT_API_PUBLIC;
int ABT_self_suspend(void) ABT_API_PUBLIC;
int ABT_self_suspend_to(ABT_thread thread) ABT_API_PUBLIC;
int ABT_self_resume_suspend_to(ABT_thread thread) ABT_API_PUBLIC;
int ABT_self_exit(void) ABT_API_PUBLIC;
int ABT_self_exit_to(ABT_thread thread) ABT_API_PUBLIC;
int ABT_self_resume_exit_to(ABT_thread thread) ABT_API_PUBLIC;
int ABT_self_schedule(ABT_thread thread, ABT_pool pool) ABT_API_PUBLIC;
int ABT_self_set_arg(void *arg) ABT_API_PUBLIC;
int ABT_self_get_arg(void **arg) ABT_API_PUBLIC;
int ABT_self_get_thread_func(void (**thread_func)(void *)) ABT_API_PUBLIC;
 
/* ULT-specific data */
int ABT_key_create(void (*destructor)(void *value), ABT_key *newkey) ABT_API_PUBLIC;
int ABT_key_free(ABT_key *key) ABT_API_PUBLIC;
int ABT_key_set(ABT_key key, void *value) ABT_API_PUBLIC;
int ABT_key_get(ABT_key key, void **value) ABT_API_PUBLIC;
 
/* Mutex */
int ABT_mutex_create(ABT_mutex *newmutex) ABT_API_PUBLIC;
int ABT_mutex_create_with_attr(ABT_mutex_attr attr, ABT_mutex *newmutex) ABT_API_PUBLIC;
int ABT_mutex_free(ABT_mutex *mutex) ABT_API_PUBLIC;
int ABT_mutex_lock(ABT_mutex mutex) ABT_API_PUBLIC;
int ABT_mutex_lock_high(ABT_mutex mutex) ABT_API_PUBLIC;
int ABT_mutex_lock_low(ABT_mutex mutex) ABT_API_PUBLIC;
int ABT_mutex_trylock(ABT_mutex mutex) ABT_API_PUBLIC;
int ABT_mutex_spinlock(ABT_mutex mutex) ABT_API_PUBLIC;
int ABT_mutex_unlock(ABT_mutex mutex) ABT_API_PUBLIC;
int ABT_mutex_unlock_se(ABT_mutex mutex) ABT_API_PUBLIC;
int ABT_mutex_unlock_de(ABT_mutex mutex) ABT_API_PUBLIC;
int ABT_mutex_equal(ABT_mutex mutex1, ABT_mutex mutex2, ABT_bool *result) ABT_API_PUBLIC;
int ABT_mutex_get_attr(ABT_mutex mutex, ABT_mutex_attr *attr) ABT_API_PUBLIC;
 
/* Mutex Attributes */
int ABT_mutex_attr_create(ABT_mutex_attr *newattr) ABT_API_PUBLIC;
int ABT_mutex_attr_free(ABT_mutex_attr *attr) ABT_API_PUBLIC;
int ABT_mutex_attr_set_recursive(ABT_mutex_attr attr, ABT_bool recursive) ABT_API_PUBLIC;
int ABT_mutex_attr_get_recursive(ABT_mutex_attr attr, ABT_bool *recursive) ABT_API_PUBLIC;
 
/* Condition variable */
int ABT_cond_create(ABT_cond *newcond) ABT_API_PUBLIC;
int ABT_cond_free(ABT_cond *cond) ABT_API_PUBLIC;
int ABT_cond_wait(ABT_cond cond, ABT_mutex mutex) ABT_API_PUBLIC;
int ABT_cond_timedwait(ABT_cond cond, ABT_mutex mutex,
                       const struct timespec *abstime) ABT_API_PUBLIC;
int ABT_cond_signal(ABT_cond cond) ABT_API_PUBLIC;
int ABT_cond_broadcast(ABT_cond cond) ABT_API_PUBLIC;
 
/* Readers writer lock */
int ABT_rwlock_create(ABT_rwlock *newrwlock) ABT_API_PUBLIC;
int ABT_rwlock_free(ABT_rwlock *rwlock) ABT_API_PUBLIC;
int ABT_rwlock_rdlock(ABT_rwlock rwlock) ABT_API_PUBLIC;
int ABT_rwlock_wrlock(ABT_rwlock rwlock) ABT_API_PUBLIC;
int ABT_rwlock_unlock(ABT_rwlock rwlock) ABT_API_PUBLIC;
 
/* Eventual */
int ABT_eventual_create(int nbytes, ABT_eventual *neweventual) ABT_API_PUBLIC;
int ABT_eventual_free(ABT_eventual *eventual) ABT_API_PUBLIC;
int ABT_eventual_wait(ABT_eventual eventual, void **value) ABT_API_PUBLIC;
int ABT_eventual_test(ABT_eventual eventual, void **value, ABT_bool *is_ready) ABT_API_PUBLIC;
int ABT_eventual_set(ABT_eventual eventual, void *value, int nbytes) ABT_API_PUBLIC;
int ABT_eventual_reset(ABT_eventual eventual) ABT_API_PUBLIC;
 
/* Futures */
int ABT_future_create(uint32_t num_compartments, void (*cb_func)(void **arg),
                      ABT_future *newfuture) ABT_API_PUBLIC;
int ABT_future_free(ABT_future *future) ABT_API_PUBLIC;
int ABT_future_wait(ABT_future future) ABT_API_PUBLIC;
int ABT_future_test(ABT_future future, ABT_bool *is_ready) ABT_API_PUBLIC;
int ABT_future_set(ABT_future future, void *value) ABT_API_PUBLIC;
int ABT_future_reset(ABT_future future) ABT_API_PUBLIC;
 
/* Barrier */
int ABT_barrier_create(uint32_t num_waiters, ABT_barrier *newbarrier) ABT_API_PUBLIC;
int ABT_barrier_reinit(ABT_barrier barrier, uint32_t num_waiters) ABT_API_PUBLIC;
int ABT_barrier_free(ABT_barrier *barrier) ABT_API_PUBLIC;
int ABT_barrier_wait(ABT_barrier barrier) ABT_API_PUBLIC;
int ABT_barrier_get_num_waiters(ABT_barrier barrier, uint32_t *num_waiters)
                                ABT_API_PUBLIC;
 
/* Error */
int ABT_error_get_str(int err, char *str, size_t *len) ABT_API_PUBLIC;
 
/* Timer */
double ABT_get_wtime(void) ABT_API_PUBLIC;
int ABT_timer_create(ABT_timer *newtimer) ABT_API_PUBLIC;
int ABT_timer_dup(ABT_timer timer, ABT_timer *newtimer) ABT_API_PUBLIC;
int ABT_timer_free(ABT_timer *timer) ABT_API_PUBLIC;
int ABT_timer_start(ABT_timer timer) ABT_API_PUBLIC;
int ABT_timer_stop(ABT_timer timer) ABT_API_PUBLIC;
int ABT_timer_read(ABT_timer timer, double *secs) ABT_API_PUBLIC;
int ABT_timer_stop_and_read(ABT_timer timer, double *secs) ABT_API_PUBLIC;
int ABT_timer_stop_and_add(ABT_timer timer, double *secs) ABT_API_PUBLIC;
int ABT_timer_get_overhead(double *overhead) ABT_API_PUBLIC;
 
/* Information */
int ABT_info_query_config(ABT_info_query_kind query_kind,
                          void *val) ABT_API_PUBLIC;
int ABT_info_print_config(FILE *fp) ABT_API_PUBLIC;
int ABT_info_print_all_xstreams(FILE *fp) ABT_API_PUBLIC;
int ABT_info_print_xstream(FILE *fp, ABT_xstream xstream) ABT_API_PUBLIC;
int ABT_info_print_sched(FILE *fp, ABT_sched sched) ABT_API_PUBLIC;
int ABT_info_print_pool(FILE* fp, ABT_pool pool) ABT_API_PUBLIC;
int ABT_info_print_thread(FILE* fp, ABT_thread thread) ABT_API_PUBLIC;
int ABT_info_print_thread_attr(FILE* fp, ABT_thread_attr attr) ABT_API_PUBLIC;
int ABT_info_print_task(FILE* fp, ABT_task task) ABT_API_PUBLIC;
int ABT_info_print_thread_stack(FILE *fp, ABT_thread thread) ABT_API_PUBLIC;
int ABT_info_print_thread_stacks_in_pool(FILE *fp, ABT_pool pool) ABT_API_PUBLIC;
int ABT_info_trigger_print_all_thread_stacks(FILE *fp, double timeout,
                                             void (*cb_func)(ABT_bool, void *),
                                             void *arg) ABT_API_PUBLIC;
 
/* Tool Functions */
int ABT_tool_register_thread_callback(ABT_tool_thread_callback_fn cb_func,
                                      uint64_t event_mask,
                                      void *user_arg) ABT_API_PUBLIC;
int ABT_tool_query_thread(ABT_tool_context context, uint64_t event,
                          ABT_tool_query_kind query_kind, void *val) ABT_API_PUBLIC;
 
#if defined(__cplusplus)
}
#endif
 
#endif /* ABT_H_INCLUDED */