sync upstream uv source code

Author: toyobayashi

packages/emnapi/include/uv.h

@@ -84,6 +84,23 @@ typedef void (*uv_thread_cb)(void* arg);
 UV_EXTERN int uv_thread_create(uv_thread_t* tid, uv_thread_cb entry, void* arg);
 UV_EXTERN int uv_thread_join(uv_thread_t *tid);
 
+typedef enum {
+  UV_THREAD_NO_FLAGS = 0x00,
+  UV_THREAD_HAS_STACK_SIZE = 0x01
+} uv_thread_create_flags;
+
+struct uv_thread_options_s {
+  unsigned int flags;
+  size_t stack_size;
+};
+
+typedef struct uv_thread_options_s uv_thread_options_t;
+
+UV_EXTERN int uv_thread_create_ex(uv_thread_t* tid,
+                                  const uv_thread_options_t* params,
+                                  uv_thread_cb entry,
+                                  void* arg);
+
 typedef void (*uv_close_cb)(uv_handle_t* handle);
 typedef void (*uv_async_cb)(uv_async_t* handle);
 

packages/emnapi/src/uv/threadpool.c

@@ -212,6 +212,7 @@ void uv__threadpool_cleanup(void) {
 EMNAPI_INTERNAL_EXTERN int _emnapi_async_work_pool_size();
 
 static void init_threads(void) {
+  uv_thread_options_t config;
   unsigned int i;
 #if !defined(EMNAPI_WORKER_POOL_SIZE) || !(EMNAPI_WORKER_POOL_SIZE > 0)
   const char* val;
@@ -262,11 +263,17 @@ static void init_threads(void) {
     abort();
 #endif
 
+  // config.flags = UV_THREAD_HAS_STACK_SIZE;
+  // config.stack_size = 8u << 20;  /* 8 MB */
+
+  // use DEFAULT_PTHREAD_STACK_SIZE
+  config.flags = UV_THREAD_NO_FLAGS;
+
   for (i = 0; i < nthreads; i++)
 #ifndef __EMNAPI_WASI_THREADS__
-    if (uv_thread_create(threads + i, (uv_thread_cb) worker, &sem))
+    if (uv_thread_create_ex(threads + i, &config, (uv_thread_cb) worker, &sem))
 #else
-    if (uv_thread_create(threads + i, (uv_thread_cb) worker, NULL))
+    if (uv_thread_create_ex(threads + i, &config, (uv_thread_cb) worker, NULL))
 #endif
       abort();
 

packages/emnapi/src/uv/unix/thread.c

@@ -15,6 +15,31 @@
 //     } \
 //   } while (0)
 
+static size_t uv__min_stack_size(void) {
+  static const size_t min = 8192;
+
+#ifdef PTHREAD_STACK_MIN  /* Not defined on NetBSD. */
+  if (min < (size_t) PTHREAD_STACK_MIN)
+    return PTHREAD_STACK_MIN;
+#endif  /* PTHREAD_STACK_MIN */
+
+  return min;
+}
+
+static size_t uv__default_stack_size(void) {
+#if !defined(__linux__)
+  return 0;
+#elif defined(__PPC__) || defined(__ppc__) || defined(__powerpc__)
+  return 4 << 20;  /* glibc default. */
+#else
+  return 2 << 20;  /* glibc default. */
+#endif
+}
+
+size_t uv__thread_stack_size(void) {
+  return uv__default_stack_size();
+}
+
 void uv_sem_post(sem_t* sem) {
   if (sem_post(sem))
     abort();
@@ -104,25 +129,59 @@ void uv_cond_destroy(uv_cond_t* cond) {
 }
 
 int uv_thread_create_ex(uv_thread_t* tid,
-                        void* params,
+                        const uv_thread_options_t* params,
                         void (*entry)(void *arg),
                         void *arg) {
   int err;
+  pthread_attr_t* attr;
+  pthread_attr_t attr_storage;
+  size_t pagesize;
+  size_t stack_size;
+  size_t min_stack_size;
 
   /* Used to squelch a -Wcast-function-type warning. */
   union {
     void (*in)(void*);
     void* (*out)(void*);
   } f;
 
+  stack_size =
+      params->flags & UV_THREAD_HAS_STACK_SIZE ? params->stack_size : 0;
+
+  attr = NULL;
+  if (stack_size == 0) {
+    stack_size = uv__thread_stack_size();
+  } else {
+    pagesize = 65536;
+    stack_size = (stack_size + pagesize - 1) &~ (pagesize - 1);
+    min_stack_size = uv__min_stack_size();
+    if (stack_size < min_stack_size)
+      stack_size = min_stack_size;
+  }
+
+  if (stack_size > 0) {
+    attr = &attr_storage;
+
+    if (pthread_attr_init(attr))
+      abort();
+
+    if (pthread_attr_setstacksize(attr, stack_size))
+      abort();
+  }
+
   f.in = entry;
-  err = pthread_create(tid, NULL, f.out, arg);
+  err = pthread_create(tid, attr, f.out, arg);
+
+  if (attr != NULL)
+    pthread_attr_destroy(attr);
 
   return err;
 }
 
 int uv_thread_create(uv_thread_t *tid, void (*entry)(void *arg), void *arg) {
-  return uv_thread_create_ex(tid, NULL, entry, arg);
+  uv_thread_options_t params;
+  params.flags = UV_THREAD_NO_FLAGS;
+  return uv_thread_create_ex(tid, &params, entry, arg);
 }
 
 int uv_thread_join(uv_thread_t *tid) {