diff --git a/src/gausskernel/ddes/adapter/ss_dms_bufmgr.cpp b/src/gausskernel/ddes/adapter/ss_dms_bufmgr.cpp
index 7d4a4c9bb..b5f8914fe 100644
--- a/src/gausskernel/ddes/adapter/ss_dms_bufmgr.cpp
+++ b/src/gausskernel/ddes/adapter/ss_dms_bufmgr.cpp
@@ -95,8 +95,8 @@ static void CalcSegDmsPhysicalLoc(BufferDesc* buf_desc, Buffer buffer, bool chec
         SegPageLocation loc = seg_get_physical_location(buf_desc->tag.rnode, buf_desc->tag.forkNum,
             buf_desc->tag.blockNum, check_standby);
         SegmentCheck(loc.blocknum != InvalidBlockNumber);
-        buf_desc->seg_fileno = (uint8)EXTENT_SIZE_TO_TYPE((int)loc.extent_size);
-        buf_desc->seg_blockno = loc.blocknum;
+        buf_desc->extra->seg_fileno = (uint8)EXTENT_SIZE_TO_TYPE((int)loc.extent_size);
+        buf_desc->extra->seg_blockno = loc.blocknum;
     }
 }
 
@@ -218,7 +218,7 @@ void SmgrNetPageCheckDiskLSN(BufferDesc *buf_desc, ReadBufferMode read_mode, con
     /*
      * prerequisite is that the page that initialized to zero in memory should be flush to disk
      */
-    if (ENABLE_VERIFY_PAGE_VERSION && (buf_desc->seg_fileno != EXTENT_INVALID ||
+    if (ENABLE_VERIFY_PAGE_VERSION && (buf_desc->extra->seg_fileno != EXTENT_INVALID ||
         IsSegmentBufferID(buf_desc->buf_id)) && (read_mode == RBM_NORMAL)) {
         char *origin_buf = (char *)palloc(BLCKSZ + ALIGNOF_BUFFER);
         char *temp_buf = (char *)BUFFERALIGN(origin_buf);
@@ -227,9 +227,9 @@ void SmgrNetPageCheckDiskLSN(BufferDesc *buf_desc, ReadBufferMode read_mode, con
         if (pblk != NULL) {
             rdStatus = SmgrNetPageCheckRead(smgr->smgr_rnode.node.spcNode, smgr->smgr_rnode.node.dbNode, pblk->relNode,
                             buf_desc->tag.forkNum, pblk->block, (char *)temp_buf);
-        } else if (buf_desc->seg_fileno != EXTENT_INVALID) {
+        } else if (buf_desc->extra->seg_fileno != EXTENT_INVALID) {
             rdStatus = SmgrNetPageCheckRead(smgr->smgr_rnode.node.spcNode, smgr->smgr_rnode.node.dbNode,
-                            buf_desc->seg_fileno, buf_desc->tag.forkNum, buf_desc->seg_blockno, (char *)temp_buf);
+                            buf_desc->extra->seg_fileno, buf_desc->tag.forkNum, buf_desc->extra->seg_blockno, (char *)temp_buf);
         } else {
             rdStatus = smgrread(smgr, buf_desc->tag.forkNum, buf_desc->tag.blockNum, (char *)temp_buf);
         }
@@ -286,7 +286,7 @@ Buffer TerminateReadPage(BufferDesc* buf_desc, ReadBufferMode read_mode, const X
 
         buffer = BufferDescriptorGetBuffer(buf_desc);
         if ((!RecoveryInProgress() || g_instance.dms_cxt.SSRecoveryInfo.in_flushcopy) &&
-            buf_desc->seg_fileno == EXTENT_INVALID) {
+            buf_desc->extra->seg_fileno == EXTENT_INVALID) {
             CalcSegDmsPhysicalLoc(buf_desc, buffer, !g_instance.dms_cxt.SSRecoveryInfo.in_flushcopy);
         }
     }
@@ -689,7 +689,7 @@ bool SSPageCheckIfCanEliminate(BufferDesc* buf_desc)
         return true;
     }
 
-    if (ENABLE_DSS_AIO && buf_desc->aio_in_progress) {
+    if (ENABLE_DSS_AIO && buf_desc->extra->aio_in_progress) {
         return false;
     }
 
@@ -716,7 +716,7 @@ bool SSSegRead(SMgrRelation reln, ForkNumber forknum, char *buffer)
     BufferDesc *buf_desc = BufferGetBufferDescriptor(buf);
     bool ret = false;
 
-    if ((pg_atomic_read_u32(&buf_desc->state) & BM_VALID) && buf_desc->seg_fileno != EXTENT_INVALID) {
+    if ((pg_atomic_read_u32(&buf_desc->state) & BM_VALID) && buf_desc->extra->seg_fileno != EXTENT_INVALID) {
         SMGR_READ_STATUS rdStatus;
         if (reln->seg_space == NULL) {
             reln->seg_space = spc_open(reln->smgr_rnode.node.spcNode, reln->smgr_rnode.node.dbNode, false);
@@ -726,13 +726,13 @@ bool SSSegRead(SMgrRelation reln, ForkNumber forknum, char *buffer)
         RelFileNode fakenode = {
             .spcNode = reln->smgr_rnode.node.spcNode,
             .dbNode = reln->smgr_rnode.node.dbNode,
-            .relNode = buf_desc->seg_fileno,
+            .relNode = buf_desc->extra->seg_fileno,
             .bucketNode = SegmentBktId,
             .opt = 0
         };
 
-        seg_physical_read(reln->seg_space, fakenode, forknum, buf_desc->seg_blockno, (char *)buffer);
-        if (PageIsVerified((Page)buffer, buf_desc->seg_blockno)) {
+        seg_physical_read(reln->seg_space, fakenode, forknum, buf_desc->extra->seg_blockno, (char *)buffer);
+        if (PageIsVerified((Page)buffer, buf_desc->extra->seg_blockno)) {
             rdStatus = SMGR_RD_OK;
         } else {
             rdStatus = SMGR_RD_CRC_ERROR;
diff --git a/src/gausskernel/ddes/adapter/ss_dms_callback.cpp b/src/gausskernel/ddes/adapter/ss_dms_callback.cpp
index 8d7c9ec9a..1d5b66331 100644
--- a/src/gausskernel/ddes/adapter/ss_dms_callback.cpp
+++ b/src/gausskernel/ddes/adapter/ss_dms_callback.cpp
@@ -536,8 +536,8 @@ static void tryEnterLocalPage(BufferTag *tag, dms_lock_mode_t mode, dms_buf_ctrl
             *buf_ctrl = GetDmsBufCtrl(buf_id);
             Assert(buf_id >= 0);
             Assert((*buf_ctrl)->lock_mode != DMS_LOCK_NULL);
-            (*buf_ctrl)->seg_fileno = buf_desc->seg_fileno;
-            (*buf_ctrl)->seg_blockno = buf_desc->seg_blockno;
+            (*buf_ctrl)->seg_fileno = buf_desc->extra->seg_fileno;
+            (*buf_ctrl)->seg_blockno = buf_desc->extra->seg_blockno;
         } while (0);
     }
     PG_CATCH();
@@ -674,14 +674,14 @@ static void CBVerifyPage(dms_buf_ctrl_t *buf_ctrl, char *new_page)
 
     BufferDesc *buf_desc = GetBufferDescriptor(buf_ctrl->buf_id);
 
-    if (buf_desc->seg_fileno == EXTENT_INVALID) {
-        buf_desc->seg_fileno = buf_ctrl->seg_fileno;
-        buf_desc->seg_blockno = buf_ctrl->seg_blockno;
-    } else if (buf_desc->seg_fileno != buf_ctrl->seg_fileno || buf_desc->seg_blockno != buf_ctrl->seg_blockno) {
+    if (buf_desc->extra->seg_fileno == EXTENT_INVALID) {
+        buf_desc->extra->seg_fileno = buf_ctrl->seg_fileno;
+        buf_desc->extra->seg_blockno = buf_ctrl->seg_blockno;
+    } else if (buf_desc->extra->seg_fileno != buf_ctrl->seg_fileno || buf_desc->extra->seg_blockno != buf_ctrl->seg_blockno) {
         ereport(PANIC, (errmsg("[%u/%u/%u/%d/%d %d-%u] location mismatch, seg_fileno:%d, seg_blockno:%u",
             buf_desc->tag.rnode.spcNode, buf_desc->tag.rnode.dbNode, buf_desc->tag.rnode.relNode,
             buf_desc->tag.rnode.bucketNode, buf_desc->tag.rnode.opt, buf_desc->tag.forkNum, buf_desc->tag.blockNum,
-            buf_desc->seg_fileno, buf_desc->seg_blockno)));
+            buf_desc->extra->seg_fileno, buf_desc->extra->seg_blockno)));
     }
 
     /* page content is not valid */
@@ -690,7 +690,7 @@ static void CBVerifyPage(dms_buf_ctrl_t *buf_ctrl, char *new_page)
     }
 
     /* we only verify segment-page version */
-    if (!(buf_desc->seg_fileno != EXTENT_INVALID || IsSegmentBufferID(buf_desc->buf_id))) {
+    if (!(buf_desc->extra->seg_fileno != EXTENT_INVALID || IsSegmentBufferID(buf_desc->buf_id))) {
         return;
     }
 
diff --git a/src/gausskernel/process/postmaster/pagewriter.cpp b/src/gausskernel/process/postmaster/pagewriter.cpp
index c874dae6e..27e6f4cc6 100755
--- a/src/gausskernel/process/postmaster/pagewriter.cpp
+++ b/src/gausskernel/process/postmaster/pagewriter.cpp
@@ -467,7 +467,7 @@ bool push_pending_flush_queue(Buffer buffer)
     BufferDesc* buf_desc = GetBufferDescriptor(buffer - 1);
     bool push_finish = false;
 
-    Assert(XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf_desc->rec_lsn)));
+    Assert(XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf_desc->extra->rec_lsn)));
 #if defined(__x86_64__) || defined(__aarch64__)
     push_finish = atomic_push_pending_flush_queue(&queue_head_lsn, &new_tail_loc);
     if (!push_finish) {
@@ -486,9 +486,9 @@ bool push_pending_flush_queue(Buffer buffer)
     SpinLockRelease(&g_instance.ckpt_cxt_ctl->queue_lock);
 #endif
 
-    pg_atomic_write_u64(&buf_desc->rec_lsn, queue_head_lsn);
+    pg_atomic_write_u64(&buf_desc->extra->rec_lsn, queue_head_lsn);
     actual_loc = new_tail_loc % g_instance.ckpt_cxt_ctl->dirty_page_queue_size;
-    buf_desc->dirty_queue_loc = actual_loc;
+    buf_desc->extra->dirty_queue_loc = actual_loc;
     g_instance.ckpt_cxt_ctl->dirty_page_queue[actual_loc].buffer = buffer;
     pg_memory_barrier();
     pg_atomic_write_u32(&g_instance.ckpt_cxt_ctl->dirty_page_queue[actual_loc].slot_state, (SLOT_VALID));
@@ -498,10 +498,10 @@ bool push_pending_flush_queue(Buffer buffer)
 
 void remove_dirty_page_from_queue(BufferDesc* buf)
 {
-    Assert(buf->dirty_queue_loc != PG_UINT64_MAX);
-    g_instance.ckpt_cxt_ctl->dirty_page_queue[buf->dirty_queue_loc].buffer = 0;
-    pg_atomic_write_u64(&buf->rec_lsn, InvalidXLogRecPtr);
-    buf->dirty_queue_loc = PG_UINT64_MAX;
+    Assert(buf->extra->dirty_queue_loc != PG_UINT64_MAX);
+    g_instance.ckpt_cxt_ctl->dirty_page_queue[buf->extra->dirty_queue_loc].buffer = 0;
+    pg_atomic_write_u64(&buf->extra->rec_lsn, InvalidXLogRecPtr);
+    buf->extra->dirty_queue_loc = PG_UINT64_MAX;
     (void)pg_atomic_fetch_sub_u32(&g_instance.ckpt_cxt_ctl->actual_dirty_page_num, 1);
 }
 
@@ -820,7 +820,7 @@ uint64 get_loc_for_lsn(XLogRecPtr target_lsn)
             continue;
         }
         buf_desc = GetBufferDescriptor(buffer - 1);
-        page_rec_lsn = pg_atomic_read_u64(&buf_desc->rec_lsn);
+        page_rec_lsn = pg_atomic_read_u64(&buf_desc->extra->rec_lsn);
         if (!BufferIsInvalid(slot->buffer) && XLByteLE(target_lsn, page_rec_lsn)) {
             last_loc = queue_loc - 1;
             break;
@@ -859,7 +859,7 @@ static uint32 get_page_num_for_lsn(XLogRecPtr target_lsn, uint32 max_num)
             continue; /* this tempLoc maybe set 0 when remove dirty page */
         }
         buf_desc = GetBufferDescriptor(buffer - 1);
-        page_rec_lsn = pg_atomic_read_u64(&buf_desc->rec_lsn);
+        page_rec_lsn = pg_atomic_read_u64(&buf_desc->extra->rec_lsn);
         if (!BufferIsInvalid(slot->buffer) && XLByteLE(target_lsn, page_rec_lsn)) {
             break;
         }
@@ -1647,7 +1647,7 @@ static void incre_ckpt_aio_callback(struct io_event *event)
         _exit(0);
     }
 
-    buf_desc->aio_in_progress = false;
+    buf_desc->extra->aio_in_progress = false;
     UnpinBuffer(buf_desc, true);
 }
 
@@ -1930,7 +1930,7 @@ static void ckpt_try_prune_dirty_page_queue()
                 continue;
             }
             move_slot->buffer = slot->buffer;
-            bufhdr->dirty_queue_loc = move_loc;
+            bufhdr->extra->dirty_queue_loc = move_loc;
             slot->buffer = 0;
             pg_write_barrier();
             UnlockBufHdr(bufhdr, buf_state);
@@ -2150,10 +2150,10 @@ static bool check_buffer_dirty_flag(BufferDesc* buf_desc)
     Block tmpBlock = BufHdrGetBlock(buf_desc);
     uint32 local_buf_state = pg_atomic_read_u32(&buf_desc->state);
     bool check_lsn_not_match = (local_buf_state & BM_VALID) && !(local_buf_state & BM_DIRTY) &&
-        XLByteLT(buf_desc->lsn_on_disk, PageGetLSN(tmpBlock)) && RecoveryInProgress() && !segment_buf;
+        XLByteLT(buf_desc->extra->lsn_on_disk, PageGetLSN(tmpBlock)) && RecoveryInProgress() && !segment_buf;
 
     if (ENABLE_DMS && check_lsn_not_match &&
-        (XLogRecPtrIsInvalid(buf_desc->lsn_on_disk) || GetDmsBufCtrl(buf_desc->buf_id)->state & BUF_DIRTY_NEED_FLUSH)) {
+        (XLogRecPtrIsInvalid(buf_desc->extra->lsn_on_disk) || GetDmsBufCtrl(buf_desc->buf_id)->state & BUF_DIRTY_NEED_FLUSH)) {
         return false;
     }
 
@@ -2163,7 +2163,7 @@ static bool check_buffer_dirty_flag(BufferDesc* buf_desc)
             pg_memory_barrier();
             local_buf_state = pg_atomic_read_u32(&buf_desc->state);
             check_lsn_not_match = (local_buf_state & BM_VALID) && !(local_buf_state & BM_DIRTY) &&
-                XLByteLT(buf_desc->lsn_on_disk, PageGetLSN(tmpBlock)) && RecoveryInProgress();
+                XLByteLT(buf_desc->extra->lsn_on_disk, PageGetLSN(tmpBlock)) && RecoveryInProgress();
             if (check_lsn_not_match) {
                 MarkBufferDirty(BufferDescriptorGetBuffer(buf_desc));
                 LWLockRelease(buf_desc->content_lock);
@@ -2171,7 +2171,7 @@ static bool check_buffer_dirty_flag(BufferDesc* buf_desc)
                 const uint32 shiftSize = 32;
                 ereport(DEBUG1, (errmodule(MOD_INCRE_BG),
                     errmsg("check lsn is not matched on disk:%X/%X on page %X/%X, relnode info:%u/%u/%u %u %u stat:%u",
-                        (uint32)(buf_desc->lsn_on_disk >> shiftSize), (uint32)(buf_desc->lsn_on_disk),
+                        (uint32)(buf_desc->extra->lsn_on_disk >> shiftSize), (uint32)(buf_desc->extra->lsn_on_disk),
                         (uint32)(PageGetLSN(tmpBlock) >> shiftSize), (uint32)(PageGetLSN(tmpBlock)),
                         buf_desc->tag.rnode.spcNode, buf_desc->tag.rnode.dbNode, buf_desc->tag.rnode.relNode,
                         buf_desc->tag.blockNum, buf_desc->tag.forkNum, local_buf_state)));
diff --git a/src/gausskernel/storage/access/heap/visibilitymap.cpp b/src/gausskernel/storage/access/heap/visibilitymap.cpp
index 1c56555e5..e50f73d3a 100644
--- a/src/gausskernel/storage/access/heap/visibilitymap.cpp
+++ b/src/gausskernel/storage/access/heap/visibilitymap.cpp
@@ -289,7 +289,7 @@ bool visibilitymap_test(Relation rel, BlockNumber heapBlk, Buffer *buf)
         volatile BufferDesc *bufHdr = NULL;
 
         if (BufferIsLocal(*buf)) {
-            bufHdr = &(u_sess->storage_cxt.LocalBufferDescriptors[-(*buf) - 1]);
+            bufHdr = (BufferDesc *)&(u_sess->storage_cxt.LocalBufferDescriptors[-(*buf) - 1].bufferdesc);
         } else {
             bufHdr = GetBufferDescriptor(*buf - 1);
         }
diff --git a/src/gausskernel/storage/access/redo/redo_segpage.cpp b/src/gausskernel/storage/access/redo/redo_segpage.cpp
index 94fddf04a..8644411d6 100644
--- a/src/gausskernel/storage/access/redo/redo_segpage.cpp
+++ b/src/gausskernel/storage/access/redo/redo_segpage.cpp
@@ -456,7 +456,7 @@ void SegPageRedoNewPage(XLogBlockHead *blockhead, XLogBlockSegNewPage *newPageIn
 void MarkSegPageRedoChildPageDirty(RedoBufferInfo *bufferinfo)
 {
     BufferDesc *bufDesc = GetBufferDescriptor(bufferinfo->buf - 1);
-    if (bufferinfo->dirtyflag || XLByteLT(bufDesc->lsn_on_disk, PageGetLSN(bufferinfo->pageinfo.page))) {
+    if (bufferinfo->dirtyflag || XLByteLT(bufDesc->extra->lsn_on_disk, PageGetLSN(bufferinfo->pageinfo.page))) {
         if (IsSegmentPhysicalRelNode(bufferinfo->blockinfo.rnode)) {
             SegMarkBufferDirty(bufferinfo->buf);
         } else {
@@ -471,7 +471,7 @@ void MarkSegPageRedoChildPageDirty(RedoBufferInfo *bufferinfo)
             ereport(mode, (errmsg("extreme_rto segment page not mark dirty:lsn %X/%X, lsn_disk %X/%X, \
                                   lsn_page %X/%X, page %u/%u/%u %u",
                                   (uint32)(bufferinfo->lsn >> shiftSz), (uint32)(bufferinfo->lsn),
-                                  (uint32)(bufDesc->lsn_on_disk >> shiftSz), (uint32)(bufDesc->lsn_on_disk),
+                                  (uint32)(bufDesc->extra->lsn_on_disk >> shiftSz), (uint32)(bufDesc->extra->lsn_on_disk),
                                   (uint32)(PageGetLSN(bufferinfo->pageinfo.page) >> shiftSz),
                                   (uint32)(PageGetLSN(bufferinfo->pageinfo.page)),
                                   bufferinfo->blockinfo.rnode.spcNode, bufferinfo->blockinfo.rnode.dbNode,
diff --git a/src/gausskernel/storage/access/redo/redo_xlogutils.cpp b/src/gausskernel/storage/access/redo/redo_xlogutils.cpp
index 3e983847e..3aba4214f 100644
--- a/src/gausskernel/storage/access/redo/redo_xlogutils.cpp
+++ b/src/gausskernel/storage/access/redo/redo_xlogutils.cpp
@@ -1688,7 +1688,7 @@ void ExtremeRtoFlushBuffer(RedoBufferInfo *bufferinfo, bool updateFsm)
     } else {
         if (bufferinfo->pageinfo.page != NULL) {
             BufferDesc *bufDesc = GetBufferDescriptor(bufferinfo->buf - 1);
-            if (bufferinfo->dirtyflag || XLByteLT(bufDesc->lsn_on_disk, PageGetLSN(bufferinfo->pageinfo.page))) {
+            if (bufferinfo->dirtyflag || XLByteLT(bufDesc->extra->lsn_on_disk, PageGetLSN(bufferinfo->pageinfo.page))) {
                 MarkBufferDirty(bufferinfo->buf);
                 if (!bufferinfo->dirtyflag && bufferinfo->blockinfo.forknum == MAIN_FORKNUM) {
                     int mode = WARNING;
@@ -1699,7 +1699,7 @@ void ExtremeRtoFlushBuffer(RedoBufferInfo *bufferinfo, bool updateFsm)
                     ereport(mode, (errmsg("extreme_rto not mark dirty:lsn %X/%X, lsn_disk %X/%X, \
                                           lsn_page %X/%X, page %u/%u/%u %u",
                                           (uint32)(bufferinfo->lsn >> shiftSz), (uint32)(bufferinfo->lsn), 
-                                          (uint32)(bufDesc->lsn_on_disk >> shiftSz), (uint32)(bufDesc->lsn_on_disk), 
+                                          (uint32)(bufDesc->extra->lsn_on_disk >> shiftSz), (uint32)(bufDesc->extra->lsn_on_disk), 
                                           (uint32)(PageGetLSN(bufferinfo->pageinfo.page) >> shiftSz), 
                                           (uint32)(PageGetLSN(bufferinfo->pageinfo.page)), 
                                           bufferinfo->blockinfo.rnode.spcNode, bufferinfo->blockinfo.rnode.dbNode,
diff --git a/src/gausskernel/storage/access/transam/double_write.cpp b/src/gausskernel/storage/access/transam/double_write.cpp
index ec5b30cb1..a6119cbf8 100644
--- a/src/gausskernel/storage/access/transam/double_write.cpp
+++ b/src/gausskernel/storage/access/transam/double_write.cpp
@@ -2068,14 +2068,14 @@ void dw_init()
 void dw_transfer_phybuffer_addr(const BufferDesc *buf_desc, BufferTag *buf_tag)
 {
     if (XLOG_NEED_PHYSICAL_LOCATION(buf_desc->tag.rnode)) {
-        if (buf_desc->seg_fileno != EXTENT_INVALID) {
+        if (buf_desc->extra->seg_fileno != EXTENT_INVALID) {
             // buffer descriptor contains the physical location
-            Assert(buf_desc->seg_fileno <= EXTENT_TYPES && buf_desc->seg_fileno > EXTENT_INVALID);
-            buf_tag->rnode.relNode = buf_desc->seg_fileno;
-            buf_tag->blockNum = buf_desc->seg_blockno;
+            Assert(buf_desc->extra->seg_fileno <= EXTENT_TYPES && buf_desc->extra->seg_fileno > EXTENT_INVALID);
+            buf_tag->rnode.relNode = buf_desc->extra->seg_fileno;
+            buf_tag->blockNum = buf_desc->extra->seg_blockno;
         } else if (ENABLE_REFORM && SS_BEFORE_RECOVERY) {
-            buf_tag->rnode.relNode = buf_desc->seg_fileno;
-            buf_tag->blockNum = buf_desc->seg_blockno;
+            buf_tag->rnode.relNode = buf_desc->extra->seg_fileno;
+            buf_tag->blockNum = buf_desc->extra->seg_blockno;
         } else {
             SegPageLocation loc =
                 seg_get_physical_location(buf_desc->tag.rnode, buf_desc->tag.forkNum, buf_desc->tag.blockNum);
@@ -2169,7 +2169,7 @@ static XLogRecPtr dw_copy_page(ThrdDwCxt* thrd_dw_cxt, int buf_desc_id, bool* is
     UnpinBuffer(buf_desc, true);
 
     page_lsn = PageGetLSN(dest_addr);
-    if (buf_desc->encrypt) {
+    if (buf_desc->extra->encrypt) {
         dw_encrypt_page(buf_desc->tag, dest_addr);
     }
 
diff --git a/src/gausskernel/storage/access/transam/extreme_rto/page_redo.cpp b/src/gausskernel/storage/access/transam/extreme_rto/page_redo.cpp
index 23e37d068..0df2493a1 100755
--- a/src/gausskernel/storage/access/transam/extreme_rto/page_redo.cpp
+++ b/src/gausskernel/storage/access/transam/extreme_rto/page_redo.cpp
@@ -2782,7 +2782,7 @@ void RepairPageAndRecoveryXLog(BadBlockRecEnt* page_info, const char *page)
 
     MarkBufferDirty(buffer.buf);
     bufDesc = GetBufferDescriptor(buffer.buf - 1);
-    bufDesc->lsn_on_disk = PageGetLSN(buffer.pageinfo.page);
+    bufDesc->extra->lsn_on_disk = PageGetLSN(buffer.pageinfo.page);
     UnlockReleaseBuffer(buffer.buf);
 
     /* recovery the page xlog */
diff --git a/src/gausskernel/storage/access/transam/seg_double_write.cpp b/src/gausskernel/storage/access/transam/seg_double_write.cpp
index ed82d8153..75909b718 100644
--- a/src/gausskernel/storage/access/transam/seg_double_write.cpp
+++ b/src/gausskernel/storage/access/transam/seg_double_write.cpp
@@ -327,7 +327,7 @@ uint16 seg_dw_single_flush(BufferDesc *buf_desc, bool* flush_old_file)
 
     if (!dw_flush) {
         *flush_old_file = false;
-        pos = second_version_dw_single_flush(buf_desc->tag, block, page_lsn, buf_desc->encrypt, phy_tag);
+        pos = second_version_dw_single_flush(buf_desc->tag, block, page_lsn, buf_desc->extra->encrypt, phy_tag);
     }
     return pos;
 }
diff --git a/src/gausskernel/storage/access/transam/single_double_write.cpp b/src/gausskernel/storage/access/transam/single_double_write.cpp
index b384ece20..7e6b0a9b1 100644
--- a/src/gausskernel/storage/access/transam/single_double_write.cpp
+++ b/src/gausskernel/storage/access/transam/single_double_write.cpp
@@ -681,7 +681,7 @@ uint16 first_version_dw_single_flush(BufferDesc *buf_desc)
     securec_check(rc, "\0", "\0");
 
     XLogWaitFlush(page_lsn);
-    if (buf_desc->encrypt) {
+    if (buf_desc->extra->encrypt) {
         dw_encrypt_page(buf_desc->tag, buf);
     }
 
diff --git a/src/gausskernel/storage/access/transam/xlog.cpp b/src/gausskernel/storage/access/transam/xlog.cpp
index 03568b05a..a5e294c69 100755
--- a/src/gausskernel/storage/access/transam/xlog.cpp
+++ b/src/gausskernel/storage/access/transam/xlog.cpp
@@ -18990,7 +18990,7 @@ XLogRecPtr ckpt_get_min_rec_lsn(void)
             continue;
         }
         buf_desc = GetBufferDescriptor(buffer - 1);
-        page_rec_lsn = pg_atomic_read_u64(&buf_desc->rec_lsn);
+        page_rec_lsn = pg_atomic_read_u64(&buf_desc->extra->rec_lsn);
         if (!BufferIsInvalid(slot->buffer)) {
             min_rec_lsn = page_rec_lsn;
         }
diff --git a/src/gausskernel/storage/access/transam/xloginsert.cpp b/src/gausskernel/storage/access/transam/xloginsert.cpp
index cd6f53e72..efb8335c4 100755
--- a/src/gausskernel/storage/access/transam/xloginsert.cpp
+++ b/src/gausskernel/storage/access/transam/xloginsert.cpp
@@ -261,11 +261,11 @@ void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags, TdeInfo* tde
             return;
         }
         BufferDesc *bufDesc = GetBufferDescriptor(buffer - 1);
-        if (bufDesc->seg_fileno != EXTENT_INVALID) {  
+        if (bufDesc->extra->seg_fileno != EXTENT_INVALID) {  
             // buffer descriptor contains the physical location
-            SegmentCheck(bufDesc->seg_fileno <= EXTENT_TYPES);
-            regbuf->seg_file_no = bufDesc->seg_fileno;
-            regbuf->seg_block = bufDesc->seg_blockno;
+            SegmentCheck(bufDesc->extra->seg_fileno <= EXTENT_TYPES);
+            regbuf->seg_file_no = bufDesc->extra->seg_fileno;
+            regbuf->seg_block = bufDesc->extra->seg_blockno;
         } else {
             SegPageLocation loc = seg_get_physical_location(regbuf->rnode, regbuf->forkno, regbuf->block);
             SegmentCheck(loc.blocknum != InvalidBlockNumber);
diff --git a/src/gausskernel/storage/buffer/buf_init.cpp b/src/gausskernel/storage/buffer/buf_init.cpp
index f5197ea6c..5a16ba890 100644
--- a/src/gausskernel/storage/buffer/buf_init.cpp
+++ b/src/gausskernel/storage/buffer/buf_init.cpp
@@ -72,13 +72,20 @@ void InitBufferPool(void)
     bool found_bufs = false;
     bool found_descs = false;
     bool found_buf_ckpt = false;
+    bool found_buf_extra = false;
     uint64 buffer_size;
+    BufferDescExtra *extra = NULL;
 
     t_thrd.storage_cxt.BufferDescriptors = (BufferDescPadded *)CACHELINEALIGN(
         ShmemInitStruct("Buffer Descriptors",
                         TOTAL_BUFFER_NUM * sizeof(BufferDescPadded) + PG_CACHE_LINE_SIZE,
                         &found_descs));
 
+    extra = (BufferDescExtra *)CACHELINEALIGN(
+        ShmemInitStruct("Buffer Descriptors Extra",
+                        TOTAL_BUFFER_NUM * sizeof(BufferDescExtra) + PG_CACHE_LINE_SIZE,
+                        &found_buf_extra));
+
     /* Init candidate buffer list and candidate buffer free map */
     candidate_buf_init();
 
@@ -145,9 +152,9 @@ void InitBufferPool(void)
             relfilenode_fork_hashtbl_create("unlink_rel_one_fork_hashtbl", true);
     }
 
-    if (found_descs || found_bufs || found_buf_ckpt) {
+    if (found_descs || found_bufs || found_buf_ckpt || found_buf_extra) {
         /* both should be present or neither */
-        Assert(found_descs && found_bufs && found_buf_ckpt);
+        Assert(found_descs && found_bufs && found_buf_ckpt && found_buf_extra);
         /* note: this path is only taken in EXEC_BACKEND case */
     } else {
         int i;
@@ -162,13 +169,14 @@ void InitBufferPool(void)
             pg_atomic_init_u32(&buf->state, 0);
             buf->wait_backend_pid = 0;
 
+            buf->extra = &extra[i];
             buf->buf_id = i;
             buf->io_in_progress_lock = LWLockAssign(LWTRANCHE_BUFFER_IO_IN_PROGRESS);
             buf->content_lock = LWLockAssign(LWTRANCHE_BUFFER_CONTENT);
-            pg_atomic_init_u64(&buf->rec_lsn, InvalidXLogRecPtr);
-            buf->aio_in_progress = false;
-            buf->dirty_queue_loc = PG_UINT64_MAX;
-            buf->encrypt = false;
+            pg_atomic_init_u64(&buf->extra->rec_lsn, InvalidXLogRecPtr);
+            buf->extra->aio_in_progress = false;
+            buf->extra->dirty_queue_loc = PG_UINT64_MAX;
+            buf->extra->encrypt = false;
         }
         g_instance.bgwriter_cxt.rel_hashtbl_lock = LWLockAssign(LWTRANCHE_UNLINK_REL_TBL);
         g_instance.bgwriter_cxt.rel_one_fork_hashtbl_lock = LWLockAssign(LWTRANCHE_UNLINK_REL_FORK_TBL);
@@ -207,6 +215,8 @@ Size BufferShmemSize(void)
     /* size of buffer descriptors */
     size = add_size(size, mul_size(TOTAL_BUFFER_NUM, sizeof(BufferDescPadded)));
     size = add_size(size, PG_CACHE_LINE_SIZE);
+    size = add_size(size, mul_size(TOTAL_BUFFER_NUM, sizeof(BufferDescExtra)));
+    size = add_size(size, PG_CACHE_LINE_SIZE);
 
     /* size of data pages */
     size = add_size(size, mul_size((NORMAL_SHARED_BUFFER_NUM + SEGMENT_BUFFER_NUM), BLCKSZ));
diff --git a/src/gausskernel/storage/buffer/bufmgr.cpp b/src/gausskernel/storage/buffer/bufmgr.cpp
index f41e18bba..7fe34b220 100644
--- a/src/gausskernel/storage/buffer/bufmgr.cpp
+++ b/src/gausskernel/storage/buffer/bufmgr.cpp
@@ -2207,7 +2207,7 @@ Buffer ReadBuffer_common_for_dms(ReadBufferMode readmode, BufferDesc* buf_desc,
     pfree_ext(past_image);
 #endif
 
-    buf_desc->lsn_on_disk = PageGetLSN(bufBlock);
+    buf_desc->extra->lsn_on_disk = PageGetLSN(bufBlock);
 #ifdef USE_ASSERT_CHECKING
     buf_desc->lsn_dirty = InvalidXLogRecPtr;
 #endif
@@ -2222,8 +2222,8 @@ Buffer ReadBuffer_common_for_dms(ReadBufferMode readmode, BufferDesc* buf_desc,
 static inline void BufferDescSetPBLK(BufferDesc *buf, const XLogPhyBlock *pblk)
 {
     if (pblk != NULL) {
-        buf->seg_fileno = pblk->relNode;
-        buf->seg_blockno = pblk->block;
+        buf->extra->seg_fileno = pblk->relNode;
+        buf->extra->seg_blockno = pblk->block;
     }
 }
 
@@ -2295,7 +2295,7 @@ static Buffer ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumb
          */
         bufHdr = BufferAlloc(smgr, relpersistence, forkNum, blockNum, strategy, &found, pblk);
         if (g_instance.attr.attr_security.enable_tde && IS_PGXC_DATANODE) {
-            bufHdr->encrypt = smgr->encrypt ? true : false; /* set tde flag */
+            bufHdr->extra->encrypt = smgr->encrypt ? true : false; /* set tde flag */
         }
         if (found) {
             u_sess->instr_cxt.pg_buffer_usage->shared_blks_hit++;
@@ -2500,7 +2500,7 @@ found_branch:
         if (ENABLE_INCRE_CKPT) {
             for (;;) {
                 buf_state = old_buf_state | (BM_DIRTY | BM_JUST_DIRTIED);
-                if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&bufHdr->rec_lsn))) {
+                if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&bufHdr->extra->rec_lsn))) {
                     break;
                 }
 
@@ -2536,7 +2536,7 @@ found_branch:
         buf_state |= BM_VALID;
         pg_atomic_write_u32(&bufHdr->state, buf_state);
     } else {
-        bufHdr->lsn_on_disk = PageGetLSN(bufBlock);
+        bufHdr->extra->lsn_on_disk = PageGetLSN(bufBlock);
 #ifdef USE_ASSERT_CHECKING
         bufHdr->lsn_dirty = InvalidXLogRecPtr;
 #endif
@@ -2568,7 +2568,7 @@ void SimpleMarkBufDirty(BufferDesc *buf)
     if (ENABLE_INCRE_CKPT) {
         for (;;) {
             bufState = oldBufState | (BM_DIRTY | BM_JUST_DIRTIED);
-            if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf->rec_lsn))) {
+            if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf->extra->rec_lsn))) {
                 break;
             }
 
@@ -2592,7 +2592,7 @@ void PageCheckIfCanEliminate(BufferDesc *buf, uint32 *oldFlags, bool *needGetLoc
 
     Block tmpBlock = BufHdrGetBlock(buf);
 
-    if ((*oldFlags & BM_TAG_VALID) && !XLByteEQ(buf->lsn_on_disk, PageGetLSN(tmpBlock)) && !(*oldFlags & BM_DIRTY) &&
+    if ((*oldFlags & BM_TAG_VALID) && !XLByteEQ(buf->extra->lsn_on_disk, PageGetLSN(tmpBlock)) && !(*oldFlags & BM_DIRTY) &&
         RecoveryInProgress()) {
         int mode = DEBUG1;
 #ifdef USE_ASSERT_CHECKING
@@ -2601,7 +2601,7 @@ void PageCheckIfCanEliminate(BufferDesc *buf, uint32 *oldFlags, bool *needGetLoc
         const uint32 shiftSize = 32;
         ereport(mode, (errmodule(MOD_INCRE_BG),
                 errmsg("check lsn is not matched on disk:%X/%X on page %X/%X, relnode info:%u/%u/%u %u %u",
-                       (uint32)(buf->lsn_on_disk >> shiftSize), (uint32)(buf->lsn_on_disk),
+                       (uint32)(buf->extra->lsn_on_disk >> shiftSize), (uint32)(buf->extra->lsn_on_disk),
                        (uint32)(PageGetLSN(tmpBlock) >> shiftSize), (uint32)(PageGetLSN(tmpBlock)),
                        buf->tag.rnode.spcNode, buf->tag.rnode.dbNode, buf->tag.rnode.relNode,
                        buf->tag.blockNum, buf->tag.forkNum)));
@@ -2620,7 +2620,7 @@ void PageCheckWhenChosedElimination(const BufferDesc *buf, uint32 oldFlags)
 
     if ((oldFlags & BM_TAG_VALID) && RecoveryInProgress()) {
         if (!XLByteEQ(buf->lsn_dirty, InvalidXLogRecPtr)) {
-            Assert(XLByteEQ(buf->lsn_on_disk, buf->lsn_dirty));
+            Assert(XLByteEQ(buf->extra->lsn_on_disk, buf->lsn_dirty));
         }
     }
 }
@@ -2714,8 +2714,8 @@ static BufferDesc *BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumbe
         /* set Physical segment file. */
         if (ENABLE_DMS && pblk != NULL) {
             Assert(PhyBlockIsValid(*pblk));
-            buf->seg_fileno = pblk->relNode;
-            buf->seg_blockno = pblk->block;
+            buf->extra->seg_fileno = pblk->relNode;
+            buf->extra->seg_blockno = pblk->block;
             MarkReadPblk(buf->buf_id, pblk);
         }
 
@@ -3009,14 +3009,14 @@ static BufferDesc *BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumbe
     /* set Physical segment file. */
     if (pblk != NULL) {
         Assert(PhyBlockIsValid(*pblk));
-        buf->seg_fileno = pblk->relNode;
-        buf->seg_blockno = pblk->block;
+        buf->extra->seg_fileno = pblk->relNode;
+        buf->extra->seg_blockno = pblk->block;
         if (ENABLE_DMS) {
             MarkReadPblk(buf->buf_id, pblk);
         }
     } else {
-        buf->seg_fileno = EXTENT_INVALID;
-        buf->seg_blockno = InvalidBlockNumber;
+        buf->extra->seg_fileno = EXTENT_INVALID;
+        buf->extra->seg_blockno = InvalidBlockNumber;
     }
     LWLockRelease(new_partition_lock);
 
@@ -3125,7 +3125,7 @@ retry:
 
     /* remove from dirty page list */
     if (ENABLE_INCRE_CKPT && (buf_state & BM_DIRTY)) {
-        if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf->rec_lsn))) {
+        if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf->extra->rec_lsn))) {
             remove_dirty_page_from_queue(buf);
         } else {
             ereport(PANIC, (errmodule(MOD_INCRE_CKPT), errcode(ERRCODE_INVALID_BUFFER),
@@ -3221,7 +3221,7 @@ void MarkBufferDirty(Buffer buffer)
     if (ENABLE_INCRE_CKPT) {
         for (;;) {
             buf_state = old_buf_state | (BM_DIRTY | BM_JUST_DIRTIED);
-            if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf_desc->rec_lsn))) {
+            if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf_desc->extra->rec_lsn))) {
                 break;
             }
 
@@ -3303,7 +3303,7 @@ Buffer ReleaseAndReadBuffer(Buffer buffer, Relation relation, BlockNumber block_
 
     if (BufferIsValid(buffer)) {
         if (BufferIsLocal(buffer)) {
-            buf_desc = &u_sess->storage_cxt.LocalBufferDescriptors[-buffer - 1];
+            buf_desc = (BufferDesc *)&u_sess->storage_cxt.LocalBufferDescriptors[-buffer - 1].bufferdesc;
             if (buf_desc->tag.blockNum == block_num && RelFileNodeEquals(buf_desc->tag.rnode, relation->rd_node) &&
                 buf_desc->tag.forkNum == fork_num)
                 return buffer;
@@ -4144,7 +4144,7 @@ bool SyncFlushOneBuffer(int buf_id, bool get_condition_lock)
         (void)LWLockAcquire(buf_desc->content_lock, LW_SHARED);
     }
 
-    if (ENABLE_DMS && buf_desc->aio_in_progress) {
+    if (ENABLE_DMS && buf_desc->extra->aio_in_progress) {
         LWLockRelease(buf_desc->content_lock);
         UnpinBuffer(buf_desc, true);
         return false;
@@ -4216,12 +4216,12 @@ uint32 SyncOneBuffer(int buf_id, bool skip_recently_used, WritebackContext* wb_c
     }
 
     tag = buf_desc->tag;
-    if (buf_desc->seg_fileno != EXTENT_INVALID) {
+    if (buf_desc->extra->seg_fileno != EXTENT_INVALID) {
         SegmentCheck(XLOG_NEED_PHYSICAL_LOCATION(buf_desc->tag.rnode));
-        SegmentCheck(buf_desc->seg_blockno != InvalidBlockNumber);
-        SegmentCheck(ExtentTypeIsValid(buf_desc->seg_fileno));
-        tag.rnode.relNode = buf_desc->seg_fileno;
-        tag.blockNum = buf_desc->seg_blockno;
+        SegmentCheck(buf_desc->extra->seg_blockno != InvalidBlockNumber);
+        SegmentCheck(ExtentTypeIsValid(buf_desc->extra->seg_fileno));
+        tag.rnode.relNode = buf_desc->extra->seg_fileno;
+        tag.blockNum = buf_desc->extra->seg_blockno;
     }
 
     if (!t_thrd.dms_cxt.buf_in_aio) {
@@ -4395,7 +4395,7 @@ void PrintBufferLeakWarning(Buffer buffer)
 
     Assert(BufferIsValid(buffer));
     if (BufferIsLocal(buffer)) {
-        buf = &u_sess->storage_cxt.LocalBufferDescriptors[-buffer - 1];
+        buf = (BufferDesc *)&u_sess->storage_cxt.LocalBufferDescriptors[-buffer - 1].bufferdesc;
         loccount = u_sess->storage_cxt.LocalRefCount[-buffer - 1];
         backend = BackendIdForTempRelations;
     } else {
@@ -4524,7 +4524,7 @@ BlockNumber BufferGetBlockNumber(Buffer buffer)
     Assert(BufferIsPinned(buffer));
 
     if (BufferIsLocal(buffer)) {
-        buf_desc = &(u_sess->storage_cxt.LocalBufferDescriptors[-buffer - 1]);
+        buf_desc = (BufferDesc *)&(u_sess->storage_cxt.LocalBufferDescriptors[-buffer - 1].bufferdesc);
     } else {
         buf_desc = GetBufferDescriptor(buffer - 1);
     }
@@ -4540,7 +4540,7 @@ void BufferGetTag(Buffer buffer, RelFileNode *rnode, ForkNumber *forknum, BlockN
     /* Do the same checks as BufferGetBlockNumber. */
     Assert(BufferIsPinned(buffer));
     if (BufferIsLocal(buffer)) {
-        buf_desc = &(u_sess->storage_cxt.LocalBufferDescriptors[-buffer - 1]);
+        buf_desc = (BufferDesc *)&(u_sess->storage_cxt.LocalBufferDescriptors[-buffer - 1].bufferdesc);
     } else {
         buf_desc = GetBufferDescriptor(buffer - 1);
     }
@@ -4590,7 +4590,7 @@ char* PageDataEncryptForBuffer(Page page, BufferDesc *bufdesc, bool is_segbuf)
     char *bufToWrite = NULL;
     TdeInfo tde_info = {0};
 
-    if (bufdesc->encrypt) {
+    if (bufdesc->extra->encrypt) {
         TDE::TDEBufferCache::get_instance().search_cache(bufdesc->tag.rnode, &tde_info);
         if (strlen(tde_info.dek_cipher) == 0) {
             ereport(ERROR, (errmodule(MOD_SEC_TDE), errcode(ERRCODE_UNEXPECTED_NULL_VALUE),
@@ -4710,17 +4710,17 @@ void FlushBuffer(void *buf, SMgrRelation reln, ReadBufferMethod flushmethod, boo
 
     INSTR_TIME_SET_CURRENT(io_start);
 
-    if (bufdesc->seg_fileno != EXTENT_INVALID) {
+    if (bufdesc->extra->seg_fileno != EXTENT_INVALID) {
         /* FlushBuffer only used for data buffer, matedata buffer is flushed by SegFlushBuffer */
         SegmentCheck(!PageIsSegmentVersion(bufBlock) || PageIsNew(bufBlock));
         SegmentCheck(XLOG_NEED_PHYSICAL_LOCATION(bufdesc->tag.rnode));
-        SegmentCheck(bufdesc->seg_blockno != InvalidBlockNumber);
-        SegmentCheck(ExtentTypeIsValid(bufdesc->seg_fileno));
+        SegmentCheck(bufdesc->extra->seg_blockno != InvalidBlockNumber);
+        SegmentCheck(ExtentTypeIsValid(bufdesc->extra->seg_fileno));
 
         if (unlikely(bufToWrite != (char *)bufBlock)) {
-            PageSetChecksumInplace((Page)bufToWrite, bufdesc->seg_blockno);
+            PageSetChecksumInplace((Page)bufToWrite, bufdesc->extra->seg_blockno);
         } else {
-            bufToWrite = PageSetChecksumCopy((Page)bufToWrite, bufdesc->seg_blockno, true);
+            bufToWrite = PageSetChecksumCopy((Page)bufToWrite, bufdesc->extra->seg_blockno, true);
         }
 
         SegSpace* spc = spc_open(reln->smgr_rnode.node.spcNode, reln->smgr_rnode.node.dbNode, false);
@@ -4728,13 +4728,13 @@ void FlushBuffer(void *buf, SMgrRelation reln, ReadBufferMethod flushmethod, boo
         RelFileNode fakenode = {
             .spcNode = spc->spcNode,
             .dbNode = spc->dbNode,
-            .relNode = bufdesc->seg_fileno,
+            .relNode = bufdesc->extra->seg_fileno,
             .bucketNode = SegmentBktId,
             .opt = 0
         };
 
 #ifdef USE_ASSERT_CHECKING
-        SegFlushCheckDiskLSN(spc, fakenode, bufferinfo.blockinfo.forknum, bufdesc->seg_blockno, bufToWrite);
+        SegFlushCheckDiskLSN(spc, fakenode, bufferinfo.blockinfo.forknum, bufdesc->extra->seg_blockno, bufToWrite);
 #endif
 
         if (ENABLE_DMS && t_thrd.role == PAGEWRITER_THREAD && ENABLE_DSS_AIO) {
@@ -4748,26 +4748,26 @@ void FlushBuffer(void *buf, SMgrRelation reln, ReadBufferMethod flushmethod, boo
 
             struct iocb *iocb_ptr = DSSAioGetIOCB(aio_cxt);
             int32 io_ret = seg_physical_aio_prep_pwrite(spc, fakenode, bufferinfo.blockinfo.forknum,
-                bufdesc->seg_blockno, tempBuf, (void *)iocb_ptr);
+                bufdesc->extra->seg_blockno, tempBuf, (void *)iocb_ptr);
             if (io_ret != DSS_SUCCESS) {
                 ereport(PANIC, (errmsg("dss aio failed, buffer: %d/%d/%d/%d/%d %d-%u",
                     fakenode.spcNode, fakenode.dbNode, fakenode.relNode, (int)fakenode.bucketNode,
-                    (int)fakenode.opt, bufferinfo.blockinfo.forknum, bufdesc->seg_blockno)));
+                    (int)fakenode.opt, bufferinfo.blockinfo.forknum, bufdesc->extra->seg_blockno)));
             }
 
-            if (bufdesc->aio_in_progress) {
+            if (bufdesc->extra->aio_in_progress) {
                 ereport(PANIC, (errmsg("buffer is already in aio progress, buffer: %d/%d/%d/%d/%d %d-%u",
                     fakenode.spcNode, fakenode.dbNode, fakenode.relNode, (int)fakenode.bucketNode,
-                    (int)fakenode.opt, bufferinfo.blockinfo.forknum, bufdesc->seg_blockno)));
+                    (int)fakenode.opt, bufferinfo.blockinfo.forknum, bufdesc->extra->seg_blockno)));
             }
 
             t_thrd.dms_cxt.buf_in_aio = true;
-            bufdesc->aio_in_progress = true;
+            bufdesc->extra->aio_in_progress = true;
             /* should be after io_prep_pwrite, because io_prep_pwrite will memset iocb struct */
             iocb_ptr->data = (void *)bufdesc;
             DSSAioAppendIOCB(aio_cxt, iocb_ptr);
         } else {
-            seg_physical_write(spc, fakenode, bufferinfo.blockinfo.forknum, bufdesc->seg_blockno, bufToWrite, false);
+            seg_physical_write(spc, fakenode, bufferinfo.blockinfo.forknum, bufdesc->extra->seg_blockno, bufToWrite, false);
         }
     } else {
         SegmentCheck(!IsSegmentFileNode(bufdesc->tag.rnode));
@@ -4784,7 +4784,7 @@ void FlushBuffer(void *buf, SMgrRelation reln, ReadBufferMethod flushmethod, boo
 
     u_sess->instr_cxt.pg_buffer_usage->shared_blks_written++;
 
-    ((BufferDesc *)buf)->lsn_on_disk = bufferinfo.lsn;
+    ((BufferDesc *)buf)->extra->lsn_on_disk = bufferinfo.lsn;
 
     /*
      * Mark the buffer as clean (unless BM_JUST_DIRTIED has become set) and
@@ -4969,13 +4969,13 @@ void DropSegRelNodeSharedBuffer(RelFileNode node, ForkNumber forkNum)
         BufferDesc *buf_desc = GetBufferDescriptor(i);
         uint32 buf_state;
 
-        if (buf_desc->seg_fileno != node.relNode || buf_desc->tag.rnode.spcNode != node.spcNode ||
+        if (buf_desc->extra->seg_fileno != node.relNode || buf_desc->tag.rnode.spcNode != node.spcNode ||
             buf_desc->tag.rnode.dbNode != node.dbNode) {
             continue;
         }
 
         buf_state = LockBufHdr(buf_desc);
-        if (buf_desc->seg_fileno == node.relNode && buf_desc->tag.rnode.spcNode == node.spcNode &&
+        if (buf_desc->extra->seg_fileno == node.relNode && buf_desc->tag.rnode.spcNode == node.spcNode &&
             buf_desc->tag.rnode.dbNode == node.dbNode && buf_desc->tag.forkNum == forkNum) {
             InvalidateBuffer(buf_desc); /* releases spinlock */
         } else {
@@ -5786,7 +5786,7 @@ void MarkBufferDirtyHint(Buffer buffer, bool buffer_std)
         if (ENABLE_INCRE_CKPT) {
             for (;;) {
                 buf_state = old_buf_state | (BM_DIRTY | BM_JUST_DIRTIED);
-                if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf_desc->rec_lsn))) {
+                if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf_desc->extra->rec_lsn))) {
                     break;
                 }
 
@@ -6358,7 +6358,7 @@ bool StartBufferIO(BufferDesc *buf, bool for_input)
          */
         (void)LWLockAcquire(buf->io_in_progress_lock, LW_EXCLUSIVE);
 
-        if (buf->aio_in_progress) {
+        if (buf->extra->aio_in_progress) {
             LWLockRelease(buf->io_in_progress_lock);
             pg_usleep(1000L);
             continue;
@@ -6471,7 +6471,7 @@ static void TerminateBufferIO_common(BufferDesc *buf, bool clear_dirty, uint32 s
 
     if (clear_dirty) {
         if (ENABLE_INCRE_CKPT) {
-            if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf->rec_lsn))) {
+            if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf->extra->rec_lsn))) {
                 remove_dirty_page_from_queue(buf);
             } else {
                 ereport(PANIC, (errmodule(MOD_INCRE_CKPT), errcode(ERRCODE_INVALID_BUFFER),
diff --git a/src/gausskernel/storage/buffer/localbuf.cpp b/src/gausskernel/storage/buffer/localbuf.cpp
index 6ac87aef6..01dc544d9 100644
--- a/src/gausskernel/storage/buffer/localbuf.cpp
+++ b/src/gausskernel/storage/buffer/localbuf.cpp
@@ -102,7 +102,7 @@ void LocalBufferFlushAllBuffer()
     int i;
 
     for (i = 0; i < u_sess->storage_cxt.NLocBuffer; i++) {
-        BufferDesc *bufHdr = &u_sess->storage_cxt.LocalBufferDescriptors[i];
+        BufferDesc *bufHdr = &u_sess->storage_cxt.LocalBufferDescriptors[i].bufferdesc;
         uint32 buf_state;
 
         buf_state = pg_atomic_read_u32(&bufHdr->state);
@@ -156,7 +156,7 @@ BufferDesc *LocalBufferAlloc(SMgrRelation smgr, ForkNumber forkNum, BlockNumber
     hresult = (LocalBufferLookupEnt*)hash_search(u_sess->storage_cxt.LocalBufHash, (void*)&new_tag, HASH_FIND, NULL);
     if (hresult != NULL) {
         b = hresult->id;
-        buf_desc = &u_sess->storage_cxt.LocalBufferDescriptors[b];
+        buf_desc = &u_sess->storage_cxt.LocalBufferDescriptors[b].bufferdesc;
         LocalBufferSanityCheck(buf_desc->tag, new_tag);
 #ifdef LBDEBUG
         fprintf(stderr, "LB ALLOC (%u,%d,%d) %d\n", smgr->smgr_rnode.node.relNode, forkNum, blockNum, -b - 1);
@@ -199,7 +199,7 @@ BufferDesc *LocalBufferAlloc(SMgrRelation smgr, ForkNumber forkNum, BlockNumber
         if (++u_sess->storage_cxt.nextFreeLocalBuf >= u_sess->storage_cxt.NLocBuffer)
             u_sess->storage_cxt.nextFreeLocalBuf = 0;
 
-        buf_desc = &u_sess->storage_cxt.LocalBufferDescriptors[b];
+        buf_desc = &u_sess->storage_cxt.LocalBufferDescriptors[b].bufferdesc;
 
         if (u_sess->storage_cxt.LocalRefCount[b] == 0) {
             buf_state = pg_atomic_read_u32(&buf_desc->state);
@@ -268,14 +268,14 @@ BufferDesc *LocalBufferAlloc(SMgrRelation smgr, ForkNumber forkNum, BlockNumber
      * it's all ours now.
      */
     buf_desc->tag = new_tag;
-    buf_desc->encrypt = smgr->encrypt ? true : false; /* set tde flag */
+    buf_desc->extra->encrypt = smgr->encrypt ? true : false; /* set tde flag */
     buf_state &= ~(BM_VALID | BM_DIRTY | BM_JUST_DIRTIED | BM_IO_ERROR);
     buf_state |= BM_TAG_VALID;
     buf_state &= ~BUF_USAGECOUNT_MASK;
     buf_state += BUF_USAGECOUNT_ONE;
     pg_atomic_write_u32(&buf_desc->state, buf_state);
 
-    buf_desc->seg_fileno = EXTENT_INVALID;
+    buf_desc->extra->seg_fileno = EXTENT_INVALID;
 
     *foundPtr = FALSE;
     return buf_desc;
@@ -301,7 +301,7 @@ void MarkLocalBufferDirty(Buffer buffer)
 
     Assert(u_sess->storage_cxt.LocalRefCount[buf_id] > 0);
 
-    buf_desc = &u_sess->storage_cxt.LocalBufferDescriptors[buf_id];
+    buf_desc = &u_sess->storage_cxt.LocalBufferDescriptors[buf_id].bufferdesc;
 
     buf_state = pg_atomic_fetch_or_u32(&buf_desc->state, BM_DIRTY);
     if (!(buf_state & BM_DIRTY)) {
@@ -326,7 +326,7 @@ void DropRelFileNodeLocalBuffers(const RelFileNode &rnode, ForkNumber forkNum, B
     int i;
 
     for (i = 0; i < u_sess->storage_cxt.NLocBuffer; i++) {
-        BufferDesc* buf_desc = &u_sess->storage_cxt.LocalBufferDescriptors[i];
+        BufferDesc* buf_desc = &u_sess->storage_cxt.LocalBufferDescriptors[i].bufferdesc;
         LocalBufferLookupEnt* hresult = NULL;
         uint32 buf_state;
 
@@ -368,7 +368,7 @@ void DropRelFileNodeAllLocalBuffers(const RelFileNode &rnode)
     int i;
 
     for (i = 0; i < u_sess->storage_cxt.NLocBuffer; i++) {
-        BufferDesc* buf_desc = &u_sess->storage_cxt.LocalBufferDescriptors[i];
+        BufferDesc* buf_desc = &u_sess->storage_cxt.LocalBufferDescriptors[i].bufferdesc;
         LocalBufferLookupEnt* hresult = NULL;
         uint32 buf_state;
 
@@ -412,23 +412,25 @@ static void InitLocalBuffers(void)
     int nbufs = u_sess->attr.attr_storage.num_temp_buffers;
     HASHCTL info;
     int i;
-
+    BufferDescExtra* extra;
     /* Allocate and zero buffer headers and auxiliary arrays */
-    u_sess->storage_cxt.LocalBufferDescriptors = (BufferDesc*)MemoryContextAllocZero(
-        SESS_GET_MEM_CXT_GROUP(MEMORY_CONTEXT_STORAGE), (unsigned int)nbufs * sizeof(BufferDesc));
+    u_sess->storage_cxt.LocalBufferDescriptors = (BufferDescPadded*)MemoryContextAllocZero(
+        SESS_GET_MEM_CXT_GROUP(MEMORY_CONTEXT_STORAGE), (unsigned int)nbufs * sizeof(BufferDescPadded));
     u_sess->storage_cxt.LocalBufferBlockPointers = (Block*)MemoryContextAllocZero(
         SESS_GET_MEM_CXT_GROUP(MEMORY_CONTEXT_STORAGE), (unsigned int)nbufs * sizeof(Block));
     u_sess->storage_cxt.LocalRefCount = (int32*)MemoryContextAllocZero(
         SESS_GET_MEM_CXT_GROUP(MEMORY_CONTEXT_STORAGE), (unsigned int)nbufs * sizeof(int32));
+    extra = (BufferDescExtra *)MemoryContextAllocZero(
+        SESS_GET_MEM_CXT_GROUP(MEMORY_CONTEXT_STORAGE), (unsigned int)nbufs * sizeof(BufferDescExtra));
     if (!u_sess->storage_cxt.LocalBufferDescriptors || !u_sess->storage_cxt.LocalBufferBlockPointers ||
-        !u_sess->storage_cxt.LocalRefCount)
+        !u_sess->storage_cxt.LocalRefCount  || !extra)
         ereport(FATAL, (errcode(ERRCODE_OUT_OF_MEMORY), errmsg("out of memory")));
 
     u_sess->storage_cxt.nextFreeLocalBuf = 0;
 
     /* initialize fields that need to start off nonzero */
     for (i = 0; i < nbufs; i++) {
-        BufferDesc* buf = &u_sess->storage_cxt.LocalBufferDescriptors[i];
+        BufferDesc* buf = &u_sess->storage_cxt.LocalBufferDescriptors[i].bufferdesc;
 
         /*
          * negative to indicate local buffer. This is tricky: shared buffers
@@ -437,6 +439,7 @@ static void InitLocalBuffers(void)
          * is -1.)
          */
         buf->buf_id = -i - 2;
+        buf->extra = &extra[i];
     }
 
     /* Create the lookup hash table */
diff --git a/src/gausskernel/storage/nvm/nvmbuffer.cpp b/src/gausskernel/storage/nvm/nvmbuffer.cpp
index dfcc74690..a7584b192 100644
--- a/src/gausskernel/storage/nvm/nvmbuffer.cpp
+++ b/src/gausskernel/storage/nvm/nvmbuffer.cpp
@@ -440,9 +440,9 @@ restart:
                                         BufferGetBlock(nvmBuf->buf_id + 1), BLCKSZ);
                                     securec_check(rc, "\0", "\0");
                                     buf->tag = nvmBuf->tag;
-                                    buf->seg_fileno = nvmBuf->seg_fileno;
-                                    buf->seg_blockno = nvmBuf->seg_blockno;
-                                    buf->lsn_on_disk = nvmBuf->lsn_on_disk;
+                                    buf->extra->seg_fileno = nvmBuf->extra->seg_fileno;
+                                    buf->extra->seg_blockno = nvmBuf->extra->seg_blockno;
+                                    buf->extra->lsn_on_disk = nvmBuf->extra->lsn_on_disk;
 
                                     /* Assert nvmBuf is not dirty \ cas without buffer header lock */
                                     nvm_buf_state &= ~(BM_TAG_VALID);
@@ -475,9 +475,9 @@ restart:
                                     BufferGetBlock(nvmBuf->buf_id + 1), BLCKSZ);
                                 securec_check(rc, "\0", "\0");
                                 buf->tag = nvmBuf->tag;
-                                buf->seg_fileno = nvmBuf->seg_fileno;
-                                buf->seg_blockno = nvmBuf->seg_blockno;
-                                buf->lsn_on_disk = nvmBuf->lsn_on_disk;
+                                buf->extra->seg_fileno = nvmBuf->extra->seg_fileno;
+                                buf->extra->seg_blockno = nvmBuf->extra->seg_blockno;
+                                buf->extra->lsn_on_disk = nvmBuf->extra->lsn_on_disk;
 
                                 // Assert nvmBuf is not dirty
                                 nvm_buf_state &= ~(BM_TAG_VALID);
@@ -761,11 +761,11 @@ restart:
     /* set Physical segment file. */
     if (pblk != NULL) {
         Assert(PhyBlockIsValid(*pblk));
-        buf->seg_fileno = pblk->relNode;
-        buf->seg_blockno = pblk->block;
+        buf->extra->seg_fileno = pblk->relNode;
+        buf->extra->seg_blockno = pblk->block;
     } else {
-        buf->seg_fileno = EXTENT_INVALID;
-        buf->seg_blockno = InvalidBlockNumber;
+        buf->extra->seg_fileno = EXTENT_INVALID;
+        buf->extra->seg_blockno = InvalidBlockNumber;
     }
     LWLockRelease(new_partition_lock);
 
diff --git a/src/gausskernel/storage/smgr/segment/segbuffer.cpp b/src/gausskernel/storage/smgr/segment/segbuffer.cpp
index f6a297334..2de3fe839 100644
--- a/src/gausskernel/storage/smgr/segment/segbuffer.cpp
+++ b/src/gausskernel/storage/smgr/segment/segbuffer.cpp
@@ -81,7 +81,7 @@ static bool SegStartBufferIO(BufferDesc *buf, bool forInput)
     while (true) {
         LWLockAcquire(buf->io_in_progress_lock, LW_EXCLUSIVE);
 
-        if (buf->aio_in_progress) {
+        if (buf->extra->aio_in_progress) {
             LWLockRelease(buf->io_in_progress_lock);
             pg_usleep(1000L);
             continue;
@@ -126,7 +126,7 @@ void SegTerminateBufferIO(BufferDesc *buf, bool clear_dirty, uint32 set_flag_bit
     buf_state &= ~(BM_IO_IN_PROGRESS | BM_IO_ERROR);
     if (clear_dirty) {
         if (ENABLE_INCRE_CKPT) {
-            if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf->rec_lsn))) {
+            if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf->extra->rec_lsn))) {
                 remove_dirty_page_from_queue(buf);
             } else {
                 ereport(PANIC, (errmodule(MOD_INCRE_CKPT), errcode(ERRCODE_INVALID_BUFFER),
@@ -289,7 +289,7 @@ void SegMarkBufferDirty(Buffer buf)
     if (ENABLE_INCRE_CKPT) {
         for (;;) {
             buf_state = old_buf_state | (BM_DIRTY | BM_JUST_DIRTIED);
-            if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&bufHdr->rec_lsn))) {
+            if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&bufHdr->extra->rec_lsn))) {
                 break;
             }
 
@@ -404,13 +404,13 @@ void SegFlushBuffer(BufferDesc *buf, SMgrRelation reln)
                 (int)buf->tag.rnode.opt, buf->tag.forkNum, buf->tag.blockNum)));
         }
 
-        if (buf->aio_in_progress) {
+        if (buf->extra->aio_in_progress) {
             ereport(PANIC, (errmsg("buffer is already in aio progress, buffer: %d/%d/%d/%d/%d %d-%u",
                 buf->tag.rnode.spcNode, buf->tag.rnode.dbNode, buf->tag.rnode.relNode, (int)buf->tag.rnode.bucketNode,
                 (int)buf->tag.rnode.opt, buf->tag.forkNum, buf->tag.blockNum)));
         }
 
-        buf->aio_in_progress = true;
+        buf->extra->aio_in_progress = true;
         t_thrd.dms_cxt.buf_in_aio = true;
         /* should be after io_prep_pwrite, because io_prep_pwrite will memset iocb struct */
         iocb_ptr->data = (void *)buf;
@@ -541,7 +541,7 @@ Buffer ReadSegBufferForDMS(BufferDesc* bufHdr, ReadBufferMode mode, SegSpace *sp
         }
     }
 
-    bufHdr->lsn_on_disk = PageGetLSN(bufBlock);
+    bufHdr->extra->lsn_on_disk = PageGetLSN(bufBlock);
 #ifdef USE_ASSERT_CHECKING
     bufHdr->lsn_dirty = InvalidXLogRecPtr;
 #endif
@@ -632,7 +632,7 @@ Buffer ReadBufferFast(SegSpace *spc, RelFileNode rnode, ForkNumber forkNum, Bloc
                                 blockNum, relpathperm(rnode, forkNum), PageGetPageLayoutVersion(bufBlock))));
             }
         }
-        bufHdr->lsn_on_disk = PageGetLSN(bufBlock);
+        bufHdr->extra->lsn_on_disk = PageGetLSN(bufBlock);
 #ifdef USE_ASSERT_CHECKING
         bufHdr->lsn_dirty = InvalidXLogRecPtr;
 #endif
diff --git a/src/gausskernel/storage/smgr/segment/segxlog.cpp b/src/gausskernel/storage/smgr/segment/segxlog.cpp
index fe1b431bf..264c8bb86 100644
--- a/src/gausskernel/storage/smgr/segment/segxlog.cpp
+++ b/src/gausskernel/storage/smgr/segment/segxlog.cpp
@@ -533,7 +533,7 @@ void move_extent_flush_buffer(XLogMoveExtent *xlog_data)
             BlockNumber new_seg_blockno = xlog_data->new_extent + i;
 
             BufferDesc *buf_desc = BufferGetBufferDescriptor(buffer);
-            if (buf_desc->seg_blockno == old_seg_blockno) {
+            if (buf_desc->extra->seg_blockno == old_seg_blockno) {
                 uint32 buf_state = LockBufHdr(buf_desc);
                 if (buf_state & BM_DIRTY) {
                     /* spin-lock should be released before IO */
@@ -558,7 +558,7 @@ void move_extent_flush_buffer(XLogMoveExtent *xlog_data)
                 }
             } else {
                 /* Get here only because standby read after we modifiy the segment head */
-                SegmentCheck(buf_desc->seg_blockno == new_seg_blockno);
+                SegmentCheck(buf_desc->extra->seg_blockno == new_seg_blockno);
                 UnpinBuffer(buf_desc, true);
             }
         }
diff --git a/src/gausskernel/storage/smgr/segment/space.cpp b/src/gausskernel/storage/smgr/segment/space.cpp
index 462489b18..9de167b89 100644
--- a/src/gausskernel/storage/smgr/segment/space.cpp
+++ b/src/gausskernel/storage/smgr/segment/space.cpp
@@ -597,8 +597,8 @@ static void copy_extent(SegExtentGroup *seg, RelFileNode logic_rnode, uint32 log
 
         if (BufferIsValid(buf)) {
             BufferDesc *bufdesc = GetBufferDescriptor(buf - 1);
-            SegmentCheck(bufdesc->seg_fileno == seg->rnode.relNode);
-            bufdesc->seg_blockno = to_block;
+            SegmentCheck(bufdesc->extra->seg_fileno == seg->rnode.relNode);
+            bufdesc->extra->seg_blockno = to_block;
 
             LockBuffer(buf, BUFFER_LOCK_UNLOCK);
             UnpinBuffer(bufdesc, true);
diff --git a/src/gausskernel/storage/smgr/segstore.cpp b/src/gausskernel/storage/smgr/segstore.cpp
index f36fa8221..3f9102db4 100755
--- a/src/gausskernel/storage/smgr/segstore.cpp
+++ b/src/gausskernel/storage/smgr/segstore.cpp
@@ -1456,8 +1456,8 @@ void seg_extend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, cha
                     reln->seg_desc[forknum]->head_blocknum, seg_head->nblocks, seg_head->total_blocks, blocknum)));
 
     /* Add physical location for XLog */
-    buf_desc->seg_fileno = (uint8)EXTENT_SIZE_TO_TYPE(loc.extent_size);
-    buf_desc->seg_blockno = loc.blocknum;
+    buf_desc->extra->seg_fileno = (uint8)EXTENT_SIZE_TO_TYPE(loc.extent_size);
+    buf_desc->extra->seg_blockno = loc.blocknum;
 
     if (seg_head->nblocks <= blocknum) {
         XLogDataSegmentExtend xlog_data;
@@ -1558,8 +1558,8 @@ SMGR_READ_STATUS seg_read(SMgrRelation reln, ForkNumber forknum, BlockNumber blo
     Buffer buf = BlockGetBuffer(buffer);
     if (BufferIsValid(buf)) {
         BufferDesc *buf_desc = BufferGetBufferDescriptor(buf);
-        buf_desc->seg_fileno = (uint8)EXTENT_SIZE_TO_TYPE(loc.extent_size);
-        buf_desc->seg_blockno = loc.blocknum;
+        buf_desc->extra->seg_fileno = (uint8)EXTENT_SIZE_TO_TYPE(loc.extent_size);
+        buf_desc->extra->seg_blockno = loc.blocknum;
     }
 
     SegReleaseBuffer(seg_buffer);
diff --git a/src/include/access/double_write.h b/src/include/access/double_write.h
index f5fad0a69..7acc213d4 100644
--- a/src/include/access/double_write.h
+++ b/src/include/access/double_write.h
@@ -322,7 +322,7 @@ inline bool dw_buf_valid_aio_finished(BufferDesc *buf_desc, uint32 buf_state)
         return true;
     }
 
-    return ((buf_state & BM_VALID) && ((buf_state & BM_DIRTY) || buf_desc->aio_in_progress));
+    return ((buf_state & BM_VALID) && ((buf_state & BM_DIRTY) || buf_desc->extra->aio_in_progress));
 }
 
 extern bool free_space_enough(int buf_id);
diff --git a/src/include/knl/knl_session.h b/src/include/knl/knl_session.h
index 9f6116f4d..298555389 100644
--- a/src/include/knl/knl_session.h
+++ b/src/include/knl/knl_session.h
@@ -1846,7 +1846,7 @@ typedef struct knl_u_storage_context {
     /* Pointers to shared state */
     // struct BufferStrategyControl* StrategyControl;
     int NLocBuffer; /* until buffers are initialized */
-    struct BufferDesc* LocalBufferDescriptors;
+    union BufferDescPadded* LocalBufferDescriptors;
     Block* LocalBufferBlockPointers;
     int32* LocalRefCount;
     int nextFreeLocalBuf;
diff --git a/src/include/storage/buf/buf_internals.h b/src/include/storage/buf/buf_internals.h
index 9222a264f..f42d14a16 100644
--- a/src/include/storage/buf/buf_internals.h
+++ b/src/include/storage/buf/buf_internals.h
@@ -191,30 +191,35 @@ typedef struct {
  * We use this same struct for local buffer headers, but the lock fields
  * are not used and not all of the flag bits are useful either.
  */
-typedef struct BufferDesc {
-    BufferTag tag; /* ID of page contained in buffer */
-    /* state of the tag, containing flags, refcount and usagecount */
-    pg_atomic_uint32 state;
-
+typedef struct BufferDescExtra {
     /* Cached physical location for segment-page storage, used for xlog */
     uint8 seg_fileno;
     BlockNumber seg_blockno;
 
+    /* below fields are used for incremental checkpoint */
+    pg_atomic_uint64 rec_lsn;        /* recovery LSN */
+    volatile uint64 dirty_queue_loc; /* actual loc of dirty page queue */
+    bool encrypt; /* enable table's level data encryption */
+
+    volatile uint64 lsn_on_disk;
+
+    volatile bool aio_in_progress; /* indicate aio is in progress */
+} BufferDescExtra;
+
+typedef struct BufferDesc {
+    BufferTag tag; /* ID of page contained in buffer */
     int buf_id;    /* buffer's index number (from 0) */
 
+    /* state of the tag, containing flags, refcount and usagecount */
+    pg_atomic_uint32 state;
+
     ThreadId wait_backend_pid; /* backend PID of pin-count waiter */
 
     LWLock* io_in_progress_lock; /* to wait for I/O to complete */
     LWLock* content_lock;        /* to lock access to buffer contents */
 
-    /* below fields are used for incremental checkpoint */
-    pg_atomic_uint64 rec_lsn;        /* recovery LSN */
-    volatile uint64 dirty_queue_loc; /* actual loc of dirty page queue */
-    bool encrypt; /* enable table's level data encryption */
-    
-    volatile uint64 lsn_on_disk;
+    BufferDescExtra *extra;
 
-    volatile bool aio_in_progress; /* indicate aio is in progress */
 #ifdef USE_ASSERT_CHECKING
     volatile uint64 lsn_dirty;
 #endif
@@ -240,7 +245,8 @@ typedef struct BufferDesc {
  * platform with either 32 or 128 byte line sizes, it's good to align to
  * boundaries and avoid false sharing.
  */
-#define BUFFERDESC_PAD_TO_SIZE (SIZEOF_VOID_P == 8 ? 128 : 1)
+//#define BUFFERDESC_PAD_TO_SIZE (SIZEOF_VOID_P == 8 ? 128 : 1)
+#define BUFFERDESC_PAD_TO_SIZE (SIZEOF_VOID_P == 8 ? 64 : 1)
 
 typedef union BufferDescPadded {
     BufferDesc bufferdesc;
@@ -248,12 +254,12 @@ typedef union BufferDescPadded {
 } BufferDescPadded;
 
 #define GetBufferDescriptor(id) (&t_thrd.storage_cxt.BufferDescriptors[(id)].bufferdesc)
-#define GetLocalBufferDescriptor(id) (&t_thrd.storage_cxt.LocalBufferDescriptors[(id)])
+#define GetLocalBufferDescriptor(id) ((BufferDesc *)&u_sess->storage_cxt.LocalBufferDescriptors[(id)].bufferdesc)
 #define BufferDescriptorGetBuffer(bdesc) ((bdesc)->buf_id + 1)
 
 #define BufferGetBufferDescriptor(buffer)                          \
     (AssertMacro(BufferIsValid(buffer)), BufferIsLocal(buffer) ?   \
-        &u_sess->storage_cxt.LocalBufferDescriptors[-(buffer)-1] : \
+        (BufferDesc *)&u_sess->storage_cxt.LocalBufferDescriptors[-(buffer)-1].bufferdesc : \
         &t_thrd.storage_cxt.BufferDescriptors[(buffer)-1].bufferdesc)
 
 #define BufferDescriptorGetContentLock(bdesc) (((bdesc)->content_lock))