ARGOBOTS  1.1b1
info.c
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 #include "abti.h"
7 
9  ABTI_pool *p_pool);
11  FILE *fp, double timeout, void (*cb_func)(ABT_bool, void *), void *arg);
12 
200 int ABT_info_query_config(ABT_info_query_kind query_kind, void *val)
201 {
202 #ifndef ABT_CONFIG_ENABLE_VER_20_API
203  /* Argobots 1.x always requires an init check. */
204  ABTI_SETUP_GLOBAL(NULL);
205 #endif
206  switch (query_kind) {
208  ABTI_global *p_global;
209  ABTI_SETUP_GLOBAL(&p_global);
210  *((ABT_bool *)val) = p_global->use_debug;
211  } break;
213 #ifdef ABT_CONFIG_PRINT_ABT_ERRNO
214  *((ABT_bool *)val) = ABT_TRUE;
215 #else
216  *((ABT_bool *)val) = ABT_FALSE;
217 #endif
218  break;
220  ABTI_global *p_global;
221  ABTI_SETUP_GLOBAL(&p_global);
222  *((ABT_bool *)val) = p_global->use_logging;
223  } break;
225 #ifdef HAVE_VALGRIND_SUPPORT
226  *((ABT_bool *)val) = ABT_TRUE;
227 #else
228  *((ABT_bool *)val) = ABT_FALSE;
229 #endif
230  break;
232 #ifndef ABT_CONFIG_DISABLE_ERROR_CHECK
233  *((ABT_bool *)val) = ABT_TRUE;
234 #else
235  *((ABT_bool *)val) = ABT_FALSE;
236 #endif
237  break;
239  *((ABT_bool *)val) = ABT_FALSE;
240  break;
242  *((ABT_bool *)val) = ABT_FALSE;
243  break;
245 #if !defined(ABTD_FCONTEXT_PRESERVE_FPU) && defined(ABT_CONFIG_USE_FCONTEXT)
246  *((ABT_bool *)val) = ABT_FALSE;
247 #else
248  /* If ucontext is used, FPU is preserved. */
249  *((ABT_bool *)val) = ABT_TRUE;
250 #endif
251  break;
253 #ifndef ABT_CONFIG_DISABLE_THREAD_CANCEL
254  *((ABT_bool *)val) = ABT_TRUE;
255 #else
256  *((ABT_bool *)val) = ABT_FALSE;
257 #endif
258  break;
260 #ifndef ABT_CONFIG_DISABLE_TASK_CANCEL
261  *((ABT_bool *)val) = ABT_TRUE;
262 #else
263  *((ABT_bool *)val) = ABT_FALSE;
264 #endif
265  break;
267 #ifndef ABT_CONFIG_DISABLE_MIGRATION
268  *((ABT_bool *)val) = ABT_TRUE;
269 #else
270  *((ABT_bool *)val) = ABT_FALSE;
271 #endif
272  break;
274  *((ABT_bool *)val) = ABT_TRUE;
275  break;
277 #ifndef ABT_CONFIG_DISABLE_EXT_THREAD
278  *((ABT_bool *)val) = ABT_TRUE;
279 #else
280  *((ABT_bool *)val) = ABT_FALSE;
281 #endif
282  break;
284 #ifdef ABT_CONFIG_USE_SCHED_SLEEP
285  *((ABT_bool *)val) = ABT_TRUE;
286 #else
287  *((ABT_bool *)val) = ABT_FALSE;
288 #endif
289  break;
291  ABTI_global *p_global;
292  ABTI_SETUP_GLOBAL(&p_global);
293  *((ABT_bool *)val) = p_global->print_config;
294  } break;
296  ABTI_global *p_global;
297  ABTI_SETUP_GLOBAL(&p_global);
298  *((ABT_bool *)val) = p_global->set_affinity;
299  } break;
301  ABTI_global *p_global;
302  ABTI_SETUP_GLOBAL(&p_global);
303  *((unsigned int *)val) = p_global->max_xstreams;
304  } break;
306  ABTI_global *p_global;
307  ABTI_SETUP_GLOBAL(&p_global);
308  *((size_t *)val) = p_global->thread_stacksize;
309  } break;
311  ABTI_global *p_global;
312  ABTI_SETUP_GLOBAL(&p_global);
313  *((size_t *)val) = p_global->sched_stacksize;
314  } break;
316  ABTI_global *p_global;
317  ABTI_SETUP_GLOBAL(&p_global);
318  *((uint64_t *)val) = p_global->sched_event_freq;
319  } break;
321  ABTI_global *p_global;
322  ABTI_SETUP_GLOBAL(&p_global);
323  *((uint64_t *)val) = p_global->sched_sleep_nsec;
324  } break;
326 #ifndef ABT_CONFIG_DISABLE_TOOL_INTERFACE
327  *((ABT_bool *)val) = ABT_TRUE;
328 #else
329  *((ABT_bool *)val) = ABT_FALSE;
330 #endif
331  break;
333 #ifdef ABT_CONFIG_USE_FCONTEXT
334  *((ABT_bool *)val) = ABT_TRUE;
335 #else
336  *((ABT_bool *)val) = ABT_FALSE;
337 #endif
338  break;
340 #if ABT_CONFIG_THREAD_TYPE == ABT_THREAD_TYPE_DYNAMIC_PROMOTION
341  *((ABT_bool *)val) = ABT_TRUE;
342 #else
343  *((ABT_bool *)val) = ABT_FALSE;
344 #endif
345  break;
347 #ifdef ABT_CONFIG_ENABLE_STACK_UNWIND
348  *((ABT_bool *)val) = ABT_TRUE;
349 #else
350  *((ABT_bool *)val) = ABT_FALSE;
351 #endif
352  break;
354 #if ABT_CONFIG_STACK_CHECK_TYPE == ABTI_STACK_CHECK_TYPE_CANARY
355  *((int *)val) = 1;
356 #else
357  *((int *)val) = 0;
358 #endif
359  break;
360  default:
362  break;
363  }
364  return ABT_SUCCESS;
365 }
366 
397 {
398  ABTI_global *p_global;
399 #ifndef ABT_CONFIG_ENABLE_VER_20_API
400  /* Argobots 1.x always requires an init check. */
401  ABTI_SETUP_GLOBAL(&p_global);
402 #else
403  p_global = ABTI_global_get_global_or_null();
404  if (!p_global) {
405  fprintf(fp, "Argobots is not initialized.\n");
406  fflush(fp);
407  return ABT_SUCCESS;
408  }
409 #endif
410  ABTI_info_print_config(p_global, fp);
411  return ABT_SUCCESS;
412 }
413 
444 {
445  ABTI_global *p_global;
446 #ifndef ABT_CONFIG_ENABLE_VER_20_API
447  /* Argobots 1.x always requires an init check. */
448  ABTI_SETUP_GLOBAL(&p_global);
449 #else
450  p_global = ABTI_global_get_global_or_null();
451  if (!p_global) {
452  fprintf(fp, "Argobots is not initialized.\n");
453  fflush(fp);
454  return ABT_SUCCESS;
455  }
456 #endif
457 
459 
460  fprintf(fp, "# of created ESs: %d\n", p_global->num_xstreams);
461 
462  ABTI_xstream *p_xstream = p_global->p_xstream_head;
463  while (p_xstream) {
464  ABTI_xstream_print(p_xstream, fp, 0, ABT_FALSE);
465  p_xstream = p_xstream->p_next;
466  }
467 
469 
470  fflush(fp);
471  return ABT_SUCCESS;
472 }
473 
504 int ABT_info_print_xstream(FILE *fp, ABT_xstream xstream)
505 {
506  ABTI_xstream *p_xstream = ABTI_xstream_get_ptr(xstream);
507 #ifndef ABT_CONFIG_ENABLE_VER_20_API
508  /* Argobots 1.x requires a NULL-handle check. */
509  ABTI_CHECK_NULL_XSTREAM_PTR(p_xstream);
510 #endif
511  ABTI_xstream_print(p_xstream, fp, 0, ABT_FALSE);
512  return ABT_SUCCESS;
513 }
514 
545 int ABT_info_print_sched(FILE *fp, ABT_sched sched)
546 {
547  ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
548 #ifndef ABT_CONFIG_ENABLE_VER_20_API
549  /* Argobots 1.x requires a NULL-handle check. */
550  ABTI_CHECK_NULL_SCHED_PTR(p_sched);
551 #endif
552  ABTI_sched_print(p_sched, fp, 0, ABT_TRUE);
553  return ABT_SUCCESS;
554 }
555 
586 int ABT_info_print_pool(FILE *fp, ABT_pool pool)
587 {
588  ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
589 #ifndef ABT_CONFIG_ENABLE_VER_20_API
590  /* Argobots 1.x requires a NULL-handle check. */
591  ABTI_CHECK_NULL_POOL_PTR(p_pool);
592 #endif
593  ABTI_pool_print(p_pool, fp, 0);
594  return ABT_SUCCESS;
595 }
596 
631 int ABT_info_print_thread(FILE *fp, ABT_thread thread)
632 {
633  ABTI_thread *p_thread = ABTI_thread_get_ptr(thread);
634 #ifndef ABT_CONFIG_ENABLE_VER_20_API
635  /* Argobots 1.x requires a NULL-handle check. */
636  ABTI_CHECK_NULL_THREAD_PTR(p_thread);
637 #endif
638  ABTI_thread_print(p_thread, fp, 0);
639  return ABT_SUCCESS;
640 }
641 
673 {
675 #ifndef ABT_CONFIG_ENABLE_VER_20_API
676  /* Argobots 1.x requires a NULL-handle check. */
678 #endif
679  ABTI_thread_attr_print(p_attr, fp, 0);
680  return ABT_SUCCESS;
681 }
682 
718 int ABT_info_print_task(FILE *fp, ABT_task task)
719 {
720  ABTI_thread *p_thread = ABTI_thread_get_ptr(task);
721 #ifndef ABT_CONFIG_ENABLE_VER_20_API
722  /* Argobots 1.x requires a NULL-handle check. */
723  ABTI_CHECK_NULL_TASK_PTR(p_thread);
724 #endif
725  ABTI_thread_print(p_thread, fp, 0);
726  return ABT_SUCCESS;
727 }
728 
764 int ABT_info_print_thread_stack(FILE *fp, ABT_thread thread)
765 {
766  ABTI_thread *p_thread = ABTI_thread_get_ptr(thread);
767 #ifndef ABT_CONFIG_ENABLE_VER_20_API
768  /* Argobots 1.x requires a NULL-handle check. */
769  ABTI_CHECK_NULL_THREAD_PTR(p_thread);
770 #endif
771  if (!p_thread) {
772  fprintf(fp, "no stack\n");
773  fflush(0);
774  } else {
775  ABTI_ythread *p_ythread;
776  if (p_thread->type & ABTI_THREAD_TYPE_YIELDABLE) {
777  p_ythread = ABTI_thread_get_ythread(p_thread);
778  ABTI_ythread_print_stack(p_ythread, fp);
779  } else {
780  fprintf(fp, "no stack\n");
781  fflush(0);
782  }
783  }
784  return ABT_SUCCESS;
785 }
786 
820 {
821  ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
822 #ifndef ABT_CONFIG_ENABLE_VER_20_API
823  /* Argobots 1.x requires a NULL-handle check. */
824  ABTI_CHECK_NULL_POOL_PTR(p_pool);
825 #endif
826  int abt_errno = info_print_thread_stacks_in_pool(fp, p_pool);
827  ABTI_CHECK_ERROR(abt_errno);
828  return ABT_SUCCESS;
829 }
830 
895 int ABT_info_trigger_print_all_thread_stacks(FILE *fp, double timeout,
896  void (*cb_func)(ABT_bool, void *),
897  void *arg)
898 {
899  info_trigger_print_all_thread_stacks(fp, timeout, cb_func, arg);
900  return ABT_SUCCESS;
901 }
902 
903 /*****************************************************************************/
904 /* Private APIs */
905 /*****************************************************************************/
906 
908  FILE *fp);
909 
910 #define PRINT_STACK_FLAG_UNSET 0
911 #define PRINT_STACK_FLAG_INITIALIZE 1
912 #define PRINT_STACK_FLAG_WAIT 2
913 #define PRINT_STACK_FLAG_FINALIZE 3
914 
917 static FILE *print_stack_fp = NULL;
918 static double print_stack_timeout = 0.0;
919 static void (*print_cb_func)(ABT_bool, void *) = NULL;
920 static void *print_arg = NULL;
923 
925 {
928  return;
929 
930  /* Wait for the other execution streams using a barrier mechanism. */
931  int self_value = ABTD_atomic_fetch_add_int(&print_stack_barrier, 1);
932  if (self_value == 0) {
933  ABTI_global *p_global = ABTI_global_get_global();
934  /* This ES becomes the main ES. */
935  double start_time = ABTI_get_wtime();
936  ABT_bool force_print = ABT_FALSE;
937 
938  /* xstreams_lock is acquired to avoid dynamic ES creation while
939  * printing data. */
941  while (1) {
943  p_global->num_xstreams) {
944  break;
945  }
946  if (print_stack_timeout >= 0.0 &&
947  (ABTI_get_wtime() - start_time) >= print_stack_timeout) {
948  force_print = ABT_TRUE;
949  break;
950  }
954  }
955  /* All the available ESs are (supposed to be) stopped. We *assume* that
956  * no ES is calling and will call Argobots functions except this
957  * function while printing stack information. */
958  if (force_print) {
959  fprintf(print_stack_fp,
960  "ABT_info_trigger_print_all_thread_stacks: "
961  "timeout (only %d ESs stop)\n",
963  }
964  int abt_errno = print_all_thread_stacks(p_global, print_stack_fp);
965  if (ABTI_IS_ERROR_CHECK_ENABLED && abt_errno != ABT_SUCCESS) {
966  fprintf(print_stack_fp, "ABT_info_trigger_print_all_thread_stacks: "
967  "failed because of an internal error.\n");
968  }
969  fflush(print_stack_fp);
970  /* Release the lock that protects ES data. */
972  if (print_cb_func)
973  print_cb_func(force_print, print_arg);
974  /* Update print_stack_flag to 3. */
977  } else {
978  /* Wait for the main ES's work. */
982  }
985 
986  /* Decrement the barrier value. */
987  int dec_value = ABTD_atomic_fetch_sub_int(&print_stack_barrier, 1);
988  if (dec_value == 0) {
989  /* The last execution stream resets the flag. */
992  }
993 }
994 
995 void ABTI_info_print_config(ABTI_global *p_global, FILE *fp)
996 {
997  fprintf(fp, "Argobots Configuration:\n");
998  fprintf(fp, " - version: " ABT_VERSION "\n");
999  fprintf(fp, " - # of cores: %d\n", p_global->num_cores);
1000  fprintf(fp, " - cache line size: %u B\n", ABT_CONFIG_STATIC_CACHELINE_SIZE);
1001  fprintf(fp, " - huge page size: %zu B\n", p_global->huge_page_size);
1002  fprintf(fp, " - max. # of ESs: %d\n", p_global->max_xstreams);
1003  fprintf(fp, " - cur. # of ESs: %d\n", p_global->num_xstreams);
1004  fprintf(fp, " - ES affinity: %s\n",
1005  (p_global->set_affinity == ABT_TRUE) ? "on" : "off");
1006  fprintf(fp, " - logging: %s\n",
1007  (p_global->use_logging == ABT_TRUE) ? "on" : "off");
1008  fprintf(fp, " - debug output: %s\n",
1009  (p_global->use_debug == ABT_TRUE) ? "on" : "off");
1010  fprintf(fp, " - print errno: "
1011 #ifdef ABT_CONFIG_PRINT_ABT_ERRNO
1012  "on"
1013 #else
1014  "off"
1015 #endif
1016  "\n");
1017  fprintf(fp, " - valgrind support: "
1018 #ifdef HAVE_VALGRIND_SUPPORT
1019  "yes"
1020 #else
1021  "no"
1022 #endif
1023  "\n");
1024  fprintf(fp, " - thread cancellation: "
1025 #ifndef ABT_CONFIG_DISABLE_THREAD_CANCEL
1026  "enabled"
1027 #else
1028  "disabled"
1029 #endif
1030  "\n");
1031  fprintf(fp, " - task cancellation: "
1032 #ifndef ABT_CONFIG_DISABLE_TASK_CANCEL
1033  "enabled"
1034 #else
1035  "disabled"
1036 #endif
1037  "\n");
1038  fprintf(fp, " - thread migration: "
1039 #ifndef ABT_CONFIG_DISABLE_MIGRATION
1040  "enabled"
1041 #else
1042  "disabled"
1043 #endif
1044  "\n");
1045  fprintf(fp, " - external thread: "
1046 #ifndef ABT_CONFIG_DISABLE_EXT_THREAD
1047  "enabled"
1048 #else
1049  "disabled"
1050 #endif
1051  "\n");
1052  fprintf(fp, " - error check: "
1053 #ifndef ABT_CONFIG_DISABLE_ERROR_CHECK
1054  "enabled"
1055 #else
1056  "disable"
1057 #endif
1058  "\n");
1059  fprintf(fp, " - tool interface: "
1061  "yes"
1062 #else
1063  "no"
1064 #endif
1065  "\n");
1066  fprintf(fp, " - context-switch: "
1068  "fcontext"
1071  " (dynamic-promotion)"
1073  !defined(ABTD_FCONTEXT_PRESERVE_FPU)
1074  " (dynamic-promotion, no FPU save)"
1076  !defined(ABTD_FCONTEXT_PRESERVE_FPU)
1077  " (no FPU save)"
1078 #endif /* ABT_CONFIG_THREAD_TYPE, ABTD_FCONTEXT_PRESERVE_FPU */
1079 
1080 #else /* ABT_CONFIG_USE_FCONTEXT */
1081  "ucontext"
1082 #endif /* !ABT_CONFIG_USE_FCONTEXT */
1083  "\n");
1084 
1085  fprintf(fp, " - key table entries: %" PRIu32 "\n",
1086  p_global->key_table_size);
1087  fprintf(fp, " - default ULT stack size: %zu KB\n",
1088  p_global->thread_stacksize / 1024);
1089  fprintf(fp, " - default scheduler stack size: %zu KB\n",
1090  p_global->sched_stacksize / 1024);
1091  fprintf(fp, " - default scheduler event check frequency: %u\n",
1092  p_global->sched_event_freq);
1093  fprintf(fp, " - default scheduler sleep: "
1094 #ifdef ABT_CONFIG_USE_SCHED_SLEEP
1095  "on"
1096 #else
1097  "off"
1098 #endif
1099  "\n");
1100  fprintf(fp, " - default scheduler sleep duration : %" PRIu64 " [ns]\n",
1101  p_global->sched_sleep_nsec);
1102 
1103  fprintf(fp, " - timer function: "
1104 #if defined(ABT_CONFIG_USE_CLOCK_GETTIME)
1105  "clock_gettime"
1106 #elif defined(ABT_CONFIG_USE_MACH_ABSOLUTE_TIME)
1107  "mach_absolute_time"
1108 #elif defined(ABT_CONFIG_USE_GETTIMEOFDAY)
1109  "gettimeofday"
1110 #endif
1111  "\n");
1112 
1113 #ifdef ABT_CONFIG_USE_MEM_POOL
1114  fprintf(fp, "Memory Pool:\n");
1115  fprintf(fp, " - page size for allocation: %zu KB\n",
1116  p_global->mem_page_size / 1024);
1117  fprintf(fp, " - stack page size: %zu KB\n", p_global->mem_sp_size / 1024);
1118  fprintf(fp, " - max. # of stacks per ES: %u\n", p_global->mem_max_stacks);
1119  fprintf(fp, " - max. # of descs per ES: %u\n", p_global->mem_max_descs);
1120  switch (p_global->mem_lp_alloc) {
1121  case ABTI_MEM_LP_MALLOC:
1122  fprintf(fp, " - large page allocation: malloc\n");
1123  break;
1124  case ABTI_MEM_LP_MMAP_RP:
1125  fprintf(fp, " - large page allocation: mmap regular pages\n");
1126  break;
1128  fprintf(fp, " - large page allocation: mmap huge pages + "
1129  "regular pages\n");
1130  break;
1132  fprintf(fp, " - large page allocation: mmap huge pages + THPs\n");
1133  break;
1134  case ABTI_MEM_LP_THP:
1135  fprintf(fp, " - large page allocation: THPs\n");
1136  break;
1137  }
1138 #endif /* ABT_CONFIG_USE_MEM_POOL */
1139 
1140  fflush(fp);
1141 }
1142 
1143 /*****************************************************************************/
1144 /* Internal static functions */
1145 /*****************************************************************************/
1146 
1147 struct info_print_unit_arg_t {
1148  FILE *fp;
1149  ABT_pool pool;
1150 };
1153  ABT_pool *pools;
1154  size_t num;
1155  size_t len;
1156 };
1158 static void info_print_unit(void *arg, ABT_unit unit)
1159 {
1160  /* This function may not have any side effect on unit because it is passed
1161  * to p_print_all. */
1162  struct info_print_unit_arg_t *p_arg;
1163  p_arg = (struct info_print_unit_arg_t *)arg;
1164  FILE *fp = p_arg->fp;
1165  ABT_pool pool = p_arg->pool;
1166  ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
1167  ABT_thread thread = p_pool->u_get_thread(unit);
1168  ABTI_thread *p_thread = ABTI_thread_get_ptr(thread);
1169 
1170  if (!p_thread) {
1171  fprintf(fp, "=== unknown (%p) ===\n", (void *)unit);
1172  } else if (p_thread->type & ABTI_THREAD_TYPE_YIELDABLE) {
1173  fprintf(fp, "=== ULT (%p) ===\n", (void *)unit);
1174  ABTI_ythread *p_ythread = ABTI_thread_get_ythread(p_thread);
1175  ABT_unit_id thread_id = ABTI_thread_get_id(&p_ythread->thread);
1176  fprintf(fp,
1177  "id : %" PRIu64 "\n"
1178  "ctx : %p\n",
1179  (uint64_t)thread_id, (void *)&p_ythread->ctx);
1180  ABTI_ythread_print_stack(p_ythread, fp);
1181  } else {
1182  fprintf(fp, "=== tasklet (%p) ===\n", (void *)unit);
1183  }
1184 }
1185 
1187  ABTI_pool *p_pool)
1188 {
1189  if (p_pool == NULL) {
1190  fprintf(fp, "== NULL pool ==\n");
1191  fflush(fp);
1192  return ABT_SUCCESS;
1193  }
1195 
1197 
1198  fprintf(fp, "== pool (%p) ==\n", (void *)p_pool);
1199  struct info_print_unit_arg_t arg;
1200  arg.fp = fp;
1201  arg.pool = pool;
1202  p_pool->p_print_all(pool, &arg, info_print_unit);
1203  fflush(fp);
1204  return ABT_SUCCESS;
1205 }
1206 
1207 ABTU_ret_err static inline int
1209 {
1210  size_t default_len = 16;
1211  int abt_errno =
1212  ABTU_malloc(sizeof(ABT_pool) * default_len, (void **)&p_set->pools);
1213  ABTI_CHECK_ERROR(abt_errno);
1214  p_set->num = 0;
1215  p_set->len = default_len;
1216  return ABT_SUCCESS;
1217 }
1218 
1219 static inline void info_finalize_pool_set(struct info_pool_set_t *p_set)
1220 {
1221  ABTU_free(p_set->pools);
1223 
1224 ABTU_ret_err static inline int info_add_pool_set(ABT_pool pool,
1225  struct info_pool_set_t *p_set)
1226 {
1227  size_t i;
1228  for (i = 0; i < p_set->num; i++) {
1229  if (p_set->pools[i] == pool)
1230  return ABT_SUCCESS;
1231  }
1232  /* Add pool to p_set. */
1233  if (p_set->num == p_set->len) {
1234  size_t new_len = p_set->len * 2;
1235  int abt_errno =
1236  ABTU_realloc(sizeof(ABT_pool) * p_set->len,
1237  sizeof(ABT_pool) * new_len, (void **)&p_set->pools);
1238  ABTI_CHECK_ERROR(abt_errno);
1239  p_set->len = new_len;
1240  }
1241  p_set->pools[p_set->num++] = pool;
1242  return ABT_SUCCESS;
1243 }
1244 
1246  FILE *fp, double timeout, void (*cb_func)(ABT_bool, void *), void *arg)
1247 {
1248  /* This function is signal-safe, so it may not call other functions unless
1249  * you really know what the called functions do. */
1255  /* Save fp and timeout. */
1256  print_stack_fp = fp;
1257  print_stack_timeout = timeout;
1258  print_cb_func = cb_func;
1259  print_arg = arg;
1260  /* Here print_stack_barrier must be 0. */
1262  0);
1265  }
1266  }
1267 }
1268 
1269 ABTU_ret_err static int print_all_thread_stacks(ABTI_global *p_global, FILE *fp)
1270 {
1271  size_t i;
1272  int abt_errno;
1273  struct info_pool_set_t pool_set;
1274 
1275  abt_errno = info_initialize_pool_set(&pool_set);
1276  ABTI_CHECK_ERROR(abt_errno);
1277  ABTI_xstream *p_xstream = p_global->p_xstream_head;
1278  while (p_xstream) {
1279  ABTI_sched *p_main_sched = p_xstream->p_main_sched;
1280  fprintf(fp, "= xstream[%d] (%p) =\n", p_xstream->rank,
1281  (void *)p_xstream);
1282  fprintf(fp, "main_sched : %p\n", (void *)p_main_sched);
1283  if (!p_main_sched)
1284  continue;
1285  for (i = 0; i < p_main_sched->num_pools; i++) {
1286  ABT_pool pool = p_main_sched->pools[i];
1287  ABTI_ASSERT(pool != ABT_POOL_NULL);
1288  fprintf(fp, " pools[%zu] : %p\n", i,
1289  (void *)ABTI_pool_get_ptr(pool));
1290  abt_errno = info_add_pool_set(pool, &pool_set);
1291  if (ABTI_IS_ERROR_CHECK_ENABLED && abt_errno != ABT_SUCCESS) {
1292  info_finalize_pool_set(&pool_set);
1293  ABTI_HANDLE_ERROR(abt_errno);
1294  }
1295  }
1296  p_xstream = p_xstream->p_next;
1297  }
1298  for (i = 0; i < pool_set.num; i++) {
1299  ABT_pool pool = pool_set.pools[i];
1300  ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
1301  abt_errno = info_print_thread_stacks_in_pool(fp, p_pool);
1302  if (abt_errno != ABT_SUCCESS)
1303  fprintf(fp, " Failed to print (errno = %d).\n", abt_errno);
1304  }
1305  info_finalize_pool_set(&pool_set);
1306  return ABT_SUCCESS;
1307 }
ABT_INFO_QUERY_KIND_ENABLED_STACK_OVERFLOW_CHECK
@ ABT_INFO_QUERY_KIND_ENABLED_STACK_OVERFLOW_CHECK
Definition: abt.h:621
ABTI_CHECK_NULL_SCHED_PTR
#define ABTI_CHECK_NULL_SCHED_PTR(p)
Definition: abti_error.h:177
ABTD_atomic_fetch_sub_int
static int ABTD_atomic_fetch_sub_int(ABTD_atomic_int *ptr, int v)
Definition: abtd_atomic.h:487
ABT_info_print_xstream
int ABT_info_print_xstream(FILE *fp, ABT_xstream xstream)
Print the information of an execution stream.
Definition: info.c:504
ABTI_sched_get_ptr
static ABTI_sched * ABTI_sched_get_ptr(ABT_sched sched)
Definition: abti_sched.h:11
ABTI_global::sched_sleep_nsec
uint64_t sched_sleep_nsec
Definition: abti.h:198
info_print_unit_arg_t::fp
FILE * fp
Definition: info.c:1151
ABT_bool
int ABT_bool
Boolean type.
Definition: abt.h:999
ABTI_global::sched_stacksize
size_t sched_stacksize
Definition: abti.h:196
info_trigger_print_all_thread_stacks
static void info_trigger_print_all_thread_stacks(FILE *fp, double timeout, void(*cb_func)(ABT_bool, void *), void *arg)
Definition: info.c:1248
ABTI_MEM_LP_MMAP_HP_THP
@ ABTI_MEM_LP_MMAP_HP_THP
Definition: abti_mem.h:21
ABTD_atomic_int
Definition: abtd_atomic.h:15
ABTI_CHECK_NULL_TASK_PTR
#define ABTI_CHECK_NULL_TASK_PTR(p)
Definition: abti_error.h:222
ABTU_realloc
static ABTU_ret_err int ABTU_realloc(size_t old_size, size_t new_size, void **p_ptr)
Definition: abtu.h:240
ABT_info_print_thread_attr
int ABT_info_print_thread_attr(FILE *fp, ABT_thread_attr attr)
Print the information of a ULT attribute.
Definition: info.c:673
ABTI_pool::p_print_all
ABT_pool_print_all_fn p_print_all
Definition: abti.h:329
ABTI_global::mem_lp_alloc
int mem_lp_alloc
Definition: abti.h:210
ABT_thread_attr
struct ABT_thread_attr_opaque * ABT_thread_attr
ULT attribute handle type.
Definition: abt.h:895
ABT_task
struct ABT_thread_opaque * ABT_task
Work unit handle type.
Definition: abt.h:929
ABT_thread
struct ABT_thread_opaque * ABT_thread
Work unit handle type.
Definition: abt.h:888
ABTI_SETUP_GLOBAL
#define ABTI_SETUP_GLOBAL(pp_global)
Definition: abti_error.h:59
ABT_info_print_all_xstreams
int ABT_info_print_all_xstreams(FILE *fp)
Print the information of all execution streams.
Definition: info.c:443
ABTI_thread::type
ABTI_thread_type type
Definition: abti.h:353
ABT_INFO_QUERY_KIND_DEFAULT_SCHED_STACKSIZE
@ ABT_INFO_QUERY_KIND_DEFAULT_SCHED_STACKSIZE
Definition: abt.h:607
ABTI_global_get_global
static ABTI_global * ABTI_global_get_global(void)
Definition: abti_global.h:9
ABT_INFO_QUERY_KIND_ENABLED_STACK_UNWIND
@ ABT_INFO_QUERY_KIND_ENABLED_STACK_UNWIND
Definition: abt.h:619
info_print_unit_arg_t
Definition: info.c:1150
ABT_ERR_POOL
#define ABT_ERR_POOL
Error code: error related to a pool.
Definition: abt.h:282
info_finalize_pool_set
static void info_finalize_pool_set(struct info_pool_set_t *p_set)
Definition: info.c:1222
ABTI_thread_print
void ABTI_thread_print(ABTI_thread *p_thread, FILE *p_os, int indent)
Definition: thread.c:2390
ABTI_info_check_print_all_thread_stacks
void ABTI_info_check_print_all_thread_stacks(void)
Definition: info.c:927
ABTI_CHECK_ERROR
#define ABTI_CHECK_ERROR(abt_errno)
Definition: abti_error.h:120
ABTI_sched::num_pools
size_t num_pools
Definition: abti.h:277
ABT_THREAD_TYPE_DYNAMIC_PROMOTION
#define ABT_THREAD_TYPE_DYNAMIC_PROMOTION
Definition: abti.h:62
ABTI_xstream::rank
int rank
Definition: abti.h:250
ABTI_MEM_LP_MALLOC
@ ABTI_MEM_LP_MALLOC
Definition: abti_mem.h:18
ABTI_THREAD_TYPE_YIELDABLE
#define ABTI_THREAD_TYPE_YIELDABLE
Definition: abti.h:83
ABTI_thread_get_ythread
static ABTI_ythread * ABTI_thread_get_ythread(ABTI_thread *p_thread)
Definition: abti_thread.h:52
ABTI_thread_get_id
ABT_unit_id ABTI_thread_get_id(ABTI_thread *p_thread)
Definition: thread.c:2490
print_stack_flag
static ABTD_atomic_int print_stack_flag
Definition: info.c:918
ABTI_global::print_config
ABT_bool print_config
Definition: abti.h:224
ABT_CONFIG_USE_FCONTEXT
#define ABT_CONFIG_USE_FCONTEXT
Definition: abt_config.h:90
print_stack_fp
static FILE * print_stack_fp
Definition: info.c:920
ABT_info_trigger_print_all_thread_stacks
int ABT_info_trigger_print_all_thread_stacks(FILE *fp, double timeout, void(*cb_func)(ABT_bool, void *), void *arg)
Print stacks of work units in pools associated with all the main schedulers.
Definition: info.c:898
ABT_INFO_QUERY_KIND_ENABLED_MIGRATION
@ ABT_INFO_QUERY_KIND_ENABLED_MIGRATION
Definition: abt.h:590
ABT_info_print_thread_stacks_in_pool
int ABT_info_print_thread_stacks_in_pool(FILE *fp, ABT_pool pool)
Print stacks of all work units in a pool.
Definition: info.c:822
print_cb_func
static void(* print_cb_func)(ABT_bool, void *)
Definition: info.c:922
ABT_CONFIG_DISABLE_TOOL_INTERFACE
#define ABT_CONFIG_DISABLE_TOOL_INTERFACE
Definition: abt_config.h:39
ABTI_thread
Definition: abti.h:349
ABTI_IS_ERROR_CHECK_ENABLED
#define ABTI_IS_ERROR_CHECK_ENABLED
Definition: abti.h:20
ABTI_thread_attr_get_ptr
static ABTI_thread_attr * ABTI_thread_attr_get_ptr(ABT_thread_attr attr)
Definition: abti_thread_attr.h:11
info_pool_set_t
Definition: info.c:1155
ABTI_xstream
Definition: abti.h:245
info_print_unit_arg_t::pool
ABT_pool pool
Definition: info.c:1152
ABTI_CHECK_NULL_THREAD_ATTR_PTR
#define ABTI_CHECK_NULL_THREAD_ATTR_PTR(p)
Definition: abti_error.h:213
ABT_pool
struct ABT_pool_opaque * ABT_pool
Pool handle type.
Definition: abt.h:839
info_print_thread_stacks_in_pool
static ABTU_ret_err int info_print_thread_stacks_in_pool(FILE *fp, ABTI_pool *p_pool)
Definition: info.c:1189
ABTI_xstream::p_next
ABTI_xstream * p_next
Definition: abti.h:248
ABT_CONFIG_THREAD_TYPE
#define ABT_CONFIG_THREAD_TYPE
Definition: abt_config.h:72
ABTI_thread_attr_print
void ABTI_thread_attr_print(ABTI_thread_attr *p_attr, FILE *p_os, int indent)
Definition: thread_attr.c:369
ABTI_thread_attr
Definition: abti.h:366
ABT_sched
struct ABT_sched_opaque * ABT_sched
Scheduler handle type.
Definition: abt.h:806
ABT_INFO_QUERY_KIND_FCONTEXT
@ ABT_INFO_QUERY_KIND_FCONTEXT
Definition: abt.h:615
ABT_ERR_INV_QUERY_KIND
#define ABT_ERR_INV_QUERY_KIND
Error code: invalid query kind.
Definition: abt.h:240
ABTI_pool
Definition: abti.h:305
print_stack_timeout
static double print_stack_timeout
Definition: info.c:921
ABTI_MEM_LP_THP
@ ABTI_MEM_LP_THP
Definition: abti_mem.h:22
ABT_POOL_NULL
#define ABT_POOL_NULL
Definition: abt.h:1057
info_print_unit
static void info_print_unit(void *arg, ABT_unit unit)
Definition: info.c:1161
ABT_INFO_QUERY_KIND_ENABLED_EXTERNAL_THREAD
@ ABT_INFO_QUERY_KIND_ENABLED_EXTERNAL_THREAD
Definition: abt.h:594
abti.h
ABTI_CHECK_NULL_THREAD_PTR
#define ABTI_CHECK_NULL_THREAD_PTR(p)
Definition: abti_error.h:195
ABT_INFO_QUERY_KIND_ENABLED_AFFINITY
@ ABT_INFO_QUERY_KIND_ENABLED_AFFINITY
Definition: abt.h:601
ABTI_global::use_logging
ABT_bool use_logging
Definition: abti.h:192
ABT_info_query_config
int ABT_info_query_config(ABT_info_query_kind query_kind, void *val)
Retrieve the configuration information.
Definition: info.c:200
info_pool_set_t::num
size_t num
Definition: info.c:1157
ABT_INFO_QUERY_KIND_ENABLED_CHECK_POOL_PRODUCER
@ ABT_INFO_QUERY_KIND_ENABLED_CHECK_POOL_PRODUCER
Definition: abt.h:579
ABT_unit_id
uint64_t ABT_unit_id
Work unit ID type.
Definition: abt.h:877
ABT_xstream
struct ABT_xstream_opaque * ABT_xstream
Execution stream handle type.
Definition: abt.h:787
ABT_info_print_thread_stack
int ABT_info_print_thread_stack(FILE *fp, ABT_thread thread)
Print stack of a work unit.
Definition: info.c:767
ABTI_global::mem_page_size
size_t mem_page_size
Definition: abti.h:206
ABT_INFO_QUERY_KIND_ENABLED_VALGRIND
@ ABT_INFO_QUERY_KIND_ENABLED_VALGRIND
Definition: abt.h:575
ABTI_global::thread_stacksize
size_t thread_stacksize
Definition: abti.h:195
ABT_CONFIG_USE_CLOCK_GETTIME
#define ABT_CONFIG_USE_CLOCK_GETTIME
Definition: abt_config.h:78
ABTI_HANDLE_ERROR
#define ABTI_HANDLE_ERROR(n)
Definition: abti_error.h:114
ABTD_atomic_pause
static void ABTD_atomic_pause(void)
Definition: abtd_atomic.h:1257
ABTI_global::huge_page_size
size_t huge_page_size
Definition: abti.h:204
ABTU_malloc
static ABTU_ret_err int ABTU_malloc(size_t size, void **p_ptr)
Definition: abtu.h:218
ABTI_MEM_LP_MMAP_HP_RP
@ ABTI_MEM_LP_MMAP_HP_RP
Definition: abti_mem.h:20
ABT_info_query_kind
ABT_info_query_kind
Query kind for ABT_info_query_config().
Definition: abt.h:567
ABT_INFO_QUERY_KIND_ENABLED_STACKABLE_SCHED
@ ABT_INFO_QUERY_KIND_ENABLED_STACKABLE_SCHED
Definition: abt.h:592
PRINT_STACK_FLAG_INITIALIZE
#define PRINT_STACK_FLAG_INITIALIZE
Definition: info.c:914
ABTI_xstream::p_main_sched
ABTI_sched * p_main_sched
Definition: abti.h:253
ABT_INFO_QUERY_KIND_ENABLED_PRINT_CONFIG
@ ABT_INFO_QUERY_KIND_ENABLED_PRINT_CONFIG
Definition: abt.h:599
info_add_pool_set
static ABTU_ret_err int info_add_pool_set(ABT_pool pool, struct info_pool_set_t *p_set)
Definition: info.c:1227
ABTI_pool::u_get_thread
ABT_unit_get_thread_fn u_get_thread
Definition: abti.h:315
ABTI_global::sched_event_freq
uint32_t sched_event_freq
Definition: abti.h:197
info_pool_set_t::pools
ABT_pool * pools
Definition: info.c:1156
ABTI_spinlock_release
static void ABTI_spinlock_release(ABTI_spinlock *p_lock)
Definition: abti_spinlock.h:42
ABTI_spinlock_acquire
static void ABTI_spinlock_acquire(ABTI_spinlock *p_lock)
Definition: abti_spinlock.h:28
ABT_unit
struct ABT_unit_opaque * ABT_unit
Work unit handle type for scheduling.
Definition: abt.h:867
ABT_INFO_QUERY_KIND_ENABLED_DEBUG
@ ABT_INFO_QUERY_KIND_ENABLED_DEBUG
Definition: abt.h:569
ABTI_ythread::ctx
ABTD_ythread_context ctx
Definition: abti.h:386
ABTI_xstream_print
void ABTI_xstream_print(ABTI_xstream *p_xstream, FILE *p_os, int indent, ABT_bool print_sub)
Definition: stream.c:1591
ABTI_ASSERT
#define ABTI_ASSERT(cond)
Definition: abti_error.h:12
ABTI_global::mem_sp_size
size_t mem_sp_size
Definition: abti.h:207
ABTI_sched::pools
ABT_pool * pools
Definition: abti.h:276
ABT_CONFIG_STATIC_CACHELINE_SIZE
#define ABT_CONFIG_STATIC_CACHELINE_SIZE
Definition: abt_config.h:69
ABTI_global::num_xstreams
int num_xstreams
Definition: abti.h:184
ABTD_atomic_fetch_add_int
static int ABTD_atomic_fetch_add_int(ABTD_atomic_int *ptr, int v)
Definition: abtd_atomic.h:429
ABT_INFO_QUERY_KIND_ENABLED_TOOL
@ ABT_INFO_QUERY_KIND_ENABLED_TOOL
Definition: abt.h:613
ABT_SUCCESS
#define ABT_SUCCESS
Error code: the routine returns successfully.
Definition: abt.h:92
PRINT_STACK_FLAG_UNSET
#define PRINT_STACK_FLAG_UNSET
Definition: info.c:913
ABTU_ret_err
#define ABTU_ret_err
Definition: abtu.h:138
ABT_INFO_QUERY_KIND_DYNAMIC_PROMOTION
@ ABT_INFO_QUERY_KIND_DYNAMIC_PROMOTION
Definition: abt.h:617
ABTI_global::p_xstream_head
ABTI_xstream * p_xstream_head
Definition: abti.h:185
ABTD_atomic_acquire_load_int
static int ABTD_atomic_acquire_load_int(const ABTD_atomic_int *ptr)
Definition: abtd_atomic.h:878
print_stack_barrier
static ABTD_atomic_int print_stack_barrier
Definition: info.c:924
ABTI_global::xstream_list_lock
ABTI_spinlock xstream_list_lock
Definition: abti.h:187
ABT_info_print_pool
int ABT_info_print_pool(FILE *fp, ABT_pool pool)
Print the information of a pool.
Definition: info.c:586
ABT_INFO_QUERY_KIND_DEFAULT_THREAD_STACKSIZE
@ ABT_INFO_QUERY_KIND_DEFAULT_THREAD_STACKSIZE
Definition: abt.h:605
ABT_TRUE
#define ABT_TRUE
True constant for ABT_bool.
Definition: abt.h:746
ABTI_pool_get_ptr
static ABTI_pool * ABTI_pool_get_ptr(ABT_pool pool)
Definition: abti_pool.h:11
ABTD_ATOMIC_INT_STATIC_INITIALIZER
#define ABTD_ATOMIC_INT_STATIC_INITIALIZER(val)
Definition: abtd_atomic.h:47
ABT_INFO_QUERY_KIND_ENABLED_CHECK_POOL_CONSUMER
@ ABT_INFO_QUERY_KIND_ENABLED_CHECK_POOL_CONSUMER
Definition: abt.h:581
ABTI_global::key_table_size
uint32_t key_table_size
Definition: abti.h:194
PRINT_STACK_FLAG_WAIT
#define PRINT_STACK_FLAG_WAIT
Definition: info.c:915
ABTI_sched
Definition: abti.h:270
ABT_INFO_QUERY_KIND_ENABLED_CHECK_ERROR
@ ABT_INFO_QUERY_KIND_ENABLED_CHECK_ERROR
Definition: abt.h:577
ABT_FALSE
#define ABT_FALSE
False constant for ABT_bool.
Definition: abt.h:748
ABTI_ythread
Definition: abti.h:384
ABTI_global::mem_max_stacks
uint32_t mem_max_stacks
Definition: abti.h:208
ABT_info_print_thread
int ABT_info_print_thread(FILE *fp, ABT_thread thread)
Print the information of a work unit.
Definition: info.c:632
ABTI_CHECK_NULL_POOL_PTR
#define ABTI_CHECK_NULL_POOL_PTR(p)
Definition: abti_error.h:168
print_arg
static void * print_arg
Definition: info.c:923
ABTI_CHECK_NULL_XSTREAM_PTR
#define ABTI_CHECK_NULL_XSTREAM_PTR(p)
Definition: abti_error.h:159
ABTU_free
static void ABTU_free(void *ptr)
Definition: abtu.h:211
print_all_thread_stacks
static ABTU_ret_err int print_all_thread_stacks(ABTI_global *p_global, FILE *fp)
Definition: info.c:1272
ABTI_xstream_get_ptr
static ABTI_xstream * ABTI_xstream_get_ptr(ABT_xstream xstream)
Definition: abti_stream.h:11
ABT_INFO_QUERY_KIND_ENABLED_PRESERVE_FPU
@ ABT_INFO_QUERY_KIND_ENABLED_PRESERVE_FPU
Definition: abt.h:584
ABTI_global::use_debug
ABT_bool use_debug
Definition: abti.h:193
ABTD_atomic_bool_cas_strong_int
static int ABTD_atomic_bool_cas_strong_int(ABTD_atomic_int *ptr, int oldv, int newv)
Definition: abtd_atomic.h:385
ABTI_ythread_print_stack
void ABTI_ythread_print_stack(ABTI_ythread *p_ythread, FILE *p_os)
Definition: ythread.c:100
ABT_INFO_QUERY_KIND_ENABLED_PRINT_ERRNO
@ ABT_INFO_QUERY_KIND_ENABLED_PRINT_ERRNO
Definition: abt.h:571
ABTI_ythread::thread
ABTI_thread thread
Definition: abti.h:385
ABT_info_print_task
int ABT_info_print_task(FILE *fp, ABT_task task)
Print the information of a work unit.
Definition: info.c:720
ABT_info_print_config
int ABT_info_print_config(FILE *fp)
Print the runtime information of Argobots.
Definition: info.c:396
ABTI_global::set_affinity
ABT_bool set_affinity
Definition: abti.h:191
ABTI_info_print_config
void ABTI_info_print_config(ABTI_global *p_global, FILE *fp)
Definition: info.c:998
ABTI_pool_print
void ABTI_pool_print(ABTI_pool *p_pool, FILE *p_os, int indent)
Definition: pool.c:887
ABTI_CHECK_TRUE
#define ABTI_CHECK_TRUE(cond, abt_errno)
Definition: abti_error.h:130
ABTI_global
Definition: abti.h:182
ABT_INFO_QUERY_KIND_ENABLED_TASK_CANCEL
@ ABT_INFO_QUERY_KIND_ENABLED_TASK_CANCEL
Definition: abt.h:588
ABT_INFO_QUERY_KIND_DEFAULT_SCHED_EVENT_FREQ
@ ABT_INFO_QUERY_KIND_DEFAULT_SCHED_EVENT_FREQ
Definition: abt.h:609
ABTI_global::num_cores
int num_cores
Definition: abti.h:190
ABTI_MEM_LP_MMAP_RP
@ ABTI_MEM_LP_MMAP_RP
Definition: abti_mem.h:19
ABTD_FCONTEXT_PRESERVE_FPU
#define ABTD_FCONTEXT_PRESERVE_FPU
Definition: abt_config.h:15
info_pool_set_t::len
size_t len
Definition: info.c:1158
ABTD_atomic_release_store_int
static void ABTD_atomic_release_store_int(ABTD_atomic_int *ptr, int val)
Definition: abtd_atomic.h:1065
ABTI_global::max_xstreams
int max_xstreams
Definition: abti.h:183
ABTI_global_get_global_or_null
static ABTI_global * ABTI_global_get_global_or_null(void)
Definition: abti_global.h:15
ABT_info_print_sched
int ABT_info_print_sched(FILE *fp, ABT_sched sched)
Print the information of a scheduler.
Definition: info.c:545
ABTI_thread_get_ptr
static ABTI_thread * ABTI_thread_get_ptr(ABT_thread thread)
Definition: abti_thread.h:9
info_initialize_pool_set
static ABTU_ret_err int info_initialize_pool_set(struct info_pool_set_t *p_set)
Definition: info.c:1211
ABTI_get_wtime
static double ABTI_get_wtime(void)
Definition: abti_timer.h:11
ABTI_pool_get_handle
static ABT_pool ABTI_pool_get_handle(ABTI_pool *p_pool)
Definition: abti_pool.h:26
ABT_INFO_QUERY_KIND_MAX_NUM_XSTREAMS
@ ABT_INFO_QUERY_KIND_MAX_NUM_XSTREAMS
Definition: abt.h:603
ABT_INFO_QUERY_KIND_DEFAULT_SCHED_SLEEP_NSEC
@ ABT_INFO_QUERY_KIND_DEFAULT_SCHED_SLEEP_NSEC
Definition: abt.h:611
ABTI_global::mem_max_descs
uint32_t mem_max_descs
Definition: abti.h:209
ABT_INFO_QUERY_KIND_ENABLED_LOG
@ ABT_INFO_QUERY_KIND_ENABLED_LOG
Definition: abt.h:573
PRINT_STACK_FLAG_FINALIZE
#define PRINT_STACK_FLAG_FINALIZE
Definition: info.c:916
ABT_VERSION
#define ABT_VERSION
Version string of Argobots.
Definition: abt.h:46
ABT_INFO_QUERY_KIND_ENABLED_THREAD_CANCEL
@ ABT_INFO_QUERY_KIND_ENABLED_THREAD_CANCEL
Definition: abt.h:586
ABT_INFO_QUERY_KIND_ENABLED_SCHED_SLEEP
@ ABT_INFO_QUERY_KIND_ENABLED_SCHED_SLEEP
Definition: abt.h:596
ABTI_sched_print
void ABTI_sched_print(ABTI_sched *p_sched, FILE *p_os, int indent, ABT_bool print_sub)
Definition: sched.c:953