Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commitdf4077c

Browse files
committed
Remove volatile qualifiers from lwlock.c.
Now that spinlocks (hopefully!) act as compiler barriers, as of commit0709b7e, this should be safe. Thisserves as a demonstration of the new coding style, and may be optimizedbetter on some machines as well.
1 parente38da8d commitdf4077c

File tree

1 file changed

+50
-53
lines changed

1 file changed

+50
-53
lines changed

‎src/backend/storage/lmgr/lwlock.c‎

Lines changed: 50 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -112,7 +112,7 @@ static lwlock_stats lwlock_stats_dummy;
112112
boolTrace_lwlocks= false;
113113

114114
inlinestaticvoid
115-
PRINT_LWDEBUG(constchar*where,constvolatileLWLock*lock)
115+
PRINT_LWDEBUG(constchar*where,constLWLock*lock)
116116
{
117117
if (Trace_lwlocks)
118118
elog(LOG,"%s(%s %d): excl %d shared %d head %p rOK %d",
@@ -406,9 +406,7 @@ LWLock *
406406
LWLockAssign(void)
407407
{
408408
LWLock*result;
409-
410-
/* use volatile pointer to prevent code rearrangement */
411-
volatileint*LWLockCounter;
409+
int*LWLockCounter;
412410

413411
LWLockCounter= (int*) ((char*)MainLWLockArray-3*sizeof(int));
414412
SpinLockAcquire(ShmemLock);
@@ -429,9 +427,7 @@ int
429427
LWLockNewTrancheId(void)
430428
{
431429
intresult;
432-
433-
/* use volatile pointer to prevent code rearrangement */
434-
volatileint*LWLockCounter;
430+
int*LWLockCounter;
435431

436432
LWLockCounter= (int*) ((char*)MainLWLockArray-3*sizeof(int));
437433
SpinLockAcquire(ShmemLock);
@@ -511,9 +507,8 @@ LWLockAcquireWithVar(LWLock *l, uint64 *valptr, uint64 val)
511507

512508
/* internal function to implement LWLockAcquire and LWLockAcquireWithVar */
513509
staticinlinebool
514-
LWLockAcquireCommon(LWLock*l,LWLockModemode,uint64*valptr,uint64val)
510+
LWLockAcquireCommon(LWLock*lock,LWLockModemode,uint64*valptr,uint64val)
515511
{
516-
volatileLWLock*lock=l;
517512
PGPROC*proc=MyProc;
518513
boolretry= false;
519514
boolresult= true;
@@ -525,7 +520,7 @@ LWLockAcquireCommon(LWLock *l, LWLockMode mode, uint64 *valptr, uint64 val)
525520
PRINT_LWDEBUG("LWLockAcquire",lock);
526521

527522
#ifdefLWLOCK_STATS
528-
lwstats=get_lwlock_stats_entry(l);
523+
lwstats=get_lwlock_stats_entry(lock);
529524

530525
/* Count lock acquisition attempts */
531526
if (mode==LW_EXCLUSIVE)
@@ -642,13 +637,13 @@ LWLockAcquireCommon(LWLock *l, LWLockMode mode, uint64 *valptr, uint64 val)
642637
* so that the lock manager or signal manager will see the received
643638
* signal when it next waits.
644639
*/
645-
LOG_LWDEBUG("LWLockAcquire",T_NAME(l),T_ID(l),"waiting");
640+
LOG_LWDEBUG("LWLockAcquire",T_NAME(lock),T_ID(lock),"waiting");
646641

647642
#ifdefLWLOCK_STATS
648643
lwstats->block_count++;
649644
#endif
650645

651-
TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(l),T_ID(l),mode);
646+
TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock),T_ID(lock),mode);
652647

653648
for (;;)
654649
{
@@ -659,9 +654,9 @@ LWLockAcquireCommon(LWLock *l, LWLockMode mode, uint64 *valptr, uint64 val)
659654
extraWaits++;
660655
}
661656

662-
TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(l),T_ID(l),mode);
657+
TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock),T_ID(lock),mode);
663658

664-
LOG_LWDEBUG("LWLockAcquire",T_NAME(l),T_ID(l),"awakened");
659+
LOG_LWDEBUG("LWLockAcquire",T_NAME(lock),T_ID(lock),"awakened");
665660

666661
/* Now loop back and try to acquire lock again. */
667662
retry= true;
@@ -675,10 +670,10 @@ LWLockAcquireCommon(LWLock *l, LWLockMode mode, uint64 *valptr, uint64 val)
675670
/* We are done updating shared state of the lock itself. */
676671
SpinLockRelease(&lock->mutex);
677672

678-
TRACE_POSTGRESQL_LWLOCK_ACQUIRE(T_NAME(l),T_ID(l),mode);
673+
TRACE_POSTGRESQL_LWLOCK_ACQUIRE(T_NAME(lock),T_ID(lock),mode);
679674

680675
/* Add lock to list of locks held by this backend */
681-
held_lwlocks[num_held_lwlocks++]=l;
676+
held_lwlocks[num_held_lwlocks++]=lock;
682677

683678
/*
684679
* Fix the process wait semaphore's count for any absorbed wakeups.
@@ -697,9 +692,8 @@ LWLockAcquireCommon(LWLock *l, LWLockMode mode, uint64 *valptr, uint64 val)
697692
* If successful, cancel/die interrupts are held off until lock release.
698693
*/
699694
bool
700-
LWLockConditionalAcquire(LWLock*l,LWLockModemode)
695+
LWLockConditionalAcquire(LWLock*lock,LWLockModemode)
701696
{
702-
volatileLWLock*lock=l;
703697
boolmustwait;
704698

705699
PRINT_LWDEBUG("LWLockConditionalAcquire",lock);
@@ -747,14 +741,16 @@ LWLockConditionalAcquire(LWLock *l, LWLockMode mode)
747741
{
748742
/* Failed to get lock, so release interrupt holdoff */
749743
RESUME_INTERRUPTS();
750-
LOG_LWDEBUG("LWLockConditionalAcquire",T_NAME(l),T_ID(l),"failed");
751-
TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL(T_NAME(l),T_ID(l),mode);
744+
LOG_LWDEBUG("LWLockConditionalAcquire",
745+
T_NAME(lock),T_ID(lock),"failed");
746+
TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL(T_NAME(lock),
747+
T_ID(lock),mode);
752748
}
753749
else
754750
{
755751
/* Add lock to list of locks held by this backend */
756-
held_lwlocks[num_held_lwlocks++]=l;
757-
TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE(T_NAME(l),T_ID(l),mode);
752+
held_lwlocks[num_held_lwlocks++]=lock;
753+
TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE(T_NAME(lock),T_ID(lock),mode);
758754
}
759755

760756
return !mustwait;
@@ -775,9 +771,8 @@ LWLockConditionalAcquire(LWLock *l, LWLockMode mode)
775771
* wake up, observe that their records have already been flushed, and return.
776772
*/
777773
bool
778-
LWLockAcquireOrWait(LWLock*l,LWLockModemode)
774+
LWLockAcquireOrWait(LWLock*lock,LWLockModemode)
779775
{
780-
volatileLWLock*lock=l;
781776
PGPROC*proc=MyProc;
782777
boolmustwait;
783778
intextraWaits=0;
@@ -788,7 +783,7 @@ LWLockAcquireOrWait(LWLock *l, LWLockMode mode)
788783
PRINT_LWDEBUG("LWLockAcquireOrWait",lock);
789784

790785
#ifdefLWLOCK_STATS
791-
lwstats=get_lwlock_stats_entry(l);
786+
lwstats=get_lwlock_stats_entry(lock);
792787
#endif
793788

794789
/* Ensure we will have room to remember the lock */
@@ -855,13 +850,14 @@ LWLockAcquireOrWait(LWLock *l, LWLockMode mode)
855850
* Wait until awakened. Like in LWLockAcquire, be prepared for bogus
856851
* wakups, because we share the semaphore with ProcWaitForSignal.
857852
*/
858-
LOG_LWDEBUG("LWLockAcquireOrWait",T_NAME(l),T_ID(l),"waiting");
853+
LOG_LWDEBUG("LWLockAcquireOrWait",T_NAME(lock),T_ID(lock),
854+
"waiting");
859855

860856
#ifdefLWLOCK_STATS
861857
lwstats->block_count++;
862858
#endif
863859

864-
TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(l),T_ID(l),mode);
860+
TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock),T_ID(lock),mode);
865861

866862
for (;;)
867863
{
@@ -872,9 +868,10 @@ LWLockAcquireOrWait(LWLock *l, LWLockMode mode)
872868
extraWaits++;
873869
}
874870

875-
TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(l),T_ID(l),mode);
871+
TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock),T_ID(lock),mode);
876872

877-
LOG_LWDEBUG("LWLockAcquireOrWait",T_NAME(l),T_ID(l),"awakened");
873+
LOG_LWDEBUG("LWLockAcquireOrWait",T_NAME(lock),T_ID(lock),
874+
"awakened");
878875
}
879876
else
880877
{
@@ -892,14 +889,16 @@ LWLockAcquireOrWait(LWLock *l, LWLockMode mode)
892889
{
893890
/* Failed to get lock, so release interrupt holdoff */
894891
RESUME_INTERRUPTS();
895-
LOG_LWDEBUG("LWLockAcquireOrWait",T_NAME(l),T_ID(l),"failed");
896-
TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_FAIL(T_NAME(l),T_ID(l),mode);
892+
LOG_LWDEBUG("LWLockAcquireOrWait",T_NAME(lock),T_ID(lock),"failed");
893+
TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_FAIL(T_NAME(lock),T_ID(lock),
894+
mode);
897895
}
898896
else
899897
{
900898
/* Add lock to list of locks held by this backend */
901-
held_lwlocks[num_held_lwlocks++]=l;
902-
TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT(T_NAME(l),T_ID(l),mode);
899+
held_lwlocks[num_held_lwlocks++]=lock;
900+
TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT(T_NAME(lock),T_ID(lock),
901+
mode);
903902
}
904903

905904
return !mustwait;
@@ -924,10 +923,8 @@ LWLockAcquireOrWait(LWLock *l, LWLockMode mode)
924923
* in shared mode, returns 'true'.
925924
*/
926925
bool
927-
LWLockWaitForVar(LWLock*l,uint64*valptr,uint64oldval,uint64*newval)
926+
LWLockWaitForVar(LWLock*lock,uint64*valptr,uint64oldval,uint64*newval)
928927
{
929-
volatileLWLock*lock=l;
930-
volatileuint64*valp=valptr;
931928
PGPROC*proc=MyProc;
932929
intextraWaits=0;
933930
boolresult= false;
@@ -938,7 +935,7 @@ LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
938935
PRINT_LWDEBUG("LWLockWaitForVar",lock);
939936

940937
#ifdefLWLOCK_STATS
941-
lwstats=get_lwlock_stats_entry(l);
938+
lwstats=get_lwlock_stats_entry(lock);
942939
#endif/* LWLOCK_STATS */
943940

944941
/*
@@ -981,7 +978,7 @@ LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
981978
}
982979
else
983980
{
984-
value=*valp;
981+
value=*valptr;
985982
if (value!=oldval)
986983
{
987984
result= false;
@@ -1023,13 +1020,14 @@ LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
10231020
* so that the lock manager or signal manager will see the received
10241021
* signal when it next waits.
10251022
*/
1026-
LOG_LWDEBUG("LWLockWaitForVar",T_NAME(l),T_ID(l),"waiting");
1023+
LOG_LWDEBUG("LWLockWaitForVar",T_NAME(lock),T_ID(lock),"waiting");
10271024

10281025
#ifdefLWLOCK_STATS
10291026
lwstats->block_count++;
10301027
#endif
10311028

1032-
TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(l),T_ID(l),LW_EXCLUSIVE);
1029+
TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock),T_ID(lock),
1030+
LW_EXCLUSIVE);
10331031

10341032
for (;;)
10351033
{
@@ -1040,17 +1038,18 @@ LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
10401038
extraWaits++;
10411039
}
10421040

1043-
TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(l),T_ID(l),LW_EXCLUSIVE);
1041+
TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock),T_ID(lock),
1042+
LW_EXCLUSIVE);
10441043

1045-
LOG_LWDEBUG("LWLockWaitForVar",T_NAME(l),T_ID(l),"awakened");
1044+
LOG_LWDEBUG("LWLockWaitForVar",T_NAME(lock),T_ID(lock),"awakened");
10461045

10471046
/* Now loop back and check the status of the lock again. */
10481047
}
10491048

10501049
/* We are done updating shared state of the lock itself. */
10511050
SpinLockRelease(&lock->mutex);
10521051

1053-
TRACE_POSTGRESQL_LWLOCK_ACQUIRE(T_NAME(l),T_ID(l),LW_EXCLUSIVE);
1052+
TRACE_POSTGRESQL_LWLOCK_ACQUIRE(T_NAME(lock),T_ID(lock),LW_EXCLUSIVE);
10541053

10551054
/*
10561055
* Fix the process wait semaphore's count for any absorbed wakeups.
@@ -1078,10 +1077,8 @@ LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
10781077
* The caller must be holding the lock in exclusive mode.
10791078
*/
10801079
void
1081-
LWLockUpdateVar(LWLock*l,uint64*valptr,uint64val)
1080+
LWLockUpdateVar(LWLock*lock,uint64*valptr,uint64val)
10821081
{
1083-
volatileLWLock*lock=l;
1084-
volatileuint64*valp=valptr;
10851082
PGPROC*head;
10861083
PGPROC*proc;
10871084
PGPROC*next;
@@ -1093,7 +1090,7 @@ LWLockUpdateVar(LWLock *l, uint64 *valptr, uint64 val)
10931090
Assert(lock->exclusive==1);
10941091

10951092
/* Update the lock's value */
1096-
*valp=val;
1093+
*valptr=val;
10971094

10981095
/*
10991096
* See if there are any LW_WAIT_UNTIL_FREE waiters that need to be woken
@@ -1139,9 +1136,8 @@ LWLockUpdateVar(LWLock *l, uint64 *valptr, uint64 val)
11391136
* LWLockRelease - release a previously acquired lock
11401137
*/
11411138
void
1142-
LWLockRelease(LWLock*l)
1139+
LWLockRelease(LWLock*lock)
11431140
{
1144-
volatileLWLock*lock=l;
11451141
PGPROC*head;
11461142
PGPROC*proc;
11471143
inti;
@@ -1154,11 +1150,11 @@ LWLockRelease(LWLock *l)
11541150
*/
11551151
for (i=num_held_lwlocks;--i >=0;)
11561152
{
1157-
if (l==held_lwlocks[i])
1153+
if (lock==held_lwlocks[i])
11581154
break;
11591155
}
11601156
if (i<0)
1161-
elog(ERROR,"lock %s %d is not held",T_NAME(l),T_ID(l));
1157+
elog(ERROR,"lock %s %d is not held",T_NAME(lock),T_ID(lock));
11621158
num_held_lwlocks--;
11631159
for (;i<num_held_lwlocks;i++)
11641160
held_lwlocks[i]=held_lwlocks[i+1];
@@ -1238,14 +1234,15 @@ LWLockRelease(LWLock *l)
12381234
/* We are done updating shared state of the lock itself. */
12391235
SpinLockRelease(&lock->mutex);
12401236

1241-
TRACE_POSTGRESQL_LWLOCK_RELEASE(T_NAME(l),T_ID(l));
1237+
TRACE_POSTGRESQL_LWLOCK_RELEASE(T_NAME(lock),T_ID(lock));
12421238

12431239
/*
12441240
* Awaken any waiters I removed from the queue.
12451241
*/
12461242
while (head!=NULL)
12471243
{
1248-
LOG_LWDEBUG("LWLockRelease",T_NAME(l),T_ID(l),"release waiter");
1244+
LOG_LWDEBUG("LWLockRelease",T_NAME(lock),T_ID(lock),
1245+
"release waiter");
12491246
proc=head;
12501247
head=proc->lwWaitLink;
12511248
proc->lwWaitLink=NULL;

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp