implement partition mode (single_bucket, less_bucket)

Author: trdtnguyen

storage/innobase/buf/buf0flu.cc

@@ -1047,7 +1047,12 @@ buf_flush_write_block_low(
 
 	/* Force the log to the disk before writing the modified block */
 	if (!srv_read_only_mode) {
+#if defined (UNIV_PMEMOBJ_LOG) || defined (UNIV_PMEMOBJ_WAL)
+		//Since the log records are persist in NVM we don't need to follow WAL rule
+		//Skip flush log here
+#else //original 
 		log_write_up_to(bpage->newest_modification, true);
+#endif
 	}
 
 	switch (buf_page_get_state(bpage)) {

storage/innobase/fil/fil0fil.cc

@@ -61,7 +61,7 @@ Created 10/25/1995 Heikki Tuuri
 //declare it at storage/innobase/srv/srv0start.cc
 extern PMEM_FILE_COLL* gb_pfc;
 #endif
-#if defined (UNIV_PMEMOBJ_LOG) || defined (UNIV_PMEMOBJ_DBW) || defined(UNIV_PMEMOBJ_BUF)
+#if defined (UNIV_PMEMOBJ_LOG) || defined (UNIV_PMEMOBJ_DBW) || defined(UNIV_PMEMOBJ_BUF) || defined (UNIV_PMEMOBJ_WAL)
 #include "my_pmem_common.h"
 #include "my_pmemobj.h"
 extern PMEM_WRAPPER* gb_pmw;
@@ -5890,6 +5890,9 @@ fil_io(
 	return(err);
 }
 #if defined (UNIV_PMEMOBJ_BUF) 
+/*
+ * pm_fil_io_batch original, without space_oriented sort
+ * */
 dberr_t
 pm_fil_io_batch(
 		const IORequest&	type,
@@ -6127,6 +6130,148 @@ pm_fil_io_batch(
 	return DB_SUCCESS;
 
 }
+#if defined (UNIV_PMEMOBJ_BUF_PARTITION)
+/*
+ *Collect information about mapping a space to a hashed list and store in local heap
+ Call this function every time writing a page form buffer pool to PMEM_BUF
+ * */
+void
+pm_filemap_update_items(
+		PMEM_BUF*		buf,
+	   	page_id_t		page_id,
+		int				hashed_id,
+		uint64_t		bucket_size) {
+	
+	ulint i;
+	ulint j;
+	uint64_t cur_count;
+	uint64_t cur_size;
+
+	PMEM_FILE_MAP* fm = buf->filemap;
+	PMEM_FILE_MAP_ITEM* item;
+
+	cur_size = fm->size;
+	//scan the array, if the input page_id has space exist, increase count 
+	for (i = 0; i < cur_size; i++) {
+		if (fm->items[i]->space_id == page_id.space()) {
+			item = fm->items[i];
+			cur_count = item->count;
+			
+			//scan in the hashed_id array of the item
+			for (j = 0; j < cur_count; j++) {
+				if (item->hashed_ids[j] == hashed_id) {
+					//This hashed_id already counted
+					item->freqs[j]++;
+					break;
+				}
+			}	
+
+			if (j == cur_count) {
+				//new hashed id count
+				item->hashed_ids[cur_count] = hashed_id;
+				item->count++;
+			}
+			break;
+		}
+	}
+	
+	if (i == cur_size) {
+		//New item
+		item = static_cast<PMEM_FILE_MAP_ITEM*> (
+			malloc(sizeof(PMEM_FILE_MAP_ITEM))); 
+
+		item->space_id = page_id.space();	
+		item->count = 0;
+
+		mutex_enter(&fil_system->mutex);
+
+		fil_space_t*	space = fil_space_get_by_id(item->space_id);
+		if( space != NULL) {
+			fil_node_t*	node = UT_LIST_GET_FIRST(space->chain);
+			//bool is_user_ts = fil_is_user_tablespace_id(item->space_id);
+			item->name = static_cast<char*> (
+					malloc(256));
+			strcpy(item->name, node->name);	
+		} 
+
+		mutex_exit(&fil_system->mutex);
+
+		item->hashed_ids = static_cast<int*> (
+			calloc(bucket_size, sizeof(int)));
+		
+		item->freqs = static_cast<uint64_t*> (
+				calloc(bucket_size, sizeof(uint64_t)));
+
+		item->hashed_ids[item->count] = hashed_id;
+		item->freqs[item->count] = 1;
+
+		item->count++;
+		fm->items[cur_size] = item;
+			
+		fm->size++;
+		printf("PMEM_PART add item space_id=%zu, name = %s\n", item->space_id, item->name);
+	}
+	//else
+	//This space_id - hashed_id map already count, does nothing		
+}
+void
+pm_filemap_close(PMEM_BUF* buf){
+	ulint i;
+	PMEM_FILE_MAP* fm = buf->filemap;	
+	PMEM_FILE_MAP_ITEM* item;
+
+		
+	for (i = 0; i < fm->size; i++) {
+		item = fm->items[i];	
+		if (buf->filemap->items[i] != NULL) {
+			free(buf->filemap->items[i]->name);
+			free(buf->filemap->items[i]->hashed_ids);
+			buf->filemap->items[i]->hashed_ids = NULL;
+
+			free(buf->filemap->items[i]->freqs);
+			buf->filemap->items[i]->freqs = NULL;
+
+			free(buf->filemap->items[i]);
+		}
+		buf->filemap->items[i]=NULL;
+	}
+
+	if (buf->filemap->items != NULL){
+		free(buf->filemap->items);
+		buf->filemap->items = NULL;
+	}
+	
+	free (buf->filemap);
+	buf->filemap = NULL;
+}
+void
+pm_filemap_print(
+		PMEM_BUF*		buf, 
+		FILE*			f){
+	ulint i;
+	ulint j;
+	PMEM_FILE_MAP* fm = buf->filemap;	
+	PMEM_FILE_MAP_ITEM* item;
+	
+	fprintf(f, "Number of spaces =%zu\n", fm->size);
+	
+
+	for (i = 0; i < fm->size; i++) {
+		item = fm->items[i];
+
+			fprintf(f, "==== Space %zu sp_name %s apears on %zu hashed list: ( ", item->space_id, item->name,  item->count);
+		//print a pair (hashed_id, freq) for each item
+		for (j = 0; j < item->count; j++) {
+			fprintf(f,"[%zu,%zu] ",
+				   	item->hashed_ids[j],
+					item->freqs[j]);
+		}
+		fprintf(f, " ) ======\n");
+	}	
+	
+}
+#endif //UNIV_PMEMOBJ_BUF_PARTITION
+
 #endif //UNIV_PMEMOBJ_BUF
 
 #ifndef UNIV_HOTBACKUP

storage/innobase/handler/ha_innodb.cc

@@ -3706,25 +3706,18 @@ innobase_init(
 		srv_aio_n_slots_per_seg = 256;
 	}
 #endif
-#if defined(UNIV_PMEMOBJ_BUF) 
-	if (!srv_pmem_buf_bucket_size) {
-		srv_pmem_buf_bucket_size = 256;
-	}
-#endif 
-#if defined (UNIV_PMEMOBJ_BUF_FLUSHER)
-	if (!srv_pmem_n_flush_threads) {
-		srv_pmem_n_flush_threads = 8;
-	}
-
-#endif 
-
-#if defined(UNIV_PMEMOBJ_BUF) || defined (UNIV_PMEMOBJ_DBW) || defined (UNIV_PMEMOBJ_LOG)
+#if defined(UNIV_PMEMOBJ_BUF) || defined (UNIV_PMEMOBJ_DBW) || defined (UNIV_PMEMOBJ_LOG) || defined (UNIV_PMEMOBJ_WAL)
 	if (!srv_pmem_home_dir) {
 		srv_pmem_home_dir = (char*) "/mnt/pmem1";
 	}
 	if (!srv_pmem_pool_size) {
 		srv_pmem_pool_size = 8 * 1024; //8 GB
 	}
+#endif
+#if defined(UNIV_PMEMOBJ_BUF) 
+	if (!srv_pmem_buf_bucket_size) {
+		srv_pmem_buf_bucket_size = 256;
+	}
 	if (!srv_pmem_buf_size) {
 		srv_pmem_buf_size = 4 * 1024 ; //4 GB
 	}
@@ -3734,7 +3727,20 @@ innobase_init(
 	if (!srv_pmem_buf_flush_pct) {
 		srv_pmem_buf_flush_pct = 0.9; 
 	}
-#endif
+#endif 
+#if defined (UNIV_PMEMOBJ_BUF_FLUSHER)
+	if (!srv_pmem_n_flush_threads) {
+		srv_pmem_n_flush_threads = 8;
+	}
+#endif 
+#if defined (UNIV_PMEMOBJ_BUF_PARTITION)
+	if (!srv_pmem_n_space_bits) {
+		srv_pmem_n_space_bits = 5;
+	}
+	if (!srv_pmem_page_per_bucket_bits) {
+		srv_pmem_page_per_bucket_bits = 8;
+	}
+#endif 
 	if (!srv_log_group_home_dir) {
 		srv_log_group_home_dir = default_path;
 	}
@@ -19506,6 +19512,16 @@ static MYSQL_SYSVAR_ULONG(pmem_n_flush_threads, srv_pmem_n_flush_threads,
 
 #endif
 
+#if defined (UNIV_PMEMOBJ_BUF_PARTITION)
+static MYSQL_SYSVAR_ULONG(pmem_n_space_bits, srv_pmem_n_space_bits,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Number of bits present a page_no in partition algorithm, from 1 to 32 (space_no is 4-bytes number), default is 5.",
+  NULL, NULL, 5, 1, 32,0);
+static MYSQL_SYSVAR_ULONG(pmem_page_per_bucket_bits, srv_pmem_page_per_bucket_bits,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Number of bits present the maxmum number of pages per space in a bucket in partition algorithm, from 1 to log2(srv_pmem_buf_bucket_size), default is 10.",
+  NULL, NULL, 10, 1, 32, 0);
+#endif 
 #if defined (UNIV_PMEMOBJ_BUF) || defined (UNIV_PMEMOBJ_DBW) || defined (UNIV_PMEMOBJ_LOG) 
 static MYSQL_SYSVAR_STR(pmem_home_dir, srv_pmem_home_dir,
   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
@@ -20344,6 +20360,10 @@ static struct st_mysql_sys_var* innobase_system_variables[]= {
 #if defined (UNIV_PMEMOBJ_BUF_FLUSHER)
   MYSQL_SYSVAR(pmem_n_flush_threads),
 #endif 
+#if defined (UNIV_PMEMOBJ_BUF_PARTITION)
+  MYSQL_SYSVAR(pmem_n_space_bits),
+  MYSQL_SYSVAR(pmem_page_per_bucket_bits),
+#endif
 #if defined (UNIV_PMEMOBJ_BUF) || defined (UNIV_PMEMOBJ_DBW) || defined (UNIV_PMEMOBJ_LOG) 
   MYSQL_SYSVAR(pmem_home_dir),
   MYSQL_SYSVAR(pmem_pool_size),

storage/innobase/include/log0log.ic

@@ -33,11 +33,11 @@ Created 12/9/1995 Heikki Tuuri
 #include "mtr0types.h"
 #endif /* UNIV_LOG_LSN_DEBUG */
 
-#if defined(UNIV_PMEMOBJ_LOG)
-//This defined in log0log.cc
+//#if defined(UNIV_PMEMOBJ_LOG)
+////This defined in log0log.cc
 //#include "my_pmemobj.h"
 //extern PMEM_WRAPPER* gb_pmw;
-#endif
+//#endif
 
 /************************************************************//**
 Gets a log block flush bit.
@@ -419,7 +419,7 @@ log_reserve_and_write_fast(
 
 	log_sys->lsn += len;
 //#if defined(UNIV_PMEMOBJ_LOG)
-//	//Update lsn and buf_free
+	//Update lsn and buf_free
 //	gb_pmw->plogbuf->lsn = log_sys->lsn;
 //	gb_pmw->plogbuf->buf_free = log_sys->buf_free;
 //#endif

storage/innobase/include/my_pmemobj.h

@@ -70,6 +70,16 @@ typedef struct __pmem_flusher PMEM_FLUSHER;
 
 struct __pmem_buf_bucket_stat;
 typedef struct __pmem_buf_bucket_stat PMEM_BUCKET_STAT;
+
+struct __pmem_file_map_item;
+typedef struct __pmem_file_map_item PMEM_FILE_MAP_ITEM;
+
+struct __pmem_file_map;
+typedef struct __pmem_file_map PMEM_FILE_MAP;
+
+struct __pmem_sort_obj;
+typedef struct __pmem_sort_obj PMEM_SORT_OBJ;
+
 #endif //UNIV_PMEMOBJ_BUF
 
 POBJ_LAYOUT_BEGIN(my_pmemobj);
@@ -279,20 +289,71 @@ struct __pmem_buf {
 	PMEM_AIO_PARAM** params_arr;
 
 	PMEM_FLUSHER* flusher;	
+
+	PMEM_FILE_MAP* filemap;
+};
+
+// PARTITION //////////////
+/*Map space id to hashed_id, for partition purpose
+ * */
+struct __pmem_file_map_item {
+	uint32_t		space_id;
+	char*			name;
+
+	int*			hashed_ids; //list of hash_id this space appears on 
+	uint64_t		count; //number of hashed list this space appears on
+
+	uint64_t*		freqs; //freq[i] is the number of times this space apearts on hashed_ids[i]
+};
+struct __pmem_file_map {
+	PMEMrwlock			lock;
+
+	uint64_t					max_size;
+	uint64_t					size;
+	PMEM_FILE_MAP_ITEM**		items;
 };
 
+//this struct for space_oriented sort
+struct __pmem_sort_obj {
+	uint32_t			space_no;
+	
+	uint32_t			n_blocks;
+	uint32_t*			block_indexes;
+};
+
+void 
+pm_filemap_init(
+		PMEM_BUF*		buf);
+void
+pm_filemap_close(PMEM_BUF* buf);
+
+/*Update the page_id in the filemap
+ *
+ * */
+void
+pm_filemap_update_items(
+		PMEM_BUF*		buf,
+	   	page_id_t		page_id,
+		int				hashed_id,
+		uint64_t		bucket_size); 
+
+void
+pm_filemap_print(
+		PMEM_BUF*		buf, 
+		FILE*			outfile);
+
 #if defined(UNIV_PMEMOBJ_BUF_STAT)
 //statistic info about a bucket
 //Objects of those struct do not need in PMEM
 struct __pmem_buf_bucket_stat {
 	PMEMrwlock		lock;
 
-	uint64_t		n_writes;
-	uint64_t		n_overwrites;
-	uint64_t		n_reads;	
-	uint64_t		n_reads_flushing;	
+	uint64_t		n_writes;/*number of writes on the bucket*/ 
+	uint64_t		n_overwrites;/*number of overwrites on the bucket*/
+	uint64_t		n_reads;/*number of reads on the list (both flushing and normal)*/	
+	uint64_t		n_reads_flushing;/*number of reads on the on-flushing list*/	
 	uint64_t		max_linked_lists;
-	uint64_t		n_flushed_lists;
+	uint64_t		n_flushed_lists; /*number of of flushes on the bucket*/
 };
 
 #endif
@@ -488,6 +549,12 @@ void
 pm_buf_flush_list_cleaner_disabled_loop(void);
 #endif
 
+ulint 
+hash_f1(
+		uint32_t		space_no,
+	   	uint32_t		page_no,
+	   	uint64_t		n_buckets,
+		uint64_t		page_per_bucket_bits);
 
 #define PMEM_BUF_LIST_INSERT(pop, list, entries, type, func, args) do {\
 	POBJ_LIST_INSERT_NEW_HEAD(pop, &list.head, entries, sizeof(type), func, &args); \