open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Convert macros to static inline functions (buf_internals.h)

Browse Source 
Dilip Kumar, reviewed by Vignesh C, Ashutosh Sharma, and me.

Discussion: http://postgr.es/m/CAFiTN-tYbM7D+2UGiNc2kAFMSQTa5FTeYvmg-Vj2HvPdVw2Gvg@mail.gmail.com
pull/95/head
Robert Haas 3 years ago
parent 03361a368e
commit 3ac88fddd9
4 changed files with 112 additions and 76 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      src/backend/storage/buffer/buf_init.c
  2. 16
      src/backend/storage/buffer/bufmgr.c
  3. 12
      src/backend/storage/buffer/localbuf.c
  4. 158
      src/include/storage/buf_internals.h

2
src/backend/storage/buffer/buf_init.c
Unescape View File

@ -116,7 +116,7 @@ InitBufferPool(void)
{ {
BufferDesc *buf = GetBufferDescriptor(i); BufferDesc *buf = GetBufferDescriptor(i);
CLEAR_BUFFERTAG(buf->tag); ClearBufferTag(&buf->tag);
pg_atomic_init_u32(&buf->state, 0); pg_atomic_init_u32(&buf->state, 0);
buf->wait_backend_pgprocno = INVALID_PGPROCNO; buf->wait_backend_pgprocno = INVALID_PGPROCNO;

16
src/backend/storage/buffer/bufmgr.c
Unescape View File

@ -515,7 +515,7 @@ PrefetchSharedBuffer(SMgrRelation smgr_reln,
Assert(BlockNumberIsValid(blockNum)); Assert(BlockNumberIsValid(blockNum));
/* create a tag so we can lookup the buffer */ /* create a tag so we can lookup the buffer */
INIT_BUFFERTAG(newTag, smgr_reln->smgr_rlocator.locator, InitBufferTag(&newTag, &smgr_reln->smgr_rlocator.locator,
forkNum, blockNum); forkNum, blockNum);
/* determine its hash code and partition lock ID */ /* determine its hash code and partition lock ID */
@ -632,7 +632,7 @@ ReadRecentBuffer(RelFileLocator rlocator, ForkNumber forkNum, BlockNumber blockN
ResourceOwnerEnlargeBuffers(CurrentResourceOwner); ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
ReservePrivateRefCountEntry(); ReservePrivateRefCountEntry();
INIT_BUFFERTAG(tag, rlocator, forkNum, blockNum); InitBufferTag(&tag, &rlocator, forkNum, blockNum);
if (BufferIsLocal(recent_buffer)) if (BufferIsLocal(recent_buffer))
{ {
@ -642,7 +642,7 @@ ReadRecentBuffer(RelFileLocator rlocator, ForkNumber forkNum, BlockNumber blockN
buf_state = pg_atomic_read_u32(&bufHdr->state); buf_state = pg_atomic_read_u32(&bufHdr->state);
/* Is it still valid and holding the right tag? */ /* Is it still valid and holding the right tag? */
if ((buf_state & BM_VALID) && BUFFERTAGS_EQUAL(tag, bufHdr->tag)) if ((buf_state & BM_VALID) && BufferTagsEqual(&tag, &bufHdr->tag))
{ {
/* /*
* Bump buffer's ref and usage counts. This is equivalent of * Bump buffer's ref and usage counts. This is equivalent of
@ -679,7 +679,7 @@ ReadRecentBuffer(RelFileLocator rlocator, ForkNumber forkNum, BlockNumber blockN
else else
buf_state = LockBufHdr(bufHdr); buf_state = LockBufHdr(bufHdr);
if ((buf_state & BM_VALID) && BUFFERTAGS_EQUAL(tag, bufHdr->tag)) if ((buf_state & BM_VALID) && BufferTagsEqual(&tag, &bufHdr->tag))
{ {
/* /*
* It's now safe to pin the buffer. We can't pin first and ask * It's now safe to pin the buffer. We can't pin first and ask
@ -1134,7 +1134,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
uint32 buf_state; uint32 buf_state;
/* create a tag so we can lookup the buffer */ /* create a tag so we can lookup the buffer */
INIT_BUFFERTAG(newTag, smgr->smgr_rlocator.locator, forkNum, blockNum); InitBufferTag(&newTag, &smgr->smgr_rlocator.locator, forkNum, blockNum);
/* determine its hash code and partition lock ID */ /* determine its hash code and partition lock ID */
newHash = BufTableHashCode(&newTag); newHash = BufTableHashCode(&newTag);
@ -1517,7 +1517,7 @@ retry:
buf_state = LockBufHdr(buf); buf_state = LockBufHdr(buf);
/* If it's changed while we were waiting for lock, do nothing */ /* If it's changed while we were waiting for lock, do nothing */
if (!BUFFERTAGS_EQUAL(buf->tag, oldTag)) if (!BufferTagsEqual(&buf->tag, &oldTag))
{ {
UnlockBufHdr(buf, buf_state); UnlockBufHdr(buf, buf_state);
LWLockRelease(oldPartitionLock); LWLockRelease(oldPartitionLock);
@ -1549,7 +1549,7 @@ retry:
* linear scans of the buffer array don't think the buffer is valid. * linear scans of the buffer array don't think the buffer is valid.
*/ */
oldFlags = buf_state & BUF_FLAG_MASK; oldFlags = buf_state & BUF_FLAG_MASK;
CLEAR_BUFFERTAG(buf->tag); ClearBufferTag(&buf->tag);
buf_state &= ~(BUF_FLAG_MASK | BUF_USAGECOUNT_MASK); buf_state &= ~(BUF_FLAG_MASK | BUF_USAGECOUNT_MASK);
UnlockBufHdr(buf, buf_state); UnlockBufHdr(buf, buf_state);
@ -3365,7 +3365,7 @@ FindAndDropRelationBuffers(RelFileLocator rlocator, ForkNumber forkNum,
uint32 buf_state; uint32 buf_state;
/* create a tag so we can lookup the buffer */ /* create a tag so we can lookup the buffer */
INIT_BUFFERTAG(bufTag, rlocator, forkNum, curBlock); InitBufferTag(&bufTag, &rlocator, forkNum, curBlock);
/* determine its hash code and partition lock ID */ /* determine its hash code and partition lock ID */
bufHash = BufTableHashCode(&bufTag); bufHash = BufTableHashCode(&bufTag);

12
src/backend/storage/buffer/localbuf.c
Unescape View File

@ -68,7 +68,7 @@ PrefetchLocalBuffer(SMgrRelation smgr, ForkNumber forkNum,
BufferTag newTag; /* identity of requested block */ BufferTag newTag; /* identity of requested block */
LocalBufferLookupEnt *hresult; LocalBufferLookupEnt *hresult;
INIT_BUFFERTAG(newTag, smgr->smgr_rlocator.locator, forkNum, blockNum); InitBufferTag(&newTag, &smgr->smgr_rlocator.locator, forkNum, blockNum);
/* Initialize local buffers if first request in this session */ /* Initialize local buffers if first request in this session */
if (LocalBufHash == NULL) if (LocalBufHash == NULL)
@ -117,7 +117,7 @@ LocalBufferAlloc(SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum,
bool found; bool found;
uint32 buf_state; uint32 buf_state;
INIT_BUFFERTAG(newTag, smgr->smgr_rlocator.locator, forkNum, blockNum); InitBufferTag(&newTag, &smgr->smgr_rlocator.locator, forkNum, blockNum);
/* Initialize local buffers if first request in this session */ /* Initialize local buffers if first request in this session */
if (LocalBufHash == NULL) if (LocalBufHash == NULL)
@ -131,7 +131,7 @@ LocalBufferAlloc(SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum,
{ {
b = hresult->id; b = hresult->id;
bufHdr = GetLocalBufferDescriptor(b); bufHdr = GetLocalBufferDescriptor(b);
Assert(BUFFERTAGS_EQUAL(bufHdr->tag, newTag)); Assert(BufferTagsEqual(&bufHdr->tag, &newTag));
#ifdef LBDEBUG #ifdef LBDEBUG
fprintf(stderr, "LB ALLOC (%u,%d,%d) %d\n", fprintf(stderr, "LB ALLOC (%u,%d,%d) %d\n",
smgr->smgr_rlocator.locator.relNumber, forkNum, blockNum, -b - 1); smgr->smgr_rlocator.locator.relNumber, forkNum, blockNum, -b - 1);
@ -253,7 +253,7 @@ LocalBufferAlloc(SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum,
if (!hresult) /* shouldn't happen */ if (!hresult) /* shouldn't happen */
elog(ERROR, "local buffer hash table corrupted"); elog(ERROR, "local buffer hash table corrupted");
/* mark buffer invalid just in case hash insert fails */ /* mark buffer invalid just in case hash insert fails */
CLEAR_BUFFERTAG(bufHdr->tag); ClearBufferTag(&bufHdr->tag);
buf_state &= ~(BM_VALID | BM_TAG_VALID); buf_state &= ~(BM_VALID | BM_TAG_VALID);
pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state); pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
} }
@ -354,7 +354,7 @@ DropRelationLocalBuffers(RelFileLocator rlocator, ForkNumber forkNum,
if (!hresult) /* shouldn't happen */ if (!hresult) /* shouldn't happen */
elog(ERROR, "local buffer hash table corrupted"); elog(ERROR, "local buffer hash table corrupted");
/* Mark buffer invalid */ /* Mark buffer invalid */
CLEAR_BUFFERTAG(bufHdr->tag); ClearBufferTag(&bufHdr->tag);
buf_state &= ~BUF_FLAG_MASK; buf_state &= ~BUF_FLAG_MASK;
buf_state &= ~BUF_USAGECOUNT_MASK; buf_state &= ~BUF_USAGECOUNT_MASK;
pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state); pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
@ -398,7 +398,7 @@ DropRelationAllLocalBuffers(RelFileLocator rlocator)
if (!hresult) /* shouldn't happen */ if (!hresult) /* shouldn't happen */
elog(ERROR, "local buffer hash table corrupted"); elog(ERROR, "local buffer hash table corrupted");
/* Mark buffer invalid */ /* Mark buffer invalid */
CLEAR_BUFFERTAG(bufHdr->tag); ClearBufferTag(&bufHdr->tag);
buf_state &= ~BUF_FLAG_MASK; buf_state &= ~BUF_FLAG_MASK;
buf_state &= ~BUF_USAGECOUNT_MASK; buf_state &= ~BUF_USAGECOUNT_MASK;
pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state); pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);

158
src/include/storage/buf_internals.h
Unescape View File

@ -85,7 +85,7 @@
* relation is visible yet (its xact may have started before the xact that * relation is visible yet (its xact may have started before the xact that
* created the rel). The storage manager must be able to cope anyway. * created the rel). The storage manager must be able to cope anyway.
* *
* Note: if there's any pad bytes in the struct, INIT_BUFFERTAG will have * Note: if there's any pad bytes in the struct, InitBufferTag will have
* to be fixed to zero them, since this struct is used as a hash key. * to be fixed to zero them, since this struct is used as a hash key.
*/ */
typedef struct buftag typedef struct buftag
@ -95,28 +95,32 @@ typedef struct buftag
BlockNumber blockNum; /* blknum relative to begin of reln */ BlockNumber blockNum; /* blknum relative to begin of reln */
} BufferTag; } BufferTag;
#define CLEAR_BUFFERTAG(a) \ static inline void
( \ ClearBufferTag(BufferTag *tag)
(a).rlocator.spcOid = InvalidOid, \ {
(a).rlocator.dbOid = InvalidOid, \ tag->rlocator.spcOid = InvalidOid;
(a).rlocator.relNumber = InvalidRelFileNumber, \ tag->rlocator.dbOid = InvalidOid;
(a).forkNum = InvalidForkNumber, \ tag->rlocator.relNumber = InvalidRelFileNumber;
(a).blockNum = InvalidBlockNumber \ tag->forkNum = InvalidForkNumber;
) tag->blockNum = InvalidBlockNumber;
}
#define INIT_BUFFERTAG(a,xx_rlocator,xx_forkNum,xx_blockNum) \
( \ static inline void
(a).rlocator = (xx_rlocator), \ InitBufferTag(BufferTag *tag, const RelFileLocator *rlocator,
(a).forkNum = (xx_forkNum), \ ForkNumber forkNum, BlockNumber blockNum)
(a).blockNum = (xx_blockNum) \ {
) tag->rlocator = *rlocator;
tag->forkNum = forkNum;
#define BUFFERTAGS_EQUAL(a,b) \ tag->blockNum = blockNum;
( \ }
RelFileLocatorEquals((a).rlocator, (b).rlocator) && \
(a).blockNum == (b).blockNum && \ static inline bool
(a).forkNum == (b).forkNum \ BufferTagsEqual(const BufferTag *tag1, const BufferTag *tag2)
) {
return RelFileLocatorEquals(tag1->rlocator, tag2->rlocator) &&
(tag1->blockNum == tag2->blockNum) &&
(tag1->forkNum == tag2->forkNum);
}
/* /*
* The shared buffer mapping table is partitioned to reduce contention. * The shared buffer mapping table is partitioned to reduce contention.
@ -124,13 +128,24 @@ typedef struct buftag
* hash code with BufTableHashCode(), then apply BufMappingPartitionLock(). * hash code with BufTableHashCode(), then apply BufMappingPartitionLock().
* NB: NUM_BUFFER_PARTITIONS must be a power of 2! * NB: NUM_BUFFER_PARTITIONS must be a power of 2!
*/ */
#define BufTableHashPartition(hashcode) \ static inline uint32
((hashcode) % NUM_BUFFER_PARTITIONS) BufTableHashPartition(uint32 hashcode)
#define BufMappingPartitionLock(hashcode) \ {
(&MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET + \ return hashcode % NUM_BUFFER_PARTITIONS;
BufTableHashPartition(hashcode)].lock) }
#define BufMappingPartitionLockByIndex(i) \
(&MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET + (i)].lock) static inline LWLock *
BufMappingPartitionLock(uint32 hashcode)
{
return &MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET +
BufTableHashPartition(hashcode)].lock;
}
static inline LWLock *
BufMappingPartitionLockByIndex(uint32 index)
{
return &MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET + index].lock;
}
/* /*
* BufferDesc -- shared descriptor/state data for a single shared buffer. * BufferDesc -- shared descriptor/state data for a single shared buffer.
@ -220,37 +235,6 @@ typedef union BufferDescPadded
char pad[BUFFERDESC_PAD_TO_SIZE]; char pad[BUFFERDESC_PAD_TO_SIZE];
} BufferDescPadded; } BufferDescPadded;
#define GetBufferDescriptor(id) (&BufferDescriptors[(id)].bufferdesc)
#define GetLocalBufferDescriptor(id) (&LocalBufferDescriptors[(id)])
#define BufferDescriptorGetBuffer(bdesc) ((bdesc)->buf_id + 1)
#define BufferDescriptorGetIOCV(bdesc) \
(&(BufferIOCVArray[(bdesc)->buf_id]).cv)
#define BufferDescriptorGetContentLock(bdesc) \
((LWLock*) (&(bdesc)->content_lock))
extern PGDLLIMPORT ConditionVariableMinimallyPadded *BufferIOCVArray;
/*
* The freeNext field is either the index of the next freelist entry,
* or one of these special values:
*/
#define FREENEXT_END_OF_LIST (-1)
#define FREENEXT_NOT_IN_LIST (-2)
/*
* Functions for acquiring/releasing a shared buffer header's spinlock. Do
* not apply these to local buffers!
*/
extern uint32 LockBufHdr(BufferDesc *desc);
#define UnlockBufHdr(desc, s) \
do { \
pg_write_barrier(); \
pg_atomic_write_u32(&(desc)->state, (s) & (~BM_LOCKED)); \
} while (0)
/* /*
* The PendingWriteback & WritebackContext structure are used to keep * The PendingWriteback & WritebackContext structure are used to keep
* information about pending flush requests to be issued to the OS. * information about pending flush requests to be issued to the OS.
@ -276,11 +260,63 @@ typedef struct WritebackContext
/* in buf_init.c */ /* in buf_init.c */
extern PGDLLIMPORT BufferDescPadded *BufferDescriptors; extern PGDLLIMPORT BufferDescPadded *BufferDescriptors;
extern PGDLLIMPORT ConditionVariableMinimallyPadded *BufferIOCVArray;
extern PGDLLIMPORT WritebackContext BackendWritebackContext; extern PGDLLIMPORT WritebackContext BackendWritebackContext;
/* in localbuf.c */ /* in localbuf.c */
extern PGDLLIMPORT BufferDesc *LocalBufferDescriptors; extern PGDLLIMPORT BufferDesc *LocalBufferDescriptors;
static inline BufferDesc *
GetBufferDescriptor(uint32 id)
{
return &(BufferDescriptors[id]).bufferdesc;
}
static inline BufferDesc *
GetLocalBufferDescriptor(uint32 id)
{
return &LocalBufferDescriptors[id];
}
static inline Buffer
BufferDescriptorGetBuffer(const BufferDesc *bdesc)
{
return (Buffer) (bdesc->buf_id + 1);
}
static inline ConditionVariable *
BufferDescriptorGetIOCV(const BufferDesc *bdesc)
{
return &(BufferIOCVArray[bdesc->buf_id]).cv;
}
static inline LWLock *
BufferDescriptorGetContentLock(const BufferDesc *bdesc)
{
return (LWLock *) (&bdesc->content_lock);
}
/*
* The freeNext field is either the index of the next freelist entry,
* or one of these special values:
*/
#define FREENEXT_END_OF_LIST (-1)
#define FREENEXT_NOT_IN_LIST (-2)
/*
* Functions for acquiring/releasing a shared buffer header's spinlock. Do
* not apply these to local buffers!
*/
extern uint32 LockBufHdr(BufferDesc *desc);
static inline void
UnlockBufHdr(BufferDesc *desc, uint32 buf_state)
{
pg_write_barrier();
pg_atomic_write_u32(&desc->state, buf_state & (~BM_LOCKED));
}
/* in bufmgr.c */ /* in bufmgr.c */
/* /*

Write Preview
Loading…
Cancel
Save