aboutsummaryrefslogtreecommitdiff
path: root/libio/genops.c
diff options
context:
space:
mode:
authorSzabolcs Nagy <szabolcs.nagy@arm.com>2017-07-04 16:05:12 +0100
committerSzabolcs Nagy <szabolcs.nagy@arm.com>2017-07-04 16:05:12 +0100
commitd2e04918833d90bae7fe5410bb70a045bbd2b64d (patch)
tree19bb304474eb148611f811ad8b80848a4d993e77 /libio/genops.c
parent1ff6c67a252e59488a26e3c8f6690b29ef56e369 (diff)
downloadglibc-d2e04918833d90bae7fe5410bb70a045bbd2b64d.zip
glibc-d2e04918833d90bae7fe5410bb70a045bbd2b64d.tar.gz
glibc-d2e04918833d90bae7fe5410bb70a045bbd2b64d.tar.bz2
Single threaded stdio optimization
Locking overhead can be significant in some stdio operations that are common in single threaded applications. This patch adds the _IO_FLAGS2_NEED_LOCK flag to indicate if an _IO_FILE object needs to be locked and some of the stdio functions just jump to their _unlocked variant when not. The flag is set on all _IO_FILE objects when the first thread is created. A new GLIBC_PRIVATE libc symbol, _IO_enable_locks, was added to do this from libpthread. The optimization can be applied to more stdio functions, currently it is only applied to single flag check or single non-wide-char standard operations. The flag should probably be never set for files with _IO_USER_LOCK, but that's just a further optimization, not a correctness requirement. The optimization is valid in a single thread because stdio operations are non-as-safe (so lock state is not observable from a signal handler) and stdio locks are recursive (so lock state is not observable via deadlock). The optimization is not valid if a thread may be created while an stdio lock is taken and thus it should be disabled if any user code may run during an stdio operation (interposed malloc, printf hooks, etc). This makes the optimization more complicated for some stdio operations (e.g. printf), but those are bigger and thus less important to optimize so this patch does not try to do that. * libio/libio.h (_IO_FLAGS2_NEED_LOCK, _IO_need_lock): Define. * libio/libioP.h (_IO_enable_locks): Declare. * libio/Versions (_IO_enable_locks): New symbol. * libio/genops.c (_IO_enable_locks): Define. (_IO_old_init): Initialize flags2. * libio/feof.c.c (_IO_feof): Avoid locking when not needed. * libio/ferror.c (_IO_ferror): Likewise. * libio/fputc.c (fputc): Likewise. * libio/putc.c (_IO_putc): Likewise. * libio/getc.c (_IO_getc): Likewise. * libio/getchar.c (getchar): Likewise. * libio/ioungetc.c (_IO_ungetc): Likewise. * nptl/pthread_create.c (__pthread_create_2_1): Enable stdio locks. * libio/iofopncook.c (_IO_fopencookie): Enable locking for the file. * sysdeps/pthread/flockfile.c (__flockfile): Likewise.
Diffstat (limited to 'libio/genops.c')
-rw-r--r--libio/genops.c28
1 files changed, 28 insertions, 0 deletions
diff --git a/libio/genops.c b/libio/genops.c
index a466cfa..6ad7346 100644
--- a/libio/genops.c
+++ b/libio/genops.c
@@ -570,11 +570,39 @@ _IO_init (_IO_FILE *fp, int flags)
_IO_init_internal (fp, flags);
}
+static int stdio_needs_locking;
+
+/* In a single-threaded process most stdio locks can be omitted. After
+ _IO_enable_locks is called, locks are not optimized away any more.
+ It must be first called while the process is still single-threaded.
+
+ This lock optimization can be disabled on a per-file basis by setting
+ _IO_FLAGS2_NEED_LOCK, because a file can have user-defined callbacks
+ or can be locked with flockfile and then a thread may be created
+ between a lock and unlock, so omitting the lock is not valid.
+
+ Here we have to make sure that the flag is set on all existing files
+ and files created later. */
+void
+_IO_enable_locks (void)
+{
+ _IO_ITER i;
+
+ if (stdio_needs_locking)
+ return;
+ stdio_needs_locking = 1;
+ for (i = _IO_iter_begin (); i != _IO_iter_end (); i = _IO_iter_next (i))
+ _IO_iter_file (i)->_flags2 |= _IO_FLAGS2_NEED_LOCK;
+}
+libc_hidden_def (_IO_enable_locks)
+
void
_IO_old_init (_IO_FILE *fp, int flags)
{
fp->_flags = _IO_MAGIC|flags;
fp->_flags2 = 0;
+ if (stdio_needs_locking)
+ fp->_flags2 |= _IO_FLAGS2_NEED_LOCK;
fp->_IO_buf_base = NULL;
fp->_IO_buf_end = NULL;
fp->_IO_read_base = NULL;