ARGOBOTS  140a356fc09a44696eb3487150e459266f9b5405
abtd_env.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 #include <unistd.h>
8 #include <strings.h>
9 
10 #define ABTD_KEY_TABLE_DEFAULT_SIZE 4
11 #define ABTD_THREAD_DEFAULT_STACKSIZE 16384
12 #define ABTD_SCHED_DEFAULT_STACKSIZE (4 * 1024 * 1024)
13 #define ABTD_SCHED_EVENT_FREQ 50
14 #define ABTD_SCHED_SLEEP_NSEC 100
15 
16 #define ABTD_HUGE_PAGE_SIZE (2 * 1024 * 1024)
17 #define ABTD_MEM_PAGE_SIZE (2 * 1024 * 1024)
18 #define ABTD_MEM_STACK_PAGE_SIZE (8 * 1024 * 1024)
19 #define ABTD_MEM_MAX_NUM_STACKS 1024
20 #define ABTD_MEM_MAX_TOTAL_STACK_SIZE (64 * 1024 * 1024)
21 #define ABTD_MEM_MAX_NUM_DESCS 4096
22 
23 /* To avoid potential overflow, we intentionally use a smaller value than the
24  * real limit. */
25 #define ABTD_ENV_INT_MAX ((int)(INT_MAX / 2))
26 #define ABTD_ENV_UINT32_MAX ((int)(UINT32_MAX / 2))
27 #define ABTD_ENV_UINT64_MAX ((int)(UINT64_MAX / 2))
28 #define ABTD_ENV_SIZE_MAX ((int)(SIZE_MAX / 2))
29 
30 static uint32_t roundup_pow2_uint32(uint32_t val);
31 static const char *get_abt_env(const char *env_suffix);
32 static ABT_bool is_false(const char *str, ABT_bool include0);
33 static ABT_bool is_true(const char *str, ABT_bool include1);
34 static ABT_bool load_env_bool(const char *env_suffix, ABT_bool default_val);
35 static int load_env_int(const char *env_suffix, int default_val, int min_val,
36  int max_val);
37 static uint32_t load_env_uint32(const char *env_suffix, uint32_t default_val,
38  uint32_t min_val, uint32_t max_val);
39 static uint64_t load_env_uint64(const char *env_suffix, uint64_t default_val,
40  uint64_t min_val, uint64_t max_val);
41 static size_t load_env_size(const char *env_suffix, size_t default_val,
42  size_t min_val, size_t max_val);
43 
44 void ABTD_env_init(ABTI_global *p_global)
45 {
46  const char *env;
47 
48  /* Get the number of available cores in the system */
49  p_global->num_cores = sysconf(_SC_NPROCESSORS_ONLN);
50 
51  /* ABT_SET_AFFINITY, ABT_ENV_SET_AFFINITY */
52  env = get_abt_env("SET_AFFINITY");
53  if (env != NULL && is_false(env, ABT_FALSE)) {
54  p_global->set_affinity = ABT_FALSE;
55  } else {
56  /* By default, we use the CPU affinity */
57  p_global->set_affinity = ABT_TRUE;
58  ABTD_affinity_init(env);
59  }
60 
61 #ifdef ABT_CONFIG_USE_DEBUG_LOG_PRINT
62  /* If the debug log printing is set in configure, logging is turned on by
63  * default. */
64  const ABT_bool default_use_logging = ABT_TRUE;
65  const ABT_bool default_use_debug = ABT_TRUE;
66 #else
67  /* Otherwise, logging is not turned on by default. */
68  const ABT_bool default_use_logging = ABT_FALSE;
69  const ABT_bool default_use_debug = ABT_FALSE;
70 #endif
71  /* ABT_USE_LOG, ABT_ENV_USE_LOG */
72  p_global->use_logging = load_env_bool("USE_LOG", default_use_logging);
73 
74  /* ABT_USE_DEBUG, ABT_ENV_USE_DEBUG */
75  p_global->use_debug = load_env_bool("USE_DEBUG", default_use_debug);
76 
77  /* ABT_MAX_NUM_XSTREAMS, ABT_ENV_MAX_NUM_XSTREAMS
78  * Maximum size of the internal ES array */
79  p_global->max_xstreams =
80  load_env_int("MAX_NUM_XSTREAMS", p_global->num_cores, 1,
82 
83  /* ABT_KEY_TABLE_SIZE, ABT_ENV_KEY_TABLE_SIZE
84  * Default key table size */
86  load_env_uint32("KEY_TABLE_SIZE", ABTD_KEY_TABLE_DEFAULT_SIZE, 1,
88 
89  /* ABT_THREAD_STACKSIZE, ABT_ENV_THREAD_STACKSIZE
90  * Default stack size for ULT */
91  p_global->thread_stacksize =
92  ABTU_roundup_size(load_env_size("THREAD_STACKSIZE",
96 
97  /* ABT_SCHED_STACKSIZE, ABT_ENV_SCHED_STACKSIZE
98  * Default stack size for scheduler */
99  p_global->sched_stacksize =
100  ABTU_roundup_size(load_env_size("SCHED_STACKSIZE",
104 
105  /* ABT_SCHED_EVENT_FREQ, ABT_ENV_SCHED_EVENT_FREQ
106  * Default frequency for event checking by the scheduler */
107  p_global->sched_event_freq =
108  load_env_uint32("SCHED_EVENT_FREQ", ABTD_SCHED_EVENT_FREQ, 1,
110 
111  /* ABT_SCHED_SLEEP_NSEC, ABT_ENV_SCHED_SLEEP_NSEC
112  * Default nanoseconds for scheduler sleep */
113  p_global->sched_sleep_nsec =
114  load_env_uint64("SCHED_SLEEP_NSEC", ABTD_SCHED_SLEEP_NSEC, 0,
116 
117  /* ABT_MUTEX_MAX_HANDOVERS, ABT_ENV_MUTEX_MAX_HANDOVERS
118  * Default maximum number of mutex handover */
119  p_global->mutex_max_handovers =
120  load_env_uint32("MUTEX_MAX_HANDOVERS", 64, 1, ABTD_ENV_UINT32_MAX);
121 
122  /* ABT_MUTEX_MAX_WAKEUPS, ABT_ENV_MUTEX_MAX_WAKEUPS
123  * Default maximum number of mutex wakeup operations */
124  p_global->mutex_max_wakeups =
125  load_env_uint32("MUTEX_MAX_WAKEUPS", 1, 1, ABTD_ENV_UINT32_MAX);
126 
127  /* ABT_HUGE_PAGE_SIZE, ABT_ENV_HUGE_PAGE_SIZE
128  * Huge page size */
129  p_global->huge_page_size =
130  load_env_size("HUGE_PAGE_SIZE", ABTD_HUGE_PAGE_SIZE, 4096,
132 
133 #ifdef ABT_CONFIG_USE_MEM_POOL
134  /* ABT_MEM_PAGE_SIZE, ABT_ENV_MEM_PAGE_SIZE
135  * Page size for memory allocation */
136  p_global->mem_page_size =
138  4096, ABTD_ENV_SIZE_MAX),
140 
141  /* ABT_MEM_STACK_PAGE_SIZE, ABT_ENV_MEM_STACK_PAGE_SIZE
142  * Stack page size for memory allocation */
143  p_global->mem_sp_size =
144  ABTU_roundup_size(load_env_size("MEM_STACK_PAGE_SIZE",
146  p_global->thread_stacksize * 4,
149 
150  /* ABT_MEM_MAX_NUM_STACKS, ABT_ENV_MEM_MAX_NUM_STACKS
151  * Maximum number of stacks that each ES can keep during execution. */
152  /* If each execution stream caches too many stacks in total, let's reduce
153  * the max # of stacks. */
154  const uint32_t default_mem_max_stacks =
156  p_global->thread_stacksize,
158  /* The value must be a multiple of ABT_MEM_POOL_MAX_LOCAL_BUCKETS. */
159  p_global->mem_max_stacks =
160  ABTU_roundup_uint32(load_env_uint32("MEM_MAX_NUM_STACKS",
161  default_mem_max_stacks,
165 
166  /* ABT_MEM_MAX_NUM_DESCS, ABT_ENV_MEM_MAX_NUM_DESCS
167  * Maximum number of descriptors that each ES can keep during execution */
168  /* The value must be a multiple of ABT_MEM_POOL_MAX_LOCAL_BUCKETS. */
169  p_global->mem_max_descs =
170  ABTU_roundup_uint32(load_env_uint32("MEM_MAX_NUM_DESCS",
175 
176  /* ABT_MEM_LP_ALLOC, ABT_ENV_MEM_LP_ALLOC
177  * How to allocate large pages. The default is to use mmap() for huge
178  * pages and then to fall back to allocate regular pages using mmap() when
179  * huge pages are run out of. */
180  env = get_abt_env("MEM_LP_ALLOC");
181 #if defined(HAVE_MAP_ANONYMOUS) || defined(HAVE_MAP_ANON)
182 #if defined(__x86_64__)
183  int lp_alloc = ABTI_MEM_LP_MMAP_HP_RP;
184 #else
185  /*
186  * If hugepage is used, mmap() needs a correct size of hugepage; otherwise,
187  * error happens on munmap(). However, the default size is for typical
188  * x86/64 machines, not for other architectures, so the error happens when
189  * the hugepage size is different. To run Argobots with default settings
190  * on these architectures, we disable hugepage allocation by default on
191  * non-x86/64 architectures; on such a machine, hugepage settings should
192  * be explicitly enabled via an environmental variable.
193  *
194  * TODO: fix this issue by detecting and setting a correct hugepage size.
195  */
196  int lp_alloc = ABTI_MEM_LP_MALLOC;
197 #endif
198 #else
199  int lp_alloc = ABTI_MEM_LP_MALLOC;
200 #endif
201  if (env != NULL) {
202  if (strcasecmp(env, "malloc") == 0) {
203  lp_alloc = ABTI_MEM_LP_MALLOC;
204 #if defined(HAVE_MAP_ANONYMOUS) || defined(HAVE_MAP_ANON)
205  } else if (strcasecmp(env, "mmap_rp") == 0) {
206  lp_alloc = ABTI_MEM_LP_MMAP_RP;
207  } else if (strcasecmp(env, "mmap_hp_rp") == 0) {
208  lp_alloc = ABTI_MEM_LP_MMAP_HP_RP;
209  } else if (strcasecmp(env, "mmap_hp_thp") == 0) {
210  lp_alloc = ABTI_MEM_LP_MMAP_HP_THP;
211 #endif
212  } else if (strcasecmp(env, "thp") == 0) {
213  lp_alloc = ABTI_MEM_LP_THP;
214  }
215  }
216 
217  /* Check if the requested allocation method is really possible. */
218  if (lp_alloc != ABTI_MEM_LP_MALLOC) {
219  p_global->mem_lp_alloc = ABTI_mem_check_lp_alloc(lp_alloc);
220  } else {
221  p_global->mem_lp_alloc = lp_alloc;
222  }
223 #endif
224 
225  /* ABT_PRINT_CONFIG, ABT_ENV_PRINT_CONFIG
226  * Whether to print the configuration on ABT_init() */
227  p_global->print_config = load_env_bool("PRINT_CONFIG", ABT_FALSE);
228 
229  /* Init timer */
230  ABTD_time_init();
231 }
232 
233 /*****************************************************************************/
234 /* Internal static functions */
235 /*****************************************************************************/
236 
237 static uint32_t roundup_pow2_uint32(uint32_t val)
238 {
239  /* 3 -> 4
240  * 4 -> 4
241  * 5 -> 8 */
242  if (val == 0)
243  return 0;
244  uint32_t i;
245  for (i = 0; i < sizeof(uint32_t) * 8; i++) {
246  if ((val - 1) >> i == 0)
247  break;
248  }
249  return ((uint32_t)1) << i;
250 }
251 
252 static const char *get_abt_env(const char *env_suffix)
253 {
254  /* Valid prefix is ABT_ and ABT_ENV_. ABT_ is prioritized. */
255  char buffer[128];
256  const char *prefixes[] = { "ABT_", "ABT_ENV_" };
257  uint32_t i;
258  for (i = 0; i < sizeof(prefixes) / sizeof(prefixes[0]); i++) {
259  strcpy(buffer, prefixes[i]);
260  strcpy(buffer + strlen(prefixes[i]), env_suffix);
261  const char *env = getenv(buffer);
262  if (env)
263  return env;
264  }
265  return NULL;
266 }
267 
268 static ABT_bool is_false(const char *str, ABT_bool include0)
269 {
270  if (include0 && strcmp(str, "0") == 0) {
271  return ABT_TRUE;
272  } else if (strcasecmp(str, "n") == 0 || strcasecmp(str, "no") == 0 ||
273  strcasecmp(str, "false") == 0 || strcasecmp(str, "off") == 0) {
274  return ABT_TRUE;
275  }
276  return ABT_FALSE;
277 }
278 
279 static ABT_bool is_true(const char *str, ABT_bool include1)
280 {
281  if (include1 && strcmp(str, "1") == 0) {
282  return ABT_TRUE;
283  } else if (strcasecmp(str, "y") == 0 || strcasecmp(str, "yes") == 0 ||
284  strcasecmp(str, "true") == 0 || strcasecmp(str, "on") == 0) {
285  return ABT_TRUE;
286  }
287  return ABT_FALSE;
288 }
289 
290 static ABT_bool load_env_bool(const char *env_suffix, ABT_bool default_val)
291 {
292  const char *env = get_abt_env(env_suffix);
293  if (!env) {
294  return default_val;
295  } else {
296  if (default_val) {
297  /* If env is not "false", return true */
298  return is_false(env, ABT_TRUE) ? ABT_FALSE : ABT_TRUE;
299  } else {
300  /* If env is not "true", return false */
301  return is_true(env, ABT_TRUE) ? ABT_TRUE : ABT_FALSE;
302  }
303  }
304 }
305 
306 static int load_env_int(const char *env_suffix, int default_val, int min_val,
307  int max_val)
308 {
309  const char *env = get_abt_env(env_suffix);
310  if (!env) {
311  return ABTU_max_int(min_val, ABTU_min_int(max_val, default_val));
312  } else {
313  int val;
314  int abt_errno = ABTU_atoi(env, &val, NULL);
315  if (abt_errno != ABT_SUCCESS) {
316  return ABTU_max_int(min_val, ABTU_min_int(max_val, default_val));
317  } else {
318  return ABTU_max_int(min_val, ABTU_min_int(max_val, val));
319  }
320  }
321 }
322 
323 static uint32_t load_env_uint32(const char *env_suffix, uint32_t default_val,
324  uint32_t min_val, uint32_t max_val)
325 {
326  const char *env = get_abt_env(env_suffix);
327  if (!env) {
328  return ABTU_max_uint32(min_val, ABTU_min_uint32(max_val, default_val));
329  } else {
330  uint32_t val;
331  int abt_errno = ABTU_atoui32(env, &val, NULL);
332  if (abt_errno != ABT_SUCCESS) {
333  return ABTU_max_uint32(min_val,
334  ABTU_min_uint32(max_val, default_val));
335  } else {
336  return ABTU_max_uint32(min_val, ABTU_min_uint32(max_val, val));
337  }
338  }
339 }
340 
341 static uint64_t load_env_uint64(const char *env_suffix, uint64_t default_val,
342  uint64_t min_val, uint64_t max_val)
343 {
344  const char *env = get_abt_env(env_suffix);
345  if (!env) {
346  return ABTU_max_uint64(min_val, ABTU_min_uint64(max_val, default_val));
347  } else {
348  uint64_t val;
349  int abt_errno = ABTU_atoui64(env, &val, NULL);
350  if (abt_errno != ABT_SUCCESS) {
351  return ABTU_max_uint64(min_val,
352  ABTU_min_uint64(max_val, default_val));
353  } else {
354  return ABTU_max_uint64(min_val, ABTU_min_uint64(max_val, val));
355  }
356  }
357 }
358 
359 static size_t load_env_size(const char *env_suffix, size_t default_val,
360  size_t min_val, size_t max_val)
361 {
362  const char *env = get_abt_env(env_suffix);
363  if (!env) {
364  return ABTU_max_size(min_val, ABTU_min_size(max_val, default_val));
365  } else {
366  size_t val;
367  int abt_errno = ABTU_atosz(env, &val, NULL);
368  if (abt_errno != ABT_SUCCESS) {
369  return ABTU_max_size(min_val, ABTU_min_size(max_val, default_val));
370  } else {
371  return ABTU_max_size(min_val, ABTU_min_size(max_val, val));
372  }
373  }
374 }
ABTD_affinity_init
void ABTD_affinity_init(const char *affinity_str)
Definition: abtd_affinity.c:296
load_env_uint64
static uint64_t load_env_uint64(const char *env_suffix, uint64_t default_val, uint64_t min_val, uint64_t max_val)
Definition: abtd_env.c:341
load_env_uint32
static uint32_t load_env_uint32(const char *env_suffix, uint32_t default_val, uint32_t min_val, uint32_t max_val)
Definition: abtd_env.c:323
ABTU_max_size
static size_t ABTU_max_size(size_t a, size_t b)
Definition: abtu.h:40
ABTU_min_int
static int ABTU_min_int(int a, int b)
Definition: abtu.h:45
ABTD_MEM_MAX_TOTAL_STACK_SIZE
#define ABTD_MEM_MAX_TOTAL_STACK_SIZE
Definition: abtd_env.c:20
ABTD_env_init
void ABTD_env_init(ABTI_global *p_global)
Definition: abtd_env.c:44
ABTI_global::sched_sleep_nsec
uint64_t sched_sleep_nsec
Definition: abti.h:193
ABT_bool
int ABT_bool
Boolean type.
Definition: abt.h:988
ABTI_global::sched_stacksize
size_t sched_stacksize
Definition: abti.h:191
ABTU_max_uint64
static uint64_t ABTU_max_uint64(uint64_t a, uint64_t b)
Definition: abtu.h:35
ABTI_MEM_LP_MMAP_HP_THP
@ ABTI_MEM_LP_MMAP_HP_THP
Definition: abti_mem.h:21
is_true
static ABT_bool is_true(const char *str, ABT_bool include1)
Definition: abtd_env.c:279
ABTU_max_int
static int ABTU_max_int(int a, int b)
Definition: abtu.h:15
ABTI_global::mem_lp_alloc
int mem_lp_alloc
Definition: abti.h:205
ABTD_MEM_MAX_NUM_STACKS
#define ABTD_MEM_MAX_NUM_STACKS
Definition: abtd_env.c:19
ABTU_roundup_size
static size_t ABTU_roundup_size(size_t val, size_t multiple)
Definition: abtu.h:95
load_env_size
static size_t load_env_size(const char *env_suffix, size_t default_val, size_t min_val, size_t max_val)
Definition: abtd_env.c:359
ABTI_mem_check_lp_alloc
int ABTI_mem_check_lp_alloc(int lp_alloc)
ABTI_MEM_LP_MALLOC
@ ABTI_MEM_LP_MALLOC
Definition: abti_mem.h:18
ABTU_min_size
static size_t ABTU_min_size(size_t a, size_t b)
Definition: abtu.h:70
ABT_MEM_POOL_MAX_LOCAL_BUCKETS
#define ABT_MEM_POOL_MAX_LOCAL_BUCKETS
Definition: abti_mem_pool.h:9
ABTI_global::print_config
ABT_bool print_config
Definition: abti.h:219
ABTD_ENV_UINT64_MAX
#define ABTD_ENV_UINT64_MAX
Definition: abtd_env.c:27
ABTD_SCHED_SLEEP_NSEC
#define ABTD_SCHED_SLEEP_NSEC
Definition: abtd_env.c:14
ABTU_min_uint64
static uint64_t ABTU_min_uint64(uint64_t a, uint64_t b)
Definition: abtu.h:65
roundup_pow2_uint32
static uint32_t roundup_pow2_uint32(uint32_t val)
Definition: abtd_env.c:237
load_env_int
static int load_env_int(const char *env_suffix, int default_val, int min_val, int max_val)
Definition: abtd_env.c:306
ABTD_MEM_PAGE_SIZE
#define ABTD_MEM_PAGE_SIZE
Definition: abtd_env.c:17
is_false
static ABT_bool is_false(const char *str, ABT_bool include0)
Definition: abtd_env.c:268
ABTU_max_uint32
static uint32_t ABTU_max_uint32(uint32_t a, uint32_t b)
Definition: abtu.h:25
ABTU_atoui64
ABTU_ret_err int ABTU_atoui64(const char *str, uint64_t *p_val, ABT_bool *p_overflow)
Definition: atoi.c:65
ABTI_MEM_LP_THP
@ ABTI_MEM_LP_THP
Definition: abti_mem.h:22
get_abt_env
static const char * get_abt_env(const char *env_suffix)
Definition: abtd_env.c:252
ABTD_ENV_UINT32_MAX
#define ABTD_ENV_UINT32_MAX
Definition: abtd_env.c:26
abti.h
ABTI_global::use_logging
ABT_bool use_logging
Definition: abti.h:187
ABTD_KEY_TABLE_DEFAULT_SIZE
#define ABTD_KEY_TABLE_DEFAULT_SIZE
Definition: abtd_env.c:10
ABTI_global::mem_page_size
size_t mem_page_size
Definition: abti.h:201
ABTD_SCHED_EVENT_FREQ
#define ABTD_SCHED_EVENT_FREQ
Definition: abtd_env.c:13
ABTI_global::thread_stacksize
size_t thread_stacksize
Definition: abti.h:190
ABTI_global::huge_page_size
size_t huge_page_size
Definition: abti.h:199
ABTI_MEM_LP_MMAP_HP_RP
@ ABTI_MEM_LP_MMAP_HP_RP
Definition: abti_mem.h:20
ABTI_global::sched_event_freq
uint32_t sched_event_freq
Definition: abti.h:192
ABTD_ENV_INT_MAX
#define ABTD_ENV_INT_MAX
Definition: abtd_env.c:25
ABTI_global::mutex_max_handovers
uint32_t mutex_max_handovers
Definition: abti.h:197
ABTI_global::mem_sp_size
size_t mem_sp_size
Definition: abti.h:202
ABT_CONFIG_STATIC_CACHELINE_SIZE
#define ABT_CONFIG_STATIC_CACHELINE_SIZE
Definition: abt_config.h:63
ABTD_time_init
void ABTD_time_init(void)
Definition: abtd_time.c:11
ABTD_ENV_SIZE_MAX
#define ABTD_ENV_SIZE_MAX
Definition: abtd_env.c:28
ABT_SUCCESS
#define ABT_SUCCESS
Error code: the routine returns successfully.
Definition: abt.h:90
ABTU_atoui32
ABTU_ret_err int ABTU_atoui32(const char *str, uint32_t *p_val, ABT_bool *p_overflow)
Definition: atoi.c:39
ABTI_global::mutex_max_wakeups
uint32_t mutex_max_wakeups
Definition: abti.h:198
ABT_TRUE
#define ABT_TRUE
True constant for ABT_bool.
Definition: abt.h:735
ABTI_global::key_table_size
uint32_t key_table_size
Definition: abti.h:189
ABTD_THREAD_DEFAULT_STACKSIZE
#define ABTD_THREAD_DEFAULT_STACKSIZE
Definition: abtd_env.c:11
ABTU_atoi
ABTU_ret_err int ABTU_atoi(const char *str, int *p_val, ABT_bool *p_overflow)
Definition: atoi.c:11
ABT_FALSE
#define ABT_FALSE
False constant for ABT_bool.
Definition: abt.h:737
ABTD_MEM_MAX_NUM_DESCS
#define ABTD_MEM_MAX_NUM_DESCS
Definition: abtd_env.c:21
ABTI_global::mem_max_stacks
uint32_t mem_max_stacks
Definition: abti.h:203
ABTI_global::use_debug
ABT_bool use_debug
Definition: abti.h:188
load_env_bool
static ABT_bool load_env_bool(const char *env_suffix, ABT_bool default_val)
Definition: abtd_env.c:290
ABTI_global::set_affinity
ABT_bool set_affinity
Definition: abti.h:186
ABTI_global
Definition: abti.h:177
ABTD_SCHED_DEFAULT_STACKSIZE
#define ABTD_SCHED_DEFAULT_STACKSIZE
Definition: abtd_env.c:12
ABTU_atosz
ABTU_ret_err int ABTU_atosz(const char *str, size_t *p_val, ABT_bool *p_overflow)
Definition: atoi.c:85
ABTI_global::num_cores
int num_cores
Definition: abti.h:185
ABTD_HUGE_PAGE_SIZE
#define ABTD_HUGE_PAGE_SIZE
Definition: abtd_env.c:16
ABTI_MEM_LP_MMAP_RP
@ ABTI_MEM_LP_MMAP_RP
Definition: abti_mem.h:19
ABTI_global::max_xstreams
int max_xstreams
Definition: abti.h:178
ABTD_MEM_STACK_PAGE_SIZE
#define ABTD_MEM_STACK_PAGE_SIZE
Definition: abtd_env.c:18
ABTU_min_uint32
static uint32_t ABTU_min_uint32(uint32_t a, uint32_t b)
Definition: abtu.h:55
ABTI_global::mem_max_descs
uint32_t mem_max_descs
Definition: abti.h:204
ABTU_roundup_uint32
static uint32_t ABTU_roundup_uint32(uint32_t val, uint32_t multiple)
Definition: abtu.h:75