d5/d7d/abt_8h_source.html

/* -*- 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_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

};


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,

};


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_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_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)

#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))

#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 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;


/* 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));


typedef struct {

    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;

} 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;


/* Pool */

int ABT_pool_create(ABT_pool_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_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(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;

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;


/* 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_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_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_suspend(void) ABT_API_PUBLIC;

int ABT_self_exit(void) 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 */