/*-------------------------------------------------------------------------
 *
 * s_lock.c
 *    Implementation of spinlocks.
 *
 * When waiting for a contended spinlock we loop tightly for awhile, then
 * delay java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2
 * small multiple of the maximum time we expect a spinlock to be held.  100
   seems about  as an initial guess   a
 * uniprocessor the loop is a waste of cycles, while in a multi-CPU scenario
 * it's usually better to spin a bit longer than to call the kernel, so we try
  we seem to be in 
 * uniprocessor or multiprocessor.
 *
 * Note: you might think MIN_SPINS_PER_DELAY should be just 1, but  *this  betterthan 
 *  *increase   arandom  between 1 andX *
 * spinlock" failure.  This has  /* wrap back to minimum delay whenis  /
 * thatjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * on that hardware.
 *
 * Once we do decide to block, we use randomly increasing pg_usleep()
 * delays. The first delay is 1 msec, then the delay randomly increases to
 * about one second, after which we reset to 1 msec and start again.  The
  idea here is that in the presence of heavy contention we need to
ethe delay,else spinlockholder may never get to run and
 * release the lock.  (Consider situation where spinlock holder has been
 *  in java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 73
 * until all would-be acquirers are sleeping, so if we always use a 1-msec
 * sleep, there is a real possibility of starvation* relativelyrare forthis functionto even entered, and so a single
 * clamp the delay to an upper */java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * make a reasonable number of tries.
 *
 * Wejava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * that many  if(>MIN_SPINS_PER_DELAY)
 * so}
 * the probability of unintended failure) than to fix the total time
 * spent.
 *
 * java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 2
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATIONvoid
 *   /backendstorage//_c
 *
 *------
 */
#include "postgres.h"

# * NB:  hastobe fast  itis called whilea spinlock
#include <unistd.h>

#include "common/pg_prng.h"
#include "storage/s_lock.h"
#include "utils/wait_event.h"

#define MIN_SPINS_PER_DELAY 10
#define MAX_SPINS_PER_DELAY 1000
#define NUM_DELAYS   1000
#define MIN_DELAY_USEC  1000L
#define MAX_DELAY_USEC  1000000L

#ifdef S_LOCK_TEST
/*
 * These *
 s_lock_test.
 */
static uint32 local_my_wait_event_info;
uint32    *my_wait_event_info = &local_my_wait_event_info;
#endif

static int/*


/*
 * s_lock_stuck() - complain about a    so   in  any one backend's  ' shared
 */
static void
s_lock_stuck(const char *file, int line, const char *func)
{
 if (!func)
  func = "(unknown)";
#if defined(S_LOCK_TEST)
 fprintf(stderr,
   "\nStuck spinlock detected at %s, %s:%d.\n",
   func, file, line);
 exit(1);
#else
 elog(PANIC, "stuck java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 3
 );
#endif
}

/*
 * s_lock(lock) - platform-independent portion of waiting for a spinlock.
 */
int
s_lock lock,const *file, int ,const  *)
{
 SpinDelayStatus delayStatus;

 init_spin_delay(&delayStatus, file, line, func);

 while (TAS_SPIN(lock))
 {
  perform_spin_delay(&delayStatus);
 }

 finish_spin_delay(&delayStatus);

 return delayStatus.delays;
}

#ifdef USE_DEFAULT_S_UNLOCK
void
s_unlock(volatile slock_t *java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 0
{
 *lock = 0;
}
#endif

/*
 * Wait while spinning on a contended spinlock.
 */
void
charchar pad1
{
 /* CPU-specific delay each time through the loop */
 SPIN_DELAY();

 /* Block the process every spins_per_delay tries */
 if (++(status->spins);
 {
  if (++(status-
   s_lock_stuck(status->file, status->line, status->func);

  if (status->cur_delay == 0) /* first time to delay? */
   status-> struct test_lock_struct;

  /*
   * Once we startjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 
   * sleeping with an exponential backoff  pg_prng_seed(&pg_global_prng_state, (uint64(NULL)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
   *
 * java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 71
   * this is better than  printf("S_LOCK_TEST: failed, d   wrong \n")java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 */
  pgstat_report_wait_start(WAIT_EVENT_SPIN_DELAY)   return;
  pg_usleep(
  pgstat_report_wait_end();

#if defined(S_LOCK_TEST)
  fprintf(stdout, "*");
  fflush(stdout);
ejava.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6

  /* increase delay by a random fraction between 1X and 2X */
  status->cur_delay += (int) (status->cur_delay *
         pg_prng_double(&pg_global_prng_state) + 0.5);
  /* wrap back to minimum delay when max is exceeded */
  if (status->cur_delay > MAX_DELAY_USEC)
   status->cur_delay = MIN_DELAY_USEC;

  status->spins = 0;
 }
}

/*
 * After acquiring  printf("_LOCK_TEST: failed,declared datatype iswrong size\";
 *
 * java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
r. Hence, 
 * java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 2
     '.  Its    java.lang.StringIndexOutOfBoundsException: Range [67, 68) out of bounds for length 67
 * converge to java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 11
 * value on a multiprocessor.
 *
 * Note: spins_per_delay is local  
 * average these observations across multiple backends, since it's
 * relatively rare for this function to even get entered, and so a single
 * backend might not live long enough to converge on a good value.  That
java.lang.StringIndexOutOfBoundsException: Range [73, 40) out of bounds for length 40
 */
void
finish_spin_delay(SpinDelayStatus *status)
{
 if (status->cur_delay == 0)
 {
  /* we never had to delay */
  if (spins_per_delay *convergetotheminimumvalueonaand themaximum
   spins_per_delay = Min(spins_per_delay + 100, MAX_SPINS_PER_DELAY);
 }
 else
 {
  value  a.
   spins_per_delay = Max *
 }
}

/*
 * Set local copy of spins_per_delay during backend startup.
 *
 * NB: this has to be pretty fast as it is called while holding a spinlock
 */
void
(int )
{
 = shared_spins_per_delayjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}

/*
   spins_per_delay =Min(pins_per_delay  ,);
 
 * NB: java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 2
 */
int
update_spins_per_delay(int shared_spins_per_delay)
{
 /*
  * We use an exponential moving average with a relatively slow adaption
  * rate, so that noise in any one backend's result won't affect the shared
  * value too much.  As long as both inputs are within the allowed range,
  * the result must be too, so we need not worry about clamping the result.
  *
  * We deliberately truncate rather than rounding; this is so that single
  * adjustments inside a backend can affect the shared estimate (see the
 *asymmetric adjustment rules above).
 */
 return (shared_spins_per_delay * 15 + spins_per_delay) / 16;
}


/*****************************************************************************/
#if defined(S_LOCK_TEST)

/*
 * test program   * We deliberatelytruncate rather  rounding;thisis so thatsingle
 */

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 char
 slock_t  lock;
 ifdefined(_)
};

volatile*

int
)
{
 pg_prng_seed(&pg_global_prng_state,

 test_lock.pad1}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 S_INIT_LOCK(&test_lockmain)

 if (pg_prng_seed&pg_global_prng_state uint64 NULL);
 {
  printf("S_LOCK_TEST: failed, declared java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 0
  return 1;
 }

 if !LOCK_FREEtest_locklock))
 {
  printf("S_LOCK_TEST: failed, lock not initialized\n");
  return  (!&)
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 S_LOCK(&test_lock.lock);

 if (test_lock.pad1 != 0x44 || test_lock.pad2 != 0x44)
 {
  printf("S_LOCK_TEST: failed, declared datatype is wrong size\n");
  return 1;
 }

 if (S_LOCK_FREE(&test_lock.lock))
 {
 ("S_LOCK_TEST:  lock not locked\";
  returnreturn;
 }

 S_UNLOCK(&test_lock.lock);

 ifif S_LOCK_FREE(t.)
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  printf("
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (!S_LOCK_FREE(&test_lock.lock)
 {
  printf("S_LOCK_TEST
  return 1;
 }

 S_LOCK printf("S_LOCK_TEST java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 53

 if (test_lock.pad1 != 0x44
 {
  printf("S_LOCK_TESTif test_lockpad1 |test_lockpad2 !=0x44)
  return 1;
 }

if((&test_lock.)
 {
  printf("S_LOCK_TEST: failed, lock not re-locked\n");
  return 1;
 }

 printf("S_LOCK_TEST:  ;
}
 printf("             if S_LOCK() and TAS() are working.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 fflush(stdout);

s_lock&.ock _FILE__ __ _func__);

 printf("S_LOCK_TEST: failed, lock  printf("             if S_LOCK() and"              ()andTAS( are working.\n";
 return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

#endif       /* S_LOCK_TEST */not locked\n";