Skip to content

Commit 60e3ad1

Browse files
trdtnguyentrdtnguyen
committed
solve conflict
2 parents 7770a12 + 219f77c commit 60e3ad1

File tree

10 files changed

+1521
-50
lines changed

10 files changed

+1521
-50
lines changed

Diff for: ‎build_mysql.sh

+70
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
#!/bin/bash
2+
MYSQL_HOME=/home/vldb/mysql-pmem
3+
4+
#debug mode
5+
IS_DEBUG=0
6+
#IS_DEBUG=1
7+
8+
##The original InnoDB
9+
#BUILD_NAME="-DUNIV_TRACE_FLUSH_TIME"
10+
#BUILD_NAME="-DUNIV_PMEMOBJ_DBW -DUNIV_TRACE_FLUSH_TIME"
11+
#BUILD_NAME="-DUNIV_PMEMOBJ_WAL -DUNIV_TRACE_FLUSH_TIME"
12+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_RECOVERY -DUNIV_PMEMOBJ_BUF_STAT -DUNIV_TRACE_FLUSH_TIME"
13+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_RECOVERY -DUNIV_PMEMOBJ_BUF_PARTITION -DUNIV_PMEMOBJ_BUF_STAT -DUNIV_TRACE_FLUSH_TIME"
14+
#BUILD_NAME="-DUNIV_PMEMOBJ_NO_PERSIST -DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_RECOVERY -DUNIV_PMEMOBJ_BUF_PARTITION -DUNIV_PMEMOBJ_BUF_STAT -DUNIV_TRACE_FLUSH_TIME"
15+
16+
#Simulate DRAM latency
17+
#BUILD_NAME="-DUNIV_PMEM_SIM_LATENCY -DUNIV_PMEMOBJ_DBW -DUNIV_TRACE_FLUSH_TIME"
18+
BUILD_NAME="-DUNIV_PMEM_SIM_LATENCY -DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_RECOVERY -DUNIV_PMEMOBJ_BUF_PARTITION -DUNIV_PMEMOBJ_BUF_STAT -DUNIV_TRACE_FLUSH_TIME"
19+
20+
#LSB
21+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_LSB -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_TRACE_FLUSH_TIME"
22+
#BUILD_NAME="-DUNIV_PMEMOBJ_WAL -DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_RECOVERY -DUNIV_PMEMOBJ_BUF_PARTITION -DUNIV_PMEMOBJ_BUF_STAT -DUNIV_TRACE_FLUSH_TIME"
23+
24+
#for LSB implementation
25+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_LSB -DUNIV_PMEMOBJ_LSB_DEBUG -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_TRACE_FLUSH_TIME"
26+
27+
#BUILD_NAME=-DUNIV_NVM_LOG
28+
#BUILD_NAME=-DUNIV_PMEMOBJ_LOG
29+
#BUILD_NAME="-DUNIV_NVM_LOG -DUNIV_PMEMOBJ_LOG"
30+
31+
## WAL is the new log optimization that integrate log buffer and log file into one place in NVM
32+
#BUILD_NAME="-DUNIV_PMEMOBJ_DBW -DUNIV_TRACE_FLUSH_TIME"
33+
#BUILD_NAME="-DUNIV_PMEMOBJ_WAL -DUNIV_TRACE_FLUSH_TIME"
34+
35+
##the stable version: use free pool, no flusher
36+
#BUILD_NAME=-DUNIV_PMEMOBJ_BUF
37+
38+
##UNIV_PMEMOBJ_BUF_STAT collect statistics information, can be used as additional with other PMEMOBJ_BUF_***
39+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_STAT"
40+
41+
##The UNIV_PMEMOBJ_BUF_V2 reused the UNIV_PMEMOBJ_BUF, just overwrite the pm_buf_write and pm_buf_handle_finished that does not use the free_pool
42+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_V2"
43+
44+
##PMEMOBJ_BUF_FLUSHER use pmem_n_flush_threads to handle aio_batch sothat the cleaner thread can return immediately
45+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER"
46+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_APPEND"
47+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_PARTITION"
48+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_PARTITION -DUNIV_PMEMOBJ_BUF_PARTITION_STAT"
49+
50+
## For EVEN
51+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_RECOVERY"
52+
##Use this for statistic information, n_writes, n_overwrites, n_reads, n_reads_hit, n_reads_flushing, ...
53+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_RECOVERY -DUNIV_PMEMOBJ_BUF_STAT -DUNIV_TRACE_FLUSH_TIME"
54+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_RECOVERY -DUNIV_PMEMOBJ_BUF_STAT -DUNIV_TRACE_FLUSH_TIME -DUNIV_PMEMOBJ_BUF_RECOVERY_DEBUG"
55+
56+
## For SINGLE and LESS
57+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_RECOVERY -DUNIV_PMEMOBJ_BUF_PARTITION -DUNIV_PMEMOBJ_BUF_STAT -DUNIV_TRACE_FLUSH_TIME"
58+
#BUILD_NAME="-DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_RECOVERY -DUNIV_PMEMOBJ_BUF_PARTITION -DUNIV_PMEMOBJ_BUF_STAT -DUNIV_TRACE_FLUSH_TIME -DUNIV_PMEMOBJ_BUF_RECOVERY_DEBUG"
59+
60+
##combine all
61+
#BUILD_NAME="-DUNIV_NVM_LOG -DUNIV_PMEMOBJ_LOG -DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER"
62+
#BUILD_NAME="-DUNIV_PMEMOBJ_WAL -DUNIV_PMEMOBJ_BUF -DUNIV_PMEMOBJ_BUF_FLUSHER -DUNIV_PMEMOBJ_BUF_RECOVERY -DUNIV_PMEMOBJ_BUF_PARTITION -DUNIV_PMEMOBJ_BUF_STAT -DUNIV_TRACE_FLUSH_TIME"
63+
64+
65+
66+
67+
echo "BUILD MODE: $BUILD_NAME with debug=$IS_DEBUG"
68+
cd $MYSQL_HOME/bld
69+
cmake .. -DWITH_DEBUG=$IS_DEBUG -DCMAKE_C_FLAGS="$BUILD_NAME -DUNIV_AIO_IMPROVE" -DCMAKE_CXX_FLAGS="$BUILD_NAME -DUNIV_AIO_IMPROVE" -DDOWNLOAD_BOOST=1 -DWITH_BOOST=/root/boost
70+
make install -j48

Diff for: ‎storage/innobase/buf/buf0flu.cc

+141-36
Original file line numberDiff line numberDiff line change
@@ -1092,15 +1092,17 @@ buf_flush_write_block_low(
10921092
#if defined(UNIV_PMEMOBJ_BUF)
10931093

10941094
//printf("\n [begin pm_buf_write space %zu page %zu==>", bpage->id.space(),bpage->id.page_no());
1095-
// if (!fsp_is_system_temporary(bpage->id.space())){
1096-
#if defined (UNIV_PMEMOBJ_BUF_V2)
1097-
int ret = pm_buf_write_no_free_pool(gb_pmw->pop, gb_pmw->pbuf, bpage->id, bpage->size, frame, sync);
1095+
1096+
#if defined(UNIV_PMEMOBJ_LSB)
1097+
int ret = pm_lsb_write(gb_pmw->pop, gb_pmw->plsb, bpage->id, bpage->size, frame, sync);
1098+
#elif defined (UNIV_PMEMOBJ_BUF_V2)
1099+
int ret = pm_buf_write_no_free_pool(gb_pmw->pop, gb_pmw->pbuf, bpage->id, bpage->size, frame, sync);
10981100
#elif defined (UNIV_PMEMOBJ_BUF_FLUSHER)
1099-
int ret = pm_buf_write_with_flusher(gb_pmw->pop, gb_pmw->pbuf, bpage->id, bpage->size, frame, sync);
1101+
int ret = pm_buf_write_with_flusher(gb_pmw->pop, gb_pmw->pbuf, bpage->id, bpage->size, frame, sync);
11001102
#elif defined (UNIV_PMEMOBJ_BUF_APPEND)
1101-
int ret = pm_buf_write_with_flusher_append(gb_pmw->pop, gb_pmw->pbuf, bpage->id, bpage->size, frame, sync);
1103+
int ret = pm_buf_write_with_flusher_append(gb_pmw->pop, gb_pmw->pbuf, bpage->id, bpage->size, frame, sync);
11021104
#else
1103-
int ret = pm_buf_write(gb_pmw->pop, gb_pmw->pbuf, bpage->id, bpage->size, frame, sync);
1105+
int ret = pm_buf_write(gb_pmw->pop, gb_pmw->pbuf, bpage->id, bpage->size, frame, sync);
11041106
#endif
11051107
//printf("END pm_buf_write space %zu page %zu]\n", bpage->id.space(),bpage->id.page_no());
11061108
//printf(" END pm_buf_write]");
@@ -3520,7 +3522,12 @@ DECLARE_THREAD(buf_flush_page_cleaner_coordinator)(
35203522
buf_page_cleaner_is_active = false;
35213523
#if defined (UNIV_PMEMOBJ_BUF_FLUSHER)
35223524
printf ("PMEM_DEBUG buf_page_cleaner_is_active = false\n");
3525+
3526+
#if defined (UNIV_PMEMOBJ_LSB)
3527+
PMEM_FLUSHER* flusher = gb_pmw->plsb->flusher;
3528+
#else
35233529
PMEM_FLUSHER* flusher = gb_pmw->pbuf->flusher;
3530+
#endif
35243531
os_event_set(flusher->is_req_not_empty);
35253532
#endif
35263533

@@ -3910,9 +3917,8 @@ FlushObserver::flush()
39103917

39113918
#if defined (UNIV_PMEMOBJ_BUF_FLUSHER)
39123919
//******************* FLUSHER implementation **********/
3913-
void
3920+
PMEM_FLUSHER*
39143921
pm_flusher_init(
3915-
PMEM_BUF* buf,
39163922
const size_t size) {
39173923
PMEM_FLUSHER* flusher;
39183924
ulint i;
@@ -3935,52 +3941,55 @@ pm_flusher_init(
39353941
flusher->n_requested = 0;
39363942
flusher->is_running = false;
39373943

3938-
//flusher->flush_list_arr = static_cast <PMEM_BUF_BLOCK_LIST*> ( calloc(size, sizeof(PMEM_BUF_BLOCK_LIST*)));
39393944
flusher->flush_list_arr = static_cast <PMEM_BUF_BLOCK_LIST**> ( calloc(size, sizeof(PMEM_BUF_BLOCK_LIST*)));
39403945
for (i = 0; i < size; i++) {
3941-
//flusher->flush_list_arr[i] = static_cast <PMEM_BUF_BLOCK_LIST*> (
3942-
// malloc(sizeof(PMEM_BUF_BLOCK_LIST)));
39433946
flusher->flush_list_arr[i] = NULL;
39443947
}
3945-
buf->flusher = flusher;
3948+
#if defined (UNIV_PMEMOBJ_LSB)
3949+
flusher->bucket_arr = static_cast <PMEM_LSB_HASH_BUCKET**> ( calloc(size, sizeof(PMEM_LSB_HASH_BUCKET*)));
3950+
for (i = 0; i < size; i++) {
3951+
flusher->bucket_arr[i] = NULL;
3952+
}
3953+
#endif
3954+
return flusher;
39463955
}
39473956
void
39483957
pm_buf_flusher_close(
3949-
PMEM_BUF* buf) {
3958+
PMEM_FLUSHER* flusher) {
39503959
ulint i;
39513960

39523961
//wait for all workers finish their work
3953-
while (buf->flusher->n_workers > 0) {
3962+
while (flusher->n_workers > 0) {
39543963
os_thread_sleep(10000);
39553964
}
39563965

3957-
for (i = 0; i < buf->flusher->size; i++) {
3958-
if (buf->flusher->flush_list_arr[i]){
3966+
for (i = 0; i < flusher->size; i++) {
3967+
if (flusher->flush_list_arr[i]){
39593968
//free(buf->flusher->flush_list_arr[i]);
3960-
buf->flusher->flush_list_arr[i] = NULL;
3969+
flusher->flush_list_arr[i] = NULL;
39613970
}
39623971

39633972
}
39643973

3965-
if (buf->flusher->flush_list_arr){
3966-
free(buf->flusher->flush_list_arr);
3967-
buf->flusher->flush_list_arr = NULL;
3974+
if (flusher->flush_list_arr){
3975+
free(flusher->flush_list_arr);
3976+
flusher->flush_list_arr = NULL;
39683977
}
39693978
//printf("free array ok\n");
39703979

3971-
mutex_destroy(&buf->flusher->mutex);
3980+
mutex_destroy(&flusher->mutex);
39723981

3973-
os_event_destroy(buf->flusher->is_req_not_empty);
3974-
os_event_destroy(buf->flusher->is_req_full);
3982+
os_event_destroy(flusher->is_req_not_empty);
3983+
os_event_destroy(flusher->is_req_full);
39753984
//os_event_destroy(buf->flusher->is_flush_full);
39763985

3977-
os_event_destroy(buf->flusher->is_all_finished);
3978-
os_event_destroy(buf->flusher->is_all_closed);
3986+
os_event_destroy(flusher->is_all_finished);
3987+
os_event_destroy(flusher->is_all_closed);
39793988
//printf("destroys mutex and events ok\n");
39803989

3981-
if(buf->flusher){
3982-
buf->flusher = NULL;
3983-
free(buf->flusher);
3990+
if(flusher){
3991+
flusher = NULL;
3992+
free(flusher);
39843993
}
39853994
//printf("free flusher ok\n");
39863995
}
@@ -4024,7 +4033,12 @@ DECLARE_THREAD(pm_flusher_coordinator)(
40244033
}
40254034
#endif /* UNIV_LINUX */
40264035

4036+
#if defined (UNIV_PMEMOBJ_LSB)
4037+
PMEM_FLUSHER* flusher = gb_pmw->plsb->flusher;
4038+
#else
40274039
PMEM_FLUSHER* flusher = gb_pmw->pbuf->flusher;
4040+
#endif //UNIV_PMEMOBJ_LSB
4041+
40284042
flusher->is_running = true;
40294043
//ulint ret;
40304044

@@ -4066,7 +4080,12 @@ DECLARE_THREAD(pm_flusher_worker)(
40664080
{
40674081
ulint i;
40684082

4083+
#if defined (UNIV_PMEMOBJ_LSB)
4084+
PMEM_FLUSHER* flusher = gb_pmw->plsb->flusher;
4085+
#else
40694086
PMEM_FLUSHER* flusher = gb_pmw->pbuf->flusher;
4087+
#endif //UNIV_PMEM_LSB
4088+
40704089
PMEM_BUF_BLOCK_LIST* plist = NULL;
40714090

40724091
my_thread_init();
@@ -4087,6 +4106,25 @@ DECLARE_THREAD(pm_flusher_worker)(
40874106
mutex_enter(&flusher->mutex);
40884107
if (flusher->n_requested > 0) {
40894108

4109+
#if defined (UNIV_PMEMOBJ_LSB)
4110+
//Case B: Implement of LSB
4111+
// find the first non-null pointer and do aio flush for the bucket
4112+
for (i = 0; i < flusher->size; i++) {
4113+
PMEM_LSB_HASH_BUCKET* bucket = flusher->bucket_arr[i];
4114+
if (bucket){
4115+
pm_lsb_flush_bucket(gb_pmw->pop, gb_pmw->plsb, bucket);
4116+
flusher->n_requested--;
4117+
os_event_set(flusher->is_req_full);
4118+
flusher->bucket_arr[i] = NULL;
4119+
#if defined (UNIV_PMEMOBJ_LSB_DEBUG)
4120+
//printf("LSB [2] pm_flusher_worker flusher->size %zu bucket pointer index %zu\n", flusher->size, i);
4121+
#endif
4122+
break;
4123+
}
4124+
}
4125+
4126+
#else //UNIV_PMEMOBJ_BUF
4127+
//Case A: Implement of PB-NVM
40904128
for (i = 0; i < flusher->size; i++) {
40914129
plist = flusher->flush_list_arr[i];
40924130
if (plist)
@@ -4106,6 +4144,8 @@ DECLARE_THREAD(pm_flusher_worker)(
41064144
break;
41074145
}
41084146
}
4147+
#endif //UNIV_PMEMOBJ_LSB
4148+
41094149
} //end if flusher->n_requested > 0
41104150

41114151
if (flusher->n_requested == 0) {
@@ -4294,6 +4334,76 @@ pm_handle_finished_block_with_flusher(
42944334
//the list has some unfinished aio
42954335
pmemobj_rwlock_unlock(pop, &pflush_list->lock);
42964336
}
4337+
4338+
#if defined (UNIV_PMEMOBJ_LSB)
4339+
/*
4340+
*Handle finish block in the aio
4341+
Note that this function may has contention between flush threads
4342+
* */
4343+
void
4344+
pm_lsb_handle_finished_block(
4345+
PMEMobjpool* pop,
4346+
PMEM_LSB* lsb,
4347+
PMEM_BUF_BLOCK* pblock)
4348+
{
4349+
PMEM_FLUSHER* flusher;
4350+
ulint i;
4351+
4352+
//(1) handle the lsb_list
4353+
PMEM_BUF_BLOCK_LIST* plsb_list = D_RW(lsb->lsb_list);
4354+
4355+
//Unlike PB-NVM, LSB implement lock the lsb list until all pages finish propagation, so we don't need to lock the list
4356+
//pmemobj_rwlock_wrlock(pop, &pflush_list->lock);
4357+
pmemobj_rwlock_wrlock(pop, &lsb->lsb_aio_lock);
4358+
++lsb->n_aio_completed;
4359+
pmemobj_rwlock_unlock(pop, &lsb->lsb_aio_lock);
4360+
4361+
if (lsb->n_aio_completed == plsb_list->cur_pages)
4362+
//if (lsb->n_aio_completed == lsb->n_aio_submitted)
4363+
{
4364+
#if defined (UNIV_PMEMOBJ_LSB_DEBUG)
4365+
printf("LSB [5] pm_lsb_handle_finished_block ALL FINISHED lsb->n_aio_completed/n_aio_submitted %zu/%zu cur_pages %zu max_pages %zu \n", lsb->n_aio_completed, lsb->n_aio_submitted, plsb_list->cur_pages, plsb_list->max_pages);
4366+
#endif
4367+
//(0) flush spaces
4368+
pm_lsb_flush_spaces_in_list(pop, lsb, plsb_list);
4369+
//
4370+
// Reset the param_array
4371+
ulint arr_idx;
4372+
arr_idx = plsb_list->param_arr_index;
4373+
assert(arr_idx >= 0);
4374+
4375+
for (i = 0; i < lsb->param_arr_size; ++i){
4376+
lsb->param_arrs[i].is_free = true;
4377+
}
4378+
lsb->cur_free_param = 0;
4379+
4380+
//(1) Reset blocks in the list
4381+
for (i = 0; i < plsb_list->max_pages; i++) {
4382+
D_RW(D_RW(plsb_list->arr)[i])->state = PMEM_FREE_BLOCK;
4383+
D_RW(D_RW(plsb_list->arr)[i])->sync = false;
4384+
}
4385+
plsb_list->cur_pages = 0;
4386+
plsb_list->is_flush = false;
4387+
4388+
//(2) Reset the hashtable
4389+
pm_lsb_hashtable_reset(pop, lsb);
4390+
lsb->n_aio_submitted = lsb->n_aio_completed = 0;
4391+
4392+
// (3) Reset the flusher
4393+
flusher = lsb->flusher;
4394+
mutex_enter(&flusher->mutex);
4395+
for (i = 0; i < flusher->size; ++i) {
4396+
flusher->bucket_arr[i] = NULL;
4397+
}
4398+
flusher->n_requested = 0;
4399+
mutex_exit(&flusher->mutex);
4400+
4401+
//(4) wakeup the write thread
4402+
os_event_set(lsb->all_aio_finished);
4403+
}
4404+
}
4405+
#endif //UNIV_PMEMOBJ_LSB
4406+
42974407
#endif // UNIV_PMEMOBJ_BUF_FLUSHER
42984408

42994409
/////////////////////////////////////////////////
@@ -4333,24 +4443,19 @@ DECLARE_THREAD(pm_buf_flush_list_cleaner_coordinator)(
43334443
pfs_register_thread(pm_list_cleaner_thread_key);
43344444
#endif /* UNIV_PFS_THREAD */
43354445

4336-
#if defined(UNIV_PMEMOBJ_BUF_FLUSHER)
4337-
PMEM_FLUSHER* flusher = gb_pmw->pbuf->flusher;
4338-
#endif
43394446

43404447
while (srv_shutdown_state == SRV_SHUTDOWN_NONE) {
43414448
//print out each 10s
43424449
os_thread_sleep(10000000);
43434450
if (srv_shutdown_state != SRV_SHUTDOWN_NONE) {
43444451
break;
43454452
}
4453+
#if defined (UNIV_PMEMOBJ_LSB)
4454+
printf("cur lsb_list cur pages/max_pages = %zu/%zu\n", D_RW(gb_pmw->plsb->lsb_list)->cur_pages, D_RW(gb_pmw->plsb->lsb_list)->max_pages);
4455+
#else
43464456
printf("cur free list = %zu, cur spec_list = %zu\n",
43474457
D_RW(gb_pmw->pbuf->free_pool)->cur_lists,
43484458
D_RW(gb_pmw->pbuf->spec_list)->cur_pages);
4349-
4350-
#if defined(UNIV_PMEMOBJ_BUF_FLUSHER)
4351-
//mutex_enter(&flusher->mutex);
4352-
//printf(" n_requested/size %zu/%zu \n", flusher->n_requested, flusher->size);
4353-
//mutex_exit(&flusher->mutex);
43544459
#endif
43554460
} //end while thread
43564461

Diff for: ‎storage/innobase/buf/buf0rea.cc

+3-1
Original file line numberDiff line numberDiff line change
@@ -199,7 +199,9 @@ buf_read_page_low(
199199
#if defined (UNIV_PMEMOBJ_BUF)
200200
//printf ("\n[start our func ");
201201
//printf("pm_buf_read space %zu page %zu start...", page_id.space(), page_id.page_no());
202-
#if defined (UNIV_PMEMOBJ_BUF_APPEND)
202+
#if defined (UNIV_PMEMOBJ_LSB)
203+
const PMEM_BUF_BLOCK* pblock= pm_lsb_read(gb_pmw->pop, gb_pmw->plsb, page_id, page_size, (byte*)dst, sync);
204+
#elif defined (UNIV_PMEMOBJ_BUF_APPEND)
203205
const PMEM_BUF_BLOCK* pblock= pm_buf_read_lasted(gb_pmw->pop, gb_pmw->pbuf, page_id, page_size, (byte*)dst, sync);
204206
#else
205207
const PMEM_BUF_BLOCK* pblock= pm_buf_read(gb_pmw->pop, gb_pmw->pbuf, page_id, page_size, (byte*)dst, sync);

0 commit comments

Comments
 (0)