Marginal performance improvement in LockBuffer --- calculate address

tglsfdc · tglsfdc · commit c40a0a1b52a0 · 2000-03-14T22:46:27.000Z
of BufferLocks[] entry just once.  Seems to save 10% or so of the
routine's runtime, which'd not be worth worrying about if it weren't
such a hotspot.
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.75 2000/02/21 18:49:00 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.76 2000/03/14 22:46:27 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -2072,12 +2072,14 @@ void
 LockBuffer(Buffer buffer, int mode)
 {
 	BufferDesc *buf;
+	bits8 *buflock;
 
 	Assert(BufferIsValid(buffer));
 	if (BufferIsLocal(buffer))
 		return;
 
 	buf = &(BufferDescriptors[buffer - 1]);
+	buflock = &(BufferLocks[buffer - 1]);
 
 #ifdef HAS_TEST_AND_SET
 	S_LOCK(&(buf->cntx_lock));
@@ -2087,21 +2089,21 @@ LockBuffer(Buffer buffer, int mode)
 
 	if (mode == BUFFER_LOCK_UNLOCK)
 	{
-		if (BufferLocks[buffer - 1] & BL_R_LOCK)
+		if (*buflock & BL_R_LOCK)
 		{
 			Assert(buf->r_locks > 0);
 			Assert(!(buf->w_lock));
-			Assert(!(BufferLocks[buffer - 1] & (BL_W_LOCK | BL_RI_LOCK)))
-				(buf->r_locks)--;
-			BufferLocks[buffer - 1] &= ~BL_R_LOCK;
+			Assert(!(*buflock & (BL_W_LOCK | BL_RI_LOCK)));
+			(buf->r_locks)--;
+			*buflock &= ~BL_R_LOCK;
 		}
-		else if (BufferLocks[buffer - 1] & BL_W_LOCK)
+		else if (*buflock & BL_W_LOCK)
 		{
 			Assert(buf->w_lock);
 			Assert(buf->r_locks == 0);
-			Assert(!(BufferLocks[buffer - 1] & (BL_R_LOCK | BL_RI_LOCK)))
-				buf->w_lock = false;
-			BufferLocks[buffer - 1] &= ~BL_W_LOCK;
+			Assert(!(*buflock & (BL_R_LOCK | BL_RI_LOCK)));
+			buf->w_lock = false;
+			*buflock &= ~BL_W_LOCK;
 		}
 		else
 			elog(ERROR, "UNLockBuffer: buffer %lu is not locked", buffer);
@@ -2110,7 +2112,7 @@ LockBuffer(Buffer buffer, int mode)
 	{
 		unsigned	i = 0;
 
-		Assert(!(BufferLocks[buffer - 1] & (BL_R_LOCK | BL_W_LOCK | BL_RI_LOCK)));
+		Assert(!(*buflock & (BL_R_LOCK | BL_W_LOCK | BL_RI_LOCK)));
 		while (buf->ri_lock || buf->w_lock)
 		{
 #ifdef HAS_TEST_AND_SET
@@ -2124,24 +2126,24 @@ LockBuffer(Buffer buffer, int mode)
 #endif
 		}
 		(buf->r_locks)++;
-		BufferLocks[buffer - 1] |= BL_R_LOCK;
+		*buflock |= BL_R_LOCK;
 	}
 	else if (mode == BUFFER_LOCK_EXCLUSIVE)
 	{
 		unsigned	i = 0;
 
-		Assert(!(BufferLocks[buffer - 1] & (BL_R_LOCK | BL_W_LOCK | BL_RI_LOCK)));
+		Assert(!(*buflock & (BL_R_LOCK | BL_W_LOCK | BL_RI_LOCK)));
 		while (buf->r_locks > 0 || buf->w_lock)
 		{
-			if (buf->r_locks > 3 || (BufferLocks[buffer - 1] & BL_RI_LOCK))
+			if (buf->r_locks > 3 || (*buflock & BL_RI_LOCK))
 			{
 				/*
 				 * Our RI lock might be removed by concurrent W lock
 				 * acquiring (see what we do with RI locks below
 				 * when our own W acquiring succeeded) and so
 				 * we set RI lock again if we already did this.
 				 */
-				BufferLocks[buffer - 1] |= BL_RI_LOCK;
+				*buflock |= BL_RI_LOCK;
 				buf->ri_lock = true;
 			}
 #ifdef HAS_TEST_AND_SET
@@ -2155,15 +2157,15 @@ LockBuffer(Buffer buffer, int mode)
 #endif
 		}
 		buf->w_lock = true;
-		BufferLocks[buffer - 1] |= BL_W_LOCK;
-		if (BufferLocks[buffer - 1] & BL_RI_LOCK)
+		*buflock |= BL_W_LOCK;
+		if (*buflock & BL_RI_LOCK)
 		{
 			/*
 			 * It's possible to remove RI locks acquired by another
 			 * W lockers here, but they'll take care about it.
 			 */
 			buf->ri_lock = false;
-			BufferLocks[buffer - 1] &= ~BL_RI_LOCK;
+			*buflock &= ~BL_RI_LOCK;
 		}
 	}
 	else

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`	`*`
`9`	`9`	`*`
`10`	`10`	`* IDENTIFICATION`
`11`		`- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.75 2000/02/21 18:49:00 tgl Exp $`
	`11`	`+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.76 2000/03/14 22:46:27 tgl Exp $`
`12`	`12`	`*`
`13`	`13`	`*-------------------------------------------------------------------------`
`14`	`14`	`*/`
`@@ -2072,12 +2072,14 @@ void`
`2072`	`2072`	`LockBuffer(Buffer buffer, int mode)`
`2073`	`2073`	`{`
`2074`	`2074`	`BufferDesc *buf;`
	`2075`	`+ bits8 *buflock;`
`2075`	`2076`
`2076`	`2077`	`Assert(BufferIsValid(buffer));`
`2077`	`2078`	`if (BufferIsLocal(buffer))`
`2078`	`2079`	`return;`
`2079`	`2080`
`2080`	`2081`	`buf = &(BufferDescriptors[buffer - 1]);`
	`2082`	`+ buflock = &(BufferLocks[buffer - 1]);`
`2081`	`2083`
`2082`	`2084`	`#ifdef HAS_TEST_AND_SET`
`2083`	`2085`	`S_LOCK(&(buf->cntx_lock));`
`@@ -2087,21 +2089,21 @@ LockBuffer(Buffer buffer, int mode)`
`2087`	`2089`
`2088`	`2090`	`if (mode == BUFFER_LOCK_UNLOCK)`
`2089`	`2091`	`{`
`2090`		`- if (BufferLocks[buffer - 1] & BL_R_LOCK)`
	`2092`	`+ if (*buflock & BL_R_LOCK)`
`2091`	`2093`	`{`
`2092`	`2094`	`Assert(buf->r_locks > 0);`
`2093`	`2095`	`Assert(!(buf->w_lock));`
`2094`		`- Assert(!(BufferLocks[buffer - 1] & (BL_W_LOCK \| BL_RI_LOCK)))`
`2095`		`- (buf->r_locks)--;`
`2096`		`- BufferLocks[buffer - 1] &= ~BL_R_LOCK;`
	`2096`	`+ Assert(!(*buflock & (BL_W_LOCK \| BL_RI_LOCK)));`
	`2097`	`+ (buf->r_locks)--;`
	`2098`	`+ *buflock &= ~BL_R_LOCK;`
`2097`	`2099`	`}`
`2098`		`- else if (BufferLocks[buffer - 1] & BL_W_LOCK)`
	`2100`	`+ else if (*buflock & BL_W_LOCK)`
`2099`	`2101`	`{`
`2100`	`2102`	`Assert(buf->w_lock);`
`2101`	`2103`	`Assert(buf->r_locks == 0);`
`2102`		`- Assert(!(BufferLocks[buffer - 1] & (BL_R_LOCK \| BL_RI_LOCK)))`
`2103`		`- buf->w_lock = false;`
`2104`		`- BufferLocks[buffer - 1] &= ~BL_W_LOCK;`
	`2104`	`+ Assert(!(*buflock & (BL_R_LOCK \| BL_RI_LOCK)));`
	`2105`	`+ buf->w_lock = false;`
	`2106`	`+ *buflock &= ~BL_W_LOCK;`
`2105`	`2107`	`}`
`2106`	`2108`	`else`
`2107`	`2109`	`elog(ERROR, "UNLockBuffer: buffer %lu is not locked", buffer);`
`@@ -2110,7 +2112,7 @@ LockBuffer(Buffer buffer, int mode)`
`2110`	`2112`	`{`
`2111`	`2113`	`unsigned i = 0;`
`2112`	`2114`
`2113`		`- Assert(!(BufferLocks[buffer - 1] & (BL_R_LOCK \| BL_W_LOCK \| BL_RI_LOCK)));`
	`2115`	`+ Assert(!(*buflock & (BL_R_LOCK \| BL_W_LOCK \| BL_RI_LOCK)));`
`2114`	`2116`	`while (buf->ri_lock \|\| buf->w_lock)`
`2115`	`2117`	`{`
`2116`	`2118`	`#ifdef HAS_TEST_AND_SET`
`@@ -2124,24 +2126,24 @@ LockBuffer(Buffer buffer, int mode)`
`2124`	`2126`	`#endif`
`2125`	`2127`	`}`
`2126`	`2128`	`(buf->r_locks)++;`
`2127`		`- BufferLocks[buffer - 1] \|= BL_R_LOCK;`
	`2129`	`+ *buflock \|= BL_R_LOCK;`
`2128`	`2130`	`}`
`2129`	`2131`	`else if (mode == BUFFER_LOCK_EXCLUSIVE)`
`2130`	`2132`	`{`
`2131`	`2133`	`unsigned i = 0;`
`2132`	`2134`
`2133`		`- Assert(!(BufferLocks[buffer - 1] & (BL_R_LOCK \| BL_W_LOCK \| BL_RI_LOCK)));`
	`2135`	`+ Assert(!(*buflock & (BL_R_LOCK \| BL_W_LOCK \| BL_RI_LOCK)));`
`2134`	`2136`	`while (buf->r_locks > 0 \|\| buf->w_lock)`
`2135`	`2137`	`{`
`2136`		`- if (buf->r_locks > 3 \|\| (BufferLocks[buffer - 1] & BL_RI_LOCK))`
	`2138`	`+ if (buf->r_locks > 3 \|\| (*buflock & BL_RI_LOCK))`
`2137`	`2139`	`{`
`2138`	`2140`	`/*`
`2139`	`2141`	`* Our RI lock might be removed by concurrent W lock`
`2140`	`2142`	`* acquiring (see what we do with RI locks below`
`2141`	`2143`	`* when our own W acquiring succeeded) and so`
`2142`	`2144`	`* we set RI lock again if we already did this.`
`2143`	`2145`	`*/`
`2144`		`- BufferLocks[buffer - 1] \|= BL_RI_LOCK;`
	`2146`	`+ *buflock \|= BL_RI_LOCK;`
`2145`	`2147`	`buf->ri_lock = true;`
`2146`	`2148`	`}`
`2147`	`2149`	`#ifdef HAS_TEST_AND_SET`
`@@ -2155,15 +2157,15 @@ LockBuffer(Buffer buffer, int mode)`
`2155`	`2157`	`#endif`
`2156`	`2158`	`}`
`2157`	`2159`	`buf->w_lock = true;`
`2158`		`- BufferLocks[buffer - 1] \|= BL_W_LOCK;`
`2159`		`- if (BufferLocks[buffer - 1] & BL_RI_LOCK)`
	`2160`	`+ *buflock \|= BL_W_LOCK;`
	`2161`	`+ if (*buflock & BL_RI_LOCK)`
`2160`	`2162`	`{`
`2161`	`2163`	`/*`
`2162`	`2164`	`* It's possible to remove RI locks acquired by another`
`2163`	`2165`	`* W lockers here, but they'll take care about it.`
`2164`	`2166`	`*/`
`2165`	`2167`	`buf->ri_lock = false;`
`2166`		`- BufferLocks[buffer - 1] &= ~BL_RI_LOCK;`
	`2168`	`+ *buflock &= ~BL_RI_LOCK;`
`2167`	`2169`	`}`
`2168`	`2170`	`}`
`2169`	`2171`	`else`