sysdeps/unix/sysv/linux/powerpc/elision-conf.c

   1 /* elision-conf.c: Lock elision tunable parameters.
   2    Copyright (C) 2015-2019 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include "config.h"
  20 #include <pthreadP.h>
  21 #include <elision-conf.h>
  22 #include <unistd.h>
  23 #include <dl-procinfo.h>
  24
  25 #if HAVE_TUNABLES
  26 # define TUNABLE_NAMESPACE elision
  27 #endif
  28 #include <elf/dl-tunables.h>
  29
  30 /* Reasonable initial tuning values, may be revised in the future.
  31    This is a conservative initial value.  */
  32
  33 struct elision_config __elision_aconf =
  34   {
  35     /* How many times to use a non-transactional lock after a transactional
  36        failure has occurred because the lock is already acquired.  Expressed
  37        in number of lock acquisition attempts.  */
  38     .skip_lock_busy = 3,
  39     /* How often to not attempt to use elision if a transaction aborted due
  40        to reasons other than other threads' memory accesses.  Expressed in
  41        number of lock acquisition attempts.  */
  42     .skip_lock_internal_abort = 3,
  43     /* How often to not attempt to use elision if a lock used up all retries
  44        without success.  Expressed in number of lock acquisition attempts.  */
  45     .skip_lock_out_of_tbegin_retries = 3,
  46     /* How often we retry using elision if there is chance for the transaction
  47        to finish execution (e.g., it wasn't aborted due to the lock being
  48        already acquired.  */
  49     .try_tbegin = 3,
  50     /* Same as SKIP_LOCK_INTERNAL_ABORT but for trylock.  */
  51     .skip_trylock_internal_abort = 3,
  52   };
  53
  54 /* Force elision for all new locks.  This is used to decide whether existing
  55    DEFAULT locks should be automatically use elision in pthread_mutex_lock().
  56    Disabled for suid programs.  Only used when elision is available.  */
  57
  58 int __pthread_force_elision attribute_hidden = 0;
  59
  60 #if HAVE_TUNABLES
  61 static inline void
  62 __always_inline
  63 do_set_elision_enable (int32_t elision_enable)
  64 {
  65   /* Enable elision if it's avaliable in hardware. It's not necessary to check
  66      if __libc_enable_secure isn't enabled since elision_enable will be set
  67      according to the default, which is disabled.  */
  68   if (elision_enable == 1)
  69     __pthread_force_elision = (GLRO (dl_hwcap2)
  70                                & PPC_FEATURE2_HAS_HTM) ? 1 : 0;
  71 }
  72
  73 /* The pthread->elision_enable tunable is 0 or 1 indicating that elision
  74    should be disabled or enabled respectively.  The feature will only be used
  75    if it's supported by the hardware.  */
  76
  77 void
  78 TUNABLE_CALLBACK (set_elision_enable) (tunable_val_t *valp)
  79 {
  80   int32_t elision_enable = (int32_t) valp->numval;
  81   do_set_elision_enable (elision_enable);
  82 }
  83
  84 #define TUNABLE_CALLBACK_FNDECL(__name, __type)                 \
  85 static inline void                                              \
  86 __always_inline                                                 \
  87 do_set_elision_ ## __name (__type value)                        \
  88 {                                                               \
  89   __elision_aconf.__name = value;                               \
  90 }                                                               \
  91 void                                                            \
  92 TUNABLE_CALLBACK (set_elision_ ## __name) (tunable_val_t *valp) \
  93 {                                                               \
  94   __type value = (__type) (valp)->numval;                       \
  95   do_set_elision_ ## __name (value);                            \
  96 }
  97
  98 TUNABLE_CALLBACK_FNDECL (skip_lock_busy, int32_t);
  99 TUNABLE_CALLBACK_FNDECL (skip_lock_internal_abort, int32_t);
 100 TUNABLE_CALLBACK_FNDECL (skip_lock_out_of_tbegin_retries, int32_t);
 101 TUNABLE_CALLBACK_FNDECL (try_tbegin, int32_t);
 102 TUNABLE_CALLBACK_FNDECL (skip_trylock_internal_abort, int32_t);
 103 #endif
 104
 105 /* Initialize elision.  */
 106
 107 static void
 108 elision_init (int argc __attribute__ ((unused)),
 109               char **argv  __attribute__ ((unused)),
 110               char **environ)
 111 {
 112 #if HAVE_TUNABLES
 113   /* Elision depends on tunables and must be explicitly turned on by setting
 114      the appropriate tunable on a supported platform.  */
 115
 116   TUNABLE_GET (enable, int32_t,
 117                TUNABLE_CALLBACK (set_elision_enable));
 118   TUNABLE_GET (skip_lock_busy, int32_t,
 119                TUNABLE_CALLBACK (set_elision_skip_lock_busy));
 120   TUNABLE_GET (skip_lock_internal_abort, int32_t,
 121                TUNABLE_CALLBACK (set_elision_skip_lock_internal_abort));
 122   TUNABLE_GET (skip_lock_after_retries, int32_t,
 123                TUNABLE_CALLBACK (set_elision_skip_lock_out_of_tbegin_retries));
 124   TUNABLE_GET (tries, int32_t,
 125                TUNABLE_CALLBACK (set_elision_try_tbegin));
 126   TUNABLE_GET (skip_trylock_internal_abort, int32_t,
 127                TUNABLE_CALLBACK (set_elision_skip_trylock_internal_abort));
 128 #endif
 129
 130   /* Linux from 3.9 through 4.2 do not abort HTM transaction on syscalls,
 131      instead it suspends the transaction and resumes it when returning to
 132      usercode.  The side-effects of the syscall will always remain visible,
 133      even if the transaction is aborted.  This is an issue when a transaction
 134      is used along with futex syscall, on pthread_cond_wait for instance,
 135      where futex might succeed but the transaction is rolled back leading
 136      the condition variable object in an inconsistent state.
 137
 138      Glibc used to prevent it by always aborting a transaction before issuing
 139      a syscall.  Linux 4.2 also decided to abort active transaction in
 140      syscalls which makes the glibc workaround superflours.  Worse, glibc
 141      transaction abortions leads to a performance issues on recent kernels.
 142
 143      So Lock Elision is just enabled when it has been explict set (either
 144      by tunables of by a configure switch) and if kernel aborts HTM
 145      transactions on syscalls (PPC_FEATURE2_HTM_NOSC)  */
 146
 147   __pthread_force_elision = (__pthread_force_elision
 148                              && GLRO (dl_hwcap2) & PPC_FEATURE2_HTM_NOSC);
 149
 150   if (!__pthread_force_elision)
 151     __elision_aconf.try_tbegin = 0; /* Disable elision on rwlocks.  */
 152 }
 153
 154 #ifdef SHARED
 155 # define INIT_SECTION ".init_array"
 156 # define MAYBE_CONST
 157 #else
 158 # define INIT_SECTION ".preinit_array"
 159 # define MAYBE_CONST const
 160 #endif
 161
 162 void (*MAYBE_CONST __pthread_init_array []) (int, char **, char **)
 163   __attribute__ ((section (INIT_SECTION), aligned (sizeof (void *)))) =
 164 {
 165   &elision_init
 166 };