FastMap v1.0

Author: Anastasios Papagiannis

LICENCE

@@ -0,0 +1,14 @@
+SUBDIRS	= driver ioctl tests logbench
+
+all: $(SUBDIRS)
+	sync && sync && sync
+
+$(SUBDIRS):
+	$(MAKE) -C $(@)
+
+clean:
+	for dir in $(SUBDIRS); do \
+		$(MAKE) -C $$dir $(@); \
+	done
+
+.PHONY: $(SUBDIRS) clean

Makefile

@@ -0,0 +1,50 @@
+# FastMap
+
+This library provides an optimized memory-mapped I/O path inside the Linux kernel. It is implemented as a kernel module and supported by user-space libraries for management purposes.
+
+## Prerequisites
+
+FastMap runs on a modified version of Linux 4.14. In order to build and run 
+this version of FastMap you can clone this kernel with:
+```bash
+git clone https://github.com/tpapagian/linux-4.14.72-spf.git -b fastmap
+```
+
+The modifications are minimal as they contain only some exported symbols and 
+the addition of 2 fields in a single struct. The specific modification can
+be found at this [commit](https://github.com/tpapagian/linux-4.14.72-spf/commit/fdca6433c36bad7977ca019470225c54a4ef8fb7).
+
+After that you should configure, build and install this kernel using 
+specific instruction based on your setup.
+
+## Building FastMap
+
+In order to build FastMap simply run ```make``` on the top level directory. This will build the driver (located in driver directory) and 
+the associated user space tools (located in ioctl directory). After that it will also install FastMap module and run ```depmod```.
+
+## Running FastMap
+
+The only required parameter is the number of 4KB DRAM pages that it will use as cache. You can define this in the ```driver/main.c``` file in the
+```perma_mmap_buf_size``` variable. Alternatively you can use this as a command line argument (i.e. ```modprobe dmap perma_mmap_buf_size=1024``` and in this case it will allocate 1024 4KB pages tottalling in 4GB of DRAM cache).
+
+In ```scripts``` directory you can find several scripts (with the appropriate comments) on how to laod and unload FastMap. These include:
+| Script                      | Description                                                                                     |
+|-----------------------------|----------------------------------------|
+| scripts/load-it-blkdev.sh   | Load FastMap for a block device.       |
+| scripts/unload-it-blkdev.sh | Unload FastMap for a block device.     |
+| scripts/load-it-fs.sh       | Load FastMap for a file system.        |
+| scripts/unload-it-fs.sh     | Unload FastMap for a file system.      |
+
+## Design and Evaluation
+
+The following paper presents the design and experimental analysis of FastMap.
+```
+Anastasios Papagiannis, Giorgos Xanthakis, Giorgos Saloustros, Manolis Marazakis, and Angelos Bilas. Optimizing Memory-mapped I/O for Fast Storage Devices. In proceedings of the 2020 USENIX Annual Technical Conference (USENIX ATC 20). July 2020.
+```
+The pdf, slides, and presentation can be found [here](https://www.usenix.org/conference/atc20/presentation/papagiannis).
+
+Please cite this publication if you use/modify/evaluate FastMap.
+
+## Funding 
+
+This work is supported by [EVOLVE](https://www.evolve-h2020.eu/) (Grant Agreement ID: 825061) and [ExaNeSt](http://www.exanest.eu/) (Grant Agreement ID: 671553) EU funded projects.

README.md

@@ -0,0 +1,24 @@
+obj-m	    := dmap.o
+dmap-objs := 	main.o \
+							mmap_fault_handler.o \
+							mmap_buffer_rbtree.o \
+							mmap_banked_buffer.o \
+							mmap_buffer_hash_table.o \
+							mmap_generational_fifo_buffer.o \
+							mmap_buffer_sync_daemon.o \
+							di-mmap_parameters.o \
+							buffer_runtime_parameters.o \
+							buffer_loadtime_parameters.o \
+							helpers.o \
+							write_tagged_page.o \
+							write_dirty_pages.o \
+							tagged_page.o \
+							dmapfs_dentry.o \
+							dmapfs_file.o \
+							dmapfs_inode.o \
+							dmapfs_lookup.o \
+							dmapfs_main.o \
+							dmapfs_mmap.o \
+							dmapfs_super.o \
+							lpfifo_non_atomic.o \
+							dfifo_non_atomic.o

driver/Kbuild

@@ -0,0 +1,31 @@
+EXTRA_CFLAGS := -pipe -m64 -ansi -fPIC -O2 -fno-exceptions -fstack-protector -Wl,-z,relro -Wl,-z,now -fvisibility=internal -W -Wall -Wno-unused-parameter -Wno-unused-function -Wno-unused-label -Wpointer-arith -Wformat -Wreturn-type -Wsign-compare -Wmultichar -Wformat-nonliteral -Winit-self -Wuninitialized -Wno-deprecated -Wformat-security -Werror -Wall -Winline -Wextra -Wshadow -funsigned-char -fwrapv -Wmissing-format-attribute -Wwrite-strings -Wenum-compare -Wlogical-op -Wsuggest-attribute=noreturn -Wunreachable-code -fno-omit-frame-pointer
+
+NAME=dmap
+KDIR ?= /lib/modules/`uname -r`/build
+KVERSION = $(shell uname -r)
+
+default: target install
+
+target:
+	$(MAKE) -C $(KDIR) M=$$PWD
+
+clean:
+	$(MAKE) -C $(KDIR) M=$$PWD clean
+
+help:
+	$(MAKE) -C $(KDIR) M=$$PWD help
+
+install:	
+	/lib/modules/`uname -r`/source/scripts/sign-file sha512  /lib/modules/`uname -r`/source/certs/signing_key.pem  /lib/modules/`uname -r`/source/certs/signing_key.x509 dmap.ko
+	if [ -f $(NAME).ko ]; then \
+		if ! cp $(NAME).ko /lib/modules/$(KVERSION)/kernel/drivers/char; \
+			then exit 1; fi; \
+	fi;
+	/sbin/depmod -a
+
+uninstall:
+	if [ -f /lib/modules/$(KVERSION)/kernel/drivers/char/$(NAME).ko ]; then \
+		if ! rm -f /lib/modules/$(KVERSION)/kernel/drivers/char/$(NAME).ko; \
+			then exit 1; fi; \
+	fi;
+	/sbin/depmod -a

driver/Makefile

@@ -0,0 +1,32 @@
+#ifndef _BTREE_META_
+#define _BTREE_META_
+
+typedef enum
+{
+	leafNode = 590675399,
+	internalNode = 790393380,
+	rootNode = 742729384,
+	leafRootNode = 748939994 /*special case for a newly created tree*/
+} nodeType_t;
+
+typedef struct block_header
+{
+	void *next_block;
+} block_header;
+
+/*leaf or internal node metadata, place always in the first 4KB data block*/
+typedef struct node_header
+{
+	uint64_t epoch; /*epoch of the node. It will be used for knowing when to perform copy on write*/
+	uint64_t fragmentation;
+	/*data log info, KV log for leaves private for index*/
+	block_header *first_key_block;
+	block_header *last_key_block;
+	uint64_t key_log_size;
+	int32_t height;  /*0 are leaves, 1 are Bottom Internal nodes, and then we have INs and root*/
+	nodeType_t type; /*internal or leaf node*/
+	uint16_t numberOfEntriesInNode;
+	char pad[8];
+} node_header;
+
+#endif // _BTREE_META_

driver/btree_metadata.h

@@ -0,0 +1,212 @@
+#include <linux/mm.h>
+
+#include "dmap.h"
+#include "buffer_loadtime_parameters.h"
+
+int init_ld_params(buf_ld_params_t *ld_params)
+{
+  ld_params->mmap_buf_size = 0;
+  ld_params->superpage_alloc_order = 0;
+  ld_params->hot_page_fifo_alloc_ratio.mul = 1;
+  ld_params->hot_page_fifo_alloc_ratio.logb2_shift = HPF_ALLOC_RATIO_SHIFT;
+  ld_params->victim_queue_alloc_ratio.mul = 1;
+  ld_params->victim_queue_alloc_ratio.logb2_shift = VQ_ALLOC_RATIO_SHIFT;
+  return 0;
+}
+
+int copy_ld_params(buf_ld_params_t *dst, buf_ld_params_t *src)
+{
+  dst->mmap_buf_size = src->mmap_buf_size;
+  dst->superpage_alloc_order = src->superpage_alloc_order;
+  dst->hot_page_fifo_alloc_ratio.mul = src->hot_page_fifo_alloc_ratio.mul;
+  dst->hot_page_fifo_alloc_ratio.logb2_shift = src->hot_page_fifo_alloc_ratio.logb2_shift;
+  dst->victim_queue_alloc_ratio.mul = src->victim_queue_alloc_ratio.mul;
+  dst->victim_queue_alloc_ratio.logb2_shift = src->victim_queue_alloc_ratio.logb2_shift;
+  return 0;
+}
+
+int display_ld_params(buf_ld_params_t *ld_params, char *str)
+{
+  return sprintf(str, "ld_params: mmap_buf_size=%ld superpage_alloc_order=%d",
+                 ld_params->mmap_buf_size, ld_params->superpage_alloc_order);
+}
+
+int print_ld_params(buf_ld_params_t *ld_params)
+{
+  return 0;
+}
+
+/*************************************************************************
+ * Sysfs function interface
+ ************************************************************************/
+/* Extract the load-time parameters from the top level dimmap_buffer_t data structure */
+static ssize_t buf_ld_params_show(struct class *class, struct class_attribute *attr, char *buf, ssize_t (*format)(buf_ld_params_t *ld_params, char *))
+{
+  buf_ld_params_t *ld_params = to_dimmap_buf_ld_params(class);
+  ssize_t ret = -EINVAL;
+  ret = (*format)(ld_params, buf);
+  return ret;
+}
+
+/* Generate a show function for a load-time parameter field */
+#define SHOW_LD_PARAM(field, format_string)                                                   \
+  static ssize_t ld_param_format_##field(buf_ld_params_t *ld_params, char *buf)               \
+  {                                                                                           \
+    return scnprintf(buf, PAGE_SIZE, format_string, ld_params->field);                        \
+  }                                                                                           \
+  ssize_t show_ld_param_##field(struct class *class, struct class_attribute *attr, char *buf) \
+  {                                                                                           \
+    return buf_ld_params_show(class, attr, buf, ld_param_format_##field);                     \
+  }
+
+/* Generate a show function for a runtime parameter field */
+#define SHOW_LD_PARAM_TUPLE(field, f1, f2, format_string)                                     \
+  static ssize_t ld_param_format_##field(buf_ld_params_t *ld_params, char *buf)               \
+  {                                                                                           \
+    int f2_ = 1 << ld_params->field.f2;                                                       \
+    return scnprintf(buf, PAGE_SIZE, format_string, ld_params->field.f1, f2_);                \
+  }                                                                                           \
+  ssize_t show_ld_param_##field(struct class *class, struct class_attribute *attr, char *buf) \
+  {                                                                                           \
+    return buf_ld_params_show(class, attr, buf, ld_param_format_##field);                     \
+  }
+
+/* Generate a store function for an integer runtime parameter field */
+#define STORE_INTEGER_LD_PARAM(field)                                                                              \
+  ssize_t store_ld_param_##field(struct class *class, struct class_attribute *attr, const char *buf, size_t count) \
+  {                                                                                                                \
+    buf_ld_params_t *ld_params = to_dimmap_buf_ld_params(class);                                                   \
+    int ret = -EINVAL;                                                                                             \
+    int val = 0;                                                                                                   \
+    ret = kstrtoint(buf, 0, &val);                                                                                 \
+    if (ret)                                                                                                       \
+    {                                                                                                              \
+      goto err;                                                                                                    \
+    }                                                                                                              \
+    ld_params->field = val;                                                                                        \
+    update_dimmap_buf_ld_params(class);                                                                            \
+    ret = count;                                                                                                   \
+  err:                                                                                                             \
+    return ret;                                                                                                    \
+  }
+
+SHOW_LD_PARAM(mmap_buf_size, "%ld\n")
+
+ssize_t store_ld_param_mmap_buf_size(struct class *class, struct class_attribute *attr, const char *buf, size_t count)
+{
+  dimmap_buffer_t *dimmap_buf = to_dimmap_buf(class);
+  buf_ld_params_t *ld_params = to_dimmap_buf_ld_params(class);
+  int ret = -EINVAL;
+  long new_size;
+
+  ret = kstrtoul(buf, 0, &new_size);
+  if (ret)
+  {
+    goto err;
+  }
+
+  ld_params->mmap_buf_size = new_size >> ld_params->superpage_alloc_order;
+  ret = count;
+  update_dimmap_buf_ld_params(class);
+
+  init_mmap_params(&dimmap_buf->ld_params);
+
+err:
+  return ret;
+}
+
+SHOW_LD_PARAM(superpage_alloc_order, "%d\n")
+STORE_INTEGER_LD_PARAM(superpage_alloc_order)
+
+SHOW_LD_PARAM_TUPLE(hot_page_fifo_alloc_ratio, mul, logb2_shift, "%d/%d\n");
+SHOW_LD_PARAM_TUPLE(victim_queue_alloc_ratio, mul, logb2_shift, "%d/%d\n");
+
+ssize_t store_ld_param_hot_page_fifo_alloc_ratio(struct class *class, struct class_attribute *attr, const char *buf, size_t count)
+{
+  dimmap_buffer_t *dimmap_buf = to_dimmap_buf(class);
+  buf_ld_params_t *ld_params = to_dimmap_buf_ld_params(class);
+  int ret = -EINVAL;
+  int mul = 0, logb2_shift = 0, denominator = 0;
+  int i;
+
+  ret = sscanf(buf, "%d/%d", &mul, &denominator);
+  if (ret != 2)
+  {
+    goto err;
+  }
+  for (i = 0; (1 << i) < denominator; i++)
+  {
+    logb2_shift = i + 1;
+  }
+
+  ret = count;
+  if (1 << logb2_shift != denominator)
+  {
+    printk(KERN_ALERT "The specified denominator (%d) cannot be encoded as the logb2 (%d) of the provided value.\n", denominator, logb2_shift);
+    goto err;
+  }
+
+  ld_params->hot_page_fifo_alloc_ratio.mul = mul;
+  ld_params->hot_page_fifo_alloc_ratio.logb2_shift = logb2_shift;
+  update_dimmap_buf_ld_params(class);
+
+  init_mmap_params(&dimmap_buf->ld_params);
+
+err:
+  return ret;
+}
+
+ssize_t store_ld_param_victim_queue_alloc_ratio(struct class *class, struct class_attribute *attr, const char *buf, size_t count)
+{
+  dimmap_buffer_t *dimmap_buf = to_dimmap_buf(class);
+  buf_ld_params_t *ld_params = to_dimmap_buf_ld_params(class);
+  int ret = -EINVAL;
+  int mul = 0, logb2_shift = 0, denominator = 0;
+  int i;
+
+  ret = sscanf(buf, "%d/%d", &mul, &denominator);
+  if (ret != 2)
+  {
+    goto err;
+  }
+  for (i = 0; (1 << i) < denominator; i++)
+  {
+    logb2_shift = i + 1;
+  }
+
+  ret = count;
+  if (1 << logb2_shift != denominator)
+  {
+    printk(KERN_ALERT "The specified denominator (%d) cannot be encoded as the logb2 (%d) of the provided value.\n", denominator, logb2_shift);
+    goto err;
+  }
+
+  ld_params->victim_queue_alloc_ratio.mul = mul;
+  ld_params->victim_queue_alloc_ratio.logb2_shift = logb2_shift;
+  update_dimmap_buf_ld_params(class);
+
+  init_mmap_params(&dimmap_buf->ld_params);
+
+err:
+  return ret;
+}
+
+/* Buffer loadtime parameters */
+static struct class_attribute ld_param_class_attrs[] = {
+    __ATTR(1_buffer_size, S_IRUGO | S_IWUSR, show_ld_param_mmap_buf_size, store_ld_param_mmap_buf_size),
+    __ATTR(1_superpage_alloc_order, S_IRUGO | S_IWUSR, show_ld_param_superpage_alloc_order, store_ld_param_superpage_alloc_order),
+    __ATTR(1_hot_page_fifo_alloc_ratio, S_IRUGO | S_IWUSR, show_ld_param_hot_page_fifo_alloc_ratio, store_ld_param_hot_page_fifo_alloc_ratio),
+    __ATTR(1_victim_queue_alloc_ratio, S_IRUGO | S_IWUSR, show_ld_param_victim_queue_alloc_ratio, store_ld_param_victim_queue_alloc_ratio),
+    __ATTR_NULL,
+};
+
+int copy_ld_param_class_attrs(struct class_attribute *global_class_attrs, int offset)
+{
+  int i = 0;
+  while (ld_param_class_attrs[i].attr.name != NULL)
+  {
+    global_class_attrs[offset + i] = ld_param_class_attrs[i];
+    i++;
+  }
+  return offset + i;
+}