normal shutdown works

Author: JonghyeokPark

storage/innobase/CMakeLists.txt

@@ -20,6 +20,7 @@ INCLUDE(innodb.cmake)
 SET(INNOBASE_SOURCES
 	pmem/pmem0mmap.cc
 	pmem/pmem0buf.cc
+	pmem/pmem0recv.cc
 	api/api0api.cc
 	api/api0misc.cc
 	btr/btr0btr.cc

storage/innobase/btr/btr0cur.cc

@@ -4943,6 +4943,10 @@ btr_cur_del_mark_set_clust_rec(
 			ulint cur_rec_size = rec_offs_size(offsets); 
 			pm_mmap_mtrlogbuf_commit(rec, cur_rec_size, nvm_bpage->id.space(), nvm_bpage->id.page_no());
     } else {
+        if ( nvm_bpage->id.space() == 28) {
+          fprintf(stderr, "[JONGQ] WATCH-OUT-2\n");
+          exit(-1);
+        }
         btr_cur_del_mark_set_clust_rec_log(rec, index, trx->id,
 					    roll_ptr, mtr);
     }
@@ -5048,10 +5052,16 @@ btr_cur_del_mark_set_sec_rec(
 	rec_t*		rec;
 	dberr_t		err;
 
+
 	block = btr_cur_get_block(cursor);
 	rec = btr_cur_get_rec(cursor);
 
-	err = lock_sec_rec_modify_check_and_lock(flags,
+  fprintf(stderr,"[JONGQ] btr_cur_del_mark_set_sec_rec! space: %lu\n", block->page.id.space());
+  if (block->page.id.space() == 28) {
+    fprintf(stderr, "[JONGQ] WRONG!!!\n");
+  }
+	
+  err = lock_sec_rec_modify_check_and_lock(flags,
 						 btr_cur_get_block(cursor),
 						 rec, cursor->index, thr, mtr);
 	if (err != DB_SUCCESS) {
@@ -6544,7 +6554,6 @@ btr_cur_unmark_extern_fields(
 
 	for (i = 0; i < n; i++) {
 		if (rec_offs_nth_extern(offsets, i)) {
-
 			btr_cur_set_ownership_of_extern_field(
 				page_zip, rec, index, offsets, i, TRUE, mtr);
 		}
@@ -7535,6 +7544,11 @@ btr_rec_free_externally_stored_fields(
 	ulint	n_fields;
 	ulint	i;
 
+  // dbug
+  if (index->space == 28) {
+    fprintf(stderr, "[JONGQ] btr_rec_Free_externally_stored_fields\n");
+  }
+
 	ut_ad(rec_offs_validate(rec, index, offsets));
 	ut_ad(mtr_is_page_fix(mtr, rec, MTR_MEMO_PAGE_X_FIX, index->table));
 	/* Free possible externally stored fields in the record */

storage/innobase/buf/buf0buf.cc

@@ -1620,8 +1620,6 @@ buf_chunk_nvm_init(
 	// NVDIMM-porting
 	chunk->mem = buf_pool->allocator.allocate_large_nvm(mem_size,
 							&chunk->mem_pfx);
-	//chunk->mem = pm_mmap_buf_chunk_alloc(mem_size, &chunk->mem_pfx);
-
 	if (UNIV_UNLIKELY(chunk->mem == NULL)) {
 		return(NULL);
 	}
@@ -2207,11 +2205,17 @@ buf_pool_free_instance(
 	chunks = buf_pool->chunks;
 	chunk = chunks + buf_pool->n_chunks;
 
+  fprintf(stderr, "[JONGQ] buf_pool->instance_no check: %lu\n", buf_pool->instance_no);
+  
 	while (--chunk >= chunks) {
 		buf_block_t*	block = chunk->blocks;
-   
+  
 #ifdef UNIV_NVDIMM_CACHE
-    if (buf_pool->instance_no == 8 && chunk == chunks) break;
+    if (buf_pool->instance_no == 8 && chunk == chunks) {
+			//buf_pool->allocator.deallocate_large_nvm(
+			//	chunk->mem, &chunk->mem_pfx);
+			break;
+		}
 #endif /* UNIV_NVDIMM_CACHE */
 
 		for (ulint i = chunk->size; i--; block++) {
@@ -2220,8 +2224,18 @@ buf_pool_free_instance(
 			ut_d(rw_lock_free(&block->debug_latch));
 		}
 
+#ifdef UNIV_NVDIMM_CACHE
+    if (buf_pool->instance_no == 8) {
+      buf_pool->allocator.deallocate_large_nvm(
+			          chunk->mem, &chunk->mem_pfx);
+    } else {
+      buf_pool->allocator.deallocate_large(
+			  chunk->mem, &chunk->mem_pfx);
+    }
+#else
 		buf_pool->allocator.deallocate_large(
 			chunk->mem, &chunk->mem_pfx);
+#endif
 	}
 
 	for (ulint i = BUF_FLUSH_LRU; i < BUF_FLUSH_N_TYPES; ++i) {
@@ -2298,7 +2312,7 @@ buf_pool_free(
 	}
 
 #ifdef UNIV_NVDIMM_CACHE
-    nvdimm_buf_pool_free(srv_nvdimm_buf_pool_instances);
+  nvdimm_buf_pool_free(srv_nvdimm_buf_pool_instances);
 #endif /* UNIV_NVDIMM_CACHE */
 
 	UT_DELETE(buf_chunk_map_reg);
@@ -5333,8 +5347,14 @@ buf_page_init_low(
 	HASH_INVALIDATE(bpage, hash);
 
 #ifdef UNIV_NVDIMM_CACHE
-    bpage->cached_in_nvdimm = false;
-    bpage->moved_to_nvdimm = false;
+//    bpage->cached_in_nvdimm = false;
+//    bpage->moved_to_nvdimm = false;
+	bpage->moved_to_nvdimm = false;
+	if (bpage->buf_pool_index >= srv_buf_pool_instances) {
+		bpage->cached_in_nvdimm = true;
+  } else {
+		bpage->cached_in_nvdimm = false;
+  }
 #endif /* UNIV_NVDIMM_CACHE */
 
 	ut_d(bpage->file_page_was_freed = FALSE);

storage/innobase/buf/buf0flu.cc

@@ -1047,7 +1047,15 @@ buf_flush_write_block_low(
 
 	/* Force the log to the disk before writing the modified block */
 	if (!srv_read_only_mode) {
-		log_write_up_to(bpage->newest_modification, true);
+		#if defined(UNIV_NVDIMM_CACHE_NO) && defined(UNIV_NVDIMM_CACHE_OL)
+			if (bpage->id.space() != 28) {
+				log_write_up_to(bpage->newest_modification, true);
+			} else {
+				//fprintf(stderr, "avoid neworder page to flush REDO log file\n");
+			}
+		#else
+			log_write_up_to(bpage->newest_modification, true);
+		#endif
 	}
 
 	switch (buf_page_get_state(bpage)) {

storage/innobase/buf/buf0rea.cc

@@ -153,6 +153,12 @@ buf_read_page_low(
 		return(0);
 	}
 
+  // debug
+// fprintf(stderr, "[JONGQ] read page %u:%u size=%u unzip=%u, sync=%d\n"
+//                , (unsigned) page_id.space(),
+//                  (unsigned) page_id.page_no(),
+//                  (unsigned) page_size.physical(), (unsigned) unzip, sync);
+
 	DBUG_PRINT("ib_buf", ("read page %u:%u size=%u unzip=%u,%s",
 			      (unsigned) page_id.space(),
 			      (unsigned) page_id.page_no(),
@@ -227,7 +233,7 @@ buf_read_page_low(
 			return(0);
 		}
 	}
-
+  
 	return(1);
 }
 
@@ -873,35 +879,34 @@ buf_read_recv_pages(
 		/* The tablespace is missing: do nothing */
 		return;
 	}
-
+  
 	fil_space_open_if_needed(space);
 
 	const page_size_t	page_size(space->flags);
 
 	for (i = 0; i < n_stored; i++) {
+
 		buf_pool_t*		buf_pool;
 		const page_id_t	cur_page_id(space_id, page_nos[i]);
 
 		count = 0;
 
 		buf_pool = buf_pool_get(cur_page_id);
 		while (buf_pool->n_pend_reads >= recv_n_pool_free_frames / 2) {
-
 			os_aio_simulated_wake_handler_threads();
 			os_thread_sleep(10000);
 
 			count++;
 
 			if (!(count % 1000)) {
-
 				ib::error()
 					<< "Waited for " << count / 100
 					<< " seconds for "
 					<< buf_pool->n_pend_reads
 					<< " pending reads";
 			}
 		}
-
+    
 		if ((i + 1 == n_stored) && sync) {
 			buf_read_page_low(
 				&err, true,

storage/innobase/fil/fil0fil.cc

@@ -5578,8 +5578,8 @@ fil_io(
 	least one file while holding it, if the file is not already open */
 
 	fil_mutex_enter_and_prepare_for_io(page_id.space());
-
-	fil_space_t*	space = fil_space_get_by_id(page_id.space());
+	
+  fil_space_t*	space = fil_space_get_by_id(page_id.space());
 
 	/* If we are deleting a tablespace we don't allow async read operations
 	on that. However, we do allow write operations and sync read operations. */
@@ -5609,14 +5609,12 @@ fil_io(
 	fil_node_t*	node = UT_LIST_GET_FIRST(space->chain);
 
 	for (;;) {
-
 		if (node == NULL) {
-
 			if (req_type.ignore_missing()) {
 				mutex_exit(&fil_system->mutex);
 				return(DB_ERROR);
 			}
-
+			
 			fil_report_invalid_page_access(
 				page_id.page_no(), page_id.space(),
 				space->name, byte_offset, len,
@@ -5632,7 +5630,6 @@ fil_io(
 		} else if (node->size > cur_page_no) {
 			/* Found! */
 			break;
-
 		} else {
 			if (space->id != srv_sys_space.space_id()
 			    && UT_LIST_GET_LEN(space->chain) == 1
@@ -5649,7 +5646,6 @@ fil_io(
 			}
 
 			cur_page_no -= node->size;
-
 			node = UT_LIST_GET_NEXT(chain, node);
 		}
 	}
@@ -5672,7 +5668,6 @@ fil_io(
 						     cur_page_no)
 					<< ", I/O length: " << len << " bytes";
 			}
-
 			return(DB_TABLESPACE_DELETED);
 		}
 
@@ -5774,7 +5769,7 @@ fil_io(
 #ifdef UNIV_HOTBACKUP
 	/* In mysqlbackup do normal i/o, not aio */
 	if (req_type.is_read()) {
-
+    
 		err = os_file_read(req_type, node->handle, buf, offset, len);
 
 	} else {
@@ -5793,7 +5788,6 @@ fil_io(
 		fsp_is_system_temporary(page_id.space())
 		? false : srv_read_only_mode,
 		node, message);
-
 #endif /* UNIV_HOTBACKUP */
 
 	if (err == DB_IO_NO_PUNCH_HOLE) {
@@ -5827,7 +5821,6 @@ fil_io(
 
 		ut_ad(fil_validate_skip());
 	}
-
 	return(err);
 }
 

storage/innobase/include/mtr0mtr.h

@@ -49,6 +49,7 @@ Created 11/26/1995 Heikki Tuuri
 #ifdef UNIV_NVDIMM_CACHE
 /** Commit a mini-transaction for nvdimm resident pages */
 #define mtr_commit_nvm(m) (m)->commit_nvm()
+#define mtr_commit_no_nvm(m) (m)->commit_no_nvm()
 #endif /* UNIV_NVDIMM_CACHE */
 
 /** Set and return a savepoint in mtr.
@@ -264,6 +265,7 @@ struct mtr_t {
 #ifdef UNIV_NVDIMM_CACHE
     /** Commit the mini-transaction for nvm resident page. */
     void commit_nvm();
+		void commit_no_nvm();
 #endif /* UNIV_NVDIMM_CACHE */
 
 	/** Commit a mini-transaction that did not modify any pages,

storage/innobase/include/pmem_mmap_obj.h

@@ -169,7 +169,6 @@ struct __pmem_mmap_mtrlog_hdr {
 };
 
 // logging? 
-
 int pm_mmap_mtrlogbuf_init(const size_t size);
 void pm_mmap_mtrlogbuf_mem_free();
 void pm_mmap_read_logfile_header(PMEM_MMAP_MTRLOGFILE_HDR* mtrlog_fil_hdr);
@@ -179,7 +178,6 @@ void pm_mmap_write_logfile_header_ckpt_info(uint64_t offset, uint64_t lsn);
 uint64_t pm_mmap_log_checkpoint(uint64_t cur_offset);
 void pm_mmap_log_commit(unsigned long cur_space, unsigned long cur_page, uint64_t cur_offset);
 
-
 ssize_t pm_mmap_mtrlogbuf_write(const uint8_t* buf, 
                                 unsigned long int n, unsigned long int lsn);
 
@@ -193,4 +191,32 @@ void pm_mmap_buf_init(const uint64_t size);
 void pm_mmap_buf_free(void);
 void pm_mmap_buf_write(unsigned long len, void* buf);
 //unsigned char* pm_mmap_buf_chunk_alloc(unsigned long mem_size, ut_new_pfx_t* pfx);
+
+
+// recovery
+//bool pm_mmap_recv(PMEM_MMAP_MTRLOGFILE_HDR* log_fil_hdr);
+bool pm_mmap_recv(uint64_t start_offset, uint64_t end_offset);
+uint64_t pm_mmap_recv_check(PMEM_MMAP_MTRLOGFILE_HDR* log_fil_hdr);
+void pm_mmap_recv_flush_buffer();
+
+// TODO(jhpark): covert these variables as structure (i.e., recv_sys_t)
+extern bool is_pmem_recv;
+extern uint64_t pmem_recv_offset;
+extern uint64_t pmem_recv_size;
+
+/** Recovery system data structure */
+//struct recv_sys_t{
+//  ib_mutex_t    mutex;
+	/*!< mutex protecting the fields apply_log_recs,
+	n_addrs, and the state field in each recv_addr struct */
+//  ib_mutex_t    writer_mutex; 
+	/*!< mutex coordinating 
+	flushing between recv_writer_thread and the recovery thread. */
+//  ibool   apply_log_recs;
+	/*!< this is TRUE when log rec application to pages is allowed; this flag tells the
+  i/o-handler if it should do log record application */
+//  byte*   buf;  /*!< buffer for parsing log records */
+//  ulint   len;  /*!< amount of data in buf */
+//};
+
 #endif  /* __PMEMMAPOBJ_H__ */

storage/innobase/include/ut0new.h

@@ -654,10 +654,9 @@ class ut_allocator {
 		}
 
 		ulint	n_bytes = n_elements * sizeof(T);
-    size_t offset =  mmap_buf_sys->cur_offset;
+    size_t offset = mmap_buf_sys->cur_offset;
 		pointer	ptr = reinterpret_cast<pointer>(
       gb_pm_buf + offset
-		//	os_mem_alloc_large(&n_bytes)
     );
 
 #ifdef UNIV_PFS_MEMORY
@@ -669,8 +668,6 @@ class ut_allocator {
 #endif /* UNIV_PFS_MEMORY */
 
     mmap_buf_sys->cur_offset += n_bytes;
-		//fprintf(stderr, "[JONGQ] large_nvm allocation offset:%lu cur_offset:%lu\n", 
-		//								offset, mmap_buf_sys->cur_offset);
 
 		return(ptr);
 	}
@@ -689,7 +686,6 @@ class ut_allocator {
 		deallocate_trace(pfx);
 #endif /* UNIV_PFS_MEMORY */
 
-		// fprintf(stderr, "[JONGQ] deallocation free! ptr: %p size: %lu\n",ptr, pfx->m_size);
 		mmap_buf_sys->cur_offset -= pfx->m_size;
 		//os_mem_free_large(ptr, pfx->m_size);
 	}