[newlib-cygwin] Cygwin: tls_pathbuf: Use Windows heap

[Corinna Vinschen <corinna@sourceware.org>]

https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;h=63b503916d4258cec39df09c545498e463d9a088

commit 63b503916d4258cec39df09c545498e463d9a088
Author: Corinna Vinschen <corinna@vinschen.de>
Date:   Tue Aug 23 10:59:18 2022 +0200

    Cygwin: tls_pathbuf: Use Windows heap
    
    Rather than using malloc/free for the buffers, we're now using
    HeapAlloc/HeapFree on a HEAP_NO_SERIALIZE heap created for this
    thread.
    
    Advantages:
    - Less contention. Our malloc/free doesn't scale well in
      multithreaded scenarios
    - Even faster heap allocation by using a non serialized heap.
    - Internal, local, temporary data not cluttering the user heap.
    - Internal, local, temporary data not copied over to child process
      at fork().
    
    Disadvantage:
    - A forked process has to start allocating temporary buffers from
      scratch.  However, this should be alleviated by the fact that
      buffer allocation usually reaches its peak very early in process
      runtime, so the longer the proceess runs, the less buffers have
      to allocated, and, only few processes don't exec after fork
      anyway.
    
    Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Diff:
---
 winsup/cygwin/cygtls.cc               |  2 ++
 winsup/cygwin/local_includes/cygtls.h |  3 +++
 winsup/cygwin/tls_pbuf.cc             | 25 +++++++++++++++++++------
 3 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/winsup/cygwin/cygtls.cc b/winsup/cygwin/cygtls.cc
index cf3a7daba..afaee8e97 100644
--- a/winsup/cygwin/cygtls.cc
+++ b/winsup/cygwin/cygtls.cc
@@ -64,6 +64,7 @@ _cygtls::init_thread (void *x, DWORD (*func) (void *, void *))
   initialized = CYGTLS_INITIALIZED;
   errno_addr = &(local_clib._errno);
   locals.cw_timer = NULL;
+  locals.pathbufs.clear ();
 
   if ((void *) func == (void *) cygthread::stub
       || (void *) func == (void *) cygthread::simplestub)
@@ -84,6 +85,7 @@ _cygtls::fixup_after_fork ()
   signal_arrived = NULL;
   locals.select.sockevt = NULL;
   locals.cw_timer = NULL;
+  locals.pathbufs.clear ();
   wq.thread_ev = NULL;
 }
 
diff --git a/winsup/cygwin/local_includes/cygtls.h b/winsup/cygwin/local_includes/cygtls.h
index b265978f0..018a59946 100644
--- a/winsup/cygwin/local_includes/cygtls.h
+++ b/winsup/cygwin/local_includes/cygtls.h
@@ -54,10 +54,13 @@ class tls_pathbuf
 	};
       uint64_t _counters;
     };
+  HANDLE tls_heap;
   char  *c_buf[TP_NUM_C_BUFS];
   WCHAR *w_buf[TP_NUM_W_BUFS];
 
 public:
+  void clear () { memset (this, 0, sizeof *this); }
+  void create ();
   void destroy ();
   friend class tmp_pathbuf;
   friend class san;
diff --git a/winsup/cygwin/tls_pbuf.cc b/winsup/cygwin/tls_pbuf.cc
index f5f318e98..7c8149856 100644
--- a/winsup/cygwin/tls_pbuf.cc
+++ b/winsup/cygwin/tls_pbuf.cc
@@ -10,22 +10,32 @@ details. */
 
 #define tls_pbuf	_my_tls.locals.pathbufs
 
+void
+tls_pathbuf::create ()
+{
+  tls_heap = HeapCreate (HEAP_NO_SERIALIZE | HEAP_GENERATE_EXCEPTIONS,
+			 NT_MAX_PATH * sizeof (WCHAR) * 10,	/* 640K */
+			 NT_MAX_PATH * TP_NUM_C_BUFS		/* 4.6M */
+			 + NT_MAX_PATH * TP_NUM_W_BUFS * sizeof (WCHAR));
+}
+
 void
 tls_pathbuf::destroy ()
 {
-  for (uint32_t i = 0; i < TP_NUM_C_BUFS && c_buf[i]; ++i)
-    free (c_buf[i]);
-  for (uint32_t i = 0; i < TP_NUM_W_BUFS && w_buf[i]; ++i)
-    free (w_buf[i]);
+  if (tls_heap)
+    HeapDestroy (tls_heap);
 }
 
 char *
 tmp_pathbuf::c_get ()
 {
+  if (!tls_pbuf.tls_heap)
+    tls_pbuf.create ();
   if (tls_pbuf.c_cnt >= TP_NUM_C_BUFS)
     api_fatal ("Internal error: TP_NUM_C_BUFS too small: %u", TP_NUM_C_BUFS);
   if (!tls_pbuf.c_buf[tls_pbuf.c_cnt]
-      && !(tls_pbuf.c_buf[tls_pbuf.c_cnt] = (char *) malloc (NT_MAX_PATH)))
+      && !(tls_pbuf.c_buf[tls_pbuf.c_cnt]
+	   = (char *) HeapAlloc (tls_pbuf.tls_heap, 0, NT_MAX_PATH)))
     api_fatal ("Internal error: Out of memory for new path buf.");
   return tls_pbuf.c_buf[tls_pbuf.c_cnt++];
 }
@@ -33,11 +43,14 @@ tmp_pathbuf::c_get ()
 PWCHAR
 tmp_pathbuf::w_get ()
 {
+  if (!tls_pbuf.tls_heap)
+    tls_pbuf.create ();
   if (tls_pbuf.w_cnt >= TP_NUM_W_BUFS)
     api_fatal ("Internal error: TP_NUM_W_BUFS too small: %u.", TP_NUM_W_BUFS);
   if (!tls_pbuf.w_buf[tls_pbuf.w_cnt]
       && !(tls_pbuf.w_buf[tls_pbuf.w_cnt]
-	   = (PWCHAR) malloc (NT_MAX_PATH * sizeof (WCHAR))))
+	   = (PWCHAR) HeapAlloc (tls_pbuf.tls_heap, 0,
+				 NT_MAX_PATH * sizeof (WCHAR))))
     api_fatal ("Internal error: Out of memory for new wide path buf.");
   return tls_pbuf.w_buf[tls_pbuf.w_cnt++];
 }