ARGOBOTS  8bef54a19d7b3e50f977f85716578b627bf37d9c
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  FILE *fp,
10  ABTI_pool *p_pool);
12  FILE *fp, double timeout, void (*cb_func)(ABT_bool, void *), void *arg);
13 
210 int ABT_info_query_config(ABT_info_query_kind query_kind, void *val)
211 {
212  ABTI_UB_ASSERT(val);
213 
214 #ifndef ABT_CONFIG_ENABLE_VER_20_API
215  /* Argobots 1.x always requires an init check. */
216  ABTI_SETUP_GLOBAL(NULL);
217 #endif
218  switch (query_kind) {
220  ABTI_global *p_global;
221  ABTI_SETUP_GLOBAL(&p_global);
222  *((ABT_bool *)val) = p_global->use_debug;
223  } break;
225 #ifdef ABT_CONFIG_PRINT_ABT_ERRNO
226  *((ABT_bool *)val) = ABT_TRUE;
227 #else
228  *((ABT_bool *)val) = ABT_FALSE;
229 #endif
230  break;
232  ABTI_global *p_global;
233  ABTI_SETUP_GLOBAL(&p_global);
234  *((ABT_bool *)val) = p_global->use_logging;
235  } break;
237 #ifdef HAVE_VALGRIND_SUPPORT
238  *((ABT_bool *)val) = ABT_TRUE;
239 #else
240  *((ABT_bool *)val) = ABT_FALSE;
241 #endif
242  break;
244 #ifndef ABT_CONFIG_DISABLE_ERROR_CHECK
245  *((ABT_bool *)val) = ABT_TRUE;
246 #else
247  *((ABT_bool *)val) = ABT_FALSE;
248 #endif
249  break;
251  *((ABT_bool *)val) = ABT_FALSE;
252  break;
254  *((ABT_bool *)val) = ABT_FALSE;
255  break;
257 #if !defined(ABTD_FCONTEXT_PRESERVE_FPU) && defined(ABT_CONFIG_USE_FCONTEXT)
258  *((ABT_bool *)val) = ABT_FALSE;
259 #else
260  /* If ucontext is used, FPU is preserved. */
261  *((ABT_bool *)val) = ABT_TRUE;
262 #endif
263  break;
265 #ifndef ABT_CONFIG_DISABLE_THREAD_CANCEL
266  *((ABT_bool *)val) = ABT_TRUE;
267 #else
268  *((ABT_bool *)val) = ABT_FALSE;
269 #endif
270  break;
272 #ifndef ABT_CONFIG_DISABLE_TASK_CANCEL
273  *((ABT_bool *)val) = ABT_TRUE;
274 #else
275  *((ABT_bool *)val) = ABT_FALSE;
276 #endif
277  break;
279 #ifndef ABT_CONFIG_DISABLE_MIGRATION
280  *((ABT_bool *)val) = ABT_TRUE;
281 #else
282  *((ABT_bool *)val) = ABT_FALSE;
283 #endif
284  break;
286  *((ABT_bool *)val) = ABT_TRUE;
287  break;
289 #ifndef ABT_CONFIG_DISABLE_EXT_THREAD
290  *((ABT_bool *)val) = ABT_TRUE;
291 #else
292  *((ABT_bool *)val) = ABT_FALSE;
293 #endif
294  break;
296 #ifdef ABT_CONFIG_USE_SCHED_SLEEP
297  *((ABT_bool *)val) = ABT_TRUE;
298 #else
299  *((ABT_bool *)val) = ABT_FALSE;
300 #endif
301  break;
303  ABTI_global *p_global;
304  ABTI_SETUP_GLOBAL(&p_global);
305  *((ABT_bool *)val) = p_global->print_config;
306  } break;
308  ABTI_global *p_global;
309  ABTI_SETUP_GLOBAL(&p_global);
310  *((ABT_bool *)val) = p_global->set_affinity;
311  } break;
313  ABTI_global *p_global;
314  ABTI_SETUP_GLOBAL(&p_global);
315  *((unsigned int *)val) = p_global->max_xstreams;
316  } break;
318  ABTI_global *p_global;
319  ABTI_SETUP_GLOBAL(&p_global);
320  *((size_t *)val) = p_global->thread_stacksize;
321  } break;
323  ABTI_global *p_global;
324  ABTI_SETUP_GLOBAL(&p_global);
325  *((size_t *)val) = p_global->sched_stacksize;
326  } break;
328  ABTI_global *p_global;
329  ABTI_SETUP_GLOBAL(&p_global);
330  *((uint64_t *)val) = p_global->sched_event_freq;
331  } break;
333  ABTI_global *p_global;
334  ABTI_SETUP_GLOBAL(&p_global);
335  *((uint64_t *)val) = p_global->sched_sleep_nsec;
336  } break;
338 #ifndef ABT_CONFIG_DISABLE_TOOL_INTERFACE
339  *((ABT_bool *)val) = ABT_TRUE;
340 #else
341  *((ABT_bool *)val) = ABT_FALSE;
342 #endif
343  break;
345 #ifdef ABT_CONFIG_USE_FCONTEXT
346  *((ABT_bool *)val) = ABT_TRUE;
347 #else
348  *((ABT_bool *)val) = ABT_FALSE;
349 #endif
350  break;
352 #if ABT_CONFIG_THREAD_TYPE == ABT_THREAD_TYPE_DYNAMIC_PROMOTION
353  *((ABT_bool *)val) = ABT_TRUE;
354 #else
355  *((ABT_bool *)val) = ABT_FALSE;
356 #endif
357  break;
359 #ifdef ABT_CONFIG_ENABLE_STACK_UNWIND
360  *((ABT_bool *)val) = ABT_TRUE;
361 #else
362  *((ABT_bool *)val) = ABT_FALSE;
363 #endif
364  break;
366  ABTI_global *p_global;
367  ABTI_SETUP_GLOBAL(&p_global);
368  if (p_global->stack_guard_kind == ABTI_STACK_GUARD_MPROTECT) {
369  *((int *)val) = 2;
370  } else if (p_global->stack_guard_kind ==
372  *((int *)val) = 3;
373  } else {
374 #if ABT_CONFIG_STACK_CHECK_TYPE == ABTI_STACK_CHECK_TYPE_CANARY
375  *((int *)val) = 1;
376 #else
377  *((int *)val) = 0;
378 #endif
379  }
380  } break;
382 #if ABT_CONFIG_ACTIVE_WAIT_POLICY
383  *((int *)val) = 1;
384 #else
385  *((int *)val) = 0;
386 #endif
387  break;
388  default:
390  }
391  return ABT_SUCCESS;
392 }
393 
424 {
425  ABTI_UB_ASSERT(fp);
426 
427  ABTI_global *p_global;
428 #ifndef ABT_CONFIG_ENABLE_VER_20_API
429  /* Argobots 1.x always requires an init check. */
430  ABTI_SETUP_GLOBAL(&p_global);
431 #else
432  p_global = ABTI_global_get_global_or_null();
433  if (!p_global) {
434  fprintf(fp, "Argobots is not initialized.\n");
435  fflush(fp);
436  return ABT_SUCCESS;
437  }
438 #endif
439  ABTI_info_print_config(p_global, fp);
440  return ABT_SUCCESS;
441 }
442 
473 {
474  ABTI_UB_ASSERT(fp);
475 
476  ABTI_global *p_global;
477 #ifndef ABT_CONFIG_ENABLE_VER_20_API
478  /* Argobots 1.x always requires an init check. */
479  ABTI_SETUP_GLOBAL(&p_global);
480 #else
481  p_global = ABTI_global_get_global_or_null();
482  if (!p_global) {
483  fprintf(fp, "Argobots is not initialized.\n");
484  fflush(fp);
485  return ABT_SUCCESS;
486  }
487 #endif
488 
490 
491  fprintf(fp, "# of created ESs: %d\n", p_global->num_xstreams);
492 
493  ABTI_xstream *p_xstream = p_global->p_xstream_head;
494  while (p_xstream) {
495  ABTI_xstream_print(p_xstream, fp, 0, ABT_FALSE);
496  p_xstream = p_xstream->p_next;
497  }
498 
500 
501  fflush(fp);
502  return ABT_SUCCESS;
503 }
504 
535 int ABT_info_print_xstream(FILE *fp, ABT_xstream xstream)
536 {
537  ABTI_UB_ASSERT(fp);
538 
539  ABTI_xstream *p_xstream = ABTI_xstream_get_ptr(xstream);
540 #ifndef ABT_CONFIG_ENABLE_VER_20_API
541  /* Argobots 1.x requires a NULL-handle check. */
542  ABTI_CHECK_NULL_XSTREAM_PTR(p_xstream);
543 #endif
544  ABTI_xstream_print(p_xstream, fp, 0, ABT_FALSE);
545  return ABT_SUCCESS;
546 }
547 
578 int ABT_info_print_sched(FILE *fp, ABT_sched sched)
579 {
580  ABTI_UB_ASSERT(fp);
581 
582  ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
583 #ifndef ABT_CONFIG_ENABLE_VER_20_API
584  /* Argobots 1.x requires a NULL-handle check. */
585  ABTI_CHECK_NULL_SCHED_PTR(p_sched);
586 #endif
587  ABTI_sched_print(p_sched, fp, 0, ABT_TRUE);
588  return ABT_SUCCESS;
589 }
590 
621 int ABT_info_print_pool(FILE *fp, ABT_pool pool)
622 {
623  ABTI_UB_ASSERT(fp);
624 
625  ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
626 #ifndef ABT_CONFIG_ENABLE_VER_20_API
627  /* Argobots 1.x requires a NULL-handle check. */
628  ABTI_CHECK_NULL_POOL_PTR(p_pool);
629 #endif
630  ABTI_pool_print(p_pool, fp, 0);
631  return ABT_SUCCESS;
632 }
633 
668 int ABT_info_print_thread(FILE *fp, ABT_thread thread)
669 {
670  ABTI_UB_ASSERT(fp);
671 
672  ABTI_thread *p_thread = ABTI_thread_get_ptr(thread);
673 #ifndef ABT_CONFIG_ENABLE_VER_20_API
674  /* Argobots 1.x requires a NULL-handle check. */
675  ABTI_CHECK_NULL_THREAD_PTR(p_thread);
676 #endif
677  ABTI_thread_print(p_thread, fp, 0);
678  return ABT_SUCCESS;
679 }
680 
712 {
713  ABTI_UB_ASSERT(fp);
714 
716 #ifndef ABT_CONFIG_ENABLE_VER_20_API
717  /* Argobots 1.x requires a NULL-handle check. */
719 #endif
720  ABTI_thread_attr_print(p_attr, fp, 0);
721  return ABT_SUCCESS;
722 }
723 
759 int ABT_info_print_task(FILE *fp, ABT_task task)
760 {
762 
763  ABTI_thread *p_thread = ABTI_thread_get_ptr(task);
764 #ifndef ABT_CONFIG_ENABLE_VER_20_API
765  /* Argobots 1.x requires a NULL-handle check. */
766  ABTI_CHECK_NULL_TASK_PTR(p_thread);
767 #endif
768  ABTI_thread_print(p_thread, fp, 0);
769  return ABT_SUCCESS;
770 }
771 
807 int ABT_info_print_thread_stack(FILE *fp, ABT_thread thread)
808 {
809  ABTI_UB_ASSERT(fp);
810  /* We can check if thread is running or not in ABTI_UB_ASSERT(), but as this
811  * info function is basically used for debugging, printing a corrupted stack
812  * or even crashing a program would be fine. */
813 
814  ABTI_thread *p_thread = ABTI_thread_get_ptr(thread);
815 #ifndef ABT_CONFIG_ENABLE_VER_20_API
816  /* Argobots 1.x requires a NULL-handle check. */
817  ABTI_CHECK_NULL_THREAD_PTR(p_thread);
818 #endif
819  if (!p_thread) {
820  fprintf(fp, "no stack\n");
821  fflush(0);
822  } else {
823  if (p_thread->type & ABTI_THREAD_TYPE_YIELDABLE) {
825  if (!p_global) {
826  fprintf(fp, "Argobots is not initialized.\n");
827  fflush(0);
828  } else {
829  ABTI_ythread *p_ythread = ABTI_thread_get_ythread(p_thread);
830  ABTI_ythread_print_stack(p_global, p_ythread, fp);
831  }
832  } else {
833  fprintf(fp, "no stack\n");
834  fflush(0);
835  }
836  }
837  return ABT_SUCCESS;
838 }
839 
873 {
874  ABTI_UB_ASSERT(fp);
875 
876  ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
877 #ifndef ABT_CONFIG_ENABLE_VER_20_API
878  /* Argobots 1.x requires a NULL-handle check. */
879  ABTI_CHECK_NULL_POOL_PTR(p_pool);
880 #endif
882  if (!p_global) {
883  fprintf(fp, "Argobots is not initialized.\n");
884  fflush(0);
885  } else {
886  int abt_errno = info_print_thread_stacks_in_pool(p_global, fp, p_pool);
887  ABTI_CHECK_ERROR(abt_errno);
888  }
889  return ABT_SUCCESS;
890 }
891 
956 int ABT_info_trigger_print_all_thread_stacks(FILE *fp, double timeout,
957  void (*cb_func)(ABT_bool, void *),
958  void *arg)
959 {
960  /* assert() is not signal safe, so we cannot validate variables. */
961  info_trigger_print_all_thread_stacks(fp, timeout, cb_func, arg);
962  return ABT_SUCCESS;
963 }
964 
965 /*****************************************************************************/
966 /* Private APIs */
967 /*****************************************************************************/
968 
970  FILE *fp);
971 
972 #define PRINT_STACK_FLAG_UNSET 0
973 #define PRINT_STACK_FLAG_INITIALIZE 1
974 #define PRINT_STACK_FLAG_WAIT 2
975 #define PRINT_STACK_FLAG_FINALIZE 3
976 
979 static FILE *print_stack_fp = NULL;
980 static double print_stack_timeout = 0.0;
981 static void (*print_cb_func)(ABT_bool, void *) = NULL;
982 static void *print_arg = NULL;
985 
987 {
990  return;
991 
992  /* Wait for the other execution streams using a barrier mechanism. */
993  int self_value = ABTD_atomic_fetch_add_int(&print_stack_barrier, 1);
994  if (self_value == 0) {
995  ABTI_global *p_global = ABTI_global_get_global();
996  /* This ES becomes the main ES. */
997  double start_time = ABTI_get_wtime();
998  ABT_bool force_print = ABT_FALSE;
999 
1000  /* xstreams_lock is acquired to avoid dynamic ES creation while
1001  * printing data. */
1003  while (1) {
1005  p_global->num_xstreams) {
1006  break;
1007  }
1008  if (print_stack_timeout >= 0.0 &&
1009  (ABTI_get_wtime() - start_time) >= print_stack_timeout) {
1010  force_print = ABT_TRUE;
1011  break;
1012  }
1016  }
1017  /* All the available ESs are (supposed to be) stopped. We *assume* that
1018  * no ES is calling and will call Argobots functions except this
1019  * function while printing stack information. */
1020  if (force_print) {
1021  fprintf(print_stack_fp,
1022  "ABT_info_trigger_print_all_thread_stacks: "
1023  "timeout (only %d ESs stop)\n",
1025  }
1026  int abt_errno = print_all_thread_stacks(p_global, print_stack_fp);
1027  if (ABTI_IS_ERROR_CHECK_ENABLED && abt_errno != ABT_SUCCESS) {
1028  fprintf(print_stack_fp, "ABT_info_trigger_print_all_thread_stacks: "
1029  "failed because of an internal error.\n");
1030  }
1031  fflush(print_stack_fp);
1032  /* Release the lock that protects ES data. */
1034  if (print_cb_func)
1035  print_cb_func(force_print, print_arg);
1036  /* Update print_stack_flag to 3. */
1039  } else {
1040  /* Wait for the main ES's work. */
1044  }
1047 
1048  /* Decrement the barrier value. */
1049  int dec_value = ABTD_atomic_fetch_sub_int(&print_stack_barrier, 1);
1050  if (dec_value == 0) {
1051  /* The last execution stream resets the flag. */
1054  }
1055 }
1056 
1057 void ABTI_info_print_config(ABTI_global *p_global, FILE *fp)
1058 {
1059  fprintf(fp, "Argobots Configuration:\n");
1060  fprintf(fp, " - version: " ABT_VERSION "\n");
1061  fprintf(fp, " - # of cores: %d\n", p_global->num_cores);
1062  fprintf(fp, " - cache line size: %u B\n", ABT_CONFIG_STATIC_CACHELINE_SIZE);
1063  fprintf(fp, " - huge page size: %zu B\n", p_global->huge_page_size);
1064  fprintf(fp, " - max. # of ESs: %d\n", p_global->max_xstreams);
1065  fprintf(fp, " - cur. # of ESs: %d\n", p_global->num_xstreams);
1066  fprintf(fp, " - ES affinity: %s\n",
1067  (p_global->set_affinity == ABT_TRUE) ? "on" : "off");
1068  fprintf(fp, " - logging: %s\n",
1069  (p_global->use_logging == ABT_TRUE) ? "on" : "off");
1070  fprintf(fp, " - debug output: %s\n",
1071  (p_global->use_debug == ABT_TRUE) ? "on" : "off");
1072  fprintf(fp, " - print errno: "
1073 #ifdef ABT_CONFIG_PRINT_ABT_ERRNO
1074  "on"
1075 #else
1076  "off"
1077 #endif
1078  "\n");
1079  fprintf(fp, " - valgrind support: "
1080 #ifdef HAVE_VALGRIND_SUPPORT
1081  "yes"
1082 #else
1083  "no"
1084 #endif
1085  "\n");
1086  fprintf(fp, " - thread cancellation: "
1087 #ifndef ABT_CONFIG_DISABLE_THREAD_CANCEL
1088  "enabled"
1089 #else
1090  "disabled"
1091 #endif
1092  "\n");
1093  fprintf(fp, " - task cancellation: "
1094 #ifndef ABT_CONFIG_DISABLE_TASK_CANCEL
1095  "enabled"
1096 #else
1097  "disabled"
1098 #endif
1099  "\n");
1100  fprintf(fp, " - thread migration: "
1101 #ifndef ABT_CONFIG_DISABLE_MIGRATION
1102  "enabled"
1103 #else
1104  "disabled"
1105 #endif
1106  "\n");
1107  fprintf(fp, " - external thread: "
1108 #ifndef ABT_CONFIG_DISABLE_EXT_THREAD
1109  "enabled"
1110 #else
1111  "disabled"
1112 #endif
1113  "\n");
1114  fprintf(fp, " - error check: "
1115 #ifndef ABT_CONFIG_DISABLE_ERROR_CHECK
1116  "enabled"
1117 #else
1118  "disable"
1119 #endif
1120  "\n");
1121  fprintf(fp, " - tool interface: "
1123  "yes"
1124 #else
1125  "no"
1126 #endif
1127  "\n");
1128  fprintf(fp, " - wait policy: "
1129 #ifdef ABT_CONFIG_ACTIVE_WAIT_POLICY
1130  "active"
1131 #else
1132  "passive"
1133 #endif
1134  "\n");
1135  fprintf(fp, " - context-switch: "
1137  "fcontext"
1140  " (dynamic-promotion)"
1142  !defined(ABTD_FCONTEXT_PRESERVE_FPU)
1143  " (dynamic-promotion, no FPU save)"
1145  !defined(ABTD_FCONTEXT_PRESERVE_FPU)
1146  " (no FPU save)"
1147 #endif /* ABT_CONFIG_THREAD_TYPE, ABTD_FCONTEXT_PRESERVE_FPU */
1148 
1149 #else /* ABT_CONFIG_USE_FCONTEXT */
1150  "ucontext"
1151 #endif /* !ABT_CONFIG_USE_FCONTEXT */
1152  "\n");
1153 
1154  fprintf(fp, " - key table entries: %" PRIu32 "\n",
1155  p_global->key_table_size);
1156  fprintf(fp, " - default ULT stack size: %zu KB\n",
1157  p_global->thread_stacksize / 1024);
1158  fprintf(fp, " - default scheduler stack size: %zu KB\n",
1159  p_global->sched_stacksize / 1024);
1160  fprintf(fp, " - default scheduler event check frequency: %u\n",
1161  p_global->sched_event_freq);
1162  fprintf(fp, " - default scheduler sleep: "
1163 #ifdef ABT_CONFIG_USE_SCHED_SLEEP
1164  "on"
1165 #else
1166  "off"
1167 #endif
1168  "\n");
1169  fprintf(fp, " - default scheduler sleep duration : %" PRIu64 " [ns]\n",
1170  p_global->sched_sleep_nsec);
1171 
1172  fprintf(fp, " - timer function: "
1173 #if defined(ABT_CONFIG_USE_CLOCK_GETTIME)
1174  "clock_gettime"
1175 #elif defined(ABT_CONFIG_USE_MACH_ABSOLUTE_TIME)
1176  "mach_absolute_time"
1177 #elif defined(ABT_CONFIG_USE_GETTIMEOFDAY)
1178  "gettimeofday"
1179 #endif
1180  "\n");
1181 
1182 #ifdef ABT_CONFIG_USE_MEM_POOL
1183  fprintf(fp, "Memory Pool:\n");
1184  fprintf(fp, " - page size for allocation: %zu KB\n",
1185  p_global->mem_page_size / 1024);
1186  fprintf(fp, " - stack page size: %zu KB\n", p_global->mem_sp_size / 1024);
1187  fprintf(fp, " - max. # of stacks per ES: %u\n", p_global->mem_max_stacks);
1188  fprintf(fp, " - max. # of descs per ES: %u\n", p_global->mem_max_descs);
1189  switch (p_global->mem_lp_alloc) {
1190  case ABTI_MEM_LP_MALLOC:
1191  fprintf(fp, " - large page allocation: malloc\n");
1192  break;
1193  case ABTI_MEM_LP_MMAP_RP:
1194  fprintf(fp, " - large page allocation: mmap regular pages\n");
1195  break;
1197  fprintf(fp, " - large page allocation: mmap huge pages + "
1198  "regular pages\n");
1199  break;
1201  fprintf(fp, " - large page allocation: mmap huge pages + THPs\n");
1202  break;
1203  case ABTI_MEM_LP_THP:
1204  fprintf(fp, " - large page allocation: THPs\n");
1205  break;
1206  }
1207 #endif /* ABT_CONFIG_USE_MEM_POOL */
1208 
1209  fflush(fp);
1210 }
1211 
1212 /*****************************************************************************/
1213 /* Internal static functions */
1214 /*****************************************************************************/
1215 
1216 struct info_print_unit_arg_t {
1218  FILE *fp;
1219 };
1222  ABT_pool *pools;
1223  size_t num;
1224  size_t len;
1225 };
1227 static void info_print_unit(void *arg, ABT_unit unit)
1228 {
1229  /* This function may not have any side effect on unit because it is passed
1230  * to p_print_all. */
1231  struct info_print_unit_arg_t *p_arg;
1232  p_arg = (struct info_print_unit_arg_t *)arg;
1233  FILE *fp = p_arg->fp;
1234  ABTI_thread *p_thread =
1236 
1237  if (!p_thread) {
1238  fprintf(fp, "=== unknown (%p) ===\n", (void *)unit);
1239  } else if (p_thread->type & ABTI_THREAD_TYPE_YIELDABLE) {
1240  fprintf(fp, "=== ULT (%p) ===\n", (void *)unit);
1241  ABTI_ythread *p_ythread = ABTI_thread_get_ythread(p_thread);
1242  ABT_unit_id thread_id = ABTI_thread_get_id(&p_ythread->thread);
1243  fprintf(fp,
1244  "id : %" PRIu64 "\n"
1245  "ctx : %p\n",
1246  (uint64_t)thread_id, (void *)&p_ythread->ctx);
1247  ABTI_ythread_print_stack(p_arg->p_global, p_ythread, fp);
1248  } else {
1249  fprintf(fp, "=== tasklet (%p) ===\n", (void *)unit);
1250  }
1251 }
1252 
1254  FILE *fp,
1255  ABTI_pool *p_pool)
1257  if (p_pool == NULL) {
1258  fprintf(fp, "== NULL pool ==\n");
1259  fflush(fp);
1260  return ABT_SUCCESS;
1261  }
1263 
1264  ABT_pool pool = ABTI_pool_get_handle(p_pool);
1265 
1266  fprintf(fp, "== pool (%p) ==\n", (void *)p_pool);
1267  struct info_print_unit_arg_t arg;
1268  arg.p_global = p_global;
1269  arg.fp = fp;
1270  p_pool->p_print_all(pool, &arg, info_print_unit);
1271  fflush(fp);
1272  return ABT_SUCCESS;
1273 }
1274 
1275 ABTU_ret_err static inline int
1277 {
1278  size_t default_len = 16;
1279  int abt_errno =
1280  ABTU_malloc(sizeof(ABT_pool) * default_len, (void **)&p_set->pools);
1281  ABTI_CHECK_ERROR(abt_errno);
1282  p_set->num = 0;
1283  p_set->len = default_len;
1284  return ABT_SUCCESS;
1285 }
1286 
1287 static inline void info_finalize_pool_set(struct info_pool_set_t *p_set)
1288 {
1289  ABTU_free(p_set->pools);
1291 
1292 ABTU_ret_err static inline int info_add_pool_set(ABT_pool pool,
1293  struct info_pool_set_t *p_set)
1294 {
1295  size_t i;
1296  for (i = 0; i < p_set->num; i++) {
1297  if (p_set->pools[i] == pool)
1298  return ABT_SUCCESS;
1299  }
1300  /* Add pool to p_set. */
1301  if (p_set->num == p_set->len) {
1302  size_t new_len = p_set->len * 2;
1303  int abt_errno =
1304  ABTU_realloc(sizeof(ABT_pool) * p_set->len,
1305  sizeof(ABT_pool) * new_len, (void **)&p_set->pools);
1306  ABTI_CHECK_ERROR(abt_errno);
1307  p_set->len = new_len;
1308  }
1309  p_set->pools[p_set->num++] = pool;
1310  return ABT_SUCCESS;
1311 }
1312 
1314  FILE *fp, double timeout, void (*cb_func)(ABT_bool, void *), void *arg)
1315 {
1316  /* This function is signal-safe, so it may not call other functions unless
1317  * you really know what the called functions do. */
1323  /* Save fp and timeout. */
1324  print_stack_fp = fp;
1325  print_stack_timeout = timeout;
1326  print_cb_func = cb_func;
1327  print_arg = arg;
1328  /* Here print_stack_barrier must be 0. */
1330  0);
1333  }
1334  }
1335 }
1336 
1338 {
1339  size_t i;
1340  int abt_errno;
1341  struct info_pool_set_t pool_set;
1342 
1343  abt_errno = info_initialize_pool_set(&pool_set);
1344  ABTI_CHECK_ERROR(abt_errno);
1345  ABTI_xstream *p_xstream = p_global->p_xstream_head;
1346  while (p_xstream) {
1347  ABTI_sched *p_main_sched = p_xstream->p_main_sched;
1348  fprintf(fp, "= xstream[%d] (%p) =\n", p_xstream->rank,
1349  (void *)p_xstream);
1350  fprintf(fp, "main_sched : %p\n", (void *)p_main_sched);
1351  if (!p_main_sched)
1352  continue;
1353  for (i = 0; i < p_main_sched->num_pools; i++) {
1354  ABT_pool pool = p_main_sched->pools[i];
1355  ABTI_ASSERT(pool != ABT_POOL_NULL);
1356  fprintf(fp, " pools[%zu] : %p\n", i,
1357  (void *)ABTI_pool_get_ptr(pool));
1358  abt_errno = info_add_pool_set(pool, &pool_set);
1359  if (ABTI_IS_ERROR_CHECK_ENABLED && abt_errno != ABT_SUCCESS) {
1360  info_finalize_pool_set(&pool_set);
1361  ABTI_HANDLE_ERROR(abt_errno);
1362  }
1363  }
1364  p_xstream = p_xstream->p_next;
1365  }
1366  for (i = 0; i < pool_set.num; i++) {
1367  ABT_pool pool = pool_set.pools[i];
1368  ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
1369  abt_errno = info_print_thread_stacks_in_pool(p_global, fp, p_pool);
1370  if (abt_errno != ABT_SUCCESS)
1371  fprintf(fp, " Failed to print (errno = %d).\n", abt_errno);
1372  }
1373  info_finalize_pool_set(&pool_set);
1374  return ABT_SUCCESS;
1375 }
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:193
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:535
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:228
info_print_unit_arg_t::fp
FILE * fp
Definition: info.c:1221
ABT_bool
int ABT_bool
Boolean type.
Definition: abt.h:1001
ABTI_global::sched_stacksize
size_t sched_stacksize
Definition: abti.h:226
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:1316
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:238
ABTU_realloc
static ABTU_ret_err int ABTU_realloc(size_t old_size, size_t new_size, void **p_ptr)
Definition: abtu.h:257
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:712
ABTI_pool::p_print_all
ABT_pool_print_all_fn p_print_all
Definition: abti.h:369
ABTI_STACK_GUARD_MPROTECT_STRICT
@ ABTI_STACK_GUARD_MPROTECT_STRICT
Definition: abti.h:92
ABTI_global::mem_lp_alloc
int mem_lp_alloc
Definition: abti.h:241
ABT_thread_attr
struct ABT_thread_attr_opaque * ABT_thread_attr
ULT attribute handle type.
Definition: abt.h:897
ABT_task
struct ABT_thread_opaque * ABT_task
Work unit handle type.
Definition: abt.h:931
ABT_thread
struct ABT_thread_opaque * ABT_thread
Work unit handle type.
Definition: abt.h:890
ABTI_SETUP_GLOBAL
#define ABTI_SETUP_GLOBAL(pp_global)
Definition: abti_error.h:75
ABTI_global::xstream_list_lock
ABTD_spinlock xstream_list_lock
Definition: abti.h:216
ABT_info_print_all_xstreams
int ABT_info_print_all_xstreams(FILE *fp)
Print the information of all execution streams.
Definition: info.c:472
ABTI_thread::type
ABTI_thread_type type
Definition: abti.h:393
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:1219
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:1290
ABTI_thread_print
void ABTI_thread_print(ABTI_thread *p_thread, FILE *p_os, int indent)
Definition: thread.c:2558
ABTI_info_check_print_all_thread_stacks
void ABTI_info_check_print_all_thread_stacks(void)
Definition: info.c:989
ABTI_CHECK_ERROR
#define ABTI_CHECK_ERROR(abt_errno)
Definition: abti_error.h:136
ABTI_sched::num_pools
size_t num_pools
Definition: abti.h:317
ABT_THREAD_TYPE_DYNAMIC_PROMOTION
#define ABT_THREAD_TYPE_DYNAMIC_PROMOTION
Definition: abti.h:71
ABTI_xstream::rank
int rank
Definition: abti.h:287
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:100
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:2658
print_stack_flag
static ABTD_atomic_int print_stack_flag
Definition: info.c:980
ABTI_global::print_config
ABT_bool print_config
Definition: abti.h:256
ABT_CONFIG_USE_FCONTEXT
#define ABT_CONFIG_USE_FCONTEXT
Definition: abt_config.h:102
print_stack_fp
static FILE * print_stack_fp
Definition: info.c:982
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:959
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:875
print_cb_func
static void(* print_cb_func)(ABT_bool, void *)
Definition: info.c:984
ABT_CONFIG_DISABLE_TOOL_INTERFACE
#define ABT_CONFIG_DISABLE_TOOL_INTERFACE
Definition: abt_config.h:45
ABTI_thread
Definition: abti.h:389
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:1224
ABTI_xstream
Definition: abti.h:282
ABTI_CHECK_NULL_THREAD_ATTR_PTR
#define ABTI_CHECK_NULL_THREAD_ATTR_PTR(p)
Definition: abti_error.h:229
ABT_pool
struct ABT_pool_opaque * ABT_pool
Pool handle type.
Definition: abt.h:841
ABTI_global::stack_guard_kind
ABTI_stack_guard stack_guard_kind
Definition: abti.h:254
ABTI_xstream::p_next
ABTI_xstream * p_next
Definition: abti.h:285
ABT_CONFIG_THREAD_TYPE
#define ABT_CONFIG_THREAD_TYPE
Definition: abt_config.h:84
ABTI_thread_attr_print
void ABTI_thread_attr_print(ABTI_thread_attr *p_attr, FILE *p_os, int indent)
Definition: thread_attr.c:391
ABTI_thread_attr
Definition: abti.h:406
ABT_sched
struct ABT_sched_opaque * ABT_sched
Scheduler handle type.
Definition: abt.h:808
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:345
print_stack_timeout
static double print_stack_timeout
Definition: info.c:983
ABTI_MEM_LP_THP
@ ABTI_MEM_LP_THP
Definition: abti_mem.h:22
ABT_POOL_NULL
#define ABT_POOL_NULL
Definition: abt.h:1059
info_print_unit
static void info_print_unit(void *arg, ABT_unit unit)
Definition: info.c:1230
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:211
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:221
ABT_info_query_config
int ABT_info_query_config(ABT_info_query_kind query_kind, void *val)
Retrieve the configuration information.
Definition: info.c:210
info_pool_set_t::num
size_t num
Definition: info.c:1226
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:879
ABT_xstream
struct ABT_xstream_opaque * ABT_xstream
Execution stream handle type.
Definition: abt.h:789
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:810
ABTI_global::mem_page_size
size_t mem_page_size
Definition: abti.h:237
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:225
ABTD_spinlock_acquire
static void ABTD_spinlock_acquire(ABTD_spinlock *p_lock)
Definition: abtd_spinlock.h:28
ABT_CONFIG_USE_CLOCK_GETTIME
#define ABT_CONFIG_USE_CLOCK_GETTIME
Definition: abt_config.h:90
ABTI_HANDLE_ERROR
#define ABTI_HANDLE_ERROR(n)
Definition: abti_error.h:130
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:235
ABTU_malloc
static ABTU_ret_err int ABTU_malloc(size_t size, void **p_ptr)
Definition: abtu.h:235
ABTI_MEM_LP_MMAP_HP_RP
@ ABTI_MEM_LP_MMAP_HP_RP
Definition: abti_mem.h:20
info_print_unit_arg_t::p_global
ABTI_global * p_global
Definition: info.c:1220
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:976
ABTI_xstream::p_main_sched
ABTI_sched * p_main_sched
Definition: abti.h:290
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:1295
ABTI_global::sched_event_freq
uint32_t sched_event_freq
Definition: abti.h:227
info_pool_set_t::pools
ABT_pool * pools
Definition: info.c:1225
ABT_unit
struct ABT_unit_opaque * ABT_unit
Work unit handle type for scheduling.
Definition: abt.h:869
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:426
ABTI_xstream_print
void ABTI_xstream_print(ABTI_xstream *p_xstream, FILE *p_os, int indent, ABT_bool print_sub)
Definition: stream.c:1699
ABTI_ASSERT
#define ABTI_ASSERT(cond)
Definition: abti_error.h:12
ABTI_global::mem_sp_size
size_t mem_sp_size
Definition: abti.h:238
ABTI_sched::pools
ABT_pool * pools
Definition: abti.h:316
ABT_CONFIG_STATIC_CACHELINE_SIZE
#define ABT_CONFIG_STATIC_CACHELINE_SIZE
Definition: abt_config.h:78
ABTI_global::num_xstreams
int num_xstreams
Definition: abti.h:213
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:975
ABTU_ret_err
#define ABTU_ret_err
Definition: abtu.h:155
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:214
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:986
ABTI_STACK_GUARD_MPROTECT
@ ABTI_STACK_GUARD_MPROTECT
Definition: abti.h:91
ABT_info_print_pool
int ABT_info_print_pool(FILE *fp, ABT_pool pool)
Print the information of a pool.
Definition: info.c:621
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:748
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:224
PRINT_STACK_FLAG_WAIT
#define PRINT_STACK_FLAG_WAIT
Definition: info.c:977
ABTI_sched
Definition: abti.h:307
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:750
ABTI_ythread
Definition: abti.h:424
ABTI_global::mem_max_stacks
uint32_t mem_max_stacks
Definition: abti.h:239
ABTI_UB_ASSERT
#define ABTI_UB_ASSERT(cond)
Definition: abti_error.h:19
ABT_info_print_thread
int ABT_info_print_thread(FILE *fp, ABT_thread thread)
Print the information of a work unit.
Definition: info.c:669
ABTI_CHECK_NULL_POOL_PTR
#define ABTI_CHECK_NULL_POOL_PTR(p)
Definition: abti_error.h:184
print_arg
static void * print_arg
Definition: info.c:985
ABTI_CHECK_NULL_XSTREAM_PTR
#define ABTI_CHECK_NULL_XSTREAM_PTR(p)
Definition: abti_error.h:175
ABTU_free
static void ABTU_free(void *ptr)
Definition: abtu.h:228
ABTD_spinlock_release
static void ABTD_spinlock_release(ABTD_spinlock *p_lock)
Definition: abtd_spinlock.h:42
ABTI_unit_get_thread
static ABTI_thread * ABTI_unit_get_thread(ABTI_global *p_global, ABT_unit unit)
Definition: abti_unit.h:43
print_all_thread_stacks
static ABTU_ret_err int print_all_thread_stacks(ABTI_global *p_global, FILE *fp)
Definition: info.c:1340
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:222
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
ABT_INFO_QUERY_KIND_ENABLED_PRINT_ERRNO
@ ABT_INFO_QUERY_KIND_ENABLED_PRINT_ERRNO
Definition: abt.h:571
info_print_thread_stacks_in_pool
static ABTU_ret_err int info_print_thread_stacks_in_pool(ABTI_global *p_global, FILE *fp, ABTI_pool *p_pool)
Definition: info.c:1256
ABTI_ythread::thread
ABTI_thread thread
Definition: abti.h:425
ABT_info_print_task
int ABT_info_print_task(FILE *fp, ABT_task task)
Print the information of a work unit.
Definition: info.c:761
ABT_info_print_config
int ABT_info_print_config(FILE *fp)
Print the runtime information of Argobots.
Definition: info.c:423
ABTI_global::set_affinity
ABT_bool set_affinity
Definition: abti.h:220
ABTI_info_print_config
void ABTI_info_print_config(ABTI_global *p_global, FILE *fp)
Definition: info.c:1060
ABTI_pool_print
void ABTI_pool_print(ABTI_pool *p_pool, FILE *p_os, int indent)
Definition: pool.c:955
ABTI_CHECK_TRUE
#define ABTI_CHECK_TRUE(cond, abt_errno)
Definition: abti_error.h:146
ABTI_global
Definition: abti.h:211
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:219
ABT_INFO_QUERY_KIND_WAIT_POLICY
@ ABT_INFO_QUERY_KIND_WAIT_POLICY
Definition: abt.h:623
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:1227
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:212
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:578
ABTI_ythread_print_stack
void ABTI_ythread_print_stack(ABTI_global *p_global, ABTI_ythread *p_ythread, FILE *p_os)
Definition: ythread.c:100
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:1279
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:240
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:978
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:999