ARGOBOTS  7a09f9f632d87ed4f43aec50889983fa897fba10
abti.h
Go to the documentation of this file.
1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
2 /*
3  * See COPYRIGHT in top-level directory.
4  */
5 
6 #ifndef ABTI_H_INCLUDED
7 #define ABTI_H_INCLUDED
8 
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <stdint.h>
12 #include <inttypes.h>
13 #include <string.h>
14 #include <limits.h>
15 
16 #include "abt_config.h"
17 #include "abt.h"
18 
19 #ifndef ABT_CONFIG_DISABLE_ERROR_CHECK
20 #define ABTI_IS_ERROR_CHECK_ENABLED 1
21 #else
22 #define ABTI_IS_ERROR_CHECK_ENABLED 0
23 #endif
24 
25 #ifdef ABT_CONFIG_DISABLE_EXT_THREAD
26 #define ABTI_IS_EXT_THREAD_ENABLED 0
27 #else
28 #define ABTI_IS_EXT_THREAD_ENABLED 1
29 #endif
30 
31 #include "abtu.h"
32 #include "abti_error.h"
33 #include "abti_valgrind.h"
34 
35 /* Constants */
36 #define ABTI_SCHED_NUM_PRIO 3
37 
38 #define ABTI_SCHED_REQ_FINISH (1 << 0)
39 #define ABTI_SCHED_REQ_EXIT (1 << 1)
40 #define ABTI_SCHED_REQ_REPLACE (1 << 2)
41 
42 #define ABTI_THREAD_REQ_JOIN (1 << 0)
43 #define ABTI_THREAD_REQ_TERMINATE (1 << 1)
44 #define ABTI_THREAD_REQ_CANCEL (1 << 2)
45 #define ABTI_THREAD_REQ_MIGRATE (1 << 3)
46 #define ABTI_THREAD_REQ_BLOCK (1 << 4)
47 #define ABTI_THREAD_REQ_ORPHAN (1 << 5)
48 #define ABTI_THREAD_REQ_NON_YIELD \
49  (ABTI_THREAD_REQ_CANCEL | ABTI_THREAD_REQ_MIGRATE | \
50  ABTI_THREAD_REQ_TERMINATE | ABTI_THREAD_REQ_BLOCK | \
51  ABTI_THREAD_REQ_ORPHAN)
52 
53 #define ABTI_THREAD_INIT_ID 0xFFFFFFFFFFFFFFFF
54 #define ABTI_TASK_INIT_ID 0xFFFFFFFFFFFFFFFF
55 
56 #define ABTI_INDENT 4
57 
58 #define ABTI_UNIT_HASH_TABLE_SIZE_EXP 8 /* N -> 2^N table entries */
59 #define ABTI_UNIT_HASH_TABLE_SIZE ((size_t)(1 << ABTI_UNIT_HASH_TABLE_SIZE_EXP))
60 
61 #define ABTI_SCHED_CONFIG_HTABLE_SIZE 8
62 #define ABTI_SCHED_CONFIG_UNUSED_INDEX INT_MIN
63 
64 #define ABT_THREAD_TYPE_FULLY_FLEDGED 0
65 #define ABT_THREAD_TYPE_DYNAMIC_PROMOTION 1
66 
67 #define ABTI_STACK_CHECK_TYPE_NONE 0
68 #define ABTI_STACK_CHECK_TYPE_CANARY 1
69 #define ABTI_STACK_CHECK_TYPE_MPROTECT 2
70 #define ABTI_STACK_CHECK_TYPE_MPROTECT_STRICT 3
71 
72 enum ABTI_xstream_type {
73  ABTI_XSTREAM_TYPE_PRIMARY,
74  ABTI_XSTREAM_TYPE_SECONDARY
75 };
76 
77 enum ABTI_sched_used {
78  ABTI_SCHED_NOT_USED,
79  ABTI_SCHED_MAIN,
80  ABTI_SCHED_IN_POOL
81 };
82 
83 enum ABTI_stack_guard {
84  ABTI_STACK_GUARD_NONE = 0,
85  ABTI_STACK_GUARD_MPROTECT,
86  ABTI_STACK_GUARD_MPROTECT_STRICT,
87 };
88 
89 #define ABTI_THREAD_TYPE_EXT ((ABTI_thread_type)0)
90 #define ABTI_THREAD_TYPE_THREAD ((ABTI_thread_type)(0x1 << 0))
91 #define ABTI_THREAD_TYPE_ROOT ((ABTI_thread_type)(0x1 << 1))
92 #define ABTI_THREAD_TYPE_PRIMARY ((ABTI_thread_type)(0x1 << 2))
93 #define ABTI_THREAD_TYPE_MAIN_SCHED ((ABTI_thread_type)(0x1 << 3))
94 #define ABTI_THREAD_TYPE_YIELDABLE ((ABTI_thread_type)(0x1 << 4))
95 #define ABTI_THREAD_TYPE_NAMED ((ABTI_thread_type)(0x1 << 5))
96 #define ABTI_THREAD_TYPE_MIGRATABLE ((ABTI_thread_type)(0x1 << 6))
97 
98 #define ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC ((ABTI_thread_type)(0x1 << 7))
99 #define ABTI_THREAD_TYPE_MEM_MALLOC_DESC ((ABTI_thread_type)(0x1 << 8))
100 #define ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC_STACK ((ABTI_thread_type)(0x1 << 9))
101 #define ABTI_THREAD_TYPE_MEM_MALLOC_DESC_STACK ((ABTI_thread_type)(0x1 << 10))
102 
103 #define ABTI_THREAD_TYPES_MEM \
104  (ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC | ABTI_THREAD_TYPE_MEM_MALLOC_DESC | \
105  ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC_STACK | \
106  ABTI_THREAD_TYPE_MEM_MALLOC_DESC_STACK)
107 
108 /* ABTI_MUTEX_ATTR_NONE must be 0. See ABT_MUTEX_INITIALIZER. */
109 #define ABTI_MUTEX_ATTR_NONE 0
110 /* ABTI_MUTEX_ATTR_RECURSIVE must be 1. See ABT_RECURSIVE_MUTEX_INITIALIZER. */
111 #define ABTI_MUTEX_ATTR_RECURSIVE 1
112 
113 /* Macro functions */
114 #define ABTI_UNUSED(a) (void)(a)
115 
116 /* Data Types */
117 typedef struct ABTI_global ABTI_global;
118 typedef struct ABTI_local ABTI_local;
119 typedef struct ABTI_local_func ABTI_local_func;
120 typedef struct ABTI_xstream ABTI_xstream;
121 typedef enum ABTI_xstream_type ABTI_xstream_type;
122 typedef struct ABTI_sched ABTI_sched;
123 typedef struct ABTI_sched_config_element ABTI_sched_config_element;
124 typedef struct ABTI_sched_config ABTI_sched_config;
125 typedef enum ABTI_sched_used ABTI_sched_used;
126 typedef void *ABTI_sched_id; /* Scheduler id */
127 typedef uintptr_t ABTI_sched_kind; /* Scheduler kind */
128 typedef struct ABTI_pool ABTI_pool;
129 typedef struct ABTI_pool_def ABTI_pool_def;
130 typedef struct ABTI_thread ABTI_thread;
131 typedef struct ABTI_thread_attr ABTI_thread_attr;
132 typedef struct ABTI_ythread ABTI_ythread;
133 typedef struct ABTI_thread_mig_data ABTI_thread_mig_data;
134 typedef uint32_t ABTI_thread_type;
135 typedef struct ABTI_key ABTI_key;
136 typedef struct ABTI_ktelem ABTI_ktelem;
137 typedef struct ABTI_ktable ABTI_ktable;
138 typedef struct ABTI_waitlist ABTI_waitlist;
139 typedef struct ABTI_mutex_attr ABTI_mutex_attr;
140 typedef struct ABTI_mutex ABTI_mutex;
141 typedef struct ABTI_cond ABTI_cond;
142 typedef struct ABTI_rwlock ABTI_rwlock;
143 typedef struct ABTI_eventual ABTI_eventual;
144 typedef struct ABTI_future ABTI_future;
145 typedef struct ABTI_barrier ABTI_barrier;
146 typedef struct ABTI_xstream_barrier ABTI_xstream_barrier;
147 typedef struct ABTI_timer ABTI_timer;
148 #ifndef ABT_CONFIG_DISABLE_TOOL_INTERFACE
149 typedef struct ABTI_tool_context ABTI_tool_context;
150 #endif
151 /* ID associated with native thread (e.g, Pthreads), which can distinguish
152  * execution streams and external threads */
153 struct ABTI_native_thread_id_opaque;
154 typedef struct ABTI_native_thread_id_opaque *ABTI_native_thread_id;
155 /* ID associated with thread (i.e., ULTs, tasklets, and external threads) */
156 struct ABTI_thread_id_opaque;
157 typedef struct ABTI_thread_id_opaque *ABTI_thread_id;
158 /* Unit-to-thread hash table. */
159 typedef struct ABTI_atomic_unit_to_thread ABTI_atomic_unit_to_thread;
160 typedef struct ABTI_unit_to_thread_entry ABTI_unit_to_thread_entry;
161 typedef enum ABTI_stack_guard ABTI_stack_guard;
162 
163 /* Architecture-Dependent Definitions */
164 #include "abtd.h"
165 
166 /* Basic data structure and memory pool. */
167 #include "abti_sync_lifo.h"
168 #include "abti_mem_pool.h"
169 
170 /* Definitions */
171 struct ABTI_waitlist {
172 #ifndef ABT_CONFIG_ACTIVE_WAIT_POLICY
173  ABTD_futex_multiple futex;
174 #endif
175  ABTI_thread *p_head;
176  ABTI_thread *p_tail;
177 };
178 
179 struct ABTI_mutex_attr {
180  int attrs; /* bit-or'ed attributes */
181 };
182 
183 struct ABTI_mutex {
184  int attrs; /* attributes copied from ABTI_mutex_attr. Check
185  * ABT_(RECURSIVE_)MUTEX_INITIALIZER to see how
186  * this variable can be initialized. */
187  ABTD_spinlock lock; /* lock */
188  int nesting_cnt; /* nesting count (if recursive) */
189  ABTI_thread_id owner_id; /* owner's ID (if recursive) */
190 #ifndef ABT_CONFIG_USE_SIMPLE_MUTEX
191  ABTD_spinlock waiter_lock; /* lock */
192  ABTI_waitlist waitlist; /* waiting list */
193 #endif
194 };
195 
196 struct ABTI_atomic_unit_to_thread {
197  ABTD_atomic_ptr val;
198 };
199 
200 struct ABTI_unit_to_thread_entry {
201  ABTI_atomic_unit_to_thread list;
202  ABTD_spinlock lock; /* Protecting any list update. */
203 };
204 
205 struct ABTI_global {
206  int max_xstreams; /* Largest rank used in Argobots. */
207  int num_xstreams; /* Current # of ESs */
208  ABTI_xstream *p_xstream_head; /* List of ESs (head). The list is sorted. */
209  ABTD_spinlock
210  xstream_list_lock; /* Spinlock protecting ES list. Any read and
211  * write to this list requires a lock.*/
212 
213  int num_cores; /* Number of CPU cores */
214  ABT_bool set_affinity; /* Whether CPU affinity is used */
215  ABT_bool use_logging; /* Whether logging is used */
216  ABT_bool use_debug; /* Whether debug output is used */
217  ABT_bool print_raw_stack; /* Print raw stack or not. */
218  uint32_t key_table_size; /* Default key table size */
219  size_t thread_stacksize; /* Default stack size for ULT (in bytes) */
220  size_t sched_stacksize; /* Default stack size for sched (in bytes) */
221  uint32_t sched_event_freq; /* Default check frequency for sched */
222  uint64_t sched_sleep_nsec; /* Default nanoseconds for scheduler sleep */
223  ABTI_ythread *p_primary_ythread; /* Primary ULT */
224 
225  uint32_t
226  mutex_max_handovers; /* Default max. # of local handovers (unused) */
227  uint32_t mutex_max_wakeups; /* Default max. # of wakeups (unused) */
228  size_t sys_page_size; /* System page size (typically, 4KB) */
229  size_t huge_page_size; /* Huge page size */
230 #ifdef ABT_CONFIG_USE_MEM_POOL
231  size_t mem_page_size; /* Page size for memory allocation */
232  size_t mem_sp_size; /* Stack page size */
233  uint32_t mem_max_stacks; /* Max. # of stacks kept in each ES */
234  uint32_t mem_max_descs; /* Max. # of descriptors kept in each ES */
235  int mem_lp_alloc; /* How to allocate large pages */
236 
237  ABTI_mem_pool_global_pool mem_pool_stack; /* Pool of stack (default size) */
238  ABTI_mem_pool_global_pool mem_pool_desc; /* Pool of descriptors that can
239  * store ABTI_task. */
240 #ifndef ABT_CONFIG_DISABLE_EXT_THREAD
241  /* They are used for external threads. */
242  ABTD_spinlock mem_pool_stack_lock;
243  ABTI_mem_pool_local_pool mem_pool_stack_ext;
244  ABTD_spinlock mem_pool_desc_lock;
245  ABTI_mem_pool_local_pool mem_pool_desc_ext;
246 #endif
247 #endif
248  ABTI_stack_guard stack_guard_kind; /* Stack guard type. */
249 
250  ABT_bool print_config; /* Whether to print config on ABT_init */
251 
252 #ifndef ABT_CONFIG_DISABLE_TOOL_INTERFACE
253  ABTD_spinlock tool_writer_lock;
254 
255  ABT_tool_thread_callback_fn tool_thread_cb_f;
256  void *tool_thread_user_arg;
257  ABTD_atomic_uint64 tool_thread_event_mask_tagged;
258 #endif
259 
260  ABTI_unit_to_thread_entry
261  unit_to_thread_entires[ABTI_UNIT_HASH_TABLE_SIZE]; /* Hash table that
262  maps ABT_unit to
263  ABTI_thread */
264 };
265 
266 struct ABTI_local; /* Empty. */
267 
268 struct ABTI_local_func {
269  char padding1[ABT_CONFIG_STATIC_CACHELINE_SIZE];
270  ABTI_local *(*get_local_f)(void);
271  void (*set_local_xstream_f)(ABTI_xstream *);
272  void *(*get_local_ptr_f)(void);
273  char padding2[ABT_CONFIG_STATIC_CACHELINE_SIZE];
274 };
275 
276 struct ABTI_xstream {
277  /* Linked list to manage all execution streams. */
278  ABTI_xstream *p_prev;
279  ABTI_xstream *p_next;
280 
281  int rank; /* Rank */
282  ABTI_xstream_type type; /* Type */
283  ABTD_atomic_int state; /* State (ABT_xstream_state) */
284  ABTI_sched *p_main_sched; /* Main scheduler, which is the bottom of the
285  * linked list of schedulers */
286  ABTD_xstream_context ctx; /* ES context */
287 
288  ABTI_ythread
289  *p_root_ythread; /* Root thread that schedulers the main scheduler. */
290  ABTI_pool *p_root_pool; /* Root pool that stores the main scheduler. */
291 
293  ABTI_thread *p_thread; /* Current running ULT/tasklet */
294 
295 #ifdef ABT_CONFIG_USE_MEM_POOL
296  ABTI_mem_pool_local_pool mem_pool_stack;
297  ABTI_mem_pool_local_pool mem_pool_desc;
298 #endif
299 };
300 
301 struct ABTI_sched {
302  ABTI_sched_used used; /* To know if it is used and how */
303  ABT_bool automatic; /* To know if automatic data free */
304  ABTI_sched_kind kind; /* Kind of the scheduler */
305  ABT_sched_type type; /* Can yield or not (ULT or task) */
306  ABTI_sched *p_replace_sched; /* Main scheduler that should replace this.
307  * ABTI_SCHED_REQ_REPLACE should be set. */
308  ABTI_ythread *p_replace_waiter; /* Thread waiting for replacement. */
309  ABTD_atomic_uint32 request; /* Request */
310  ABT_pool *pools; /* Thread pools */
311  size_t num_pools; /* Number of thread pools */
312  ABTI_ythread *p_ythread; /* Associated ULT */
313  void *data; /* Data for a specific scheduler */
314 
315  /* Scheduler functions */
316  ABT_sched_init_fn init;
317  ABT_sched_run_fn run;
318  ABT_sched_free_fn free;
319  ABT_sched_get_migr_pool_fn get_migr_pool;
320 
321 #ifdef ABT_CONFIG_USE_DEBUG_LOG
322  uint64_t id; /* ID */
323 #endif
324 };
325 
326 struct ABTI_sched_config_element {
327  int idx; /* Index of this element. */
328  ABT_sched_config_type type; /* Element type. */
329  char val[sizeof(double) > sizeof(void *)
330  ? sizeof(double)
331  : sizeof(void *)]; /* Memory for double, int, or pointer */
332  ABTI_sched_config_element *p_next; /* Next element. */
333 };
334 
335 struct ABTI_sched_config {
336  ABTI_sched_config_element elements[ABTI_SCHED_CONFIG_HTABLE_SIZE];
337 };
338 
339 struct ABTI_pool {
340  ABT_pool_access access; /* Access mode */
341  ABT_bool automatic; /* To know if automatic data free */
342  ABT_bool is_builtin; /* Built-in pool. */
343  /* NOTE: int32_t to check if still positive */
344  ABTD_atomic_int32 num_scheds; /* Number of associated schedulers */
345  ABTD_atomic_int32 num_blocked; /* Number of blocked ULTs */
346  void *data; /* Specific data */
347  uint64_t id; /* ID */
348 
349  /* Functions to manage units */
350  ABT_unit_is_in_pool_fn u_is_in_pool;
351  ABT_unit_create_from_thread_fn u_create_from_thread;
352  ABT_unit_free_fn u_free;
353 
354  /* Functions to manage the pool */
355  ABT_pool_init_fn p_init;
356  ABT_pool_get_size_fn p_get_size;
357  ABT_pool_push_fn p_push;
358  ABT_pool_pop_fn p_pop;
359  ABT_pool_pop_wait_fn p_pop_wait;
360  ABT_pool_pop_timedwait_fn p_pop_timedwait;
361  ABT_pool_remove_fn p_remove;
362  ABT_pool_free_fn p_free;
363  ABT_pool_print_all_fn p_print_all;
364 };
365 
366 struct ABTI_pool_def {
367  ABT_pool_access access;
368  ABT_unit_get_thread_fn u_get_thread;
369  ABT_unit_is_in_pool_fn u_is_in_pool;
370  ABT_unit_create_from_thread_fn u_create_from_thread;
371  ABT_unit_free_fn u_free;
372  ABT_pool_init_fn p_init;
373  ABT_pool_get_size_fn p_get_size;
374  ABT_pool_push_fn p_push;
375  ABT_pool_pop_fn p_pop;
376  ABT_pool_pop_wait_fn p_pop_wait;
377  ABT_pool_pop_timedwait_fn p_pop_timedwait;
378  ABT_pool_remove_fn p_remove;
379  ABT_pool_free_fn p_free;
380  ABT_pool_print_all_fn p_print_all;
381 };
382 
383 struct ABTI_thread {
384  ABTI_thread *p_prev;
385  ABTI_thread *p_next;
386  ABTD_atomic_int is_in_pool; /* Whether this thread is in a pool. */
387  ABTI_thread_type type; /* Thread type */
388  ABT_unit unit; /* Unit enclosing this thread */
389  ABTI_xstream *p_last_xstream; /* Last ES where it ran */
390  ABTI_thread *p_parent; /* Parent thread */
391  void (*f_thread)(void *); /* Thread function */
392  void *p_arg; /* Thread function argument */
393  ABTD_atomic_int state; /* State (ABT_thread_state) */
394  ABTD_atomic_uint32 request; /* Request */
395  ABTI_pool *p_pool; /* Associated pool */
396  ABTD_atomic_ptr p_keytable; /* Thread-specific data (ABTI_ktable *) */
397  ABT_unit_id id; /* ID */
398 };
399 
400 struct ABTI_thread_attr {
401  void *p_stack; /* Stack address */
402  size_t stacksize; /* Stack size (in bytes) */
403  ABTI_thread_type thread_type; /* Thread type */
404 #ifndef ABT_CONFIG_DISABLE_MIGRATION
405  ABT_bool migratable; /* Migratability */
406  void (*f_cb)(ABT_thread, void *); /* Callback function */
407  void *p_cb_arg; /* Callback function argument */
408 #endif
409 };
410 
411 struct ABTI_thread_mig_data {
412  void (*f_migration_cb)(ABT_thread, void *); /* Callback function */
413  void *p_migration_cb_arg; /* Callback function argument */
414  ABTD_atomic_ptr
415  p_migration_pool; /* Destination of migration (ABTI_pool *) */
416 };
417 
418 struct ABTI_ythread {
419  ABTI_thread thread; /* Common thread definition */
420  ABTD_ythread_context ctx; /* Context */
421  void *p_stack; /* Stack address */
422  size_t stacksize; /* Stack size (in bytes) */
423 };
424 
425 struct ABTI_key {
426  void (*f_destructor)(void *value);
427  uint32_t id;
428 };
429 
430 struct ABTI_ktelem {
431  /* information of ABTI_key */
432  void (*f_destructor)(void *value);
433  uint32_t key_id;
434  void *value;
435  ABTD_atomic_ptr p_next; /* Next element (ABTI_ktelem *) */
436 };
437 
438 struct ABTI_ktable {
439  int size; /* size of the table */
440  ABTD_spinlock lock; /* Protects any new entry creation. */
441  void *p_used_mem;
442  void *p_extra_mem;
443  size_t extra_mem_size;
444  ABTD_atomic_ptr p_elems[1]; /* element array (ABTI_ktelem *) */
445 };
446 
447 struct ABTI_cond {
448  ABTD_spinlock lock;
449  ABTI_mutex *p_waiter_mutex;
450  ABTI_waitlist waitlist;
451 };
452 
453 struct ABTI_rwlock {
454  ABTI_mutex mutex;
455  ABTI_cond cond;
456  size_t reader_count;
457  int write_flag;
458 };
459 
460 struct ABTI_eventual {
461  ABTD_spinlock lock;
462  ABT_bool ready;
463  void *value;
464  size_t nbytes;
465  ABTI_waitlist waitlist;
466 };
467 
468 struct ABTI_future {
469  ABTD_spinlock lock;
470  ABTD_atomic_size counter;
471  size_t num_compartments;
472  void **array;
473  void (*p_callback)(void **arg);
474  ABTI_waitlist waitlist;
475 };
476 
477 struct ABTI_barrier {
478  size_t num_waiters;
479  volatile size_t counter;
480  ABTD_spinlock lock;
481  ABTI_waitlist waitlist;
482 };
483 
484 struct ABTI_xstream_barrier {
485  uint32_t num_waiters;
486 #ifdef HAVE_PTHREAD_BARRIER_INIT
487  ABTD_xstream_barrier bar;
488 #else
489  ABTD_spinlock lock;
490  uint32_t counter;
491  ABTD_atomic_uint64 tag;
492 #endif
493 };
494 
495 struct ABTI_timer {
496  ABTD_time start;
497  ABTD_time end;
498 };
499 
500 #ifndef ABT_CONFIG_DISABLE_TOOL_INTERFACE
501 struct ABTI_tool_context {
502  ABTI_thread *p_caller;
503  ABTI_pool *p_pool;
504  ABTI_thread
505  *p_parent; /* Parent of the target thread. Used to get the depth */
506  ABT_sync_event_type sync_event_type;
507  void *p_sync_object; /* ABTI type */
508 };
509 #endif
510 
511 /* Global Data */
512 extern ABTI_global *gp_ABTI_global;
513 extern ABTI_local_func gp_ABTI_local_func;
514 
515 /* ES Local Data */
516 extern ABTD_XSTREAM_LOCAL ABTI_local *lp_ABTI_local;
517 
518 /* Execution Stream (ES) */
519 ABTU_ret_err int ABTI_xstream_create_primary(ABTI_global *p_global,
520  ABTI_xstream **pp_xstream);
521 void ABTI_xstream_start_primary(ABTI_global *p_global,
522  ABTI_xstream **pp_local_xstream,
523  ABTI_xstream *p_xstream,
524  ABTI_ythread *p_ythread);
525 void ABTI_xstream_free(ABTI_global *p_global, ABTI_local *p_local,
526  ABTI_xstream *p_xstream, ABT_bool force_free);
527 void ABTI_xstream_schedule(void *p_arg);
528 void ABTI_xstream_run_thread(ABTI_global *p_global,
529  ABTI_xstream **pp_local_xstream,
530  ABTI_thread *p_thread);
531 void ABTI_xstream_check_events(ABTI_xstream *p_xstream, ABTI_sched *p_sched);
532 void ABTI_xstream_print(ABTI_xstream *p_xstream, FILE *p_os, int indent,
533  ABT_bool print_sub);
534 
535 /* Scheduler */
536 ABT_sched_def *ABTI_sched_get_basic_def(void);
537 ABT_sched_def *ABTI_sched_get_basic_wait_def(void);
538 ABT_sched_def *ABTI_sched_get_prio_def(void);
539 ABT_sched_def *ABTI_sched_get_randws_def(void);
540 void ABTI_sched_finish(ABTI_sched *p_sched);
541 void ABTI_sched_exit(ABTI_sched *p_sched);
542 ABTU_ret_err int ABTI_sched_create_basic(ABT_sched_predef predef, int num_pools,
543  ABT_pool *pools,
544  ABTI_sched_config *p_config,
545  ABTI_sched **pp_newsched);
546 void ABTI_sched_free(ABTI_global *p_global, ABTI_local *p_local,
547  ABTI_sched *p_sched, ABT_bool force_free);
548 ABTU_ret_err int ABTI_sched_get_migration_pool(ABTI_sched *, ABTI_pool *,
549  ABTI_pool **);
550 ABT_bool ABTI_sched_has_to_stop(ABTI_local **pp_local, ABTI_sched *p_sched);
551 size_t ABTI_sched_get_size(ABTI_sched *p_sched);
552 size_t ABTI_sched_get_total_size(ABTI_sched *p_sched);
553 size_t ABTI_sched_get_effective_size(ABTI_local *p_local, ABTI_sched *p_sched);
554 void ABTI_sched_print(ABTI_sched *p_sched, FILE *p_os, int indent,
555  ABT_bool print_sub);
556 void ABTI_sched_reset_id(void);
557 
558 /* Scheduler config */
559 ABTU_ret_err int ABTI_sched_config_read(const ABTI_sched_config *p_config,
560  int idx, void *p_val);
561 
562 /* Pool */
563 ABTU_ret_err int ABTI_pool_create_basic(ABT_pool_kind kind,
564  ABT_pool_access access,
565  ABT_bool automatic,
566  ABTI_pool **pp_newpool);
567 void ABTI_pool_free(ABTI_pool *p_pool);
568 ABTU_ret_err int ABTI_pool_get_fifo_def(ABT_pool_access access,
569  ABTI_pool_def *p_def);
570 ABTU_ret_err int ABTI_pool_get_fifo_wait_def(ABT_pool_access access,
571  ABTI_pool_def *p_def);
572 void ABTI_pool_print(ABTI_pool *p_pool, FILE *p_os, int indent);
573 void ABTI_pool_reset_id(void);
574 
575 /* Work Unit */
576 void ABTI_unit_init_hash_table(ABTI_global *p_global);
577 void ABTI_unit_finalize_hash_table(ABTI_global *p_global);
578 ABTU_ret_err int ABTI_unit_map_thread(ABTI_global *p_global, ABT_unit unit,
579  ABTI_thread *p_thread);
580 void ABTI_unit_unmap_thread(ABTI_global *p_global, ABT_unit unit);
581 ABTI_thread *ABTI_unit_get_thread_from_user_defined_unit(ABTI_global *p_global,
582  ABT_unit unit);
583 /* Threads */
584 ABTU_ret_err int ABTI_thread_get_mig_data(ABTI_global *p_global,
585  ABTI_local *p_local,
586  ABTI_thread *p_thread,
587  ABTI_thread_mig_data **pp_mig_data);
588 ABTU_ret_err int ABTI_thread_revive(ABTI_global *p_global, ABTI_local *p_local,
589  ABTI_pool *p_pool,
590  void (*thread_func)(void *), void *arg,
591  ABTI_thread *p_thread);
592 void ABTI_thread_join(ABTI_local **pp_local, ABTI_thread *p_thread);
593 void ABTI_thread_free(ABTI_global *p_global, ABTI_local *p_local,
594  ABTI_thread *p_thread);
595 void ABTI_thread_print(ABTI_thread *p_thread, FILE *p_os, int indent);
596 void ABTI_thread_reset_id(void);
597 ABT_unit_id ABTI_thread_get_id(ABTI_thread *p_thread);
598 
599 /* Yieldable threads */
600 ABTU_ret_err int ABTI_ythread_create_root(ABTI_global *p_global,
601  ABTI_local *p_local,
602  ABTI_xstream *p_xstream,
603  ABTI_ythread **pp_root_ythread);
604 ABTU_ret_err int ABTI_ythread_create_primary(ABTI_global *p_global,
605  ABTI_local *p_local,
606  ABTI_xstream *p_xstream,
607  ABTI_ythread **p_ythread);
608 ABTU_ret_err int ABTI_ythread_create_main_sched(ABTI_global *p_global,
609  ABTI_local *p_local,
610  ABTI_xstream *p_xstream,
611  ABTI_sched *p_sched);
612 ABTU_ret_err int ABTI_ythread_create_sched(ABTI_global *p_global,
613  ABTI_local *p_local,
614  ABTI_pool *p_pool,
615  ABTI_sched *p_sched);
616 ABTU_noreturn void ABTI_ythread_exit(ABTI_xstream *p_local_xstream,
617  ABTI_ythread *p_ythread);
618 void ABTI_ythread_free_primary(ABTI_global *p_global, ABTI_local *p_local,
619  ABTI_ythread *p_ythread);
620 void ABTI_ythread_free_root(ABTI_global *p_global, ABTI_local *p_local,
621  ABTI_ythread *p_ythread);
622 void ABTI_ythread_set_blocked(ABTI_ythread *p_ythread);
623 void ABTI_ythread_suspend(ABTI_xstream **pp_local_xstream,
624  ABTI_ythread *p_ythread,
625  ABT_sync_event_type sync_event_type, void *p_sync);
626 void ABTI_ythread_set_ready(ABTI_local *p_local, ABTI_ythread *p_ythread);
627 void ABTI_ythread_print_stack(ABTI_global *p_global, ABTI_ythread *p_ythread,
628  FILE *p_os);
629 
630 /* Thread attributes */
631 void ABTI_thread_attr_print(ABTI_thread_attr *p_attr, FILE *p_os, int indent);
632 ABTU_ret_err int
633 ABTI_thread_attr_dup(const ABTI_thread_attr *p_attr,
634  ABTI_thread_attr **pp_dup_attr) ABTU_ret_err;
635 
636 /* Key */
637 void ABTI_ktable_free(ABTI_global *p_global, ABTI_local *p_local,
638  ABTI_ktable *p_ktable);
639 
640 /* Information */
641 void ABTI_info_print_config(ABTI_global *p_global, FILE *fp);
642 void ABTI_info_check_print_all_thread_stacks(void);
643 
644 #include "abti_timer.h"
645 #include "abti_log.h"
646 #include "abti_local.h"
647 #include "abti_global.h"
648 #include "abti_self.h"
649 #include "abti_pool.h"
650 #include "abti_sched.h"
651 #include "abti_config.h"
652 #include "abti_stream.h"
653 #include "abti_thread.h"
654 #include "abti_unit.h"
655 #include "abti_tool.h"
656 #include "abti_ythread.h"
657 #include "abti_thread_attr.h"
658 #include "abti_waitlist.h"
659 #include "abti_mutex.h"
660 #include "abti_mutex_attr.h"
661 #include "abti_cond.h"
662 #include "abti_rwlock.h"
663 #include "abti_eventual.h"
664 #include "abti_future.h"
665 #include "abti_barrier.h"
666 #include "abti_stream_barrier.h"
667 #include "abti_mem.h"
668 #include "abti_key.h"
669 
670 #endif /* ABTI_H_INCLUDED */
ABT_pool_pop_fn
ABT_unit(* ABT_pool_pop_fn)(ABT_pool)
Definition: abt.h:1414
gp_ABTI_local_func
ABTI_local_func gp_ABTI_local_func
Definition: local.c:23
ABT_sched_predef
ABT_sched_predef
Predefined scheduler type.
Definition: abt.h:465
abti_global.h
abti_ythread.h
ABT_bool
int ABT_bool
Boolean type.
Definition: abt.h:1001
abti_thread_attr.h
abti_key.h
ABT_unit_is_in_pool_fn
ABT_bool(* ABT_unit_is_in_pool_fn)(ABT_unit)
Definition: abt.h:1407
abti_rwlock.h
abti_sched.h
ABT_sched_run_fn
void(* ABT_sched_run_fn)(ABT_sched)
Definition: abt.h:1293
abti_cond.h
ABT_thread
struct ABT_thread_opaque * ABT_thread
Work unit handle type.
Definition: abt.h:890
abti_thread.h
abti_log.h
abti_stream.h
ABT_pool_pop_wait_fn
ABT_unit(* ABT_pool_pop_wait_fn)(ABT_pool, double)
Definition: abt.h:1415
gp_ABTI_global
ABTI_global * gp_ABTI_global
Definition: global.c:18
abti_timer.h
ABTU_noreturn
#define ABTU_noreturn
Definition: abtu.h:127
abti_barrier.h
abtd.h
ABT_pool_pop_timedwait_fn
ABT_unit(* ABT_pool_pop_timedwait_fn)(ABT_pool, double)
Definition: abt.h:1416
ABT_sched_type
ABT_sched_type
Scheduler's work unit type.
Definition: abt.h:490
ABT_pool_print_all_fn
int(* ABT_pool_print_all_fn)(ABT_pool, void *arg, void(*)(void *, ABT_unit))
Definition: abt.h:1419
abti_future.h
ABT_pool
struct ABT_pool_opaque * ABT_pool
Pool handle type.
Definition: abt.h:841
ABT_unit_free_fn
void(* ABT_unit_free_fn)(ABT_unit *)
Definition: abt.h:1410
abti_pool.h
ABT_sync_event_type
ABT_sync_event_type
Type of synchronization event.
Definition: abt.h:660
ABT_unit_id
uint64_t ABT_unit_id
Work unit ID type.
Definition: abt.h:879
ABT_pool_remove_fn
int(* ABT_pool_remove_fn)(ABT_pool, ABT_unit)
Definition: abt.h:1417
ABT_pool_init_fn
int(* ABT_pool_init_fn)(ABT_pool, ABT_pool_config)
Definition: abt.h:1411
abti_stream_barrier.h
abti_unit.h
ABT_sched_init_fn
int(* ABT_sched_init_fn)(ABT_sched, ABT_sched_config)
Definition: abt.h:1292
abti_mem.h
abti_config.h
ABT_unit
struct ABT_unit_opaque * ABT_unit
Work unit handle type for scheduling.
Definition: abt.h:869
abt_config.h
ABT_CONFIG_STATIC_CACHELINE_SIZE
#define ABT_CONFIG_STATIC_CACHELINE_SIZE
Definition: abt_config.h:75
abti_valgrind.h
ABTU_ret_err
#define ABTU_ret_err
Definition: abtu.h:155
abt.h
ABT_unit_get_thread_fn
ABT_thread(* ABT_unit_get_thread_fn)(ABT_unit)
Definition: abt.h:1405
ABT_pool_push_fn
void(* ABT_pool_push_fn)(ABT_pool, ABT_unit)
Definition: abt.h:1413
abti_waitlist.h
abti_sync_lifo.h
abti_mem_pool.h
abti_tool.h
abti_eventual.h
ABT_sched_def
A struct that defines a scheduler.
Definition: abt.h:1302
lp_ABTI_local
ABTD_XSTREAM_LOCAL ABTI_local * lp_ABTI_local
Definition: local.c:29
ABT_sched_get_migr_pool_fn
ABT_pool(* ABT_sched_get_migr_pool_fn)(ABT_sched)
Definition: abt.h:1296
ABT_pool_get_size_fn
size_t(* ABT_pool_get_size_fn)(ABT_pool)
Definition: abt.h:1412
ABT_pool_free_fn
int(* ABT_pool_free_fn)(ABT_pool)
Definition: abt.h:1418
ABTU_align_member_var
#define ABTU_align_member_var(size)
Definition: abtu.h:170
abti_mutex_attr.h
abtu.h
ABT_tool_thread_callback_fn
void(* ABT_tool_thread_callback_fn)(ABT_thread, ABT_xstream, uint64_t event, ABT_tool_context context, void *user_arg)
Definition: abt.h:1683
abti_error.h
ABT_sched_free_fn
int(* ABT_sched_free_fn)(ABT_sched)
Definition: abt.h:1294
ABT_pool_kind
ABT_pool_kind
Predefined pool type.
Definition: abt.h:504
abti_self.h
abti_local.h
ABT_unit_create_from_thread_fn
ABT_unit(* ABT_unit_create_from_thread_fn)(ABT_thread)
Definition: abt.h:1408
ABT_sched_config_type
ABT_sched_config_type
A struct that sets and gets a scheduler configuration.
Definition: abt.h:1227
ABT_pool_access
ABT_pool_access
Pool access type.
Definition: abt.h:522
abti_mutex.h