Configurable fiber stack sizes (#3773)

Author: TheNumbat

otherlibs/systhreads/st_stubs.c

@@ -393,28 +393,14 @@ static void caml_thread_leave_blocking_section(void)
   restore_runtime_state(th);
 }
 
-static int get_pthreads_stack_size_in_bytes(void)
-{
-  pthread_attr_t attr;
-  size_t res =
-    // default value, retrieved from a recent system (May 2024)
-    8388608;
-  if (pthread_attr_init(&attr) == 0) {
-    pthread_attr_getstacksize(&attr, &res);
-  }
-  pthread_attr_destroy(&attr);
-  return res;
-}
-
 /* Create and setup a new thread info block.
    This block has no associated thread descriptor and
    is not inserted in the list of threads. */
 static caml_thread_t caml_thread_new_info(void)
 {
   caml_thread_t th = NULL;
   caml_domain_state *domain_state = Caml_state;
-  uintnat stack_wsize =
-    caml_get_init_stack_wsize(Wsize_bsize(get_pthreads_stack_size_in_bytes()));
+  uintnat stack_wsize = caml_get_init_stack_wsize(STACK_SIZE_THREAD);
 
   th = (caml_thread_t)caml_stat_alloc_noexc(sizeof(struct caml_thread_struct));
   if (th == NULL) return NULL;

runtime/amd64.S

@@ -920,7 +920,8 @@ LBL(caml_start_program):
         movq    Caml_state(async_exn_handler), %r10
         movq    %r10, Cstack_async_exn_handler(%rsp)
         movq    %rsp, Caml_state(c_stack)
-    /* Load the OCaml stack. */
+    /* Load the OCaml stack.
+       Stack space used here must be accounted for in caml_maybe_expand_stack */
         movq    Caml_state(current_stack), %r11
         movq    Stack_sp(%r11), %r10
 #if Stack_padding_word

runtime/backtrace_nat.c

@@ -134,16 +134,15 @@ void caml_stash_backtrace(value exn, uintnat pc, char * sp, char* trapsp)
 
 void caml_stash_backtrace_wrapper(value exn, char* rsp, char* trapsp)
 {
-#if defined(NATIVE_CODE) && !defined(STACK_CHECKS_ENABLED)
+#ifdef STACK_GUARD_PAGES
   /* If we get an rsp that lies in the guard page, just do nothing - using rsp
    * would trigger another segfault, and we are probably in the process of
    * raising the exception from a segfault.  In any case this behaviour seems
    * consistent with runtime4, where no backtrace appears to be available at
    * this point. */
   struct stack_info *block = Caml_state->current_stack;
-  int page_size = getpagesize();
-  char* protected_low = Protected_stack_page(block, page_size);
-  char* protected_high = protected_low + page_size;
+  char* protected_low = Protected_stack_page(block);
+  char* protected_high = protected_low + caml_plat_pagesize;
   if ((rsp >= protected_low) && (rsp < protected_high)) {
     return;
   }

runtime/caml/config.h

@@ -214,6 +214,11 @@ typedef uint64_t uintnat;
 #define Stack_ctx_words (10 + 2)
 #endif
 
+/* Whether to use guard pages for fiber stacks */
+#if !defined(USE_MMAP_MAP_STACK) && defined(NATIVE_CODE) && !defined(STACK_CHECKS_ENABLED)
+#define STACK_GUARD_PAGES
+#endif
+
 /* Whether to offset Stack_high to preserve alignment. */
 #if defined(TARGET_amd64) && !defined(WITH_FRAME_POINTERS)
 #define Stack_padding_word 1

runtime/caml/fiber.h

@@ -24,6 +24,7 @@
 #include "misc.h"
 #include "mlvalues.h"
 #include "roots.h"
+#include "platform.h"
 
 struct stack_info;
 
@@ -68,7 +69,15 @@ struct stack_info {
   intnat local_limit;
 };
 
+#ifdef STACK_GUARD_PAGES
+// The OCaml stack starts after the stack_info and guard pages
+#define Stack_base(stk) ((value*)(((char*) (stk)) + 2 * caml_plat_pagesize))
+// We can assume that mmap returns page-aligned addresses.
+#define Protected_stack_page(block) (((char*) (block)) + caml_plat_pagesize)
+#else 
 #define Stack_base(stk) ((value*)(stk + 1))
+#endif
+
 #define Stack_threshold_ptr(stk) \
   (Stack_base(stk) + Stack_threshold / sizeof(value))
 #define Stack_high(stk) ((value*)stk->handler - Stack_padding_word)
@@ -271,8 +280,14 @@ CAMLextern int caml_try_realloc_stack (asize_t required_wsize);
 /* Parameters settable with OCAMLRUNPARAM */
 extern uintnat caml_init_main_stack_wsz;   /* -Xmain_stack_size= */
 extern uintnat caml_init_thread_stack_wsz; /* -Xthread_stack_size= */
+extern uintnat caml_init_fiber_stack_wsz;  /* -Xfiber_stack_size= */
+
+#define STACK_SIZE_MAIN   0
+#define STACK_SIZE_THREAD 1
+#define STACK_SIZE_FIBER  2
+
+CAMLextern uintnat caml_get_init_stack_wsize(int context);
 
-CAMLextern uintnat caml_get_init_stack_wsize(int thread_stack_wsz);
 void caml_change_max_stack_size (uintnat new_max_wsize);
 void caml_maybe_expand_stack(void);
 CAMLextern void caml_free_stack(struct stack_info* stk);
@@ -303,12 +318,6 @@ CAMLnoret CAMLextern void caml_raise_unhandled_effect (value effect);
 
 value caml_make_unhandled_effect_exn (value effect);
 
-#if defined(NATIVE_CODE) && !defined(STACK_CHECKS_ENABLED)
-// We can assume that mmap returns page-aligned addresses.
-#define Protected_stack_page(block, page_size) \
-  (((char*) (block)) + (page_size))
-#endif
-
 #endif /* CAML_INTERNALS */
 
 #endif /* CAML_FIBER_H */

runtime/domain.c

@@ -564,7 +564,7 @@ static void domain_create(uintnat initial_minor_heap_wsize,
   dom_internal* d = 0;
   caml_domain_state* domain_state;
   struct interruptor* s;
-  uintnat stack_wsize = caml_get_init_stack_wsize(-1 /* main thread */);
+  uintnat stack_wsize = caml_get_init_stack_wsize(STACK_SIZE_MAIN);
 
   CAMLassert (domain_self == 0);
 

runtime/fiber.c

@@ -64,21 +64,29 @@ static _Atomic int64_t fiber_id = 0;
 /* Parameters settable with OCAMLRUNPARAM */
 uintnat caml_init_main_stack_wsz = 0;   /* -Xmain_stack_size= */
 uintnat caml_init_thread_stack_wsz = 0; /* -Xthread_stack_size= */
+uintnat caml_init_fiber_stack_wsz = 0;  /* -Xfiber_stack_size= */
 
-uintnat caml_get_init_stack_wsize (int thread_stack_wsz)
+uintnat caml_get_init_stack_wsize (int context)
 {
-#if defined(NATIVE_CODE) && !defined(STACK_CHECKS_ENABLED)
-  uintnat init_stack_wsize =
-    thread_stack_wsz < 0
-    ? caml_init_main_stack_wsz
-    : caml_init_thread_stack_wsz > 0
-    ? caml_init_thread_stack_wsz : thread_stack_wsz;
+  uintnat init_stack_wsize = 0;
+
+#ifdef STACK_GUARD_PAGES
+  switch(context) {
+  case STACK_SIZE_MAIN:   init_stack_wsize = caml_init_main_stack_wsz; break;
+  case STACK_SIZE_THREAD: init_stack_wsize = caml_init_thread_stack_wsz; break;
+  case STACK_SIZE_FIBER:  init_stack_wsize = caml_init_fiber_stack_wsz; break;
+  default: caml_fatal_error("caml_get_init_stack_wsize: invalid context");
+  }
 #else
-  (void) thread_stack_wsz;
-  uintnat init_stack_wsize = Wsize_bsize(Stack_init_bsize);
+  switch(context) {
+  case STACK_SIZE_MAIN:
+  case STACK_SIZE_THREAD: init_stack_wsize = Wsize_bsize(Stack_init_bsize); break;
+  case STACK_SIZE_FIBER:  init_stack_wsize = Wsize_bsize(Stack_threshold * 2); break;
+  default: caml_fatal_error("caml_get_init_stack_wsize: invalid context");
+  }
 #endif
-  uintnat stack_wsize;
 
+  uintnat stack_wsize = 0;
   if (init_stack_wsize < caml_max_stack_wsize)
     stack_wsize = init_stack_wsize;
   else
@@ -171,8 +179,7 @@ Caml_inline struct stack_info* alloc_for_stack (mlsize_t wosize)
       + sizeof(value) * wosize, stack_alignment);
 
   return si;
-#else
-#if defined(NATIVE_CODE) && !defined(STACK_CHECKS_ENABLED)
+#elif defined(STACK_GUARD_PAGES)
   /* (We use the following strategy only in native code, because bytecode
    * has its own way of dealing with stack checks.)
    *
@@ -225,14 +232,14 @@ Caml_inline struct stack_info* alloc_for_stack (mlsize_t wosize)
   // mmap is always expected to return a page-aligned value.
   CAMLassert((uintnat)stack % page_size == 0);
 
-  if (mprotect(Protected_stack_page(stack, page_size), page_size, PROT_NONE)) {
+  if (mprotect(Protected_stack_page(stack), page_size, PROT_NONE)) {
     caml_mem_unmap(stack, len);
     return NULL;
   }
 
   // Assert that the guard page does not impinge on the actual stack area.
   CAMLassert((char*) stack + len - (trailer_size + Bsize_wsize(wosize))
-    >= Protected_stack_page(stack, page_size) + page_size);
+    >= Protected_stack_page(stack) + page_size);
 
   stack->size = len;
   stack->handler = (struct stack_handler*)((char*)stack + len - trailer_size);
@@ -251,8 +258,7 @@ Caml_inline struct stack_info* alloc_for_stack (mlsize_t wosize)
     round_up_p2((uintnat)stack + sizeof(struct stack_info) +
       sizeof(value) * wosize, stack_alignment);
   return stack;
-#endif /* NATIVE_CODE */
-#endif /* USE_MMAP_MAP_STACK */
+#endif /* USE_MMAP_MAP_STACK, STACK_GUARD_PAGES */
 }
 
 /* Returns the index into the [Caml_state->stack_cache] array if this size is
@@ -614,12 +620,14 @@ void caml_maybe_expand_stack (void)
     (value*)stk->sp - Stack_base(stk);
   uintnat stack_needed =
     Stack_threshold / sizeof(value)
-    + 10 /* for words pushed by caml_start_program */;
-  /* XXX does this "8" need updating?  Provisionally changed to 10 */
+    /* for words pushed by caml_start_program */
+    + 8 + Stack_padding_word;
 
-  if (stack_available < stack_needed)
-    if (!caml_try_realloc_stack (stack_needed))
+  if (stack_available < stack_needed) {
+    if (!caml_try_realloc_stack (stack_needed)) {
       caml_raise_stack_overflow();
+    }
+  }
 
   if (Caml_state->gc_regs_buckets == NULL) {
     /* Ensure there is at least one gc_regs bucket available before
@@ -793,9 +801,9 @@ void caml_rewrite_exception_stack(struct stack_info *old_stack,
 
 int caml_try_realloc_stack(asize_t required_space)
 {
-#if defined(NATIVE_CODE) && !defined(STACK_CHECKS_ENABLED)
+#if defined(USE_MMAP_MAP_STACK) || defined(STACK_GUARD_PAGES)
   (void) required_space;
-  abort();
+  return 0;
 #else
   struct stack_info *old_stack, *new_stack;
   asize_t wsize;
@@ -944,12 +952,10 @@ void caml_free_stack (struct stack_info* stack)
 #endif
 #ifdef USE_MMAP_MAP_STACK
     munmap(stack, stack->size);
-#else
-#if defined(NATIVE_CODE) && !defined(STACK_CHECKS_ENABLED)
+#elif defined(STACK_GUARD_PAGES)
     caml_mem_unmap(stack, stack->size);
 #else
     caml_stat_free(stack);
-#endif
 #endif
   }
 }

runtime/gc_ctrl.c

@@ -373,13 +373,7 @@ void caml_init_gc (void)
     caml_norm_minor_heap_size(caml_params->init_minor_heap_wsz);
 
   caml_max_stack_wsize = caml_params->init_max_stack_wsz;
-#if defined(NATIVE_CODE) && !defined(STACK_CHECKS_ENABLED)
-  // CR mslater: initial fiber stack size should be configurable, and have a smaller
-  // default than the main stack / thread stacks
-  caml_fiber_wsz = caml_get_init_stack_wsize(-1);
-#else
-  caml_fiber_wsz = (Stack_threshold * 2) / sizeof(value);
-#endif
+  caml_fiber_wsz = caml_get_init_stack_wsize(STACK_SIZE_FIBER);
   caml_percent_free = norm_pfree (caml_params->init_percent_free);
   caml_max_percent_free = norm_pmax (caml_params->init_max_percent_free);
   CAML_GC_MESSAGE(STACKS, "Initial stack limit: %"
@@ -445,6 +439,7 @@ static struct gc_tweak gc_tweaks[] = {
   { "pool_min_chunk_size", &caml_pool_min_chunk_bsz, 0 },
   { "main_stack_size", &caml_init_main_stack_wsz, 0 },
   { "thread_stack_size", &caml_init_thread_stack_wsz, 0 },
+  { "fiber_stack_size", &caml_init_fiber_stack_wsz, 0 },
   { "percent_sweep_per_mark", &caml_percent_sweep_per_mark, 0 },
   { "gc_pacing_policy", &caml_gc_pacing_policy, 0 },
   { "gc_overhead_adjustment", &caml_gc_overhead_adjustment, 0 },

runtime/signals_nat.c

@@ -90,7 +90,7 @@ void caml_garbage_collection(void)
   }
 }
 
-#if defined(NATIVE_CODE) && !defined(STACK_CHECKS_ENABLED)
+#ifdef STACK_GUARD_PAGES
 
 #if !defined(POSIX_SIGNALS)
 #error "stack checks cannot be disabled if POSIX signals are not available"
@@ -110,9 +110,8 @@ DECLARE_SIGNAL_HANDLER(segv_handler)
   struct sigaction act;
   struct stack_info *block = Caml_state->current_stack;
   char* fault_addr = info->si_addr;
-  int page_size = getpagesize();
-  char* protected_low = Protected_stack_page(block, page_size);
-  char* protected_high = protected_low + page_size;
+  char* protected_low = Protected_stack_page(block);
+  char* protected_high = protected_low + caml_plat_pagesize;
   if ((fault_addr >= protected_low) && (fault_addr < protected_high)) {
     context->uc_mcontext.gregs[REG_RIP]= (greg_t) &caml_raise_stack_overflow_nat;
   } else {

runtime/startup_aux.c

@@ -35,7 +35,9 @@
 #include "caml/signals.h"
 #include "caml/gc_ctrl.h"
 #include "caml/fiber.h"
+#include "caml/platform.h"
 
+#include <pthread.h>
 #include <sys/resource.h>
 
 #ifdef _WIN32
@@ -47,12 +49,27 @@ extern void caml_win32_unregister_overflow_detection (void);
 static struct caml_params params;
 const struct caml_params* const caml_params = &params;
 
+static size_t get_pthreads_stack_size_in_bytes(void)
+{
+  pthread_attr_t attr;
+  size_t res =
+    // default value, retrieved from a recent system (May 2024)
+    8 * 1024 * 1024;
+  if (pthread_attr_init(&attr) == 0) {
+    pthread_attr_getstacksize(&attr, &res);
+    pthread_attr_destroy(&attr);
+  }
+  return res;
+}
+
 static void init_startup_params(void)
 {
 #ifndef NATIVE_CODE
   char_os * cds_file;
 #endif
 
+  // Initial stack sizes only apply in native code with stack checks disabled.
+
   struct rlimit rlimit;
   if (getrlimit(RLIMIT_STACK, &rlimit)) {
     // default value, retrieved from a recent system (May 2024)
@@ -68,6 +85,9 @@ static void init_startup_params(void)
     caml_init_main_stack_wsz = Max_stack_def;
   }
 
+  caml_init_thread_stack_wsz = Wsize_bsize(get_pthreads_stack_size_in_bytes());
+  caml_init_fiber_stack_wsz = caml_init_thread_stack_wsz;
+
   params.init_percent_free = Percent_free_def;
   params.init_max_percent_free = Max_percent_free_def;
   params.init_minor_heap_wsz = Minor_heap_def;

runtime/startup_byt.c

@@ -458,6 +458,8 @@ CAMLexport void caml_main(char_os **argv)
   char_os * shared_lib_path, * shared_libs;
   char_os * exe_name, * proc_self_exe;
 
+  caml_init_os_params();
+  
   /* Determine options */
   caml_parse_ocamlrunparam();
 
@@ -476,7 +478,6 @@ CAMLexport void caml_main(char_os **argv)
   caml_install_invalid_parameter_handler();
 #endif
   caml_init_custom_operations();
-  caml_init_os_params();
   caml_ext_table_init(&caml_shared_libs_path, 8);
 
   /* Determine position of bytecode file */

runtime/startup_nat.c

@@ -101,6 +101,8 @@ value caml_startup_common(char_os **argv, int pooling)
   char_os * exe_name, * proc_self_exe;
   value res;
 
+  caml_init_os_params();
+  
   /* Determine options */
   caml_parse_ocamlrunparam();
 
@@ -120,7 +122,6 @@ value caml_startup_common(char_os **argv, int pooling)
   caml_install_invalid_parameter_handler();
 #endif
   caml_init_custom_operations();
-  caml_init_os_params();
   caml_init_gc ();
 
   /* runtime_events's init can cause a stop-the-world pause, so it must be done