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

   1 /* elision-conf.c: Lock elision tunable parameters.
   2    Copyright (C) 2015-2023 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    <https://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 #define TUNABLE_NAMESPACE elision
  26 #include <elf/dl-tunables.h>
  27
  28 /* Reasonable initial tuning values, may be revised in the future.
  29    This is a conservative initial value.  */
  30
  31 struct elision_config __elision_aconf =
  32   {
  33     /* How many times to use a non-transactional lock after a transactional
  34        failure has occurred because the lock is already acquired.  Expressed
  35        in number of lock acquisition attempts.  */
  36     .skip_lock_busy = 3,
  37     /* How often to not attempt to use elision if a transaction aborted due
  38        to reasons other than other threads' memory accesses.  Expressed in
  39        number of lock acquisition attempts.  */
  40     .skip_lock_internal_abort = 3,
  41     /* How often to not attempt to use elision if a lock used up all retries
  42        without success.  Expressed in number of lock acquisition attempts.  */
  43     .skip_lock_out_of_tbegin_retries = 3,
  44     /* How often we retry using elision if there is chance for the transaction
  45        to finish execution (e.g., it wasn't aborted due to the lock being
  46        already acquired.  */
  47     .try_tbegin = 3,
  48     /* Same as SKIP_LOCK_INTERNAL_ABORT but for trylock.  */
  49     .skip_trylock_internal_abort = 3,
  50   };
  51
  52 static inline void
  53 __always_inline
  54 do_set_elision_enable (int32_t elision_enable)
  55 {
  56   /* Enable elision if it's available in hardware. It's not necessary to check
  57      if __libc_enable_secure isn't enabled since elision_enable will be set
  58      according to the default, which is disabled.  */
  59   if (elision_enable == 1)
  60     __pthread_force_elision = (GLRO (dl_hwcap2)
  61                                & PPC_FEATURE2_HAS_HTM) ? 1 : 0;
  62 }
  63
  64 /* The pthread->elision_enable tunable is 0 or 1 indicating that elision
  65    should be disabled or enabled respectively.  The feature will only be used
  66    if it's supported by the hardware.  */
  67
  68 void
  69 TUNABLE_CALLBACK (set_elision_enable) (tunable_val_t *valp)
  70 {
  71   int32_t elision_enable = (int32_t) valp->numval;
  72   do_set_elision_enable (elision_enable);
  73 }
  74
  75 #define TUNABLE_CALLBACK_FNDECL(__name, __type)                 \
  76 static inline void                                              \
  77 __always_inline                                                 \
  78 do_set_elision_ ## __name (__type value)                        \
  79 {                                                               \
  80   __elision_aconf.__name = value;                               \
  81 }                                                               \
  82 void                                                            \
  83 TUNABLE_CALLBACK (set_elision_ ## __name) (tunable_val_t *valp) \
  84 {                                                               \
  85   __type value = (__type) (valp)->numval;                       \
  86   do_set_elision_ ## __name (value);                            \
  87 }
  88
  89 TUNABLE_CALLBACK_FNDECL (skip_lock_busy, int32_t);
  90 TUNABLE_CALLBACK_FNDECL (skip_lock_internal_abort, int32_t);
  91 TUNABLE_CALLBACK_FNDECL (skip_lock_out_of_tbegin_retries, int32_t);
  92 TUNABLE_CALLBACK_FNDECL (try_tbegin, int32_t);
  93 TUNABLE_CALLBACK_FNDECL (skip_trylock_internal_abort, int32_t);
  94
  95 /* Initialize elision.  */
  96
  97 void
  98 __lll_elision_init (void)
  99 {
 100   /* Elision depends on tunables and must be explicitly turned on by setting
 101      the appropriate tunable on a supported platform.  */
 102
 103   TUNABLE_GET (enable, int32_t,
 104                TUNABLE_CALLBACK (set_elision_enable));
 105   TUNABLE_GET (skip_lock_busy, int32_t,
 106                TUNABLE_CALLBACK (set_elision_skip_lock_busy));
 107   TUNABLE_GET (skip_lock_internal_abort, int32_t,
 108                TUNABLE_CALLBACK (set_elision_skip_lock_internal_abort));
 109   TUNABLE_GET (skip_lock_after_retries, int32_t,
 110                TUNABLE_CALLBACK (set_elision_skip_lock_out_of_tbegin_retries));
 111   TUNABLE_GET (tries, int32_t,
 112                TUNABLE_CALLBACK (set_elision_try_tbegin));
 113   TUNABLE_GET (skip_trylock_internal_abort, int32_t,
 114                TUNABLE_CALLBACK (set_elision_skip_trylock_internal_abort));
 115
 116   /* Linux from 3.9 through 4.2 do not abort HTM transaction on syscalls,
 117      instead it suspends the transaction and resumes it when returning to
 118      usercode.  The side-effects of the syscall will always remain visible,
 119      even if the transaction is aborted.  This is an issue when a transaction
 120      is used along with futex syscall, on pthread_cond_wait for instance,
 121      where futex might succeed but the transaction is rolled back leading
 122      the condition variable object in an inconsistent state.
 123
 124      Glibc used to prevent it by always aborting a transaction before issuing
 125      a syscall.  Linux 4.2 also decided to abort active transaction in
 126      syscalls which makes the glibc workaround superflours.  Worse, glibc
 127      transaction abortions leads to a performance issues on recent kernels.
 128
 129      So Lock Elision is just enabled when it has been explicitly set (either
 130      by tunables of by a configure switch) and if kernel aborts HTM
 131      transactions on syscalls (PPC_FEATURE2_HTM_NOSC)  */
 132
 133   __pthread_force_elision = (__pthread_force_elision
 134                              && GLRO (dl_hwcap2) & PPC_FEATURE2_HTM_NOSC);
 135
 136   if (!__pthread_force_elision)
 137     __elision_aconf.try_tbegin = 0; /* Disable elision on rwlocks.  */
 138 }