From patchwork Mon Jul 2 08:27:24 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: kemi X-Patchwork-Id: 937732 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=sourceware.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=libc-alpha-return-93896-incoming=patchwork.ozlabs.org@sourceware.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; secure) header.d=sourceware.org header.i=@sourceware.org header.b="Ml33mjgF"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 41K0pg2JSsz9s3q for ; Mon, 2 Jul 2018 18:31:37 +1000 (AEST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id; q=dns; s= default; b=DccxdWttiXyZ7Rj10xlEXM6xxjnATe9hqvGZIGyj5ctkkwYcPJUmm jegvJhglCrfSLrwhYANHxjFgBuIK3gwWBybA/mMWNkq18jZYoZ3a+6fiUBxvVJ/A 1bx+FzXS9SPpFdsFt5Nfh3zyoWD9CJOIpDzds7QMYVi78MM2MxsHJg= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id; s=default; bh=0A1X2Lou2SNqM2L8eVs+EHLNenU=; b=Ml33mjgFx0EHJv6GJdFSEzeLcO2e SHKScJXtw9trKCHXa7PuaOtlivENoAQKG9zE6ZDaU6qv50lfr7QBkUH/ZbzKpOQ0 R/j8ode4NAV24TkAIrawW+38aP0smqUF0/Zn710XIWciDA+wBKECArzGRlXX5aoM hWkF55gB4JZabIY= Received: (qmail 21933 invoked by alias); 2 Jul 2018 08:31:21 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 19289 invoked by uid 89); 2 Jul 2018 08:30:28 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-25.8 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_SHORT, SPF_PASS autolearn=ham version=3.3.2 spammy=behavior, administrator, Hardware, Adjust X-HELO: mga01.intel.com From: Kemi Wang To: Adhemerval Zanella , Florian Weimer , Rical Jason , Carlos Donell , Glibc alpha Cc: Dave Hansen , Tim Chen , Andi Kleen , Ying Huang , Aaron Lu , Lu Aubrey , Kemi Wang Subject: [PATCH v6 1/3] Tunables: Add tunables of spin count for pthread adaptive spin mutex Date: Mon, 2 Jul 2018 16:27:24 +0800 Message-Id: <1530520046-18343-1-git-send-email-kemi.wang@intel.com> This patch does not have any functionality change, we only provide a spin count tunes for pthread adaptive spin mutex. The tunable glibc.mutex.spin_count tunes can be used by system administrator to squeeze system performance according to different hardware capabilities and workload characteristics. The maximum value of spin count is limited to 30000 to avoid the overflow of mutex->__data.__spins variable with the possible type of short in pthread_mutex_lock (). The default value of spin count is set to 100 with the reference to the previous number of times of spinning via trylock. This value would be architecture-specific and can be tuned with kinds of benchmarks to fit most cases in future. This is the preparation work for the next patch, in which the way of adaptive spin would be changed from an expensive cmpxchg to read while spinning. * elf/dl-tunables.list: Add glibc.mutex.spin_count entry. * manual/tunables.texi: Add glibc.mutex.spin_count description. * nptl/Makefile: Add pthread_mutex_conf.c for compilation. * nptl/pthread_mutex_conf.h: New file. * nptl/pthread_mutex_conf.c: New file. * nptl/nptl-init.c: Put mutex tunable initialization in pthread initialization. ChangeLog: V5->V6: a) Missing "pthread mutex tunables" entry in the menu of tunables.texi, add it. V4->V5 a) Put mutex tunable (glibc.mutex.spin_count) initialization as part of overall pthread initialization, that would avoid the extra relocation, as suggested by Florian Weimer. Thanks for pointing it out! b) Move the READ_ONLY_SPIN macro definition from the third patch to this patch V3->V4 a) Add comments in elf/dl-tunables.list V2->V3 a) Polish the description of glibc.mutex.spin_count tunable with the help from Rical Jasan. b) Get rid of the TUNABLE_CALLBACK_FNDECL macros in pthread_mutex_conf.c, as suggested by Florian Weimer. c) Adjust the default value of spin count to 100 with the reference of the previous spinning way via trylock. V1->V2 a) Renamed nptl/mutex-conf.h -> nptl/pthread_mutex_conf.h b) Renamed nptl/mutex-conf.c -> nptl/pthread_mutex_conf.c c) Change the Makefile to compile pthread_mutex_conf.c d) Modify the copyright "2013-2018" -> "2018" for new added files e) Fix the indentation issue (tab -> double space) in elf/dl-tunables.list f) Remove the env alias LD_SPIN_COUNT in elf/dl-tunables.list g) Fix the typo errors and refresh glibc.mutex.spin_count tunable description in manual/tunables.texi. h) Fix the indentation issue in nptl/pthread_mutex_conf.c i) Fix the indentation issue for nested preprocessor (add one space for each level) Suggested-by: Andi Kleen Signed-off-by: Kemi Wang --- elf/dl-tunables.list | 17 ++++++++++++++ manual/tunables.texi | 23 +++++++++++++++++++ nptl/Makefile | 3 ++- nptl/nptl-init.c | 5 +++++ nptl/pthread_mutex_conf.c | 57 +++++++++++++++++++++++++++++++++++++++++++++++ nptl/pthread_mutex_conf.h | 35 +++++++++++++++++++++++++++++ 6 files changed, 139 insertions(+), 1 deletion(-) create mode 100644 nptl/pthread_mutex_conf.c create mode 100644 nptl/pthread_mutex_conf.h diff --git a/elf/dl-tunables.list b/elf/dl-tunables.list index 1f8ecb8..2c5a13f 100644 --- a/elf/dl-tunables.list +++ b/elf/dl-tunables.list @@ -121,4 +121,21 @@ glibc { default: 3 } } + +# The maximum value of spin count is limited to 30000 to avoid the overflow +# of mutex->__data.__spins variable with the possible type of short in +# pthread_mutex_lock (). +# +# The default value of spin count is set to 100 with the reference to the +# previous number of times of spinning via trylock. This value would be +# architecture-specific and can be tuned with kinds of benchmarks to fit +# most cases in future. + mutex { + spin_count { + type: INT_32 + minval: 0 + maxval: 30000 + default: 100 + } + } } diff --git a/manual/tunables.texi b/manual/tunables.texi index be33c9f..f660604 100644 --- a/manual/tunables.texi +++ b/manual/tunables.texi @@ -32,6 +32,7 @@ their own namespace. * Tunable names:: The structure of a tunable name * Memory Allocation Tunables:: Tunables in the memory allocation subsystem * Elision Tunables:: Tunables in elision subsystem +* Pthread Mutex Tunables:: Tunables in mutex * Hardware Capability Tunables:: Tunables that modify the hardware capabilities seen by @theglibc{} @end menu @@ -281,6 +282,28 @@ of try lock attempts. The default value of this tunable is @samp{3}. @end deftp +@node Pthread Mutex Tunables +@section Pthread Mutex Tunables +@cindex pthread mutex tunables + +@deftp {Tunable namespace} glibc.mutex +The behavior of pthread mutexes can be tuned to gain performance improvements +according to specific hardware capabilities and workload characteristics by +setting the following tunables in the @code{mutex} namespace: +@end deftp + +@deftp Tunable glibc.mutex.spin_count +The @code{glibc.mutex.spin_count} tunable sets the maximum number of times +a thread should spin on the lock before calling into the kernel to block. +Adaptive spin is used for mutexes initialized with the PTHREAD_MUTEX_ADAPTIVE_NP +GNU extension. It affects both pthread_mutex_lock and pthread_mutex_timedlock. + +The spinning is done until either the maximum spin times is reached or +the lock is acquired. + +The default value of this tunable is @samp{100}. +@end deftp + @node Hardware Capability Tunables @section Hardware Capability Tunables @cindex hardware capability tunables diff --git a/nptl/Makefile b/nptl/Makefile index 94be92c..bd1096f 100644 --- a/nptl/Makefile +++ b/nptl/Makefile @@ -139,7 +139,8 @@ libpthread-routines = nptl-init vars events version pt-interp \ pthread_mutex_getprioceiling \ pthread_mutex_setprioceiling \ pthread_setname pthread_getname \ - pthread_setattr_default_np pthread_getattr_default_np + pthread_setattr_default_np pthread_getattr_default_np \ + pthread_mutex_conf # pthread_setuid pthread_seteuid pthread_setreuid \ # pthread_setresuid \ # pthread_setgid pthread_setegid pthread_setregid \ diff --git a/nptl/nptl-init.c b/nptl/nptl-init.c index 1d3790f..3e6e2e1 100644 --- a/nptl/nptl-init.c +++ b/nptl/nptl-init.c @@ -38,6 +38,7 @@ #include #include #include +#include #ifndef TLS_MULTIPLE_THREADS_IN_TCB /* Pointer to the corresponding variable in libc. */ @@ -446,6 +447,10 @@ __pthread_initialize_minimal_internal (void) /* Determine whether the machine is SMP or not. */ __is_smp = is_smp_system (); + +#if HAVE_TUNABLES + mutex_tunables_init (); +#endif } strong_alias (__pthread_initialize_minimal_internal, __pthread_initialize_minimal) diff --git a/nptl/pthread_mutex_conf.c b/nptl/pthread_mutex_conf.c new file mode 100644 index 0000000..9b2c5d1 --- /dev/null +++ b/nptl/pthread_mutex_conf.c @@ -0,0 +1,57 @@ +/* pthread_mutex_conf.c: Pthread mutex tunable parameters. + Copyright (C) 2018 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include "config.h" +#include +#include +#include +#include + +#if HAVE_TUNABLES +# define TUNABLE_NAMESPACE mutex +#endif +#include + + +struct mutex_config __mutex_aconf = +{ + /* The maximum number of times a thread should spin on the lock before + calling into kernel to block. */ + .spin_count = 100, +}; + +#if HAVE_TUNABLES +static inline void __always_inline +do_set_mutex_spin_count (int32_t value) +{ + __mutex_aconf.spin_count = value; +} + +void +TUNABLE_CALLBACK (set_mutex_spin_count) (tunable_val_t *valp) +{ + int32_t value = (int32_t) (valp)->numval; + do_set_mutex_spin_count (value); +} + +void mutex_tunables_init (void) +{ + TUNABLE_GET (spin_count, int32_t, + TUNABLE_CALLBACK (set_mutex_spin_count)); +} +#endif diff --git a/nptl/pthread_mutex_conf.h b/nptl/pthread_mutex_conf.h new file mode 100644 index 0000000..74a0735 --- /dev/null +++ b/nptl/pthread_mutex_conf.h @@ -0,0 +1,35 @@ +/* pthread_mutex_conf.h: Pthread mutex tunable parameters. + Copyright (C) 2018 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ +#ifndef _PTHREAD_MUTEX_CONF_H +#define _PTHREAD_MUTEX_CONF_H 1 + +#include +#include + +struct mutex_config +{ + int spin_count; +}; + +extern struct mutex_config __mutex_aconf attribute_hidden; + +void mutex_tunables_init (void); + +#define READ_ONLY_SPIN 1 + +#endif