Initialized necessary data structures for temporary write buffer

Author: meeeejin

storage/innobase/buf/buf0buf.cc

@@ -1834,6 +1834,50 @@ buf_pool_init_instance(
 		buf_pool->watch[i].buf_pool_index = buf_pool->instance_no;
 	}
 
+    /* mijin */
+    buf_pool->need_to_flush_twb = false;
+    buf_pool->batch_running = false;
+    buf_pool->flush_running = false;
+
+    buf_pool->b_event = os_event_create(0);
+    buf_pool->f_event = os_event_create(0);
+
+    buf_pool->total_entry = srv_LRU_scan_depth;
+    buf_pool->first_free = 0;
+
+    /* Initialize the temporary write buffer. */
+    buf_pool->write_buf_unaligned = static_cast<byte*>(
+            ut_malloc_nokey((1 + buf_pool->total_entry) * UNIV_PAGE_SIZE));
+
+    buf_pool->write_buf = static_cast<byte*>(
+            ut_align(buf_pool->write_buf_unaligned,
+                UNIV_PAGE_SIZE));
+
+    /* Initialize hash structure for copy pool. */
+    srv_n_twb_hash_locks = static_cast<ulong>(
+            ut_2_power_up(srv_n_twb_hash_locks));
+
+    buf_pool->twb_hash = ib_create(
+            2 * buf_pool->total_entry,
+            LATCH_ID_HASH_TABLE_RW_LOCK,
+            srv_n_twb_hash_locks,
+            MEM_HEAP_FOR_TWB_HASH);
+
+    /* Initialize a block and page structure. */
+    buf_pool->twb_block_arr = static_cast<buf_block_t*>(
+            ut_zalloc_nokey(buf_pool->total_entry * sizeof(buf_block_t)));
+
+    for (i = 0; i < buf_pool->total_entry; i++) {
+        mutex_create(LATCH_ID_BUF_BLOCK_MUTEX,
+                &(buf_pool->copy_block_arr[i]).mutex);
+        rw_lock_create(PFS_NOT_INSTRUMENTED,
+                &(buf_pool->copy_block_arr[i]).lock, SYNC_LEVEL_VARYING);
+
+        assert(!posix_memalign((void **) &(buf_pool->copy_block_arr[i]).frame,
+                    4096, UNIV_PAGE_SIZE));
+    }
+    /* end */
+
 	/* All fields are initialized by ut_zalloc_nokey(). */
 
 	buf_pool->try_LRU_scan = TRUE;
@@ -1922,6 +1966,17 @@ buf_pool_free_instance(
 	hash_table_free(buf_pool->page_hash);
 	hash_table_free(buf_pool->zip_hash);
 
+    /* mijin */
+    os_event_destroy(buf_pool->b_event);
+    os_event_destroy(buf_pool->f_event);
+
+    ut_free(buf_pool->write_buf_unaligned);
+    ut_free(buf_pool->twb_block_arr);
+
+    ha_clear(buf_pool->twb_hash);
+    hash_table_free(buf_pool->twb_hash);
+    /* end */
+
 	buf_pool->allocator.~ut_allocator();
 }
 
@@ -5000,6 +5055,10 @@ buf_page_init_low(
 	HASH_INVALIDATE(bpage, hash);
 
 	ut_d(bpage->file_page_was_freed = FALSE);
+
+    /* mijin */
+    bpage->copy_target = false;
+    /* end */
 }
 
 /** Inits a page to the buffer buf_pool.
@@ -5882,6 +5941,30 @@ buf_page_io_complete(
 
 		buf_pool->stat.n_pages_written++;
 
+        /* mijin: TODO: NEED TO BE FIXED!!!*/
+        if (bpage->copy_target) {
+            twb_meta_dir_t* entry = NULL;
+            ulint fold;
+
+            fold = bpage->id.fold();
+
+            rw_lock_s_lock(buf_pool->twb_hash_lock);
+            HASH_SEARCH(hash, buf_pool->copy_pool_cache, fold, copy_pool_meta_dir_t*, entry, ut_ad(1),
+                    entry->space == bpage->space && entry->offset == bpage->offset);
+            rw_lock_s_unlock(buf_pool->copy_pool_cache_hash_lock);
+
+            if (entry) {
+                rw_lock_x_lock(buf_pool->copy_pool_cache_hash_lock);
+                HASH_DELETE(copy_pool_meta_dir_t, hash, buf_pool->copy_pool_cache, fold, entry);
+                rw_lock_x_unlock(buf_pool->copy_pool_cache_hash_lock);
+
+                free(entry);
+            }
+        }
+        /* end */
+
+
+
 		/* We decide whether or not to evict the page from the
 		LRU list based on the flush_type.
 		* BUF_FLUSH_LIST: don't evict

storage/innobase/ha/ha0ha.cc

@@ -59,7 +59,10 @@ ib_create(
 	hash_table_t*	table;
 
 	ut_a(type == MEM_HEAP_FOR_BTR_SEARCH
-	     || type == MEM_HEAP_FOR_PAGE_HASH);
+	     || type == MEM_HEAP_FOR_PAGE_HASH
+         /* mijin */
+	     || type == MEM_HEAP_FOR_TWB_HASH
+         /* end */);
 
 	ut_ad(ut_is_2pow(n_sync_obj));
 	table = hash_create(n);
@@ -78,9 +81,12 @@ ib_create(
 		return(table);
 	}
 
-	if (type == MEM_HEAP_FOR_PAGE_HASH) {
+	if (type == MEM_HEAP_FOR_PAGE_HASH
+        /* mijin*/
+        || type == MEM_HEAP_FOR_TWB_HASH
+        /* end */) {
 		/* We create a hash table protected by rw_locks for
-		buf_pool->page_hash. */
+		buf_pool->page_hash or buf_pool->twb_hash. */
 		hash_create_sync_obj(
 			table, HASH_TABLE_SYNC_RW_LOCK, id, n_sync_obj);
 	} else {

storage/innobase/handler/ha_innodb.cc

@@ -19709,6 +19709,13 @@ static MYSQL_SYSVAR_ULONG(page_hash_locks, srv_n_page_hash_locks,
   "Number of rw_locks protecting buffer pool page_hash. Rounded up to the next power of 2",
   NULL, NULL, 16, 1, MAX_PAGE_HASH_LOCKS, 0);
 
+/* mijin */
+static MYSQL_SYSVAR_ULONG(twb_hash_locks, srv_n_twb_hash_locks,
+  PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
+  "Number of rw_locks protecting buffer pool twb_hash. Rounded up to the next power of 2",
+  NULL, NULL, 16, 1, 1024, 0);
+/* end */
+
 static MYSQL_SYSVAR_ULONG(doublewrite_batch_size, srv_doublewrite_batch_size,
   PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
   "Number of pages reserved in doublewrite buffer for batch flushing",

storage/innobase/include/mem0mem.h

@@ -60,6 +60,9 @@ buffer pool; the latter method is used for very big heaps */
 /** Different type of heaps in terms of which datastructure is using them */
 #define MEM_HEAP_FOR_BTR_SEARCH		(MEM_HEAP_BTR_SEARCH | MEM_HEAP_BUFFER)
 #define MEM_HEAP_FOR_PAGE_HASH		(MEM_HEAP_DYNAMIC)
+/* mijin */
+#define MEM_HEAP_FOR_TWB_HASH		(MEM_HEAP_DYNAMIC)
+/* end */
 #define MEM_HEAP_FOR_RECV_SYS		(MEM_HEAP_BUFFER)
 #define MEM_HEAP_FOR_LOCK_HEAP		(MEM_HEAP_BUFFER)
 

storage/innobase/include/srv0srv.h

@@ -312,6 +312,10 @@ extern ulong		srv_buf_pool_instances;
 extern const ulong	srv_buf_pool_instances_default;
 /** Number of locks to protect buf_pool->page_hash */
 extern ulong	srv_n_page_hash_locks;
+/* mijin */
+/** Number of locks to protect buf_pool->twb_hash */
+extern ulong	srv_n_twb_hash_locks;
+/* end */
 /** Scan depth for LRU flush batch i.e.: number of blocks scanned*/
 extern ulong	srv_LRU_scan_depth;
 /** Whether or not to flush neighbors of a block */

storage/innobase/srv/srv0srv.cc

@@ -257,6 +257,10 @@ ulong	srv_buf_pool_instances;
 const ulong	srv_buf_pool_instances_default = 0;
 /** Number of locks to protect buf_pool->page_hash */
 ulong	srv_n_page_hash_locks = 16;
+/* mijin */
+/** Number of locks to protect buf_pool->twb_hash */
+ulong	srv_n_twb_hash_locks = 16;
+/* end */
 /** Scan depth for LRU flush batch i.e.: number of blocks scanned*/
 ulong	srv_LRU_scan_depth	= 1024;
 /** Whether or not to flush neighbors of a block */