2008-03-07 19:24:51 +08:00
|
|
|
/* tls_pbuf.cc
|
|
|
|
|
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
|
|
details. */
|
|
|
|
|
|
|
|
#include <winsup.h>
|
|
|
|
#include <malloc.h>
|
|
|
|
#include "tls_pbuf.h"
|
|
|
|
|
2014-08-25 22:53:49 +08:00
|
|
|
#define tls_pbuf _my_tls.locals.pathbufs
|
2008-03-07 19:24:51 +08:00
|
|
|
|
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>
2022-08-23 16:59:18 +08:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2008-03-07 19:24:51 +08:00
|
|
|
void
|
|
|
|
tls_pathbuf::destroy ()
|
|
|
|
{
|
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>
2022-08-23 16:59:18 +08:00
|
|
|
if (tls_heap)
|
|
|
|
HeapDestroy (tls_heap);
|
2008-03-07 19:24:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
char *
|
|
|
|
tmp_pathbuf::c_get ()
|
|
|
|
{
|
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>
2022-08-23 16:59:18 +08:00
|
|
|
if (!tls_pbuf.tls_heap)
|
|
|
|
tls_pbuf.create ();
|
2008-03-07 19:24:51 +08:00
|
|
|
if (tls_pbuf.c_cnt >= TP_NUM_C_BUFS)
|
2014-04-18 22:29:49 +08:00
|
|
|
api_fatal ("Internal error: TP_NUM_C_BUFS too small: %u", TP_NUM_C_BUFS);
|
2008-03-07 19:24:51 +08:00
|
|
|
if (!tls_pbuf.c_buf[tls_pbuf.c_cnt]
|
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>
2022-08-23 16:59:18 +08:00
|
|
|
&& !(tls_pbuf.c_buf[tls_pbuf.c_cnt]
|
|
|
|
= (char *) HeapAlloc (tls_pbuf.tls_heap, 0, NT_MAX_PATH)))
|
2008-03-07 19:24:51 +08:00
|
|
|
api_fatal ("Internal error: Out of memory for new path buf.");
|
|
|
|
return tls_pbuf.c_buf[tls_pbuf.c_cnt++];
|
|
|
|
}
|
|
|
|
|
|
|
|
PWCHAR
|
|
|
|
tmp_pathbuf::w_get ()
|
|
|
|
{
|
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>
2022-08-23 16:59:18 +08:00
|
|
|
if (!tls_pbuf.tls_heap)
|
|
|
|
tls_pbuf.create ();
|
2008-03-07 19:24:51 +08:00
|
|
|
if (tls_pbuf.w_cnt >= TP_NUM_W_BUFS)
|
2014-04-18 22:29:49 +08:00
|
|
|
api_fatal ("Internal error: TP_NUM_W_BUFS too small: %u.", TP_NUM_W_BUFS);
|
2008-03-07 19:24:51 +08:00
|
|
|
if (!tls_pbuf.w_buf[tls_pbuf.w_cnt]
|
|
|
|
&& !(tls_pbuf.w_buf[tls_pbuf.w_cnt]
|
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>
2022-08-23 16:59:18 +08:00
|
|
|
= (PWCHAR) HeapAlloc (tls_pbuf.tls_heap, 0,
|
|
|
|
NT_MAX_PATH * sizeof (WCHAR))))
|
2008-03-07 19:24:51 +08:00
|
|
|
api_fatal ("Internal error: Out of memory for new wide path buf.");
|
|
|
|
return tls_pbuf.w_buf[tls_pbuf.w_cnt++];
|
|
|
|
}
|