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 --git a/winsup/cygwin/cygtls.cc b/winsup/cygwin/cygtls.cc
index cf3a7daba90462b5be7932ccca0a26b9db4e1d85..afaee8e977872e57d56eb6303d61ee2b55cbefe9 100644 (file)
--- 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 b265978f0f9d8871a939ec8253c0c816fd807c8b..018a59946848874fdb7ea686c129e0797cfd3e42 100644 (file)
--- 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 f5f318e9896f08c9428ac4a561c2c088b8265ce6..7c8149856dbbfccb166c3b1b4d9b209e4eb6ef47 100644 (file)
--- 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++];
 }