├── .cproject ├── .gitignore ├── .project ├── .pydevproject ├── LICENSE ├── Makefile.am ├── NOTES ├── README.md ├── bootstrap ├── configure.ac ├── eval.py ├── m4 ├── acx_pthread.m4 ├── ax_cxx_compile_stdcxx_11.m4 ├── boost.m4 ├── libtool.m4 ├── ltoptions.m4 ├── ltsugar.m4 ├── ltversion.m4 └── lt~obsolete.m4 ├── misc ├── cowbt │ ├── cow_pbtest.cpp │ ├── libpm.cpp │ ├── libpm.h │ └── plist.h ├── linux-examples │ ├── .gitignore │ ├── FAQ.txt │ ├── LICENSE │ ├── LINUX_PMEM_API.txt │ ├── Makefile.inc │ ├── README │ ├── basic │ │ ├── .gitignore │ │ ├── README │ │ ├── basic.c │ │ └── basictest.pass │ ├── binarytree │ │ ├── .gitignore │ │ ├── README │ │ ├── freqtest.pass │ │ ├── tree.c │ │ ├── tree.h │ │ ├── tree_free.c │ │ ├── tree_insert.c │ │ ├── tree_walk.c │ │ └── tree_wordfreq.c │ ├── icount │ │ ├── .gitignore │ │ ├── README │ │ ├── icount.c │ │ ├── icount.h │ │ ├── icount_test.c │ │ └── icount_test.pass │ ├── libpm.cpp │ ├── libpm.h │ ├── libpmem │ │ ├── .gitignore │ │ ├── LIBPMEM_API.txt │ │ ├── README │ │ ├── pmem.c │ │ ├── pmem.h │ │ ├── pmem.map │ │ ├── pmem_cl.c │ │ ├── pmem_fit.c │ │ ├── pmem_inline.h │ │ └── pmem_msync.c │ ├── libpmemalloc │ │ ├── .gitignore │ │ ├── PMEMALLOC_API.txt │ │ ├── README │ │ ├── design.txt │ │ ├── pmemalloc.c │ │ ├── pmemalloc.h │ │ ├── pmemalloc.map │ │ ├── pmemalloc_check.c │ │ ├── pmemalloc_test1.c │ │ ├── pmemalloc_test2.c │ │ └── pmemalloctest.pass │ ├── pdb.cpp │ ├── plist.cpp │ ├── plist.h │ ├── pmem_use.cpp │ ├── ptreap.cpp │ ├── ptreap.h │ ├── ptree.cpp │ ├── ptree.h │ ├── trivial │ │ ├── .gitignore │ │ ├── README │ │ ├── trivial.c │ │ └── trivialtest.pass │ └── util │ │ ├── README │ │ ├── util.c │ │ └── util.h ├── micro │ └── io_test.cpp ├── mmalloc │ ├── COPYING.LIB │ ├── ChangeLog │ ├── MAINTAINERS │ ├── TODO │ ├── acinclude.m4 │ ├── attach.c │ ├── configure.in │ ├── detach.c │ ├── keys.c │ ├── mcalloc.c │ ├── mfree.c │ ├── mm.c │ ├── mmalloc.c │ ├── mmalloc.h │ ├── mmalloc.info │ ├── mmalloc.texi │ ├── mmap-sup.c │ ├── mmcheck.c │ ├── mmemalign.c │ ├── mmprivate.h │ ├── mmstats.c │ ├── mmtrace.awk │ ├── mmtrace.c │ ├── mrealloc.c │ ├── mvalloc.c │ └── sbrk-sup.c ├── pcommit │ └── pm_helper.c ├── pmem │ ├── libpm.cpp │ ├── libpm.h │ ├── pmem_check.cpp │ └── test_pmem.cpp ├── test │ ├── eclipse-cpp-google-style.xml │ ├── fields.cpp │ ├── flush_test.cpp │ ├── mmaptest.cpp │ ├── msynctest.cpp │ ├── serialize.cpp │ ├── slog.cpp │ ├── time.cpp │ └── zipf.cpp └── tpcc │ └── sqlitedriver.py ├── results ├── btree │ ├── 64 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ ├── 128 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ ├── 256 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ ├── 512 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ ├── 1024 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ ├── 2048 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ ├── 4096 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ ├── 8192 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ └── 16384 │ │ ├── lsm │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ │ ├── opt_sp │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ │ ├── opt_wal │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ │ ├── sp │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ │ └── wal │ │ ├── balanced │ │ └── 320 │ │ │ └── performance.csv │ │ ├── read-heavy │ │ └── 320 │ │ │ └── performance.csv │ │ ├── read-only │ │ └── 320 │ │ │ └── performance.csv │ │ └── write-heavy │ │ └── 320 │ │ └── performance.csv ├── ise │ ├── 1 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ ├── 10 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ ├── 100 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ ├── 1000 │ │ ├── lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── sp │ │ │ ├── balanced │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ │ └── 320 │ │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── wal │ │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ └── 10000 │ │ ├── lsm │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ │ ├── opt_sp │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ │ ├── opt_wal │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ │ ├── sp │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── performance.csv │ │ └── wal │ │ ├── balanced │ │ └── 320 │ │ │ └── performance.csv │ │ ├── read-heavy │ │ └── 320 │ │ │ └── performance.csv │ │ ├── read-only │ │ └── 320 │ │ │ └── performance.csv │ │ └── write-heavy │ │ └── 320 │ │ └── performance.csv ├── nvm_bw │ ├── random │ │ └── bw.csv │ └── sequential │ │ └── bw.csv ├── tpcc │ ├── nvm │ │ └── nvm.csv │ ├── performance │ │ ├── lsm │ │ │ └── performance.csv │ │ ├── opt_lsm │ │ │ └── performance.csv │ │ ├── opt_sp │ │ │ └── performance.csv │ │ ├── opt_wal │ │ │ └── performance.csv │ │ ├── sp │ │ │ └── performance.csv │ │ └── wal │ │ │ └── performance.csv │ ├── recovery │ │ ├── lsm │ │ │ └── recovery.csv │ │ ├── opt_lsm │ │ │ └── recovery.csv │ │ ├── opt_sp │ │ │ └── recovery.csv │ │ ├── opt_wal │ │ │ └── recovery.csv │ │ ├── sp │ │ │ └── recovery.csv │ │ └── wal │ │ │ └── recovery.csv │ └── storage │ │ └── storage.csv └── ycsb │ ├── abs_stack │ ├── ycsb-stack-balanced-320.pdf │ ├── ycsb-stack-read-heavy-320.pdf │ ├── ycsb-stack-read-only-320.pdf │ └── ycsb-stack-write-heavy-320.pdf │ ├── nvm │ ├── lsm │ │ ├── balanced │ │ │ └── nvm.csv │ │ ├── read-heavy │ │ │ └── nvm.csv │ │ ├── read-only │ │ │ └── nvm.csv │ │ └── write-heavy │ │ │ └── nvm.csv │ ├── opt_lsm │ │ ├── balanced │ │ │ └── nvm.csv │ │ ├── read-heavy │ │ │ └── nvm.csv │ │ ├── read-only │ │ │ └── nvm.csv │ │ └── write-heavy │ │ │ └── nvm.csv │ ├── opt_sp │ │ ├── balanced │ │ │ └── nvm.csv │ │ ├── read-heavy │ │ │ └── nvm.csv │ │ ├── read-only │ │ │ └── nvm.csv │ │ └── write-heavy │ │ │ └── nvm.csv │ ├── opt_wal │ │ ├── balanced │ │ │ └── nvm.csv │ │ ├── read-heavy │ │ │ └── nvm.csv │ │ ├── read-only │ │ │ └── nvm.csv │ │ └── write-heavy │ │ │ └── nvm.csv │ ├── sp │ │ ├── balanced │ │ │ └── nvm.csv │ │ ├── read-heavy │ │ │ └── nvm.csv │ │ ├── read-only │ │ │ └── nvm.csv │ │ └── write-heavy │ │ │ └── nvm.csv │ └── wal │ │ ├── balanced │ │ └── nvm.csv │ │ ├── read-heavy │ │ └── nvm.csv │ │ ├── read-only │ │ └── nvm.csv │ │ └── write-heavy │ │ └── nvm.csv │ ├── performance │ ├── lsm │ │ ├── balanced │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ ├── 160 │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ └── performance.csv │ ├── opt_lsm │ │ ├── balanced │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ ├── 160 │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ └── performance.csv │ ├── opt_sp │ │ ├── balanced │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ ├── 160 │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ └── performance.csv │ ├── opt_wal │ │ ├── balanced │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ ├── 160 │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ └── performance.csv │ ├── sp │ │ ├── balanced │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ ├── read-heavy │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ ├── read-only │ │ │ ├── 160 │ │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ │ └── performance.csv │ │ └── write-heavy │ │ │ ├── 160 │ │ │ └── performance.csv │ │ │ ├── 320 │ │ │ └── performance.csv │ │ │ └── 1280 │ │ │ └── performance.csv │ └── wal │ │ ├── balanced │ │ ├── 160 │ │ │ └── performance.csv │ │ ├── 320 │ │ │ └── performance.csv │ │ └── 1280 │ │ │ └── performance.csv │ │ ├── read-heavy │ │ ├── 160 │ │ │ └── performance.csv │ │ ├── 320 │ │ │ └── performance.csv │ │ └── 1280 │ │ │ └── performance.csv │ │ ├── read-only │ │ ├── 160 │ │ │ └── performance.csv │ │ ├── 320 │ │ │ └── performance.csv │ │ └── 1280 │ │ │ └── performance.csv │ │ └── write-heavy │ │ ├── 160 │ │ └── performance.csv │ │ ├── 320 │ │ └── performance.csv │ │ └── 1280 │ │ └── performance.csv │ ├── recovery │ ├── lsm │ │ └── recovery.csv │ ├── opt_lsm │ │ └── recovery.csv │ ├── opt_sp │ │ └── recovery.csv │ ├── opt_wal │ │ └── recovery.csv │ ├── sp │ │ └── recovery.csv │ └── wal │ │ └── recovery.csv │ ├── stack │ ├── lsm │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── stack.csv │ ├── opt_lsm │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── stack.csv │ ├── opt_sp │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── stack.csv │ ├── opt_wal │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── stack.csv │ ├── sp │ │ ├── balanced │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ ├── read-heavy │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ ├── read-only │ │ │ └── 320 │ │ │ │ └── stack.csv │ │ └── write-heavy │ │ │ └── 320 │ │ │ └── stack.csv │ └── wal │ │ ├── balanced │ │ └── 320 │ │ │ └── stack.csv │ │ ├── read-heavy │ │ └── 320 │ │ │ └── stack.csv │ │ ├── read-only │ │ └── 320 │ │ │ └── stack.csv │ │ └── write-heavy │ │ └── 320 │ │ └── stack.csv │ └── storage │ └── storage.csv ├── src ├── Makefile.am ├── clibpm.cpp ├── common │ ├── benchmark.h │ ├── clibpm.h │ ├── config.h │ ├── coordinator.h │ ├── cow_pbtree.h │ ├── database.h │ ├── engine.h │ ├── engine_api.h │ ├── field.h │ ├── libpm.h │ ├── lock_manager.h │ ├── logger.h │ ├── lsm_engine.h │ ├── opt_lsm_engine.h │ ├── opt_sp_engine.h │ ├── opt_wal_engine.h │ ├── pbtree.h │ ├── plist.h │ ├── ptreap.h │ ├── ptree.h │ ├── record.h │ ├── schema.h │ ├── serializer.h │ ├── sp_engine.h │ ├── statement.h │ ├── status.h │ ├── storage.h │ ├── table.h │ ├── table_index.h │ ├── test_benchmark.h │ ├── timer.h │ ├── tpcc_benchmark.h │ ├── transaction.h │ ├── utils.h │ ├── wal_engine.h │ └── ycsb_benchmark.h ├── libpm.cpp ├── lsm_engine.cpp ├── main.cpp ├── opt_lsm_engine.cpp ├── opt_sp_engine.cpp ├── opt_wal_engine.cpp ├── pmem_check.cpp ├── run.sh ├── sp_engine.cpp ├── test_benchmark.cpp ├── tpcc_benchmark.cpp ├── utils.cpp ├── wal_engine.cpp ├── wal_engine_fs.cpp └── ycsb_benchmark.cpp └── test ├── Makefile.am ├── test_pbtree.cpp ├── test_plist.cpp ├── test_pmem.cpp └── test_ptreap.cpp /.gitignore: -------------------------------------------------------------------------------- 1 | # Autotools 2 | Makefile 3 | Makefile.in 4 | configure 5 | *.o 6 | *~ 7 | config.* 8 | config-h.in 9 | libtool 10 | .deps 11 | aclocal.m4 12 | autom4te.cache 13 | autom4te.cache/* 14 | stamp-h1 15 | aux-scripts 16 | #*# 17 | #.#* 18 | depcomp 19 | install-sh 20 | libtool 21 | ltmain.sh 22 | missing 23 | stamp-h* 24 | 25 | # Build files 26 | build 27 | build/* 28 | *.o 29 | *.sym 30 | *.a 31 | *.la 32 | *.out 33 | *.pyc 34 | *core 35 | *.db 36 | config 37 | nstore 38 | pmem_check 39 | 40 | # Log/Tmp files 41 | log* 42 | *.log 43 | *tmp 44 | perf.* 45 | GPATH 46 | GTAGS 47 | GRTAGS 48 | 49 | # Editor 50 | .settings/* 51 | 52 | bin/* 53 | zfile 54 | 55 | # Plots 56 | results/*.pdf 57 | /Debug 58 | misc/linux-examples/* 59 | 60 | -------------------------------------------------------------------------------- /.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | n-store 4 | 5 | 6 | 7 | 8 | 9 | org.python.pydev.PyDevBuilder 10 | 11 | 12 | 13 | 14 | org.eclipse.cdt.managedbuilder.core.genmakebuilder 15 | clean,full,incremental, 16 | 17 | 18 | 19 | 20 | org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder 21 | full,incremental, 22 | 23 | 24 | 25 | 26 | 27 | org.eclipse.cdt.core.cnature 28 | org.eclipse.cdt.core.ccnature 29 | org.eclipse.cdt.managedbuilder.core.managedBuildNature 30 | org.eclipse.cdt.managedbuilder.core.ScannerConfigNature 31 | org.python.pydev.pythonNature 32 | 33 | 34 | -------------------------------------------------------------------------------- /.pydevproject: -------------------------------------------------------------------------------- 1 | 2 | 3 | Default 4 | python 2.7 5 | 6 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | BSD 3-Clause License 2 | 3 | Copyright (c) 2014-16, Carnegie Mellon University Database Group 4 | All rights reserved. 5 | 6 | Redistribution and use in source and binary forms, with or without 7 | modification, are permitted provided that the following conditions are met: 8 | 9 | * Redistributions of source code must retain the above copyright notice, this 10 | list of conditions and the following disclaimer. 11 | 12 | * Redistributions in binary form must reproduce the above copyright notice, 13 | this list of conditions and the following disclaimer in the documentation 14 | and/or other materials provided with the distribution. 15 | 16 | * Neither the name of the copyright holder nor the names of its 17 | contributors may be used to endorse or promote products derived from 18 | this software without specific prior written permission. 19 | 20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 | -------------------------------------------------------------------------------- /Makefile.am: -------------------------------------------------------------------------------- 1 | ## Makefile.am -- Process this file with automake to produce Makefile.in 2 | AUTOMAKE_OPTIONS = foreign 3 | ACLOCAL_AMFLAGS = -I m4 4 | 5 | SUBDIRS = src test 6 | 7 | # add autogen on distribution 8 | EXTRA_DIST = bootstrap 9 | 10 | clean-local: 11 | rm -f zfile log 12 | -------------------------------------------------------------------------------- /NOTES: -------------------------------------------------------------------------------- 1 | 2 | - How does the database prevent log entries from multiple 3 | threads or transactions from getting interleaved ? 4 | 5 | - There seems to be a lot of pointer chasing ? Is that necessary ? 6 | More NVM loads than stores ! 7 | 8 | - It is a test bed ! Not something you would use in commercial setting ! 9 | - No network overhead 10 | - Database is cleaned up on a shutdown, it does not persist across time 11 | - Entire heap is persistent - Objects that are required after a crash are "marked", 12 | the once that are not needed are not "marked". They are reclaimed on start. 13 | - All malloc or mmap requests are intercepted and routed to userspace memory allocator 14 | that works with best/first fit. It works with variable size chunks and not fixed page sizes 15 | - Sort of like Mnemosyne 16 | - Mmap a file as heap 17 | - Atomically update it 18 | - intercept all memory allocation requests 19 | - memcached asks for a giant heap and uses a slab allocator, traditionally 20 | - mnemosyne now manages the slab allocator, making sure all allocations and deallocations are atomic 21 | - What about a OS based atomic memory allocator ? What are the software overheads ? 22 | - If we have flush on failure, why even bother about ordering ? 23 | - Processor catches fire 24 | - Memory bus caches fire 25 | - Cache hierarchy is corrupted 26 | 27 | - There is no pcommit at the end of each transaction. Instead a "gc" thread wakes up every five milliseconds 28 | and issues a pcommit. 29 | - Surprisingly, the gc thread calls fsync on the log file + a pcommit. Redundant. Fsync already calls pcommit. 30 | - Further, why do you even have to call fsync on the log file when u are using fwrite ? 31 | - PCOMMIT latency is 100 ns. He use __asm__ __volatile__ ("pause" ::: "memory") in combination with rdtsc 32 | - One has to remember to call pmemalloc_activate after requesting a block from the memory manager or else it will reclaimed 33 | during reboot ! 34 | - wal_engine - fs_log 35 | - opt_wal_engine - pm_log 36 | - To get the db working in the emulator, i had to solve the issue of having two distinct versions of libc on a single machine 37 | - look at the sonar wiki 38 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # N-Store 2 | 3 | ## Storage architectures 4 | 5 | Evaluation of different storage architectures in database systems designed for non-volatile memory (NVM). 6 | 7 | 8 | ## Dependencies 9 | 10 | - **g++ 4.7+** 11 | - **autoconf** (`apt-get install autoconf libtool`) 12 | 13 | ## Setup 14 | 15 | ``` 16 | ./bootstrap 17 | ./configure 18 | make 19 | ``` 20 | 21 | ## Test 22 | 23 | ``` 24 | ./src/n-store -h 25 | ``` 26 | 27 | 28 | -------------------------------------------------------------------------------- /bootstrap: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | # bootstrap -- Use this script to create generated files from the CVS dist 3 | 4 | autoreconf -fvi 5 | -------------------------------------------------------------------------------- /configure.ac: -------------------------------------------------------------------------------- 1 | # configure.in -- Process this file with autoconf to produce configure 2 | AC_PREREQ([2.64]) 3 | 4 | AC_INIT([n-store], [0.1], [xyz@cs.cmu.edu]) 5 | AC_CONFIG_HEADERS([config.h:config-h.in]) 6 | AC_CONFIG_AUX_DIR([config]) 7 | AC_CONFIG_MACRO_DIR([m4]) 8 | 9 | AM_INIT_AUTOMAKE([1.0 foreign]) 10 | 11 | AC_PROG_CC 12 | 13 | if test -z $CXXFLAGS; then 14 | CXXFLAGS='-ggdb -O3' 15 | fi 16 | 17 | AC_PROG_CXX 18 | AC_PROG_LIBTOOL 19 | 20 | # Check for pthreads (uses m4/acx_pthread.m4). 21 | ACX_PTHREAD([], [AC_MSG_ERROR([failed to find pthreads])]) 22 | 23 | AC_LANG([C++]) 24 | 25 | # turn on c++11 26 | AX_CXX_COMPILE_STDCXX_11(noext) 27 | 28 | #BOOST_REQUIRE([1.45]) 29 | #BOOST_SYSTEM 30 | #BOOST_ASIO 31 | #BOOST_THREADS 32 | #BOOST_SERIALIZATION 33 | 34 | AC_CONFIG_FILES([Makefile 35 | src/Makefile 36 | test/Makefile]) 37 | 38 | #[test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h.in]) 39 | AC_OUTPUT 40 | # @end 2 41 | -------------------------------------------------------------------------------- /m4/ltversion.m4: -------------------------------------------------------------------------------- 1 | # ltversion.m4 -- version numbers -*- Autoconf -*- 2 | # 3 | # Copyright (C) 2004 Free Software Foundation, Inc. 4 | # Written by Scott James Remnant, 2004 5 | # 6 | # This file is free software; the Free Software Foundation gives 7 | # unlimited permission to copy and/or distribute it, with or without 8 | # modifications, as long as this notice is preserved. 9 | 10 | # @configure_input@ 11 | 12 | # serial 3337 ltversion.m4 13 | # This file is part of GNU Libtool 14 | 15 | m4_define([LT_PACKAGE_VERSION], [2.4.2]) 16 | m4_define([LT_PACKAGE_REVISION], [1.3337]) 17 | 18 | AC_DEFUN([LTVERSION_VERSION], 19 | [macro_version='2.4.2' 20 | macro_revision='1.3337' 21 | _LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) 22 | _LT_DECL(, macro_revision, 0) 23 | ]) 24 | -------------------------------------------------------------------------------- /misc/linux-examples/.gitignore: -------------------------------------------------------------------------------- 1 | .*.swp 2 | *.o 3 | tags 4 | testfile* 5 | *.out 6 | -------------------------------------------------------------------------------- /misc/linux-examples/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2013, Intel Corporation 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions 5 | are met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | 10 | * Redistributions in binary form must reproduce the above copyright 11 | notice, this list of conditions and the following disclaimer in 12 | the documentation and/or other materials provided with the 13 | distribution. 14 | 15 | * Neither the name of Intel Corporation nor the names of its 16 | contributors may be used to endorse or promote products derived 17 | from this software without specific prior written permission. 18 | 19 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 | -------------------------------------------------------------------------------- /misc/linux-examples/basic/.gitignore: -------------------------------------------------------------------------------- 1 | basic 2 | -------------------------------------------------------------------------------- /misc/linux-examples/basic/README: -------------------------------------------------------------------------------- 1 | This is basic/README. 2 | 3 | This is a very basic example of a program storing some data to 4 | Persistent Memory and then reading it back later. This example 5 | also illustrates how to use libpmem to make sure stores are durable. 6 | 7 | usage: basic [-FMd] [-i icount] path [strings...] 8 | 9 | Where is a file on a Persistent Memory aware file system 10 | like PMFS. If path doesn't exist, this program will create it 11 | with size DEFAULT_SIZE (defined below). 12 | 13 | Any strings provided will be written to the Persistent Memory, 14 | each terminated by a '\0' character. If no strings are 15 | provided, the Persistent Memory is dumped out in a manner similar 16 | to strings(1). 17 | 18 | The -F flag enables the fault injection testing version of libpmem. 19 | This for more meaningful icount-based runs (see the -i flag below). 20 | 21 | The -M flag enables the msync-based version of libpmem. 22 | Use this when you don't have a PM-aware file system and you're 23 | running on traditional memory-mapped files instead. 24 | 25 | The -d flag turns on debugging prints. 26 | 27 | The -i flag, if given, turns on instruction counting for the 28 | code snippet under test (the code between icount_start() and 29 | icount_stop() below). Use "-i 0" to print the count, "-i N" 30 | to simulate a crash after N instructions. For more accurate 31 | fault injection testing, use this with the -F flag described above. 32 | 33 | Here are examples of how to run the basic code: 34 | 35 | basic testfile one two three 36 | basic testfile 37 | 38 | Also, you can run the fault injection test using: 39 | 40 | make allcounts 41 | 42 | This takes a while to run. Notice how the fault injection tests show you 43 | only parts of strings getting stored in some crash scenarios. This example 44 | illustrates how your Persistent Memory data structures can be in unexpected 45 | states due to system interruptions or program crashes. Compare this example 46 | with something like the linked-list test in ../libpmemalloc, where extra 47 | work is done to prevent half-done entries into the PM data structure. 48 | -------------------------------------------------------------------------------- /misc/linux-examples/basic/basictest.pass: -------------------------------------------------------------------------------- 1 | Running test... 2 | rm -f testfile 3 | ./basic testfile one two three four 4 | ./basic testfile 5 | one 6 | two 7 | three 8 | four 9 | 0000000 o n e \0 t w o \0 t h r e e \0 f o 10 | 0000020 u r \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 11 | 0000040 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 12 | * 13 | 0020000 14 | Done. 15 | -------------------------------------------------------------------------------- /misc/linux-examples/binarytree/.gitignore: -------------------------------------------------------------------------------- 1 | tree_insert 2 | tree_walk 3 | tree_free 4 | tree_wordfreq 5 | 4000.txt 6 | 4300.txt 7 | 4302.txt 8 | 4309.txt 9 | 4500.txt 10 | 4000.zip 11 | 4300.zip 12 | 4302.zip 13 | 4309.zip 14 | 4500.zip 15 | -------------------------------------------------------------------------------- /misc/linux-examples/binarytree/README: -------------------------------------------------------------------------------- 1 | This is binarytree/README. 2 | 3 | This is a simple binary tree for Persistent Memory, implemented 4 | on top of the libpmemalloc example. All the example code is in: 5 | 6 | tree.c 7 | 8 | The interfaces provided by this example are very simple -- you can 9 | see the list of the in: 10 | 11 | tree.h 12 | 13 | The other source files here are nothing but CLIs that gather arguments 14 | and call functions in tree.c for testing. Some examples of tests you 15 | can run to play with the tree implementation: 16 | 17 | tree_insert testfile string_one string_two string_one string_three 18 | tree_walk testfile 19 | tree_free testfile 20 | 21 | Like most examples, use -M to turn on the msync mode in libpmem, -F to turn 22 | on the fault injection test mode in libpmem, and -d to enable debug output. 23 | 24 | The command: 25 | 26 | make test 27 | 28 | will pull a bunch of text files from gutenberg.com and run them through 29 | the word frequency counting program "tree_wordfreq". The Makefile does 30 | this using the freqtest script and then checks the output against expected 31 | output in "freqtest.pass". The make succeeds if the test passes. 32 | 33 | The command: 34 | 35 | make allcounts 36 | 37 | will perform a fault injection test run (takes a while to run). 38 | -------------------------------------------------------------------------------- /misc/linux-examples/binarytree/freqtest.pass: -------------------------------------------------------------------------------- 1 | Running test... 2 | rm -f testfile 3 | ./tree_wordfreq testfile 4000.txt 4300.txt 4302.txt 4309.txt 4500.txt 4 | Checking results... 5 | Summary of pmem pool: 6 | File size: 10485760, 10469312 allocatable bytes in pool 7 | 8 | State Bytes Clumps Largest Smallest 9 | Free 543744 1 543744 543744 10 | Reserved 0 0 0 0 11 | Activating 0 0 0 0 12 | Active 9925568 77543 192 128 13 | Freeing 0 0 0 0 14 | TOTAL 10469312 77544 543744 128 15 | Lines in tree: 77543 16 | Done. 17 | -------------------------------------------------------------------------------- /misc/linux-examples/binarytree/tree.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2013, Intel Corporation 3 | * 4 | * Redistribution and use in source and binary forms, with or without 5 | * modification, are permitted provided that the following conditions 6 | * are met: 7 | * 8 | * * Redistributions of source code must retain the above copyright 9 | * notice, this list of conditions and the following disclaimer. 10 | * 11 | * * Redistributions in binary form must reproduce the above copyright 12 | * notice, this list of conditions and the following disclaimer in 13 | * the documentation and/or other materials provided with the 14 | * distribution. 15 | * 16 | * * Neither the name of Intel Corporation nor the names of its 17 | * contributors may be used to endorse or promote products derived 18 | * from this software without specific prior written permission. 19 | * 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 | */ 32 | 33 | /* 34 | * tree.h -- definitions for the binary tree example 35 | */ 36 | 37 | void tree_init(const char *path, size_t size); 38 | void tree_insert(const char *s); 39 | void tree_walk(void); 40 | void tree_free(void); 41 | -------------------------------------------------------------------------------- /misc/linux-examples/icount/.gitignore: -------------------------------------------------------------------------------- 1 | icount_test 2 | -------------------------------------------------------------------------------- /misc/linux-examples/icount/icount.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2013, Intel Corporation 3 | * 4 | * Redistribution and use in source and binary forms, with or without 5 | * modification, are permitted provided that the following conditions 6 | * are met: 7 | * 8 | * * Redistributions of source code must retain the above copyright 9 | * notice, this list of conditions and the following disclaimer. 10 | * 11 | * * Redistributions in binary form must reproduce the above copyright 12 | * notice, this list of conditions and the following disclaimer in 13 | * the documentation and/or other materials provided with the 14 | * distribution. 15 | * 16 | * * Neither the name of Intel Corporation nor the names of its 17 | * contributors may be used to endorse or promote products derived 18 | * from this software without specific prior written permission. 19 | * 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 | */ 32 | 33 | /* 34 | * icount.h -- interfaces for the icount module 35 | */ 36 | 37 | void icount_start(unsigned long life_remaining); 38 | void icount_stop(void); 39 | unsigned long icount_total(void); 40 | -------------------------------------------------------------------------------- /misc/linux-examples/icount/icount_test.pass: -------------------------------------------------------------------------------- 1 | Program terminated after 4 instructions 2 | -------------------------------------------------------------------------------- /misc/linux-examples/libpmem/.gitignore: -------------------------------------------------------------------------------- 1 | libpmem.a 2 | libpmem.so 3 | -------------------------------------------------------------------------------- /misc/linux-examples/libpmem/pmem.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2013, Intel Corporation 3 | * 4 | * Redistribution and use in source and binary forms, with or without 5 | * modification, are permitted provided that the following conditions 6 | * are met: 7 | * 8 | * * Redistributions of source code must retain the above copyright 9 | * notice, this list of conditions and the following disclaimer. 10 | * 11 | * * Redistributions in binary form must reproduce the above copyright 12 | * notice, this list of conditions and the following disclaimer in 13 | * the documentation and/or other materials provided with the 14 | * distribution. 15 | * 16 | * * Neither the name of Intel Corporation nor the names of its 17 | * contributors may be used to endorse or promote products derived 18 | * from this software without specific prior written permission. 19 | * 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 | */ 32 | 33 | /* 34 | * pmem.h -- definitions of libpmem entry points 35 | */ 36 | 37 | void pmem_msync_mode(void); /* for testing on non-PM memory-mapped files */ 38 | void pmem_fit_mode(void); /* for fault injection testing */ 39 | 40 | /* commonly-used functions for Persistent Memory */ 41 | void *pmem_map(int fd, size_t len); 42 | void pmem_persist(void *addr, size_t len, int flags); 43 | 44 | /* for advanced users -- functions that do portions of pmem_persist() */ 45 | void pmem_flush_cache(void *addr, size_t len, int flags); 46 | void pmem_fence(void); 47 | void pmem_drain_pm_stores(void); 48 | -------------------------------------------------------------------------------- /misc/linux-examples/libpmem/pmem.map: -------------------------------------------------------------------------------- 1 | # Copyright (c) 2013, Intel Corporation 2 | # 3 | # Redistribution and use in source and binary forms, with or without 4 | # modification, are permitted provided that the following conditions 5 | # are met: 6 | # 7 | # * Redistributions of source code must retain the above copyright 8 | # notice, this list of conditions and the following disclaimer. 9 | # 10 | # * Redistributions in binary form must reproduce the above copyright 11 | # notice, this list of conditions and the following disclaimer in 12 | # the documentation and/or other materials provided with the 13 | # distribution. 14 | # 15 | # * Neither the name of Intel Corporation nor the names of its 16 | # contributors may be used to endorse or promote products derived 17 | # from this software without specific prior written permission. 18 | # 19 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 | # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 | # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 | # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 | # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 | # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 | # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 | # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 | # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 | # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 | 31 | # 32 | # pmem.map -- linker map file for libpmem 33 | # 34 | libpmem.so { 35 | global: 36 | pmem_map; 37 | pmem_flush; 38 | pmem_drain_pm_stores; 39 | pmem_msync_mode; 40 | pmem_fit_mode; 41 | local: 42 | *; 43 | }; 44 | -------------------------------------------------------------------------------- /misc/linux-examples/libpmemalloc/.gitignore: -------------------------------------------------------------------------------- 1 | libpmemalloc.a 2 | libpmemalloc.so 3 | pmemalloc_test1 4 | pmemalloc_test2 5 | pmemalloc_check 6 | -------------------------------------------------------------------------------- /misc/linux-examples/libpmemalloc/pmemalloc.map: -------------------------------------------------------------------------------- 1 | # Copyright (c) 2013, Intel Corporation 2 | # 3 | # Redistribution and use in source and binary forms, with or without 4 | # modification, are permitted provided that the following conditions 5 | # are met: 6 | # 7 | # * Redistributions of source code must retain the above copyright 8 | # notice, this list of conditions and the following disclaimer. 9 | # 10 | # * Redistributions in binary form must reproduce the above copyright 11 | # notice, this list of conditions and the following disclaimer in 12 | # the documentation and/or other materials provided with the 13 | # distribution. 14 | # 15 | # * Neither the name of Intel Corporation nor the names of its 16 | # contributors may be used to endorse or promote products derived 17 | # from this software without specific prior written permission. 18 | # 19 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 | # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 | # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 | # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 | # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 | # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 | # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 | # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 | # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 | # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 | 31 | # 32 | # pmemalloc.map -- linker map file for libpmemalloc 33 | # 34 | libpmemalloc.so { 35 | global: 36 | pmemalloc_init; 37 | pmemalloc_static_area; 38 | pmemalloc_reserve; 39 | pmemalloc_unreserve; 40 | pmemalloc_persist; 41 | pmemalloc_free; 42 | 43 | local: 44 | *; 45 | }; 46 | -------------------------------------------------------------------------------- /misc/linux-examples/libpmemalloc/pmemalloctest.pass: -------------------------------------------------------------------------------- 1 | Running test... 2 | rm -f testfile 3 | ./pmemalloc_test1 testfile 1 2 3 4 4 | ./pmemalloc_test1 testfile 5 | 4 3 2 1 6 | Done. 7 | -------------------------------------------------------------------------------- /misc/linux-examples/plist.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "libpm.h" 6 | #include "plist.h" 7 | 8 | using namespace std; 9 | 10 | extern struct static_info *sp; 11 | 12 | int main(int argc, char *argv[]) { 13 | const char* path = "./testfile"; 14 | 15 | long pmp_size = 10 * 1024 * 1024; 16 | if ((pmp = pmemalloc_init(path, pmp_size)) == NULL) 17 | cout << "pmemalloc_init on :" << path << endl; 18 | 19 | sp = (struct static_info *) pmemalloc_static_area(); 20 | 21 | plist* list = new plist(&sp->ptrs[0], &sp->ptrs[1]); 22 | 23 | int key; 24 | srand(time(NULL)); 25 | int ops = 3; 26 | 27 | for (int i = 0; i < ops; i++) { 28 | key = rand() % 10; 29 | 30 | std::string str(2, 'a' + key); 31 | char* data = new char[3]; 32 | pmemalloc_activate(data); 33 | strcpy(data, str.c_str()); 34 | 35 | list->push_back(data); 36 | } 37 | 38 | list->display(); 39 | 40 | char* updated_val = new char[3]; 41 | pmemalloc_activate(updated_val); 42 | strcpy(updated_val, "ab"); 43 | 44 | list->update(2, updated_val); 45 | 46 | updated_val = new char[3]; 47 | pmemalloc_activate(updated_val); 48 | strcpy(updated_val, "cd"); 49 | 50 | list->update(0, updated_val); 51 | 52 | list->display(); 53 | 54 | delete list; 55 | 56 | return 0; 57 | } 58 | 59 | -------------------------------------------------------------------------------- /misc/linux-examples/ptreap.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include "libpm.h" 8 | #include "ptreap.h" 9 | 10 | using namespace std; 11 | 12 | extern struct static_info* sp; 13 | 14 | void lookup(ptreap *tree, unsigned int version, 15 | const unsigned long key) { 16 | int* ret; 17 | 18 | ret = tree->at(version, key); 19 | cout << "version :: " << version << " key :: " << key << " "; 20 | if (ret != NULL) 21 | cout << "val :: " << (*ret) << endl; 22 | else 23 | cout << "val :: not found" << endl; 24 | 25 | } 26 | 27 | int main(int argc, char **argv) { 28 | 29 | const char* path = "./testfile"; 30 | 31 | long pmp_size = 10 * 1024 * 1024; 32 | if ((pmp = pmemalloc_init(path, pmp_size)) == NULL) 33 | cout << "pmemalloc_init on :" << path << endl; 34 | 35 | sp = (struct static_info *) pmemalloc_static_area(); 36 | 37 | int i; 38 | ptreap* tree = new ptreap(&sp->ptrs[0]); 39 | 40 | int n = 10; 41 | int* nums = new int[n]; 42 | for (i = 0; i < n; ++i) 43 | nums[i] = i * 10; 44 | 45 | printf("Persistent Tree with many versions...\n"); 46 | 47 | tree->insert(1, &(nums[1])); 48 | tree->insert(2, &(nums[2])); 49 | tree->insert(3, &(nums[3])); 50 | tree->insert(6, &(nums[6])); 51 | 52 | cout << "nodes ::" << tree->nnodes << endl; 53 | 54 | for (i = 1; i <= 4; ++i) 55 | lookup(tree, tree->current_version(), i); 56 | 57 | // Next version 58 | tree->next_version(); 59 | 60 | tree->insert(2, &(nums[5])); 61 | tree->remove(3); 62 | 63 | tree->insert(4, &(nums[4])); 64 | 65 | for (i = 1; i <= 4; ++i) 66 | lookup(tree, tree->current_version(), i); 67 | 68 | cout << "nodes ::" << tree->nnodes << endl; 69 | 70 | lookup(tree, 1, 2); 71 | lookup(tree, 1, 3); 72 | lookup(tree, 0, 2); 73 | lookup(tree, 0, 3); 74 | 75 | cout << "nodes ::" << tree->nnodes << endl; 76 | 77 | tree->delete_versions(0); 78 | 79 | lookup(tree, 0, 2); 80 | lookup(tree, 0, 3); 81 | 82 | cout << "nodes ::" << tree->nnodes << endl; 83 | 84 | delete tree; 85 | sp->ptrs[0] = NULL; 86 | 87 | cout << "nodes ::" << tree->nnodes << endl; 88 | 89 | delete[] nums; 90 | 91 | return 0; 92 | } 93 | -------------------------------------------------------------------------------- /misc/linux-examples/ptree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include "libpm.h" 8 | #include "ptree.h" 9 | 10 | using namespace std; 11 | 12 | extern struct static_info* sp; 13 | 14 | int main() { 15 | const char* path = "./testfile"; 16 | 17 | long pmp_size = 10 * 1024 * 1024; 18 | if ((pmp = pmemalloc_init(path, pmp_size)) == NULL) 19 | cout << "pmemalloc_init on :" << path << endl; 20 | 21 | sp = (struct static_info *) pmemalloc_static_area(); 22 | 23 | ptree* tree = new ptree(&sp->ptrs[0]); 24 | 25 | int key; 26 | srand(time(NULL)); 27 | int ops = 10; 28 | 29 | for (int i = 0; i < ops; i++) { 30 | key = rand() % 10; 31 | tree->insert(key, 0); 32 | } 33 | 34 | tree->display(); 35 | 36 | delete tree; 37 | 38 | } 39 | 40 | -------------------------------------------------------------------------------- /misc/linux-examples/trivial/.gitignore: -------------------------------------------------------------------------------- 1 | trivial 2 | testfile 3 | -------------------------------------------------------------------------------- /misc/linux-examples/trivial/README: -------------------------------------------------------------------------------- 1 | This is trivial/README. 2 | 3 | This is the most trivial example I could come up with to illustrate 4 | how to memory map Persistent Memory, store a few bytes to it, and 5 | make the stores durable. The example is totally self-contained in 6 | a single file. No hard problems are solved in this example -- it 7 | just shows you how to use mmap() and msync(). 8 | 9 | To build this use: 10 | make 11 | 12 | To run a trivial test use: 13 | make test 14 | -------------------------------------------------------------------------------- /misc/linux-examples/trivial/trivialtest.pass: -------------------------------------------------------------------------------- 1 | Running test... 2 | rm -f testfile 3 | dd if=/dev/zero of=testfile bs=4k count=1 status=noxfer 4 | 1+0 records in 5 | 1+0 records out 6 | ./trivial testfile 7 | Done. 8 | od -c testfile 9 | 0000000 H e l l o , P e r s i s t e n 10 | 0000020 t M e m o r y ! \0 \0 \0 \0 \0 \0 \0 11 | 0000040 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 12 | * 13 | 0010000 14 | Done. 15 | -------------------------------------------------------------------------------- /misc/linux-examples/util/README: -------------------------------------------------------------------------------- 1 | This is util/README. 2 | 3 | These are not the examples you're looking for. 4 | 5 | This directory just contains common routines for printing errors 6 | and debug information. Nothing particularly interesting here 7 | and nothing to do with Persistent Memory. Check out ../README 8 | to see which directories contain the examples. 9 | 10 | To use these routines, include util.h and compile util.c into 11 | your program. These are trivial to write, but they turn up 12 | again and again so they're here when you need them. They are: 13 | 14 | DEBUG(...) printf-like output to stderr, but only if 15 | the global flag Debug is non-zero The output 16 | includes file:line, name of function, and 17 | gets a newline appended. You can use DEBUG(NULL) 18 | to just trace that a line was executed. 19 | 20 | int Debug = 1; Put this at the top of one of your source files 21 | to turn on the DEBUG() statements mentioned above. 22 | 23 | FATAL(...) printf-like output to stderr with no return -- 24 | just like DEBUG() above but then this function 25 | calls exit(1). 26 | 27 | FATALSYS(...) Same as FATAL() above, but the message contains 28 | the equivalent of perror() appended to it. 29 | 30 | USAGE(...) Prints to stderr "Usage: " followed by 31 | the argument format from taken from the global 32 | variable Usage, followed by any printf-like message 33 | given as arguments to USAGE(). Calls exit(1). 34 | 35 | char Usage[] = Put this at the top of one of your source files 36 | "args..."; so USAGE() knows how to print the argument format. 37 | 38 | Myname = argv[0]; Put this at the top of your main() so USAGE() 39 | knows what name to print. 40 | 41 | ASSERT(cnd); Assert that condition is true, turns into FATAL() 42 | if it isn't. Prints the condition on failure. 43 | 44 | ASSERTinfo(cnd, info); Same as ASSERT() above, except it also includes 45 | the additional information (info must be a string). 46 | 47 | ASSERTeq(lhs, rhs); Assert two integer-valued expressions are equal, 48 | if not calls FATAL() to print both expressions 49 | and their values. Handy for printing everything you 50 | need to work on a blown assertion without having 51 | to wish you had printed the values. 52 | 53 | ASSERTne(lhs, rhs); Assert two integer-valued expressions are not equal. 54 | -------------------------------------------------------------------------------- /misc/mmalloc/MAINTAINERS: -------------------------------------------------------------------------------- 1 | The mmalloc directory is maintained by the GDB group's Host 2 | maintainers. 3 | 4 | This code is in a maintain-only phase - only configury patches fixing 5 | host compile problems are generally accepted. 6 | -------------------------------------------------------------------------------- /misc/mmalloc/TODO: -------------------------------------------------------------------------------- 1 | Things that still need attention: 2 | 3 | * Make implementation changes necessary to allow multiple processes 4 | to use the mmalloc managed region simultaneously. This requires, 5 | at the minimum, some sort of cooperative locking that ensures that 6 | only one process at a time is changing any of the mmalloc managed 7 | data structures (its ok for the mmalloc managed data regions to be 8 | changed at any time since we don't care about their contents). 9 | 10 | * In order to support multiple processes using the mmalloc managed 11 | region, the malloc descriptor needs to be broken into two parts, 12 | one part which is specific to the given process and is maintained 13 | separately on a per process basis, and another part which is common 14 | to all processes. As an example, the file descriptor is specific 15 | to a given process, as are the morecore and abortfunc pointers. 16 | However magic[], the version number, the flags field, etc are 17 | common to all processes. 18 | -------------------------------------------------------------------------------- /misc/mmalloc/acinclude.m4: -------------------------------------------------------------------------------- 1 | sinclude(../bfd/acinclude.m4) 2 | -------------------------------------------------------------------------------- /misc/mmalloc/configure.in: -------------------------------------------------------------------------------- 1 | dnl Autoconf configure script for MMALLOC, the GNU mmemory allocator. 2 | dnl Copyright 2000 Free Software Foundation, Inc. 3 | dnl 4 | dnl This file is part of GDB. 5 | dnl 6 | dnl This program is free software; you can redistribute it and/or modify 7 | dnl it under the terms of the GNU General Public License as published by 8 | dnl the Free Software Foundation; either version 2 of the License, or 9 | dnl (at your option) any later version. 10 | dnl 11 | dnl This program is distributed in the hope that it will be useful, 12 | dnl but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | dnl GNU General Public License for more details. 15 | dnl 16 | dnl You should have received a copy of the GNU General Public License 17 | dnl along with this program; if not, write to the Free Software 18 | dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 19 | dnl Process this file with autoconf to produce a configure script. 20 | 21 | AC_PREREQ(2.12.1)dnl 22 | AC_INIT(mmalloc.c) 23 | 24 | AC_PROG_CC 25 | AC_PROG_INSTALL 26 | AC_CHECK_TOOL(AR, ar) 27 | AC_CHECK_TOOL(RANLIB, ranlib, :) 28 | 29 | AC_FUNC_MMAP 30 | AC_CHECK_HEADERS(limits.h stddef.h unistd.h) 31 | 32 | BFD_NEED_DECLARATION(sbrk) 33 | BFD_NEED_DECLARATION(getpagesize) 34 | 35 | AC_OUTPUT(Makefile) 36 | -------------------------------------------------------------------------------- /misc/mmalloc/keys.c: -------------------------------------------------------------------------------- 1 | /* Access for application keys in mmap'd malloc managed region. 2 | Copyright 1992 Free Software Foundation, Inc. 3 | 4 | Contributed by Fred Fish at Cygnus Support. fnf@cygnus.com 5 | 6 | This file is part of the GNU C Library. 7 | 8 | The GNU C Library is free software; you can redistribute it and/or 9 | modify it under the terms of the GNU Library General Public License as 10 | published by the Free Software Foundation; either version 2 of the 11 | License, or (at your option) any later version. 12 | 13 | The GNU C Library is distributed in the hope that it will be useful, 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 | Library General Public License for more details. 17 | 18 | You should have received a copy of the GNU Library General Public 19 | License along with the GNU C Library; see the file COPYING.LIB. If 20 | not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 21 | Boston, MA 02111-1307, USA. */ 22 | 23 | /* This module provides access to some keys that the application can use to 24 | provide persistent access to locations in the mapped memory section. 25 | The intent is that these keys are to be used sparingly as sort of 26 | persistent global variables which the application can use to reinitialize 27 | access to data in the mapped region. 28 | 29 | For the moment, these keys are simply stored in the malloc descriptor 30 | itself, in an array of fixed length. This should be fixed so that there 31 | can be an unlimited number of keys, possibly using a multilevel access 32 | scheme of some sort. */ 33 | 34 | #include "mmprivate.h" 35 | 36 | int 37 | mmalloc_setkey (md, keynum, key) 38 | PTR md; 39 | int keynum; 40 | PTR key; 41 | { 42 | struct mdesc *mdp = (struct mdesc *) md; 43 | int result = 0; 44 | 45 | if ((mdp != NULL) && (keynum >= 0) && (keynum < MMALLOC_KEYS)) 46 | { 47 | mdp -> keys [keynum] = key; 48 | result++; 49 | } 50 | return (result); 51 | } 52 | 53 | PTR 54 | mmalloc_getkey (md, keynum) 55 | PTR md; 56 | int keynum; 57 | { 58 | struct mdesc *mdp = (struct mdesc *) md; 59 | PTR keyval = NULL; 60 | 61 | if ((mdp != NULL) && (keynum >= 0) && (keynum < MMALLOC_KEYS)) 62 | { 63 | keyval = mdp -> keys [keynum]; 64 | } 65 | return (keyval); 66 | } 67 | -------------------------------------------------------------------------------- /misc/mmalloc/mcalloc.c: -------------------------------------------------------------------------------- 1 | /* Copyright (C) 1991, 1992 Free Software Foundation, Inc. 2 | This file is part of the GNU C Library. 3 | 4 | The GNU C Library is free software; you can redistribute it and/or 5 | modify it under the terms of the GNU Library General Public License as 6 | published by the Free Software Foundation; either version 2 of the 7 | License, or (at your option) any later version. 8 | 9 | The GNU C Library is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | Library General Public License for more details. 13 | 14 | You should have received a copy of the GNU Library General Public 15 | License along with the GNU C Library; see the file COPYING.LIB. If 16 | not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 17 | Boston, MA 02111-1307, USA. */ 18 | 19 | #include /* GCC on HP/UX needs this before string.h. */ 20 | #include /* Prototypes for memcpy, memmove, memset, etc */ 21 | 22 | #include "mmprivate.h" 23 | 24 | /* Allocate an array of NMEMB elements each SIZE bytes long. 25 | The entire array is initialized to zeros. */ 26 | 27 | PTR 28 | mcalloc (md, nmemb, size) 29 | PTR md; 30 | register size_t nmemb; 31 | register size_t size; 32 | { 33 | register PTR result; 34 | 35 | if ((result = mmalloc (md, nmemb * size)) != NULL) 36 | { 37 | memset (result, 0, nmemb * size); 38 | } 39 | return (result); 40 | } 41 | 42 | /* When using this package, provide a version of malloc/realloc/free built 43 | on top of it, so that if we use the default sbrk() region we will not 44 | collide with another malloc package trying to do the same thing, if 45 | the application contains any "hidden" calls to malloc/realloc/free (such 46 | as inside a system library). */ 47 | 48 | PTR 49 | calloc (nmemb, size) 50 | size_t nmemb; 51 | size_t size; 52 | { 53 | return (mcalloc ((PTR) NULL, nmemb, size)); 54 | } 55 | -------------------------------------------------------------------------------- /misc/mmalloc/mm.c: -------------------------------------------------------------------------------- 1 | /* Build the entire mmalloc library as a single object module. This 2 | avoids having clients pick up part of their allocation routines 3 | from mmalloc and part from libc, which results in undefined 4 | behavior. It should also still be possible to build the library 5 | as a standard library with multiple objects. 6 | 7 | Copyright 1996, 2000 Free Software Foundation 8 | 9 | The GNU C Library is free software; you can redistribute it and/or 10 | modify it under the terms of the GNU Library General Public License as 11 | published by the Free Software Foundation; either version 2 of the 12 | License, or (at your option) any later version. 13 | 14 | The GNU C Library is distributed in the hope that it will be useful, 15 | but WITHOUT ANY WARRANTY; without even the implied warranty of 16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 | Library General Public License for more details. 18 | 19 | You should have received a copy of the GNU Library General Public 20 | License along with the GNU C Library; see the file COPYING.LIB. If 21 | not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 22 | Boston, MA 02111-1307, USA. */ 23 | 24 | #ifdef HAVE_UNISTD_H 25 | #include /* Prototypes for lseek, sbrk (maybe) */ 26 | #endif 27 | #include "mcalloc.c" 28 | #include "mfree.c" 29 | #include "mmalloc.c" 30 | #include "mmcheck.c" 31 | #include "mmemalign.c" 32 | #include "mmstats.c" 33 | #include "mmtrace.c" 34 | #include "mrealloc.c" 35 | #include "mvalloc.c" 36 | #include "mmap-sup.c" 37 | #include "attach.c" 38 | #include "detach.c" 39 | #include "keys.c" 40 | #include "sbrk-sup.c" 41 | -------------------------------------------------------------------------------- /misc/mmalloc/mmalloc.h: -------------------------------------------------------------------------------- 1 | #ifndef MMALLOC_H 2 | #define MMALLOC_H 1 3 | 4 | #ifdef HAVE_STDDEF_H 5 | # include 6 | #else 7 | # include /* for size_t */ 8 | # include /* for NULL */ 9 | #endif 10 | 11 | #include "ansidecl.h" 12 | 13 | /* Allocate SIZE bytes of memory. */ 14 | 15 | extern PTR mmalloc PARAMS ((PTR, size_t)); 16 | 17 | /* Re-allocate the previously allocated block in PTR, making the new block 18 | SIZE bytes long. */ 19 | 20 | extern PTR mrealloc PARAMS ((PTR, PTR, size_t)); 21 | 22 | /* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. */ 23 | 24 | extern PTR mcalloc PARAMS ((PTR, size_t, size_t)); 25 | 26 | /* Free a block allocated by `mmalloc', `mrealloc' or `mcalloc'. */ 27 | 28 | extern void mfree PARAMS ((PTR, PTR)); 29 | 30 | /* Allocate SIZE bytes allocated to ALIGNMENT bytes. */ 31 | 32 | extern PTR mmemalign PARAMS ((PTR, size_t, size_t)); 33 | 34 | /* Allocate SIZE bytes on a page boundary. */ 35 | 36 | extern PTR mvalloc PARAMS ((PTR, size_t)); 37 | 38 | /* Activate a standard collection of debugging hooks. */ 39 | 40 | extern int mmcheck PARAMS ((PTR, void (*) (void))); 41 | 42 | extern int mmcheckf PARAMS ((PTR, void (*) (void), int)); 43 | 44 | /* Pick up the current statistics. (see FIXME elsewhere) */ 45 | 46 | extern struct mstats mmstats PARAMS ((PTR)); 47 | 48 | extern PTR mmalloc_attach PARAMS ((int, PTR)); 49 | 50 | extern PTR mmalloc_detach PARAMS ((PTR)); 51 | 52 | extern int mmalloc_setkey PARAMS ((PTR, int, PTR)); 53 | 54 | extern PTR mmalloc_getkey PARAMS ((PTR, int)); 55 | 56 | extern int mmalloc_errno PARAMS ((PTR)); 57 | 58 | extern int mmtrace PARAMS ((void)); 59 | 60 | extern PTR mmalloc_findbase PARAMS ((int)); 61 | 62 | #endif /* MMALLOC_H */ 63 | -------------------------------------------------------------------------------- /misc/mmalloc/mmemalign.c: -------------------------------------------------------------------------------- 1 | /* Copyright (C) 1991, 1992 Free Software Foundation, Inc. 2 | This file is part of the GNU C Library. 3 | 4 | The GNU C Library is free software; you can redistribute it and/or 5 | modify it under the terms of the GNU Library General Public License as 6 | published by the Free Software Foundation; either version 2 of the 7 | License, or (at your option) any later version. 8 | 9 | The GNU C Library is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | Library General Public License for more details. 13 | 14 | You should have received a copy of the GNU Library General Public 15 | License along with the GNU C Library; see the file COPYING.LIB. If 16 | not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 17 | Boston, MA 02111-1307, USA. */ 18 | 19 | #include "mmprivate.h" 20 | 21 | PTR 22 | mmemalign (md, alignment, size) 23 | PTR md; 24 | size_t alignment; 25 | size_t size; 26 | { 27 | PTR result; 28 | unsigned long int adj; 29 | struct alignlist *l; 30 | struct mdesc *mdp; 31 | 32 | if ((result = mmalloc (md, size + alignment - 1)) != NULL) 33 | { 34 | adj = RESIDUAL (result, alignment); 35 | if (adj != 0) 36 | { 37 | mdp = MD_TO_MDP (md); 38 | for (l = mdp -> aligned_blocks; l != NULL; l = l -> next) 39 | { 40 | if (l -> aligned == NULL) 41 | { 42 | /* This slot is free. Use it. */ 43 | break; 44 | } 45 | } 46 | if (l == NULL) 47 | { 48 | l = (struct alignlist *) mmalloc (md, sizeof (struct alignlist)); 49 | if (l == NULL) 50 | { 51 | mfree (md, result); 52 | return (NULL); 53 | } 54 | l -> next = mdp -> aligned_blocks; 55 | mdp -> aligned_blocks = l; 56 | } 57 | l -> exact = result; 58 | result = l -> aligned = (char *) result + alignment - adj; 59 | } 60 | } 61 | return (result); 62 | } 63 | -------------------------------------------------------------------------------- /misc/mmalloc/mmstats.c: -------------------------------------------------------------------------------- 1 | /* Access the statistics maintained by `mmalloc'. 2 | Copyright 1990, 1991, 1992 Free Software Foundation 3 | 4 | Written May 1989 by Mike Haertel. 5 | Modified Mar 1992 by Fred Fish. (fnf@cygnus.com) 6 | 7 | The GNU C Library is free software; you can redistribute it and/or 8 | modify it under the terms of the GNU Library General Public License as 9 | published by the Free Software Foundation; either version 2 of the 10 | License, or (at your option) any later version. 11 | 12 | The GNU C Library is distributed in the hope that it will be useful, 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | Library General Public License for more details. 16 | 17 | You should have received a copy of the GNU Library General Public 18 | License along with the GNU C Library; see the file COPYING.LIB. If 19 | not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 20 | Boston, MA 02111-1307, USA. 21 | 22 | The author may be reached (Email) at the address mike@ai.mit.edu, 23 | or (US mail) as Mike Haertel c/o Free Software Foundation. */ 24 | 25 | #include "mmprivate.h" 26 | 27 | /* FIXME: See the comment in mmprivate.h where struct mstats is defined. 28 | None of the internal mmalloc structures should be externally visible 29 | outside the library. */ 30 | 31 | struct mstats 32 | mmstats (md) 33 | PTR md; 34 | { 35 | struct mstats result; 36 | struct mdesc *mdp; 37 | 38 | mdp = MD_TO_MDP (md); 39 | result.bytes_total = 40 | (char *) mdp -> morecore (mdp, 0) - mdp -> heapbase; 41 | result.chunks_used = mdp -> heapstats.chunks_used; 42 | result.bytes_used = mdp -> heapstats.bytes_used; 43 | result.chunks_free = mdp -> heapstats.chunks_free; 44 | result.bytes_free = mdp -> heapstats.bytes_free; 45 | return (result); 46 | } 47 | -------------------------------------------------------------------------------- /misc/mmalloc/mmtrace.awk: -------------------------------------------------------------------------------- 1 | # 2 | # Awk program to analyze mtrace.c output. 3 | # 4 | $1 == "+" { if (allocated[$2] != "") 5 | print "+", $2, "Alloc", NR, "duplicate:", allocated[$2]; 6 | else 7 | allocated[$2] = $3; 8 | } 9 | $1 == "-" { if (allocated[$2] != "") { 10 | allocated[$2] = ""; 11 | if (allocated[$2] != "") 12 | print "DELETE FAILED", $2, allocated[$2]; 13 | } else 14 | print "-", $2, "Free", NR, "was never alloc'd"; 15 | } 16 | $1 == "<" { if (allocated[$2] != "") 17 | allocated[$2] = ""; 18 | else 19 | print "-", $2, "Realloc", NR, "was never alloc'd"; 20 | } 21 | $1 == ">" { if (allocated[$2] != "") 22 | print "+", $2, "Realloc", NR, "duplicate:", allocated[$2]; 23 | else 24 | allocated[$2] = $3; 25 | } 26 | 27 | # Ignore "= Start" 28 | $1 == "=" { } 29 | # Ignore failed realloc attempts for now 30 | $1 == "!" { } 31 | 32 | 33 | END { for (x in allocated) 34 | if (allocated[x] != "") 35 | print "+", x, allocated[x]; 36 | } 37 | -------------------------------------------------------------------------------- /misc/mmalloc/mvalloc.c: -------------------------------------------------------------------------------- 1 | /* Allocate memory on a page boundary. 2 | Copyright (C) 1991 Free Software Foundation, Inc. 3 | 4 | The GNU C Library is free software; you can redistribute it and/or 5 | modify it under the terms of the GNU Library General Public License as 6 | published by the Free Software Foundation; either version 2 of the 7 | License, or (at your option) any later version. 8 | 9 | The GNU C Library is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | Library General Public License for more details. 13 | 14 | You should have received a copy of the GNU Library General Public 15 | License along with the GNU C Library; see the file COPYING.LIB. If 16 | not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 17 | Boston, MA 02111-1307, USA. */ 18 | 19 | #include "mmprivate.h" 20 | 21 | /* Cache the pagesize for the current host machine. Note that if the host 22 | does not readily provide a getpagesize() function, we need to emulate it 23 | elsewhere, not clutter up this file with lots of kluges to try to figure 24 | it out. */ 25 | 26 | static size_t cache_pagesize; 27 | #if NEED_DECLARATION_GETPAGESIZE 28 | extern int getpagesize PARAMS ((void)); 29 | #endif 30 | 31 | PTR 32 | mvalloc (md, size) 33 | PTR md; 34 | size_t size; 35 | { 36 | if (cache_pagesize == 0) 37 | { 38 | cache_pagesize = getpagesize (); 39 | } 40 | 41 | return (mmemalign (md, cache_pagesize, size)); 42 | } 43 | 44 | 45 | PTR 46 | valloc (size) 47 | size_t size; 48 | { 49 | return mvalloc ((PTR) NULL, size); 50 | } 51 | -------------------------------------------------------------------------------- /misc/pcommit/pm_helper.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define CPU_FREQ_MHZ (2593) 6 | 7 | static inline unsigned long read_tsc(void) 8 | { 9 | unsigned long var; 10 | unsigned int hi, lo; 11 | 12 | asm volatile ("rdtsc" : "=a" (lo), "=d" (hi)); 13 | var = ((unsigned long long int) hi << 32) | lo; 14 | 15 | return var; 16 | } 17 | 18 | static inline void cpu_pause() 19 | { 20 | __asm__ volatile ("pause" ::: "memory"); 21 | } 22 | 23 | static inline void clwb(void *addr) 24 | { 25 | cpu_pause(); 26 | } 27 | 28 | static inline void pm_wbarrier(unsigned long lat) 29 | { 30 | unsigned long etsc = read_tsc() + (unsigned long)(lat*CPU_FREQ_MHZ/1000); 31 | while (read_tsc() < etsc) 32 | cpu_pause(); 33 | } 34 | 35 | #define DELAY_IN_NS (5000) 36 | 37 | static inline void measure() 38 | { 39 | unsigned long stsc, etsc; 40 | 41 | stsc = read_tsc(); 42 | pm_wbarrier(DELAY_IN_NS); 43 | etsc = read_tsc(); 44 | printf ("pm_wbarrier latency: %lu ns\n", 45 | (unsigned long)((etsc-stsc)*1000/CPU_FREQ_MHZ)); 46 | 47 | stsc = read_tsc(); 48 | pm_wbarrier(2*DELAY_IN_NS); 49 | etsc = read_tsc(); 50 | printf ("pm_wbarrier latency: %lu ns\n", 51 | (unsigned long)((etsc-stsc)*1000/CPU_FREQ_MHZ)); 52 | 53 | stsc = read_tsc(); 54 | clwb(NULL); 55 | etsc = read_tsc(); 56 | printf ("clwb latency: %lu ns\n", 57 | (unsigned long)((etsc-stsc)*1000/CPU_FREQ_MHZ)); 58 | } 59 | 60 | int main(void) 61 | { 62 | measure(); 63 | return 0; 64 | } 65 | 66 | -------------------------------------------------------------------------------- /misc/pmem/pmem_check.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * pmemalloc_check.c -- check the health of a pmem pool 3 | * Usage: pmemalloc_check [-FMd] path 4 | * This is just a simple CLI for calling pmemalloc_check(). 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #include "libpm.h" 15 | 16 | using namespace std; 17 | 18 | char Usage[] = "pmem_check "; /* for USAGE() */ 19 | 20 | int main(int argc, char *argv[]) { 21 | const char *path; 22 | 23 | if (optind >= argc) 24 | printf("No path given \nUsage:: %s \n", Usage); 25 | path = argv[optind++]; 26 | 27 | if (optind < argc) 28 | printf("Usage :: %s \n", Usage); 29 | 30 | storage::pmemalloc_check(path); 31 | 32 | exit(0); 33 | } 34 | 35 | -------------------------------------------------------------------------------- /misc/test/mmaptest.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | int main(int argc, char *argv[]) { 11 | int fd, offset; 12 | char *data; 13 | struct stat sbuf; 14 | 15 | if (argc != 1) { 16 | fprintf(stderr, "usage: mmapdemo \n"); 17 | exit(1); 18 | } 19 | 20 | fd = open("log", O_RDWR | O_CREAT); 21 | if (fd < 0) { 22 | perror("open"); 23 | exit(1); 24 | } 25 | 26 | size_t len = 8UL * 1024; 27 | if (posix_fallocate(fd, 0, len) < 0) { 28 | perror("open"); 29 | exit(1); 30 | } 31 | 32 | if (stat("log", &sbuf) == -1) { 33 | perror("stat"); 34 | exit(1); 35 | } 36 | 37 | printf("size : %lu\n", sbuf.st_size); 38 | printf("fd : %d\n", fd); 39 | 40 | caddr_t location = (caddr_t) 0x010000000; 41 | 42 | if ((data = (char*) mmap(location, sbuf.st_size, PROT_WRITE, MAP_SHARED, fd, 43 | 0)) == (caddr_t) (-1)) { 44 | perror("mmap"); 45 | exit(1); 46 | } 47 | 48 | printf("data : %s %p\n", data, data); 49 | 50 | char cmd[512]; 51 | sprintf(cmd, "cat /proc/%d/maps", getpid()); 52 | system(cmd); 53 | 54 | data[2] = 'x'; 55 | 56 | char* ptr = (char*) (location + 2); 57 | 58 | printf("data : %p %c \n", ptr, (*ptr)); 59 | 60 | msync(data, sbuf.st_size, MS_SYNC); 61 | 62 | return 0; 63 | } 64 | 65 | -------------------------------------------------------------------------------- /misc/test/serialize.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | 13 | int main() { 14 | std::map map = { { 1, 2 }, { 2, 1 } }; 15 | std::ofstream ofile("map"); 16 | 17 | boost::archive::text_oarchive oarch(ofile, std::ofstream::out); 18 | oarch << map; 19 | 20 | ofile.close(); 21 | 22 | std::map new_map; 23 | std::ifstream ifile("map"); 24 | 25 | boost::archive::text_iarchive iarch(ifile); 26 | iarch >> new_map; 27 | 28 | std::cout << (map == new_map) << std::endl; 29 | 30 | } 31 | -------------------------------------------------------------------------------- /misc/test/slog.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | 11 | int level = 2; // verbosity level 12 | 13 | #ifdef NDEBUG 14 | #define LOG_ERR(M, ...) 15 | #define LOG_WARN(M, ...) 16 | #define LOG_INFO(M, ...) 17 | #else 18 | #define clean_errno() (errno == 0 ? "" : strerror(errno)) 19 | #define LOG_ERR(M, ...) if(level > 0) fprintf(stderr, "[EROR] [%s :: %s:%d] %s " M "\n", __FILE__, __func__, __LINE__, clean_errno(), ##__VA_ARGS__) 20 | #define LOG_WARN(M, ...) if(level > 1) fprintf(stderr, "[WARN] [%s :: %s:%d] %s " M "\n",__FILE__, __func__,__LINE__, clean_errno(), ##__VA_ARGS__) 21 | #define LOG_INFO(M, ...) if(level > 2) fprintf(stderr, "[INFO] [%s :: %s:%d] " M "\n", __FILE__, __func__, __LINE__, ##__VA_ARGS__) 22 | #endif 23 | 24 | void work() { 25 | int cnt = 16 * 1024; 26 | 27 | for (int i = 0; i < cnt; i++) { 28 | 29 | void* pmp = (void*) 0x1000034; 30 | size_t sz = 123; 31 | int state = 50; 32 | 33 | LOG_ERR("pmp: %p clump size %lu state %d", pmp, sz, state); 34 | LOG_WARN("warn: %lu", sz); 35 | } 36 | 37 | } 38 | 39 | int main() { 40 | std::vector executors; 41 | int num_thds = 4; 42 | 43 | for (int i = 0; i < num_thds; i++) 44 | executors.push_back(std::thread(work)); 45 | 46 | for (int i = 0; i < num_thds; i++) 47 | executors[i].join(); 48 | 49 | } 50 | 51 | -------------------------------------------------------------------------------- /misc/test/time.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include 6 | using namespace std; 7 | 8 | long fibonacci(int n) { 9 | if (n < 3) 10 | return 1; 11 | return fibonacci(n - 1) + fibonacci(n - 2); 12 | } 13 | 14 | int main() { 15 | std::chrono::time_point start, end; 16 | start = std::chrono::system_clock::now(); 17 | std::cout << "f(42) = " << fibonacci(40) << '\n'; 18 | end = std::chrono::system_clock::now(); 19 | 20 | std::chrono::duration elapsed_seconds = end - start; 21 | 22 | std::cout << "elapsed time: " << elapsed_seconds.count() << "s\n"; 23 | 24 | std::chrono::time_point hr_start, hr_end; 25 | hr_start = std::chrono::high_resolution_clock::now(); 26 | std::cout << "f(42) = " << fibonacci(40) << '\n'; 27 | hr_end = std::chrono::high_resolution_clock::now(); 28 | 29 | std::chrono::duration hr_elapsed_seconds = hr_end - hr_start; 30 | 31 | std::cout << "hr_elapsed time: " << hr_elapsed_seconds.count() << "s\n"; 32 | 33 | timeval t1, t2; 34 | 35 | gettimeofday(&t1, NULL); 36 | std::cout << "f(42) = " << fibonacci(40) << '\n'; 37 | gettimeofday(&t2, NULL); 38 | 39 | double duration; 40 | 41 | duration = (t2.tv_sec - t1.tv_sec) * 1000.0; // sec to ms 42 | duration += (t2.tv_usec - t1.tv_usec) / 1000.0; // us to ms 43 | 44 | cout << std::fixed << std::setprecision(2); 45 | cout << "Duration (s) : " << (duration / 1000.0) << "\n"; 46 | 47 | return 0; 48 | 49 | } 50 | -------------------------------------------------------------------------------- /misc/test/zipf.cpp: -------------------------------------------------------------------------------- 1 | // Zipf distribution 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | 13 | // Get a value in [1, N] that follows zipf distribution 14 | // P(i) = C/I^Alpha for i = 1 to N 15 | vector zipf(double alpha, int n, int num_values) { 16 | static double c = 0; // Normalization constant 17 | double z; // Uniform random number (0 < z < 1) 18 | double sum_prob; // Sum of probabilities 19 | double zipf_value; // Computed exponential value to be returned 20 | int i, j; 21 | 22 | vector zipf_dist; 23 | double* powers = new double[n + 1]; 24 | std::random_device rd; 25 | std::mt19937 gen(rd()); 26 | std::uniform_real_distribution<> dis(0, 1); 27 | 28 | for (i = 1; i <= n; i++) 29 | powers[i] = 1.0 / pow((double) i, alpha); 30 | 31 | // Compute normalization constant on first call only 32 | for (i = 1; i <= n; i++) 33 | c = c + powers[i]; 34 | c = 1.0 / c; 35 | 36 | for (j = 1; j <= num_values; j++) { 37 | // Pull a uniform random number in (0,1) 38 | do { 39 | z = dis(gen); 40 | } while ((z == 0) || (z == 1)); 41 | 42 | // Map z to the value 43 | sum_prob = 0; 44 | for (i = 1; i <= n; i++) { 45 | sum_prob = sum_prob + c * powers[i]; 46 | if (sum_prob >= z) { 47 | zipf_value = i; 48 | break; 49 | } 50 | } 51 | 52 | zipf_dist.push_back(zipf_value); 53 | } 54 | 55 | delete[] powers; 56 | 57 | return zipf_dist; 58 | } 59 | 60 | int main(void) { 61 | double alpha = 1.0; 62 | double n = 10; 63 | int num_values = 100000; 64 | 65 | zipf(alpha, n, num_values); 66 | 67 | return 0; 68 | } 69 | -------------------------------------------------------------------------------- /results/btree/1024/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 313180.11 2 | 0.50 , 347460.42 3 | -------------------------------------------------------------------------------- /results/btree/1024/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 439323.16 2 | 0.50 , 353680.97 3 | -------------------------------------------------------------------------------- /results/btree/1024/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 346374.73 2 | 0.50 , 359586.49 3 | -------------------------------------------------------------------------------- /results/btree/1024/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 227666.9 2 | 0.50 , 335533.67 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 507541.59 2 | 0.50 , 587192.6 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 783486.07 2 | 0.50 , 906050.39 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1001841.38 2 | 0.50 , 1113181.94 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 558090.6 2 | 0.50 , 554648.17 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 414465.36 2 | 0.50 , 546175.56 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 767186.95 2 | 0.50 , 1006696.17 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1189088.74 2 | 0.50 , 1561513.07 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 298900.75 2 | 0.50 , 393031.99 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1118138.77 2 | 0.50 , 1391664.49 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1604807.36 2 | 0.50 , 2142684.58 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1931614.1 2 | 0.50 , 2649036.45 3 | -------------------------------------------------------------------------------- /results/btree/1024/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 946098.74 2 | 0.50 , 1181807.84 3 | -------------------------------------------------------------------------------- /results/btree/1024/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 98806.76 2 | 0.50 , 139206.89 3 | -------------------------------------------------------------------------------- /results/btree/1024/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 339973.08 2 | 0.50 , 436328.83 3 | -------------------------------------------------------------------------------- /results/btree/1024/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 764162.39 2 | 0.50 , 899933.88 3 | -------------------------------------------------------------------------------- /results/btree/1024/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 58326.0 2 | 0.50 , 82671.22 3 | -------------------------------------------------------------------------------- /results/btree/1024/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 772448.61 2 | 0.50 , 936567.02 3 | -------------------------------------------------------------------------------- /results/btree/1024/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1448751.5 2 | 0.50 , 1897535.01 3 | -------------------------------------------------------------------------------- /results/btree/1024/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1962385.0 2 | 0.50 , 2656573.46 3 | -------------------------------------------------------------------------------- /results/btree/1024/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 537366.01 2 | 0.50 , 601710.24 3 | -------------------------------------------------------------------------------- /results/btree/128/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 293886.68 2 | 0.50 , 331182.76 3 | -------------------------------------------------------------------------------- /results/btree/128/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 421252.5 2 | 0.50 , 345095.67 3 | -------------------------------------------------------------------------------- /results/btree/128/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 334642.92 2 | 0.50 , 350145.73 3 | -------------------------------------------------------------------------------- /results/btree/128/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 219844.48 2 | 0.50 , 325884.87 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 498813.73 2 | 0.50 , 566505.88 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 748619.41 2 | 0.50 , 881646.36 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 945086.01 2 | 0.50 , 1116730.44 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 540707.58 2 | 0.50 , 546550.94 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1090633.85 2 | 0.50 , 1356309.21 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1616693.66 2 | 0.50 , 2081983.84 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1873434.51 2 | 0.50 , 2562432.88 3 | -------------------------------------------------------------------------------- /results/btree/128/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 916759.39 2 | 0.50 , 1109538.65 3 | -------------------------------------------------------------------------------- /results/btree/128/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/128/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/128/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/128/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/128/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 722858.82 2 | 0.50 , 890309.43 3 | -------------------------------------------------------------------------------- /results/btree/128/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1378083.38 2 | 0.50 , 1813432.27 3 | -------------------------------------------------------------------------------- /results/btree/128/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1796349.64 2 | 0.50 , 2457342.08 3 | -------------------------------------------------------------------------------- /results/btree/128/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 517126.18 2 | 0.50 , 591365.62 3 | -------------------------------------------------------------------------------- /results/btree/16384/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 293051.56 2 | 0.50 , 324269.12 3 | -------------------------------------------------------------------------------- /results/btree/16384/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 418050.15 2 | 0.50 , 337128.29 3 | -------------------------------------------------------------------------------- /results/btree/16384/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 341720.93 2 | 0.50 , 359809.87 3 | -------------------------------------------------------------------------------- /results/btree/16384/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 227274.48 2 | 0.50 , 322289.19 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 490290.35 2 | 0.50 , 555949.93 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 751878.85 2 | 0.50 , 850288.26 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 958123.42 2 | 0.50 , 1080827.09 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 521871.2 2 | 0.50 , 524578.12 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 271883.49 2 | 0.50 , 382401.88 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 675805.24 2 | 0.50 , 929260.51 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1462443.98 2 | 0.50 , 1841331.96 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 188553.67 2 | 0.50 , 256924.63 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1136182.23 2 | 0.50 , 1316575.3 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1558687.91 2 | 0.50 , 1952712.15 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1931905.64 2 | 0.50 , 2471375.3 3 | -------------------------------------------------------------------------------- /results/btree/16384/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 928798.32 2 | 0.50 , 1117499.33 3 | -------------------------------------------------------------------------------- /results/btree/16384/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 100138.51 2 | 0.50 , 138712.46 3 | -------------------------------------------------------------------------------- /results/btree/16384/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 341725.94 2 | 0.50 , 430342.83 3 | -------------------------------------------------------------------------------- /results/btree/16384/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 754005.94 2 | 0.50 , 898926.7 3 | -------------------------------------------------------------------------------- /results/btree/16384/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 58337.88 2 | 0.50 , 83203.43 3 | -------------------------------------------------------------------------------- /results/btree/16384/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 718188.43 2 | 0.50 , 821521.56 3 | -------------------------------------------------------------------------------- /results/btree/16384/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1381233.83 2 | 0.50 , 1729535.65 3 | -------------------------------------------------------------------------------- /results/btree/16384/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 2011094.2 2 | 0.50 , 2520113.66 3 | -------------------------------------------------------------------------------- /results/btree/16384/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 517093.9 2 | 0.50 , 554892.73 3 | -------------------------------------------------------------------------------- /results/btree/2048/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 305564.08 2 | 0.50 , 343756.06 3 | -------------------------------------------------------------------------------- /results/btree/2048/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 429751.32 2 | 0.50 , 351273.48 3 | -------------------------------------------------------------------------------- /results/btree/2048/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 334054.42 2 | 0.50 , 350406.86 3 | -------------------------------------------------------------------------------- /results/btree/2048/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 231036.55 2 | 0.50 , 331057.29 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 508529.5 2 | 0.50 , 576154.77 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 781895.22 2 | 0.50 , 888784.41 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 997295.34 2 | 0.50 , 1114207.06 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 553526.73 2 | 0.50 , 550621.83 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 427456.36 2 | 0.50 , 559505.39 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 812983.92 2 | 0.50 , 1071956.13 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1265072.75 2 | 0.50 , 1631354.97 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 302364.93 2 | 0.50 , 402851.63 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1114766.46 2 | 0.50 , 1396714.61 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1538650.91 2 | 0.50 , 2068759.89 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1848586.44 2 | 0.50 , 2548740.68 3 | -------------------------------------------------------------------------------- /results/btree/2048/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 944325.41 2 | 0.50 , 1128755.28 3 | -------------------------------------------------------------------------------- /results/btree/2048/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 98159.13 2 | 0.50 , 138213.13 3 | -------------------------------------------------------------------------------- /results/btree/2048/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 340686.86 2 | 0.50 , 430865.83 3 | -------------------------------------------------------------------------------- /results/btree/2048/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 761207.71 2 | 0.50 , 891479.13 3 | -------------------------------------------------------------------------------- /results/btree/2048/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 58367.36 2 | 0.50 , 83371.81 3 | -------------------------------------------------------------------------------- /results/btree/2048/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 781356.22 2 | 0.50 , 919909.78 3 | -------------------------------------------------------------------------------- /results/btree/2048/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1457560.48 2 | 0.50 , 1905176.05 3 | -------------------------------------------------------------------------------- /results/btree/2048/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1984530.09 2 | 0.50 , 2655175.95 3 | -------------------------------------------------------------------------------- /results/btree/2048/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 544014.07 2 | 0.50 , 607415.46 3 | -------------------------------------------------------------------------------- /results/btree/256/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 302171.1 2 | 0.50 , 341729.63 3 | -------------------------------------------------------------------------------- /results/btree/256/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 424668.19 2 | 0.50 , 347090.77 3 | -------------------------------------------------------------------------------- /results/btree/256/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 338901.67 2 | 0.50 , 351185.77 3 | -------------------------------------------------------------------------------- /results/btree/256/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 233823.83 2 | 0.50 , 330461.72 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 499612.89 2 | 0.50 , 583134.92 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 763256.02 2 | 0.50 , 900861.03 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 995720.52 2 | 0.50 , 1103820.07 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 541890.18 2 | 0.50 , 533647.4 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1110022.67 2 | 0.50 , 1385840.28 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1594674.11 2 | 0.50 , 2170678.26 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1885518.39 2 | 0.50 , 2565022.52 3 | -------------------------------------------------------------------------------- /results/btree/256/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 932997.7 2 | 0.50 , 1133132.28 3 | -------------------------------------------------------------------------------- /results/btree/256/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/256/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/256/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/256/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 0 2 | 0.50 , 0 3 | -------------------------------------------------------------------------------- /results/btree/256/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 761988.94 2 | 0.50 , 905033.48 3 | -------------------------------------------------------------------------------- /results/btree/256/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1456438.56 2 | 0.50 , 1893329.35 3 | -------------------------------------------------------------------------------- /results/btree/256/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1942890.2 2 | 0.50 , 2658938.02 3 | -------------------------------------------------------------------------------- /results/btree/256/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 540648.52 2 | 0.50 , 592520.92 3 | -------------------------------------------------------------------------------- /results/btree/4096/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 309447.22 2 | 0.50 , 339846.59 3 | -------------------------------------------------------------------------------- /results/btree/4096/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 420963.87 2 | 0.50 , 343216.7 3 | -------------------------------------------------------------------------------- /results/btree/4096/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 361785.94 2 | 0.50 , 367589.03 3 | -------------------------------------------------------------------------------- /results/btree/4096/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 222386.92 2 | 0.50 , 330296.38 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 498222.28 2 | 0.50 , 574837.36 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 772925.05 2 | 0.50 , 898335.59 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 997745.97 2 | 0.50 , 1122641.1 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 561985.09 2 | 0.50 , 545038.28 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 400605.07 2 | 0.50 , 527421.12 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 813437.0 2 | 0.50 , 1086948.69 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1312364.81 2 | 0.50 , 1744923.58 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 281557.29 2 | 0.50 , 375543.69 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1118181.59 2 | 0.50 , 1342304.18 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1510827.34 2 | 0.50 , 2014076.89 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1820225.43 2 | 0.50 , 2499230.71 3 | -------------------------------------------------------------------------------- /results/btree/4096/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 959921.25 2 | 0.50 , 1128257.81 3 | -------------------------------------------------------------------------------- /results/btree/4096/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 99621.99 2 | 0.50 , 139938.56 3 | -------------------------------------------------------------------------------- /results/btree/4096/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 339289.09 2 | 0.50 , 437617.85 3 | -------------------------------------------------------------------------------- /results/btree/4096/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 762237.17 2 | 0.50 , 898737.66 3 | -------------------------------------------------------------------------------- /results/btree/4096/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 58518.33 2 | 0.50 , 83915.35 3 | -------------------------------------------------------------------------------- /results/btree/4096/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 755569.21 2 | 0.50 , 877531.39 3 | -------------------------------------------------------------------------------- /results/btree/4096/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1445756.05 2 | 0.50 , 1878282.15 3 | -------------------------------------------------------------------------------- /results/btree/4096/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1940064.14 2 | 0.50 , 2663181.45 3 | -------------------------------------------------------------------------------- /results/btree/4096/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 528295.02 2 | 0.50 , 587061.13 3 | -------------------------------------------------------------------------------- /results/btree/512/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 305359.82 2 | 0.50 , 339226.42 3 | -------------------------------------------------------------------------------- /results/btree/512/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 418194.27 2 | 0.50 , 345913.04 3 | -------------------------------------------------------------------------------- /results/btree/512/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 340537.52 2 | 0.50 , 348406.88 3 | -------------------------------------------------------------------------------- /results/btree/512/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 224654.95 2 | 0.50 , 332672.16 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 515078.87 2 | 0.50 , 568808.52 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 782686.5 2 | 0.50 , 924101.25 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 999102.81 2 | 0.50 , 1109582.35 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 557973.17 2 | 0.50 , 555543.29 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 419719.84 2 | 0.50 , 547477.26 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 722204.04 2 | 0.50 , 968174.18 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1087678.59 2 | 0.50 , 1420261.88 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 320432.57 2 | 0.50 , 414274.62 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1145745.24 2 | 0.50 , 1384723.9 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1624143.87 2 | 0.50 , 2141709.99 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1931268.57 2 | 0.50 , 2682222.66 3 | -------------------------------------------------------------------------------- /results/btree/512/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 930186.7 2 | 0.50 , 1180812.51 3 | -------------------------------------------------------------------------------- /results/btree/512/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 98704.09 2 | 0.50 , 140033.79 3 | -------------------------------------------------------------------------------- /results/btree/512/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 336866.88 2 | 0.50 , 433777.33 3 | -------------------------------------------------------------------------------- /results/btree/512/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 772565.73 2 | 0.50 , 881697.66 3 | -------------------------------------------------------------------------------- /results/btree/512/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 57923.48 2 | 0.50 , 82736.18 3 | -------------------------------------------------------------------------------- /results/btree/512/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 764060.58 2 | 0.50 , 933212.54 3 | -------------------------------------------------------------------------------- /results/btree/512/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1482717.63 2 | 0.50 , 1952185.13 3 | -------------------------------------------------------------------------------- /results/btree/512/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1992249.15 2 | 0.50 , 2711849.7 3 | -------------------------------------------------------------------------------- /results/btree/512/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 546302.93 2 | 0.50 , 588421.43 3 | -------------------------------------------------------------------------------- /results/btree/64/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 296886.32 2 | 0.50 , 340049.31 3 | -------------------------------------------------------------------------------- /results/btree/64/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 407161.65 2 | 0.50 , 357923.93 3 | -------------------------------------------------------------------------------- /results/btree/64/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 327493.51 2 | 0.50 , 339031.03 3 | -------------------------------------------------------------------------------- /results/btree/64/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 224332.59 2 | 0.50 , 328587.06 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 510699.77 2 | 0.50 , 596477.21 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 772564.46 2 | 0.50 , 926752.39 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 969163.75 2 | 0.50 , 1149188.18 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 548824.87 2 | 0.50 , 552739.31 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 104567.62 2 | 0.50 , 149654.8 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 353763.67 2 | 0.50 , 449737.68 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 761078.74 2 | 0.50 , 902548.87 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 60852.74 2 | 0.50 , 88265.17 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1067475.81 2 | 0.50 , 1307251.49 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1471321.73 2 | 0.50 , 2052243.97 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1802584.55 2 | 0.50 , 2468405.95 3 | -------------------------------------------------------------------------------- /results/btree/64/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 887183.53 2 | 0.50 , 1107839.14 3 | -------------------------------------------------------------------------------- /results/btree/64/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 104567.62 2 | 0.50 , 149654.8 3 | -------------------------------------------------------------------------------- /results/btree/64/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 353763.67 2 | 0.50 , 449737.68 3 | -------------------------------------------------------------------------------- /results/btree/64/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 761078.74 2 | 0.50 , 902548.87 3 | -------------------------------------------------------------------------------- /results/btree/64/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 60852.74 2 | 0.50 , 88265.17 3 | -------------------------------------------------------------------------------- /results/btree/64/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 709755.38 2 | 0.50 , 869276.84 3 | -------------------------------------------------------------------------------- /results/btree/64/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1370548.76 2 | 0.50 , 1803700.56 3 | -------------------------------------------------------------------------------- /results/btree/64/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1818633.17 2 | 0.50 , 2552442.32 3 | -------------------------------------------------------------------------------- /results/btree/64/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 510351.69 2 | 0.50 , 596484.77 3 | -------------------------------------------------------------------------------- /results/btree/8192/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 298212.93 2 | 0.50 , 331810.05 3 | -------------------------------------------------------------------------------- /results/btree/8192/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 418313.36 2 | 0.50 , 343700.32 3 | -------------------------------------------------------------------------------- /results/btree/8192/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 337157.57 2 | 0.50 , 353751.24 3 | -------------------------------------------------------------------------------- /results/btree/8192/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 227968.63 2 | 0.50 , 328696.56 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 497684.24 2 | 0.50 , 567972.3 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 767300.93 2 | 0.50 , 849765.41 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 947426.14 2 | 0.50 , 1095157.86 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 545142.35 2 | 0.50 , 539949.37 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 349886.0 2 | 0.50 , 469238.73 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 760220.76 2 | 0.50 , 1024426.95 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1362686.04 2 | 0.50 , 1817693.11 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 243384.07 2 | 0.50 , 331443.66 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1105014.81 2 | 0.50 , 1361361.27 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1577868.81 2 | 0.50 , 2060507.31 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1847581.88 2 | 0.50 , 2446905.96 3 | -------------------------------------------------------------------------------- /results/btree/8192/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 928005.02 2 | 0.50 , 1112511.48 3 | -------------------------------------------------------------------------------- /results/btree/8192/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 98728.49 2 | 0.50 , 141296.19 3 | -------------------------------------------------------------------------------- /results/btree/8192/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 335636.15 2 | 0.50 , 432984.55 3 | -------------------------------------------------------------------------------- /results/btree/8192/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 723827.31 2 | 0.50 , 890005.25 3 | -------------------------------------------------------------------------------- /results/btree/8192/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 63803.43 2 | 0.50 , 84174.35 3 | -------------------------------------------------------------------------------- /results/btree/8192/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 726324.61 2 | 0.50 , 878424.8 3 | -------------------------------------------------------------------------------- /results/btree/8192/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1418157.34 2 | 0.50 , 1805313.62 3 | -------------------------------------------------------------------------------- /results/btree/8192/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1920217.83 2 | 0.50 , 2602444.41 3 | -------------------------------------------------------------------------------- /results/btree/8192/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 511730.33 2 | 0.50 , 575024.78 3 | -------------------------------------------------------------------------------- /results/ise/1/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 300180.4 2 | 0.50 , 359421.4 3 | -------------------------------------------------------------------------------- /results/ise/1/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 419532.66 2 | 0.50 , 368017.99 3 | -------------------------------------------------------------------------------- /results/ise/1/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 329587.71 2 | 0.50 , 348176.35 3 | -------------------------------------------------------------------------------- /results/ise/1/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 223370.98 2 | 0.50 , 339823.49 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 535002.9 2 | 0.50 , 600422.28 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 799348.85 2 | 0.50 , 975024.15 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 991659.28 2 | 0.50 , 1212144.72 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 566991.86 2 | 0.50 , 564303.47 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 396011.35 2 | 0.50 , 533162.05 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 818004.69 2 | 0.50 , 1066619.59 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1262876.61 2 | 0.50 , 1737075.78 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 277525.7 2 | 0.50 , 371029.19 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1137536.07 2 | 0.50 , 1400590.87 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1593551.85 2 | 0.50 , 2049810.39 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1849240.66 2 | 0.50 , 2576726.04 3 | -------------------------------------------------------------------------------- /results/ise/1/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 972239.29 2 | 0.50 , 1110992.91 3 | -------------------------------------------------------------------------------- /results/ise/1/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 103523.82 2 | 0.50 , 149814.47 3 | -------------------------------------------------------------------------------- /results/ise/1/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 350756.41 2 | 0.50 , 458654.4 3 | -------------------------------------------------------------------------------- /results/ise/1/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 766919.32 2 | 0.50 , 921392.97 3 | -------------------------------------------------------------------------------- /results/ise/1/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 61395.63 2 | 0.50 , 87240.12 3 | -------------------------------------------------------------------------------- /results/ise/1/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 739093.38 2 | 0.50 , 902185.6 3 | -------------------------------------------------------------------------------- /results/ise/1/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1432025.17 2 | 0.50 , 1881502.5 3 | -------------------------------------------------------------------------------- /results/ise/1/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1919675.04 2 | 0.50 , 2597039.18 3 | -------------------------------------------------------------------------------- /results/ise/1/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 535188.05 2 | 0.50 , 569569.42 3 | -------------------------------------------------------------------------------- /results/ise/10/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 309471.05 2 | 0.50 , 342874.6 3 | -------------------------------------------------------------------------------- /results/ise/10/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 421893.38 2 | 0.50 , 361343.75 3 | -------------------------------------------------------------------------------- /results/ise/10/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 331146.95 2 | 0.50 , 347822.31 3 | -------------------------------------------------------------------------------- /results/ise/10/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 223883.19 2 | 0.50 , 335941.34 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 584019.19 2 | 0.50 , 683360.36 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 836451.99 2 | 0.50 , 986482.11 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 989483.4 2 | 0.50 , 1140103.47 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 791386.86 2 | 0.50 , 767439.17 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 549043.48 2 | 0.50 , 735169.86 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 926687.33 2 | 0.50 , 1193979.6 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1305527.13 2 | 0.50 , 1754279.4 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 415416.5 2 | 0.50 , 567006.41 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1242409.46 2 | 0.50 , 1551169.19 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1667320.05 2 | 0.50 , 2251502.39 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1911861.74 2 | 0.50 , 2517640.0 3 | -------------------------------------------------------------------------------- /results/ise/10/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1045363.96 2 | 0.50 , 1413034.11 3 | -------------------------------------------------------------------------------- /results/ise/10/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 105046.18 2 | 0.50 , 149852.04 3 | -------------------------------------------------------------------------------- /results/ise/10/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 347952.09 2 | 0.50 , 444777.09 3 | -------------------------------------------------------------------------------- /results/ise/10/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 769591.07 2 | 0.50 , 911747.41 3 | -------------------------------------------------------------------------------- /results/ise/10/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 61389.4 2 | 0.50 , 89913.34 3 | -------------------------------------------------------------------------------- /results/ise/10/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 745653.01 2 | 0.50 , 900135.58 3 | -------------------------------------------------------------------------------- /results/ise/10/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1431137.77 2 | 0.50 , 1915247.89 3 | -------------------------------------------------------------------------------- /results/ise/10/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1880357.11 2 | 0.50 , 2616689.64 3 | -------------------------------------------------------------------------------- /results/ise/10/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 536716.62 2 | 0.50 , 591571.58 3 | -------------------------------------------------------------------------------- /results/ise/100/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 307561.09 2 | 0.50 , 351100.99 3 | -------------------------------------------------------------------------------- /results/ise/100/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 417062.7 2 | 0.50 , 362692.18 3 | -------------------------------------------------------------------------------- /results/ise/100/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 334030.12 2 | 0.50 , 346915.93 3 | -------------------------------------------------------------------------------- /results/ise/100/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 236753.4 2 | 0.50 , 338632.59 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 563589.96 2 | 0.50 , 673734.99 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 819272.48 2 | 0.50 , 984753.07 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 996749.6 2 | 0.50 , 1175293.74 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 707402.87 2 | 0.50 , 691876.21 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 522890.79 2 | 0.50 , 700888.54 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 912802.18 2 | 0.50 , 1186937.81 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1282936.8 2 | 0.50 , 1728163.36 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 380297.56 2 | 0.50 , 531294.4 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1172567.32 2 | 0.50 , 1519634.44 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1639686.65 2 | 0.50 , 2134462.61 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1875168.62 2 | 0.50 , 2550488.51 3 | -------------------------------------------------------------------------------- /results/ise/100/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1067346.64 2 | 0.50 , 1355953.58 3 | -------------------------------------------------------------------------------- /results/ise/100/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 102541.3 2 | 0.50 , 148465.27 3 | -------------------------------------------------------------------------------- /results/ise/100/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 347337.23 2 | 0.50 , 456876.56 3 | -------------------------------------------------------------------------------- /results/ise/100/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 764040.51 2 | 0.50 , 901194.7 3 | -------------------------------------------------------------------------------- /results/ise/100/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 61537.94 2 | 0.50 , 89060.85 3 | -------------------------------------------------------------------------------- /results/ise/100/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 743603.55 2 | 0.50 , 923149.21 3 | -------------------------------------------------------------------------------- /results/ise/100/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1422127.16 2 | 0.50 , 1898196.4 3 | -------------------------------------------------------------------------------- /results/ise/100/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1919272.52 2 | 0.50 , 2683881.98 3 | -------------------------------------------------------------------------------- /results/ise/100/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 539587.55 2 | 0.50 , 592131.3 3 | -------------------------------------------------------------------------------- /results/ise/1000/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 305477.04 2 | 0.50 , 353969.63 3 | -------------------------------------------------------------------------------- /results/ise/1000/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 425302.95 2 | 0.50 , 366236.85 3 | -------------------------------------------------------------------------------- /results/ise/1000/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 330661.37 2 | 0.50 , 347651.31 3 | -------------------------------------------------------------------------------- /results/ise/1000/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 230382.76 2 | 0.50 , 341997.42 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 426879.86 2 | 0.50 , 484327.03 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 745149.82 2 | 0.50 , 871786.57 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 991560.46 2 | 0.50 , 1162482.17 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 355756.68 2 | 0.50 , 375454.3 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 371656.77 2 | 0.50 , 464750.45 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 781162.81 2 | 0.50 , 997061.16 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1299574.93 2 | 0.50 , 1705998.1 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 252196.62 2 | 0.50 , 311706.31 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1078152.73 2 | 0.50 , 1282359.95 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1534947.1 2 | 0.50 , 2029293.87 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1858514.54 2 | 0.50 , 2569737.04 3 | -------------------------------------------------------------------------------- /results/ise/1000/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 899359.53 2 | 0.50 , 1041971.12 3 | -------------------------------------------------------------------------------- /results/ise/1000/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 104800.97 2 | 0.50 , 150983.97 3 | -------------------------------------------------------------------------------- /results/ise/1000/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 351641.92 2 | 0.50 , 459303.82 3 | -------------------------------------------------------------------------------- /results/ise/1000/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 748043.1 2 | 0.50 , 881103.46 3 | -------------------------------------------------------------------------------- /results/ise/1000/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 60656.23 2 | 0.50 , 88587.32 3 | -------------------------------------------------------------------------------- /results/ise/1000/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 740536.48 2 | 0.50 , 900566.43 3 | -------------------------------------------------------------------------------- /results/ise/1000/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1438007.32 2 | 0.50 , 1895156.62 3 | -------------------------------------------------------------------------------- /results/ise/1000/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1881041.97 2 | 0.50 , 2636901.32 3 | -------------------------------------------------------------------------------- /results/ise/1000/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 540043.7 2 | 0.50 , 590010.05 3 | -------------------------------------------------------------------------------- /results/ise/10000/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 302920.67 2 | 0.50 , 348332.46 3 | -------------------------------------------------------------------------------- /results/ise/10000/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 417117.78 2 | 0.50 , 365788.63 3 | -------------------------------------------------------------------------------- /results/ise/10000/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 331653.04 2 | 0.50 , 349346.81 3 | -------------------------------------------------------------------------------- /results/ise/10000/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 238100.72 2 | 0.50 , 335105.54 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 95818.85 2 | 0.50 , 102373.66 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 349337.49 2 | 0.50 , 388012.45 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1000515.27 2 | 0.50 , 1170502.57 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 56505.88 2 | 0.50 , 59734.46 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 94237.53 2 | 0.50 , 105642.54 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 343356.92 2 | 0.50 , 391345.17 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1308727.73 2 | 0.50 , 1725704.83 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 55717.3 2 | 0.50 , 61925.88 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 485836.53 2 | 0.50 , 531399.32 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1149232.76 2 | 0.50 , 1416517.62 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1877834.65 2 | 0.50 , 2599350.42 3 | -------------------------------------------------------------------------------- /results/ise/10000/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 316507.65 2 | 0.50 , 334821.74 3 | -------------------------------------------------------------------------------- /results/ise/10000/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 103867.17 2 | 0.50 , 148075.52 3 | -------------------------------------------------------------------------------- /results/ise/10000/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 352765.11 2 | 0.50 , 448593.44 3 | -------------------------------------------------------------------------------- /results/ise/10000/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 764918.25 2 | 0.50 , 877606.86 3 | -------------------------------------------------------------------------------- /results/ise/10000/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 60331.35 2 | 0.50 , 88224.57 3 | -------------------------------------------------------------------------------- /results/ise/10000/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 743560.56 2 | 0.50 , 914343.5 3 | -------------------------------------------------------------------------------- /results/ise/10000/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1440624.31 2 | 0.50 , 1867876.68 3 | -------------------------------------------------------------------------------- /results/ise/10000/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1908975.74 2 | 0.50 , 2601991.56 3 | -------------------------------------------------------------------------------- /results/ise/10000/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 522364.17 2 | 0.50 , 594032.7 3 | -------------------------------------------------------------------------------- /results/nvm_bw/random/bw.csv: -------------------------------------------------------------------------------- 1 | 1 , 12300589 , 1161803 2 | 2 , 24518630 , 2322651 3 | 4 , 49525375 , 4645421 4 | 8 , 98542272 , 8602209 5 | 16 , 196666385 , 17193787 6 | 32 , 399086943 , 34385389 7 | 64 , 742289001 , 74381764 8 | 128 , 1467726615 , 148688214 9 | 256 , 2652367014 , 242793764 10 | -------------------------------------------------------------------------------- /results/nvm_bw/sequential/bw.csv: -------------------------------------------------------------------------------- 1 | 1 , 14312100 , 1068018 2 | 2 , 28726536 , 2211824 3 | 4 , 57406676 , 4833462 4 | 8 , 114844790 , 8654170 5 | 16 , 229947725 , 17849944 6 | 32 , 457512606 , 35218765 7 | 64 , 857687030 , 81180830 8 | 128 , 1545165698 , 159337055 9 | 256 , 2888918908 , 276316557 10 | -------------------------------------------------------------------------------- /results/tpcc/nvm/nvm.csv: -------------------------------------------------------------------------------- 1 | 0 , 492839561.0 , 272241734.0 2 | 1 , 1231614887.0 , 533256979.0 3 | 2 , 758210694.0 , 405308470.0 4 | 3 , 259393290.0 , 185712323.0 5 | 4 , 627008930.0 , 313214229.0 6 | 5 , 365979999.0 , 261610438.0 7 | -------------------------------------------------------------------------------- /results/tpcc/performance/lsm/performance.csv: -------------------------------------------------------------------------------- 1 | 160 , 19759.88 2 | 320 , 16041.13 3 | 1280 , 9505.75 4 | -------------------------------------------------------------------------------- /results/tpcc/performance/opt_lsm/performance.csv: -------------------------------------------------------------------------------- 1 | 160 , 33469.3 2 | 320 , 27909.13 3 | 1280 , 16046.58 4 | -------------------------------------------------------------------------------- /results/tpcc/performance/opt_sp/performance.csv: -------------------------------------------------------------------------------- 1 | 160 , 21024.35 2 | 320 , 17554.28 3 | 1280 , 9184.24 4 | -------------------------------------------------------------------------------- /results/tpcc/performance/opt_wal/performance.csv: -------------------------------------------------------------------------------- 1 | 160 , 47474.18 2 | 320 , 36007.71 3 | 1280 , 18679.75 4 | -------------------------------------------------------------------------------- /results/tpcc/performance/sp/performance.csv: -------------------------------------------------------------------------------- 1 | 160 , 9137.77 2 | 320 , 7788.82 3 | 1280 , 3632.78 4 | -------------------------------------------------------------------------------- /results/tpcc/performance/wal/performance.csv: -------------------------------------------------------------------------------- 1 | 160 , 30519.8 2 | 320 , 25189.72 3 | 1280 , 14059.11 4 | -------------------------------------------------------------------------------- /results/tpcc/recovery/lsm/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 393.609 2 | 10000 , 4748.71 3 | 100000 , 49454.3 4 | -------------------------------------------------------------------------------- /results/tpcc/recovery/opt_lsm/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 0.029 2 | 10000 , 0.026 3 | 100000 , 0.026 4 | -------------------------------------------------------------------------------- /results/tpcc/recovery/opt_sp/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 0 2 | 10000 , 0 3 | 100000 , 0 4 | -------------------------------------------------------------------------------- /results/tpcc/recovery/opt_wal/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 0.069 2 | 10000 , 0.07 3 | 100000 , 0.068 4 | -------------------------------------------------------------------------------- /results/tpcc/recovery/sp/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 0 2 | 10000 , 0 3 | 100000 , 0 4 | -------------------------------------------------------------------------------- /results/tpcc/recovery/wal/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 472.63 2 | 10000 , 5973.54 3 | 100000 , 64043.2 4 | -------------------------------------------------------------------------------- /results/tpcc/storage/storage.csv: -------------------------------------------------------------------------------- 1 | 0 , 2.42, 0.53, 0.31, 0.21, 1.61 2 | 1 , 2.42, 0.82, 0.00, 0.00, 2.37 3 | 2 , 2.42, 0.47, 0.39, 0.00, 2.21 4 | 3 , 2.42, 0.55, 0.00, 0.00, 0.29 5 | 4 , 2.42, 0.60, 0.00, 0.00, 0.73 6 | 5 , 2.42, 0.42, 0.00, 0.00, 0.68 7 | 8 | -------------------------------------------------------------------------------- /results/ycsb/abs_stack/ycsb-stack-balanced-320.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarulraj/n-store/dda62773b6c5f54e8bcb1a467168f72d57eca38f/results/ycsb/abs_stack/ycsb-stack-balanced-320.pdf -------------------------------------------------------------------------------- /results/ycsb/abs_stack/ycsb-stack-read-heavy-320.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarulraj/n-store/dda62773b6c5f54e8bcb1a467168f72d57eca38f/results/ycsb/abs_stack/ycsb-stack-read-heavy-320.pdf -------------------------------------------------------------------------------- /results/ycsb/abs_stack/ycsb-stack-read-only-320.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarulraj/n-store/dda62773b6c5f54e8bcb1a467168f72d57eca38f/results/ycsb/abs_stack/ycsb-stack-read-only-320.pdf -------------------------------------------------------------------------------- /results/ycsb/abs_stack/ycsb-stack-write-heavy-320.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarulraj/n-store/dda62773b6c5f54e8bcb1a467168f72d57eca38f/results/ycsb/abs_stack/ycsb-stack-write-heavy-320.pdf -------------------------------------------------------------------------------- /results/ycsb/nvm/lsm/balanced/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 884308618.0 , 173570328.0 2 | 0.50 , 544180714.0 , 153768350.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/lsm/read-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 794015539.0 , 123350476.0 2 | 0.50 , 514612174.0 , 87711573.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/lsm/read-only/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 431869312.0 , 57418888.0 2 | 0.50 , 348753125.0 , 34814741.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/lsm/write-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 927689950.0 , 221760685.0 2 | 0.50 , 569683063.0 , 165334328.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_lsm/balanced/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 403753027.0 , 119625498.0 2 | 0.50 , 292114613.0 , 96719531.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_lsm/read-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 389499467.0 , 61352252.0 2 | 0.50 , 238218937.0 , 46154372.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_lsm/read-only/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 252659720.0 , 26508142.0 2 | 0.50 , 165626139.0 , 15697266.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_lsm/write-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 344815285.0 , 185333314.0 2 | 0.50 , 289723188.0 , 146879706.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_sp/balanced/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 492142876.0 , 224447142.0 2 | 0.50 , 337117751.0 , 157486979.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_sp/read-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 282577244.0 , 57722223.0 2 | 0.50 , 174463756.0 , 43354013.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_sp/read-only/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 201340011.0 , 8554529.0 2 | 0.50 , 116196415.0 , 1703812.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_sp/write-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 567393715.0 , 268071172.0 2 | 0.50 , 427532455.0 , 229281324.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_wal/balanced/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 256694148.0 , 33130964.0 2 | 0.50 , 176189433.0 , 28031510.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_wal/read-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 206707123.0 , 17578513.0 2 | 0.50 , 123152869.0 , 10126715.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_wal/read-only/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 165708067.0 , 3855981.0 2 | 0.50 , 98824707.0 , 1940316.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/opt_wal/write-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 270359118.0 , 48884666.0 2 | 0.50 , 188510616.0 , 46059626.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/sp/balanced/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1137978207.0 , 332582522.0 2 | 0.50 , 737894155.0 , 196935121.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/sp/read-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 571517379.0 , 105450583.0 2 | 0.50 , 369234795.0 , 74203827.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/sp/read-only/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 285400513.0 , 10475998.0 2 | 0.50 , 163204798.0 , 3142903.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/sp/write-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1649940496.0 , 511721920.0 2 | 0.50 , 1028202080.0 , 303569478.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/wal/balanced/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 537648684.0 , 54457710.0 2 | 0.50 , 347751000.0 , 46811532.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/wal/read-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 235892379.0 , 23919766.0 2 | 0.50 , 135054788.0 , 15321742.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/wal/read-only/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 162406173.0 , 4664463.0 2 | 0.50 , 98088807.0 , 1806630.0 3 | -------------------------------------------------------------------------------- /results/ycsb/nvm/wal/write-heavy/nvm.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 756308675.0 , 85034704.0 2 | 0.50 , 501947279.0 , 77748353.0 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/balanced/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 170960.43 2 | 0.50 , 199606.33 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/balanced/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 366662.28 2 | 0.50 , 410113.23 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 296452.3 2 | 0.50 , 340143.13 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/read-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 260686.67 2 | 0.50 , 210691.85 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/read-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 479306.19 2 | 0.50 , 425742.2 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 414461.92 2 | 0.50 , 358156.38 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/read-only/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 191410.26 2 | 0.50 , 213078.73 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/read-only/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 421428.97 2 | 0.50 , 436543.66 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 342516.1 2 | 0.50 , 361551.53 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/write-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 125686.3 2 | 0.50 , 186247.65 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/write-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 261416.76 2 | 0.50 , 398180.18 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 222076.32 2 | 0.50 , 327150.18 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/balanced/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 264814.23 2 | 0.50 , 311682.01 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/balanced/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 620195.52 2 | 0.50 , 696849.12 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 505585.26 2 | 0.50 , 589270.03 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/read-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 399260.23 2 | 0.50 , 500201.24 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/read-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 965352.77 2 | 0.50 , 1104637.93 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 775200.03 2 | 0.50 , 895495.86 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/read-only/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 482963.76 2 | 0.50 , 627908.69 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/read-only/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1188595.31 2 | 0.50 , 1307180.57 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 937915.39 2 | 0.50 , 1115064.01 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/write-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 291095.72 2 | 0.50 , 295874.25 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/write-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 686217.58 2 | 0.50 , 658102.88 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_lsm/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 542180.31 2 | 0.50 , 545635.19 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/balanced/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 200036.8 2 | 0.50 , 274201.1 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/balanced/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 519356.65 2 | 0.50 , 657749.66 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 382988.48 2 | 0.50 , 511847.94 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/read-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 377514.23 2 | 0.50 , 519401.36 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/read-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 959832.22 2 | 0.50 , 1153024.51 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 770124.34 2 | 0.50 , 988467.43 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/read-only/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 609953.45 2 | 0.50 , 884700.13 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/read-only/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1653596.37 2 | 0.50 , 2020281.61 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1203057.81 2 | 0.50 , 1563530.34 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/write-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 145647.36 2 | 0.50 , 198972.28 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/write-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 387682.76 2 | 0.50 , 481369.67 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 275290.89 2 | 0.50 , 358024.97 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/balanced/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 478765.21 2 | 0.50 , 663215.57 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/balanced/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1541288.32 2 | 0.50 , 1775526.02 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1045150.23 2 | 0.50 , 1303722.11 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/read-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 648666.6 2 | 0.50 , 960175.06 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/read-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 2276764.65 2 | 0.50 , 2770321.96 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1453253.38 2 | 0.50 , 1925655.73 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/read-only/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 750352.76 2 | 0.50 , 1155278.7 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/read-only/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 2585942.0 2 | 0.50 , 3313916.4 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1712388.14 2 | 0.50 , 2345487.36 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/write-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 416701.41 2 | 0.50 , 566321.2 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/write-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1304996.85 2 | 0.50 , 1472797.43 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/opt_wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 883546.77 2 | 0.50 , 1122015.23 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/balanced/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 49973.67 2 | 0.50 , 72633.69 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/balanced/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 120532.18 2 | 0.50 , 174811.12 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 101975.77 2 | 0.50 , 147717.56 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/read-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 168677.84 2 | 0.50 , 222494.23 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/read-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 414132.18 2 | 0.50 , 529510.13 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 343511.39 2 | 0.50 , 447528.71 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/read-only/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 439340.84 2 | 0.50 , 594549.63 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/read-only/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 885522.92 2 | 0.50 , 993837.96 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 732309.35 2 | 0.50 , 867984.64 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/write-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 29567.47 2 | 0.50 , 46241.61 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/write-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 70956.74 2 | 0.50 , 101225.22 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/sp/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 60307.43 2 | 0.50 , 86779.33 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/balanced/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 348726.09 2 | 0.50 , 474751.92 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/balanced/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 933913.59 2 | 0.50 , 1061046.52 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/balanced/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 689419.17 2 | 0.50 , 842038.7 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/read-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 601918.36 2 | 0.50 , 902121.2 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/read-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1819855.26 2 | 0.50 , 2272720.82 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/read-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1304562.51 2 | 0.50 , 1708408.79 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/read-only/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 750017.77 2 | 0.50 , 1149415.21 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/read-only/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 2584501.07 2 | 0.50 , 3300147.6 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/read-only/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 1711569.7 2 | 0.50 , 2326516.06 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/write-heavy/1280/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 270882.55 2 | 0.50 , 329381.85 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/write-heavy/160/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 642894.67 2 | 0.50 , 704686.0 3 | -------------------------------------------------------------------------------- /results/ycsb/performance/wal/write-heavy/320/performance.csv: -------------------------------------------------------------------------------- 1 | 0.10 , 500414.66 2 | 0.50 , 582243.83 3 | -------------------------------------------------------------------------------- /results/ycsb/recovery/lsm/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 7.04765 2 | 10000 , 71.6081 3 | 100000 , 822.324 4 | -------------------------------------------------------------------------------- /results/ycsb/recovery/opt_lsm/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 0.056 2 | 10000 , 0.057 3 | 100000 , 0.058 4 | -------------------------------------------------------------------------------- /results/ycsb/recovery/opt_sp/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 0 2 | 10000 , 0 3 | 100000 , 0 4 | -------------------------------------------------------------------------------- /results/ycsb/recovery/opt_wal/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 0.143 2 | 10000 , 0.137 3 | 100000 , 0.14 4 | -------------------------------------------------------------------------------- /results/ycsb/recovery/sp/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 0 2 | 10000 , 0 3 | 100000 , 0 4 | -------------------------------------------------------------------------------- /results/ycsb/recovery/wal/recovery.csv: -------------------------------------------------------------------------------- 1 | 1000 , 9.00137 2 | 10000 , 9.28821 3 | 100000 , 100.905 4 | -------------------------------------------------------------------------------- /results/ycsb/stack/lsm/balanced/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 41.0 , 17.0 , 24.9 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/lsm/read-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 49.0 , 11.0 , 26.1 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/lsm/read-only/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 63.0 , 0.0 , 32.2 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/lsm/write-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 41.0 , 29.0 , 20.6 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_lsm/balanced/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 48.0 , 9.0 , 37.2 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_lsm/read-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 56.0 , 4.0 , 31.0 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_lsm/read-only/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 64.7 , 0.0 , 31.4 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_lsm/write-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 56.0 , 14.0 , 27.2 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_sp/balanced/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 51.0 , 15.0 , 23.0 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_sp/read-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 55.0 , 9.0 , 26.0 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_sp/read-only/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 65.6 , 0.0 , 23.8 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_sp/write-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 40.0 , 17.0 , 23.0 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_wal/balanced/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 48.0 , 11.0 , 23.6 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_wal/read-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 51.0 , 4.0 , 30.3 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_wal/read-only/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 67.0 , 0.0 , 27.5 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/opt_wal/write-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 50.0 , 13.0 , 20.6 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/sp/balanced/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 37.0 , 27.0 , 18.0 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/sp/read-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 47.0 , 24.0 , 14.0 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/sp/read-only/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 51.0 , 0.0 , 21.5 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/sp/write-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 42.0 , 33.0 , 16.0 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/wal/balanced/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 38.4 , 18.1 , 20.2 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/wal/read-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 40.0 , 9.0 , 21.5 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/wal/read-only/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 55.9 , 0.0 , 24.5 2 | -------------------------------------------------------------------------------- /results/ycsb/stack/wal/write-heavy/320/stack.csv: -------------------------------------------------------------------------------- 1 | 0.1 , 40.0 , 25.0 , 15.0 2 | -------------------------------------------------------------------------------- /results/ycsb/storage/storage.csv: -------------------------------------------------------------------------------- 1 | 0 , 2.01, 0.32, 0.25, 0.12, 0.55 2 | 1 , 2.01, 0.46, 0.00, 0.00, 1.12 3 | 2 , 2.01, 0.22, 0.32, 0.00, 0.91 4 | 3 , 2.01, 0.32, 0.02, 0.00, 0.22 5 | 4 , 2.01, 0.36, 0.00, 0.00, 0.44 6 | 5 , 2.01, 0.23, 0.03, 0.00, 0.48 7 | 8 | -------------------------------------------------------------------------------- /src/Makefile.am: -------------------------------------------------------------------------------- 1 | ## Makefile.am -- Process this file with automake to produce Makefile.in 2 | 3 | bin_PROGRAMS = nstore pmem_check 4 | 5 | AM_CPPFLAGS = -I$(srcdir)/common -Wno-pointer-arith 6 | AM_CXXFLAGS = -Wall -Wextra -Werror 7 | AM_LDFLAGS = $(PTHREAD_CFLAGS) 8 | LIBS = -lrt 9 | 10 | noinst_LIBRARIES = libpm.a 11 | libpm_a_SOURCES = libpm.cpp utils.cpp 12 | 13 | #AM_CPPFLAGS = $(BOOST_CPPFLAGS) 14 | #AM_LDFLAGS = $(BOOST_SYSTEM_LDFLAGS) $(BOOST_THREAD_LDFLAGS) $(PTHREAD_CFLAGS) 15 | #LIBS = $(BOOST_SYSTEM_LIBS) $(BOOST_THREAD_LIBS) 16 | 17 | nstore_SOURCES = main.cpp \ 18 | wal_engine.cpp \ 19 | sp_engine.cpp \ 20 | lsm_engine.cpp \ 21 | opt_wal_engine.cpp \ 22 | opt_sp_engine.cpp \ 23 | opt_lsm_engine.cpp \ 24 | test_benchmark.cpp \ 25 | ycsb_benchmark.cpp \ 26 | tpcc_benchmark.cpp \ 27 | utils.cpp 28 | 29 | nstore_LDADD = libpm.a 30 | 31 | pmem_check_SOURCES = pmem_check.cpp 32 | 33 | pmem_check_LDADD = libpm.a 34 | 35 | 36 | -------------------------------------------------------------------------------- /src/common/benchmark.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "config.h" 6 | #include "engine.h" 7 | #include "timer.h" 8 | #include "database.h" 9 | 10 | namespace storage { 11 | 12 | class benchmark { 13 | public: 14 | benchmark(unsigned int _tid, database* _db, timer* _tm, 15 | struct static_info* _sp) { 16 | tid = _tid; 17 | tm = _tm; 18 | db = _db; 19 | sp = _sp; 20 | } 21 | 22 | virtual void load() = 0; 23 | virtual void execute() = 0; 24 | virtual void sim_crash() = 0; 25 | 26 | virtual ~benchmark() { 27 | } 28 | 29 | unsigned int tid; 30 | timer* tm; 31 | database* db; 32 | struct static_info* sp; 33 | }; 34 | 35 | } 36 | -------------------------------------------------------------------------------- /src/common/config.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace storage { 9 | 10 | // Logging 11 | extern int level; 12 | 13 | #define NDG 14 | #ifdef NDG 15 | #define LOG_ERR(M, ...) 16 | #define LOG_WARN(M, ...) 17 | #define LOG_INFO(M, ...) 18 | #else 19 | #define clean_errno() (errno == 0 ? "" : strerror(errno)) 20 | #define LOG_ERR(M, ...) if(level > 0) fprintf(stderr, "[EROR] [%s :: %s:%d] %s " M "\n", __FILE__, __func__, __LINE__, clean_errno(), ##__VA_ARGS__) 21 | #define LOG_WARN(M, ...) if(level > 1) fprintf(stderr, "[WARN] [%s :: %s:%d] %s " M "\n",__FILE__, __func__,__LINE__, clean_errno(), ##__VA_ARGS__) 22 | #define LOG_INFO(M, ...) if(level > 2) fprintf(stderr, "[INFO] [%s :: %s:%d] " M "\n", __FILE__, __func__, __LINE__, ##__VA_ARGS__) 23 | #endif 24 | 25 | enum engine_type { 26 | EE_INVALID, 27 | WAL, 28 | SP, 29 | LSM, 30 | OPT_WAL, 31 | OPT_SP, 32 | OPT_LSM 33 | }; 34 | 35 | enum benchmark_type { 36 | BH_INVALID, 37 | TEST, 38 | YCSB, 39 | TPCC 40 | }; 41 | 42 | class benchmark; 43 | 44 | class config { 45 | public: 46 | std::string fs_path; 47 | benchmark** partitions; 48 | struct static_info* sp; 49 | 50 | int num_keys; 51 | int num_txns; 52 | 53 | bool single; 54 | int num_executors; 55 | 56 | bool read_only; 57 | 58 | double ycsb_per_writes; 59 | int ycsb_field_size; 60 | bool ycsb_update_one; 61 | int ycsb_tuples_per_txn; 62 | int ycsb_num_val_fields; 63 | double ycsb_skew; 64 | 65 | int tpcc_num_warehouses; 66 | bool tpcc_stock_level_only; 67 | 68 | int gc_interval; 69 | 70 | int merge_interval; 71 | double merge_ratio; 72 | 73 | bool verbose; 74 | bool recovery; 75 | bool storage_stats; 76 | 77 | int active_txn_threshold; 78 | int load_batch_size; 79 | 80 | int test_benchmark_mode; 81 | 82 | engine_type etype; 83 | benchmark_type btype; 84 | }; 85 | 86 | } 87 | -------------------------------------------------------------------------------- /src/common/database.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "config.h" 4 | #include "table.h" 5 | #include "plist.h" 6 | #include "cow_pbtree.h" 7 | #include 8 | 9 | namespace storage { 10 | 11 | class database { 12 | public: 13 | database(config conf, struct static_info* sp, unsigned int tid) 14 | : tables(NULL), 15 | log(NULL), 16 | dirs(NULL) { 17 | 18 | sp->itr++; 19 | 20 | // TABLES 21 | plist* _tables = new ((plist*) pmalloc(sizeof(plist))) plist(&sp->ptrs[get_next_pp()], 22 | &sp->ptrs[get_next_pp()]); 23 | pmemalloc_activate(_tables); 24 | tables = _tables; 25 | 26 | // LOG 27 | log = new ((plist*) pmalloc(sizeof(plist))) plist(&sp->ptrs[get_next_pp()], &sp->ptrs[get_next_pp()]); 28 | pmemalloc_activate(log); 29 | 30 | // DIRS 31 | if (conf.etype == engine_type::SP) { 32 | die(); 33 | dirs = new cow_pbtree( 34 | false, (conf.fs_path + std::to_string(tid) + "_" + "cow.nvm").c_str(), 35 | NULL); 36 | // No activation 37 | } 38 | 39 | if (conf.etype == engine_type::OPT_SP) { 40 | die(); 41 | dirs = new cow_pbtree(true, NULL, &sp->ptrs[sp->itr++]); 42 | pmemalloc_activate(dirs); 43 | } 44 | } 45 | 46 | ~database() { 47 | // clean up tables 48 | std::vector table_vec = tables->get_data(); 49 | for (table* table : table_vec) 50 | delete table; 51 | 52 | delete tables; 53 | delete[] log; 54 | } 55 | 56 | void reset(config& conf, unsigned int tid) { 57 | 58 | if (conf.etype == engine_type::SP) { 59 | die(); 60 | dirs = new cow_pbtree( 61 | false, (conf.fs_path + std::to_string(tid) + "_" + "cow.nvm").c_str(), 62 | NULL); 63 | } 64 | 65 | // Clear all table data and indices 66 | if (conf.etype == engine_type::WAL || conf.etype == engine_type::LSM) { 67 | std::vector tab_vec = tables->get_data(); 68 | 69 | for (table* tab : tab_vec) { 70 | tab->pm_data->clear(); 71 | std::vector indices = tab->indices->get_data(); 72 | for (table_index* index : indices) { 73 | index->pm_map->clear(); 74 | index->off_map->clear(); 75 | } 76 | } 77 | } 78 | 79 | } 80 | 81 | plist* tables; 82 | plist* log; 83 | 84 | // SP and OPT_SP 85 | cow_pbtree* dirs; 86 | }; 87 | 88 | } 89 | -------------------------------------------------------------------------------- /src/common/engine.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "wal_engine.h" 6 | #include "sp_engine.h" 7 | #include "lsm_engine.h" 8 | #include "opt_wal_engine.h" 9 | #include "opt_sp_engine.h" 10 | #include "opt_lsm_engine.h" 11 | 12 | namespace storage { 13 | 14 | class engine { 15 | public: 16 | engine() 17 | : etype(engine_type::WAL), 18 | de(NULL) { 19 | } 20 | 21 | engine(const config& conf, unsigned int tid, database* db, bool read_only) 22 | : etype(conf.etype) { 23 | 24 | switch (conf.etype) { 25 | case engine_type::WAL: 26 | de = new wal_engine(conf, db, read_only, tid); 27 | break; 28 | case engine_type::SP: 29 | die(); 30 | de = new sp_engine(conf, db, read_only, tid); 31 | break; 32 | case engine_type::LSM: 33 | die(); 34 | de = new lsm_engine(conf, db, read_only, tid); 35 | break; 36 | case engine_type::OPT_WAL: 37 | de = new opt_wal_engine(conf, db, read_only, tid); 38 | break; 39 | case engine_type::OPT_SP: 40 | die(); 41 | de = new opt_sp_engine(conf, db, read_only, tid); 42 | break; 43 | case engine_type::OPT_LSM: 44 | die(); 45 | de = new opt_lsm_engine(conf, db, read_only, tid); 46 | break; 47 | default: 48 | std::cout << "Unknown engine type :: " << etype << std::endl; 49 | exit(EXIT_FAILURE); 50 | break; 51 | } 52 | 53 | } 54 | 55 | virtual ~engine() { 56 | delete de; 57 | } 58 | 59 | virtual std::string select(const statement& st) { 60 | return (de->select(st)); 61 | } 62 | 63 | virtual int insert(const statement& st) { 64 | return (de->insert(st)); 65 | } 66 | 67 | virtual int remove(const statement& st) { 68 | return (de->remove(st)); 69 | } 70 | 71 | virtual int update(const statement& st) { 72 | return (de->update(st)); 73 | } 74 | 75 | virtual void display() { 76 | std::cout << "ST" << std::endl; 77 | } 78 | 79 | void load(const statement& st) { 80 | de->load(st); 81 | } 82 | 83 | virtual void txn_begin() { 84 | de->txn_begin(); 85 | } 86 | 87 | virtual void txn_end(bool commit) { 88 | de->txn_end(commit); 89 | } 90 | 91 | void recovery() { 92 | de->recovery(); 93 | } 94 | 95 | engine_type etype; 96 | engine_api* de; 97 | }; 98 | 99 | } 100 | 101 | -------------------------------------------------------------------------------- /src/common/engine_api.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "statement.h" 5 | 6 | namespace storage { 7 | 8 | class engine_api { 9 | public: 10 | virtual ~engine_api() {} 11 | 12 | virtual std::string select(const statement& st) = 0; 13 | virtual int insert(const statement& st) = 0; 14 | virtual int remove(const statement& st) = 0; 15 | virtual int update(const statement& st) = 0; 16 | 17 | virtual void load(const statement& st) = 0; 18 | 19 | virtual void txn_begin() = 0; 20 | virtual void txn_end(bool commit) = 0; 21 | 22 | virtual void recovery() = 0; 23 | 24 | engine_type etype; 25 | }; 26 | 27 | } 28 | 29 | -------------------------------------------------------------------------------- /src/common/field.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace storage { 9 | 10 | enum field_type { 11 | FD_INVALID, 12 | INTEGER, 13 | DOUBLE, 14 | VARCHAR, 15 | }; 16 | 17 | struct field_info { 18 | field_info() 19 | : offset(0), 20 | ser_len(0), 21 | deser_len(0), 22 | type(field_type::FD_INVALID), 23 | inlined(1), 24 | enabled(1) { 25 | } 26 | 27 | field_info(off_t _offset, size_t _ser_len, size_t _deser_len, field_type _type, 28 | bool _inlined, bool _enabled) 29 | : offset(_offset), 30 | ser_len(_ser_len+1), 31 | deser_len(_deser_len+1), 32 | type(_type), 33 | inlined(_inlined), 34 | enabled(_enabled) { 35 | 36 | } 37 | 38 | off_t offset; 39 | size_t ser_len; 40 | size_t deser_len; 41 | field_type type; 42 | bool inlined; 43 | bool enabled; 44 | }; 45 | 46 | } 47 | 48 | -------------------------------------------------------------------------------- /src/common/libpm.h: -------------------------------------------------------------------------------- 1 | clibpm.h -------------------------------------------------------------------------------- /src/common/lock_manager.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "utils.h" 5 | 6 | namespace storage { 7 | 8 | struct lock_t { 9 | lock_t() 10 | : locked(false), 11 | writer(false), 12 | readers(0) { 13 | } 14 | 15 | bool locked; 16 | bool writer; 17 | int readers; 18 | }; 19 | 20 | class lock_manager { 21 | public: 22 | 23 | inline int tuple_rdlock(const unsigned long hash) { 24 | 25 | wrlock(&lock_table_rwlock); 26 | if (!lock_table[hash].writer) { 27 | lock_table[hash].readers++; 28 | lock_table[hash].locked = true; 29 | unlock(&lock_table_rwlock); 30 | return 0; 31 | } 32 | unlock(&lock_table_rwlock); 33 | 34 | //abort++; 35 | return -1; 36 | } 37 | 38 | inline int tuple_wrlock(const unsigned long hash) { 39 | 40 | wrlock(&lock_table_rwlock); 41 | if (lock_table[hash].readers == 0) { 42 | lock_table[hash].writer = true; 43 | lock_table[hash].locked = true; 44 | unlock(&lock_table_rwlock); 45 | return 0; 46 | } 47 | unlock(&lock_table_rwlock); 48 | 49 | //abort++; 50 | return -1; 51 | } 52 | 53 | inline int tuple_unlock(const unsigned long hash) { 54 | 55 | wrlock(&lock_table_rwlock); 56 | if (lock_table[hash].locked) { 57 | if (lock_table[hash].readers != 0) { 58 | lock_table[hash].readers--; 59 | 60 | if (lock_table[hash].readers == 0) 61 | lock_table[hash].locked = false; 62 | } else { 63 | lock_table[hash].locked = false; 64 | lock_table[hash].writer = false; 65 | } 66 | unlock(&lock_table_rwlock); 67 | return 0; 68 | } 69 | unlock(&lock_table_rwlock); 70 | 71 | return -1; 72 | } 73 | 74 | pthread_rwlock_t lock_table_rwlock = PTHREAD_RWLOCK_INITIALIZER;; 75 | std::map lock_table; 76 | 77 | unsigned int abort = 0; 78 | }; 79 | 80 | } 81 | -------------------------------------------------------------------------------- /src/common/lsm_engine.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | #include "engine_api.h" 10 | #include "config.h" 11 | #include "transaction.h" 12 | #include "record.h" 13 | #include "utils.h" 14 | #include "database.h" 15 | #include "pthread.h" 16 | #include "logger.h" 17 | #include "timer.h" 18 | #include "serializer.h" 19 | 20 | namespace storage { 21 | 22 | class lsm_engine : public engine_api { 23 | public: 24 | lsm_engine(const config& _conf, database* _db, bool _read_only, unsigned int _tid); 25 | ~lsm_engine(); 26 | 27 | std::string select(const statement& st); 28 | int update(const statement& st); 29 | int insert(const statement& t); 30 | int remove(const statement& t); 31 | 32 | void load(const statement& st); 33 | 34 | void group_commit(); 35 | void merge(bool force); 36 | 37 | void merge_check(); 38 | void txn_begin(); 39 | void txn_end(bool commit); 40 | 41 | void recovery(); 42 | 43 | //private: 44 | const config& conf; 45 | database* db; 46 | 47 | logger fs_log; 48 | std::hash hash_fn; 49 | std::stringstream entry_stream; 50 | std::string entry_str; 51 | std::thread gc; 52 | pthread_rwlock_t merge_rwlock = PTHREAD_RWLOCK_INITIALIZER; 53 | 54 | std::atomic_bool ready; 55 | unsigned long merge_looper = 0; 56 | 57 | bool read_only = false; 58 | unsigned int tid; 59 | 60 | serializer sr; 61 | }; 62 | 63 | } 64 | 65 | -------------------------------------------------------------------------------- /src/common/opt_lsm_engine.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #include "engine_api.h" 11 | #include "config.h" 12 | #include "transaction.h" 13 | #include "record.h" 14 | #include "utils.h" 15 | #include "database.h" 16 | #include "pthread.h" 17 | #include "logger.h" 18 | #include "plist.h" 19 | #include "timer.h" 20 | #include "serializer.h" 21 | 22 | namespace storage { 23 | 24 | class opt_lsm_engine : public engine_api { 25 | public: 26 | opt_lsm_engine(const config& _conf, database* _db, bool _read_only, unsigned int _tid); 27 | ~opt_lsm_engine(); 28 | 29 | std::string select(const statement& st); 30 | int update(const statement& st); 31 | int insert(const statement& t); 32 | int remove(const statement& t); 33 | 34 | void load(const statement& st); 35 | void group_commit(); 36 | 37 | void merge(bool force); 38 | void merge_check(); 39 | 40 | void txn_begin(); 41 | void txn_end(bool commit); 42 | 43 | void recovery(); 44 | 45 | //private: 46 | const config& conf; 47 | database* db; 48 | std::vector executors; 49 | 50 | plist* pm_log; 51 | std::hash hash_fn; 52 | 53 | std::stringstream entry_stream; 54 | std::string entry_str; 55 | 56 | std::vector commit_free_list; 57 | 58 | std::atomic_bool ready; 59 | unsigned long merge_looper = 0; 60 | 61 | bool read_only = false; 62 | unsigned int tid; 63 | 64 | serializer sr; 65 | }; 66 | 67 | } 68 | -------------------------------------------------------------------------------- /src/common/opt_sp_engine.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | #include "engine_api.h" 10 | #include "config.h" 11 | #include "transaction.h" 12 | #include "record.h" 13 | #include "utils.h" 14 | #include "database.h" 15 | #include "pthread.h" 16 | #include "cow_pbtree.h" 17 | #include "serializer.h" 18 | 19 | namespace storage { 20 | 21 | class opt_sp_engine : public engine_api { 22 | public: 23 | opt_sp_engine(const config& _conf, database* _db, bool _read_only, unsigned int _tid); 24 | ~opt_sp_engine(); 25 | 26 | std::string select(const statement& st); 27 | int update(const statement& st); 28 | int insert(const statement& t); 29 | int remove(const statement& t); 30 | 31 | void load(const statement& st); 32 | void group_commit(); 33 | 34 | void txn_begin(); 35 | void txn_end(bool commit); 36 | 37 | void recovery(); 38 | 39 | //private: 40 | const config& conf; 41 | database* db; 42 | 43 | std::hash hash_fn; 44 | 45 | std::thread gc; 46 | pthread_rwlock_t gc_rwlock = PTHREAD_RWLOCK_INITIALIZER; 47 | std::atomic_bool ready; 48 | 49 | cow_btree* bt; 50 | struct cow_btree_txn* txn_ptr; 51 | 52 | bool read_only = false; 53 | unsigned int tid; 54 | 55 | serializer sr; 56 | }; 57 | 58 | } 59 | -------------------------------------------------------------------------------- /src/common/opt_wal_engine.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include "engine_api.h" 8 | #include "config.h" 9 | #include "transaction.h" 10 | #include "record.h" 11 | #include "utils.h" 12 | #include "database.h" 13 | #include "pthread.h" 14 | #include "plist.h" 15 | #include "timer.h" 16 | #include "serializer.h" 17 | 18 | namespace storage { 19 | 20 | class opt_wal_engine : public engine_api { 21 | public: 22 | opt_wal_engine(const config& _conf, database* _db, bool _read_only, unsigned int _tid); 23 | ~opt_wal_engine(); 24 | 25 | std::string select(const statement& st); 26 | int update(const statement& st); 27 | int insert(const statement& t); 28 | int remove(const statement& t); 29 | 30 | void load(const statement& st); 31 | void group_commit(); 32 | 33 | void txn_begin(); 34 | void txn_end(bool commit); 35 | 36 | void recovery(); 37 | 38 | //private: 39 | const config& conf; 40 | database* db; 41 | 42 | plist* pm_log; 43 | std::hash hash_fn; 44 | 45 | std::stringstream entry_stream; 46 | std::string entry_str; 47 | std::vector commit_free_list; 48 | pthread_rwlock_t log_rwlock = PTHREAD_RWLOCK_INITIALIZER; 49 | 50 | std::atomic_bool ready; 51 | int looper = 0; 52 | 53 | bool read_only = false; 54 | unsigned int tid; 55 | 56 | serializer sr; 57 | }; 58 | 59 | } 60 | 61 | -------------------------------------------------------------------------------- /src/common/schema.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "libpm.h" 4 | #include "field.h" 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | namespace storage { 11 | 12 | class schema { 13 | public: 14 | schema(std::vector _columns) 15 | : columns(NULL), 16 | ser_len(0), 17 | deser_len(0){ 18 | 19 | num_columns = _columns.size(); 20 | columns = (field_info*) pmalloc(num_columns*(sizeof(field_info)));//new field_info[num_columns]; 21 | unsigned int itr; 22 | 23 | for (itr = 0; itr < num_columns; itr++) { 24 | columns[itr] = _columns[itr]; 25 | ser_len += columns[itr].ser_len; 26 | deser_len += columns[itr].deser_len; 27 | } 28 | 29 | pmemalloc_activate(columns); 30 | } 31 | 32 | ~schema() { 33 | delete[] columns; 34 | } 35 | 36 | void display() { 37 | unsigned int itr; 38 | 39 | for (itr = 0; itr < num_columns; itr++) { 40 | std::cout << std::setw(20); 41 | std::cout << "offset : " << columns[itr].offset << " "; 42 | std::cout << "ser_len : " << columns[itr].ser_len << " "; 43 | std::cout << "deser_len : " << columns[itr].deser_len << " "; 44 | std::cout << "type : " << (int) columns[itr].type << " "; 45 | std::cout << "inlined : " << (int) columns[itr].inlined << " "; 46 | std::cout << "enabled : " << (int) columns[itr].enabled << " "; 47 | std::cout << "\n"; 48 | } 49 | 50 | std::cout << "\n"; 51 | } 52 | 53 | field_info* columns; 54 | size_t ser_len; 55 | size_t deser_len; 56 | unsigned int num_columns; 57 | }; 58 | 59 | } 60 | 61 | -------------------------------------------------------------------------------- /src/common/sp_engine.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | #include "engine_api.h" 10 | #include "config.h" 11 | #include "transaction.h" 12 | #include "record.h" 13 | #include "utils.h" 14 | #include "database.h" 15 | #include "pthread.h" 16 | #include "cow_pbtree.h" 17 | #include "serializer.h" 18 | 19 | namespace storage { 20 | 21 | class sp_engine : public engine_api { 22 | public: 23 | sp_engine(const config& _conf, database* _db, bool _read_only, unsigned int _tid); 24 | ~sp_engine(); 25 | 26 | std::string select(const statement& st); 27 | int update(const statement& st); 28 | int insert(const statement& t); 29 | int remove(const statement& t); 30 | 31 | void load(const statement& st); 32 | 33 | void group_commit(); 34 | 35 | void txn_begin(); 36 | void txn_end(bool commit); 37 | 38 | void recovery(); 39 | 40 | //private: 41 | const config& conf; 42 | database* db; 43 | 44 | std::hash hash_fn; 45 | std::thread gc; 46 | pthread_rwlock_t gc_rwlock = PTHREAD_RWLOCK_INITIALIZER; 47 | std::atomic_bool ready; 48 | 49 | struct cow_btree* bt; 50 | struct cow_btree_txn* txn_ptr; 51 | 52 | bool read_only = false; 53 | unsigned int tid; 54 | 55 | serializer sr; 56 | }; 57 | 58 | } 59 | 60 | -------------------------------------------------------------------------------- /src/common/statement.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | #include "record.h" 7 | #include "table.h" 8 | 9 | namespace storage { 10 | 11 | enum operation_type { 12 | Insert, 13 | Delete, 14 | Update, 15 | Select 16 | }; 17 | 18 | class statement { 19 | public: 20 | 21 | statement() 22 | : transaction_id(-1), 23 | op_type(operation_type::Insert), 24 | table_id(-1), 25 | rec_ptr(NULL), 26 | table_index_id(-1), 27 | projection(NULL) { 28 | } 29 | 30 | // Insert and Delete 31 | statement(int _txn_id, operation_type _otype, int _table_id, record* _rptr) 32 | : transaction_id(_txn_id), 33 | op_type(_otype), 34 | table_id(_table_id), 35 | rec_ptr(_rptr), 36 | table_index_id(-1), 37 | projection(NULL) { 38 | } 39 | 40 | // Update 41 | statement(int _txn_id, operation_type _otype, int _table_id, record* _rptr, 42 | std::vector _fid) 43 | : transaction_id(_txn_id), 44 | op_type(_otype), 45 | table_id(_table_id), 46 | rec_ptr(_rptr), 47 | field_ids(_fid), 48 | table_index_id(-1), 49 | projection(NULL) { 50 | } 51 | 52 | // Select 53 | statement(int _txn_id, operation_type _otype, int _table_id, record* _rptr, 54 | int _table_index_id, schema* _projection) 55 | : transaction_id(_txn_id), 56 | op_type(_otype), 57 | table_id(_table_id), 58 | rec_ptr(_rptr), 59 | table_index_id(_table_index_id), 60 | projection(_projection) { 61 | } 62 | 63 | int transaction_id; 64 | operation_type op_type; 65 | 66 | // Insert and Delete 67 | int table_id; 68 | record* rec_ptr; 69 | 70 | // Update 71 | std::vector field_ids; 72 | 73 | // Select 74 | int table_index_id; 75 | schema* projection; 76 | 77 | }; 78 | 79 | } 80 | -------------------------------------------------------------------------------- /src/common/status.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace storage { 8 | 9 | class status { 10 | public: 11 | 12 | status(unsigned int _num_txns) 13 | : txn_counter(0), 14 | num_txns(_num_txns) { 15 | 16 | period = ((num_txns > 10) ? (num_txns / 10) : 1); 17 | 18 | } 19 | 20 | void display() { 21 | if (++txn_counter % period == 0) { 22 | printf("Finished :: %.2lf %% \r", 23 | ((double) (txn_counter * 100) / num_txns)); 24 | fflush(stdout); 25 | } 26 | 27 | if (txn_counter == num_txns) 28 | printf("\n"); 29 | } 30 | 31 | unsigned int txn_counter = 0; 32 | unsigned int num_txns; 33 | unsigned int period; 34 | 35 | }; 36 | 37 | } 38 | -------------------------------------------------------------------------------- /src/common/table.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "schema.h" 4 | #include "table_index.h" 5 | #include "plist.h" 6 | #include "storage.h" 7 | 8 | namespace storage { 9 | 10 | class table { 11 | public: 12 | table(const std::string& name_str, schema* _sptr, unsigned int _num_indices, 13 | __attribute__((unused)) config& conf, struct static_info* sp) 14 | : table_name(NULL), 15 | sptr(_sptr), 16 | max_tuple_size(_sptr->deser_len), 17 | num_indices(_num_indices), 18 | indices(NULL), 19 | pm_data(NULL) { 20 | 21 | size_t len = name_str.size(); 22 | table_name = (char*) pmalloc((len+1)*sizeof(char));//new char[len + 1]; 23 | memcpy(table_name, name_str.c_str(), len + 1); 24 | pmemalloc_activate(table_name); 25 | 26 | pm_data = new ((plist*) pmalloc(sizeof(plist))) plist(&sp->ptrs[get_next_pp()], &sp->ptrs[get_next_pp()]); 27 | pmemalloc_activate(pm_data); 28 | 29 | indices = new ((plist*) pmalloc(sizeof(plist))) plist(&sp->ptrs[get_next_pp()], 30 | &sp->ptrs[get_next_pp()]); 31 | pmemalloc_activate(indices); 32 | 33 | } 34 | 35 | ~table() { 36 | delete table_name; 37 | delete sptr; 38 | 39 | if (indices != NULL) { 40 | // clean up table indices 41 | std::vector index_vec = indices->get_data(); 42 | for (table_index* index : index_vec) 43 | delete index; 44 | 45 | delete indices; 46 | } 47 | } 48 | 49 | //private: 50 | char* table_name; 51 | schema* sptr; 52 | size_t max_tuple_size; 53 | unsigned int num_indices; 54 | 55 | plist* indices; 56 | 57 | storage fs_data; 58 | 59 | plist* pm_data; 60 | }; 61 | 62 | } 63 | 64 | -------------------------------------------------------------------------------- /src/common/table_index.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "schema.h" 4 | #include "record.h" 5 | #include "pbtree.h" 6 | #include "config.h" 7 | 8 | namespace storage { 9 | 10 | class table_index { 11 | public: 12 | 13 | table_index(schema* _sptr, unsigned int _num_fields, config& conf, 14 | struct static_info* sp) 15 | : sptr(_sptr), 16 | num_fields(_num_fields), 17 | pm_map(NULL), 18 | off_map(NULL) { 19 | 20 | pm_map = new ((pbtree*) pmalloc(sizeof(pbtree))) \ 21 | pbtree(&sp->ptrs[get_next_pp()]); 22 | pmemalloc_activate(pm_map); 23 | 24 | off_map = new ((pbtree*) pmalloc(sizeof(pbtree))) \ 25 | pbtree(&sp->ptrs[get_next_pp()]); 26 | pmemalloc_activate(off_map); 27 | 28 | if (conf.etype == engine_type::WAL || conf.etype == engine_type::LSM) { 29 | pm_map->disable_persistence(); 30 | off_map->disable_persistence(); 31 | } 32 | } 33 | 34 | ~table_index() { 35 | delete sptr; 36 | delete pm_map; 37 | delete off_map; 38 | } 39 | 40 | schema* sptr; 41 | unsigned int num_fields; 42 | 43 | pbtree* pm_map; 44 | pbtree* off_map; 45 | }; 46 | 47 | } 48 | -------------------------------------------------------------------------------- /src/common/test_benchmark.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include "benchmark.h" 8 | #include "field.h" 9 | #include "record.h" 10 | #include "statement.h" 11 | #include "utils.h" 12 | #include "config.h" 13 | #include "status.h" 14 | #include "libpm.h" 15 | #include "plist.h" 16 | #include "serializer.h" 17 | 18 | namespace storage { 19 | 20 | class test_benchmark : public benchmark { 21 | public: 22 | test_benchmark(config _conf, unsigned int tid, database* _db, timer* _tm, struct static_info* _sp); 23 | 24 | void load(); 25 | void execute(); 26 | 27 | void sim_crash(); 28 | 29 | void do_insert(engine* ee); 30 | void do_update(engine* ee); 31 | void do_delete(engine* ee); 32 | void do_read(engine* ee); 33 | 34 | // Table Ids 35 | static constexpr int TEST_TABLE_ID = 0; 36 | 37 | // Schema 38 | schema* test_table_schema; 39 | 40 | std::vector zipf_dist; 41 | std::vector uniform_dist; 42 | 43 | config conf; 44 | std::vector update_field_ids; 45 | serializer sr; 46 | 47 | benchmark_type btype; 48 | 49 | unsigned int txn_id; 50 | unsigned int num_keys; 51 | unsigned int num_txns; 52 | }; 53 | 54 | } 55 | -------------------------------------------------------------------------------- /src/common/timer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace storage { 9 | 10 | class timer { 11 | public: 12 | 13 | timer() { 14 | total = timeval(); 15 | } 16 | 17 | double duration() { 18 | double duration; 19 | 20 | duration = (total.tv_sec) * 1000.0; // sec to ms 21 | duration += (total.tv_usec) / 1000.0; // us to ms 22 | 23 | return duration; 24 | } 25 | 26 | void start() { 27 | gettimeofday(&t1, NULL); 28 | } 29 | 30 | void end() { 31 | gettimeofday(&t2, NULL); 32 | timersub(&t2, &t1, &diff); 33 | timeradd(&diff, &total, &total); 34 | } 35 | 36 | void reset(){ 37 | total = timeval(); 38 | } 39 | 40 | timeval t1, t2, diff; 41 | timeval total; 42 | }; 43 | 44 | } 45 | -------------------------------------------------------------------------------- /src/common/transaction.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // TRANSACTION 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | #include "statement.h" 10 | 11 | namespace storage { 12 | 13 | class transaction { 14 | public: 15 | transaction(unsigned int _txn_id, std::vector _stmts) 16 | : transaction_id(_txn_id), 17 | stmts(_stmts) { 18 | } 19 | 20 | //private: 21 | unsigned int transaction_id; 22 | std::vector stmts; 23 | 24 | }; 25 | 26 | } 27 | -------------------------------------------------------------------------------- /src/common/wal_engine.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | #include "engine_api.h" 10 | #include "config.h" 11 | #include "transaction.h" 12 | #include "record.h" 13 | #include "utils.h" 14 | #include "database.h" 15 | #include "pthread.h" 16 | #include "logger.h" 17 | #include "timer.h" 18 | #include "serializer.h" 19 | 20 | namespace storage { 21 | 22 | class wal_engine : public engine_api { 23 | public: 24 | wal_engine(const config& _conf, database* _db, bool _read_only, unsigned int _tid); 25 | ~wal_engine(); 26 | 27 | std::string select(const statement& st); 28 | int update(const statement& st); 29 | int insert(const statement& t); 30 | int remove(const statement& t); 31 | 32 | void load(const statement& t); 33 | 34 | void group_commit(); 35 | void txn_begin(); 36 | void txn_end(bool commit); 37 | void recovery(); 38 | 39 | //private: 40 | const config& conf; 41 | database* db; 42 | 43 | logger fs_log; 44 | std::hash hash_fn; 45 | std::stringstream entry_stream; 46 | std::string entry_str; 47 | 48 | std::thread gc; 49 | std::atomic_bool ready; 50 | 51 | bool read_only = false; 52 | unsigned int tid; 53 | serializer sr; 54 | }; 55 | 56 | } 57 | 58 | -------------------------------------------------------------------------------- /src/common/ycsb_benchmark.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include "benchmark.h" 8 | #include "field.h" 9 | #include "record.h" 10 | #include "statement.h" 11 | #include "utils.h" 12 | #include "config.h" 13 | #include "status.h" 14 | #include "libpm.h" 15 | #include "plist.h" 16 | #include "serializer.h" 17 | 18 | namespace storage { 19 | 20 | class ycsb_benchmark : public benchmark { 21 | public: 22 | ycsb_benchmark(config _conf, unsigned int tid, database* _db, timer* _tm, struct static_info* _sp); 23 | 24 | void load(); 25 | void execute(); 26 | 27 | void sim_crash(); 28 | 29 | void do_update(engine* ee); 30 | void do_read(engine* ee); 31 | 32 | // Table Ids 33 | static constexpr int USER_TABLE_ID = 0; 34 | 35 | // Schema 36 | schema* user_table_schema; 37 | 38 | std::vector zipf_dist; 39 | std::vector uniform_dist; 40 | 41 | config conf; 42 | std::vector update_field_ids; 43 | serializer sr; 44 | 45 | benchmark_type btype; 46 | 47 | unsigned int txn_id; 48 | unsigned int num_keys; 49 | unsigned int num_txns; 50 | }; 51 | 52 | } 53 | -------------------------------------------------------------------------------- /src/libpm.cpp: -------------------------------------------------------------------------------- 1 | clibpm.cpp -------------------------------------------------------------------------------- /src/pmem_check.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * pmemalloc_check.c -- check the health of a pmem pool 3 | * Usage: pmemalloc_check [-FMd] path 4 | * This is just a simple CLI for calling pmemalloc_check(). 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #include "libpm.h" 15 | 16 | using namespace std; 17 | 18 | char Usage[] = "pmem_check "; /* for USAGE() */ 19 | 20 | int main(int argc, char *argv[]) { 21 | const char *path; 22 | 23 | if (optind >= argc) 24 | printf("No path given \nUsage:: %s \n", Usage); 25 | path = argv[optind++]; 26 | 27 | if (optind < argc) 28 | printf("Usage :: %s \n", Usage); 29 | 30 | storage::pmemalloc_check(path); 31 | 32 | exit(0); 33 | } 34 | -------------------------------------------------------------------------------- /src/run.sh: -------------------------------------------------------------------------------- 1 | 2 | #!/bin/bash 3 | make 4 | rm -fr /dev/shm/zfile 5 | ./nstore -x20000 -k10000 -e1 -w -y -p0.5 -u 6 | rm -fr /dev/shm/zfile 7 | ./nstore -x20000 -k10000 -e2 -w -y -p0.5 -u -i 8 | -------------------------------------------------------------------------------- /test/Makefile.am: -------------------------------------------------------------------------------- 1 | ## Makefile.am -- Process this file with automake to produce Makefile.in 2 | 3 | AM_CPPFLAGS = -I$(top_srcdir)/src/common -Wno-pointer-arith 4 | AM_LDFLAGS = $(PTHREAD_CFLAGS) 5 | LIBS = -lrt 6 | 7 | check_PROGRAMS = test_plist \ 8 | test_pbtree \ 9 | test_ptreap \ 10 | test_pmem 11 | 12 | test_pbtree_SOURCES = test_pbtree.cpp 13 | test_pbtree_LDADD = $(top_builddir)/src/libpm.a 14 | 15 | test_plist_SOURCES = test_plist.cpp 16 | test_plist_LDADD = $(top_builddir)/src/libpm.a 17 | 18 | test_ptreap_SOURCES = test_ptreap.cpp 19 | test_ptreap_LDADD = $(top_builddir)/src/libpm.a 20 | 21 | test_pmem_SOURCES = test_pmem.cpp 22 | test_pmem_LDADD = $(top_builddir)/src/libpm.a 23 | 24 | TESTS = $(check_PROGRAMS) 25 | 26 | -------------------------------------------------------------------------------- /test/test_pbtree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "pbtree.h" 6 | 7 | namespace storage { 8 | 9 | void test_pbtree() { 10 | const char* path = "./zfile"; 11 | 12 | // cleanup 13 | unlink(path); 14 | 15 | long pmp_size = 10 * 1024 * 1024; 16 | if ((pmp = pmemalloc_init(path, pmp_size)) == NULL) 17 | std::cout << "pmemalloc_init on :" << path << std::endl; 18 | 19 | sp = (struct static_info *) storage::pmemalloc_static_area(); 20 | 21 | pbtree* tree = new pbtree(&sp->ptrs[0]); 22 | 23 | int key; 24 | int ops = 10; 25 | 26 | for (int i = 0; i < ops; i++) { 27 | key = i; 28 | tree->insert(key, 0); 29 | } 30 | 31 | assert(tree->size() == ops); 32 | 33 | tree->erase(0); 34 | assert(tree->size() == ops - 1); 35 | 36 | delete tree; 37 | } 38 | 39 | } 40 | 41 | extern struct static_info* sp; 42 | 43 | int main() { 44 | storage::test_pbtree(); 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /test/test_plist.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include "libpm.h" 8 | #include "plist.h" 9 | 10 | namespace storage { 11 | 12 | int test_plist() { 13 | const char* path = "./zfile"; 14 | 15 | // cleanup 16 | unlink(path); 17 | 18 | long pmp_size = 10 * 1024 * 1024; 19 | if ((pmp = pmemalloc_init(path, pmp_size)) == NULL) 20 | std::cout << "pmemalloc_init on :" << path << std::endl; 21 | 22 | sp = (struct static_info *) pmemalloc_static_area(); 23 | 24 | plist* list = new plist(&sp->ptrs[0], &sp->ptrs[1]); 25 | 26 | int key; 27 | srand(time(NULL)); 28 | int ops = 3; 29 | 30 | for (int i = 0; i < ops; i++) { 31 | key = rand() % 10; 32 | 33 | std::string str(2, 'a' + key); 34 | char* data = new char[3]; 35 | pmemalloc_activate(data); 36 | strcpy(data, str.c_str()); 37 | 38 | list->push_back(data); 39 | } 40 | 41 | char* updated_val = new char[3]; 42 | pmemalloc_activate(updated_val); 43 | strcpy(updated_val, "ab"); 44 | 45 | list->update(2, updated_val); 46 | list->display(); 47 | 48 | assert(list->at(2) == updated_val); 49 | 50 | updated_val = new char[3]; 51 | pmemalloc_activate(updated_val); 52 | strcpy(updated_val, "cd"); 53 | 54 | list->update(0, updated_val); 55 | 56 | assert(list->at(0) == updated_val); 57 | 58 | delete list; 59 | 60 | int ret = std::remove(path); 61 | 62 | return ret; 63 | } 64 | 65 | } 66 | 67 | extern struct static_info *sp; 68 | 69 | int main(int argc, char *argv[]) { 70 | storage::test_plist(); 71 | 72 | return 0; 73 | } 74 | 75 | -------------------------------------------------------------------------------- /test/test_pmem.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include "libpm.h" 8 | #include "plist.h" 9 | 10 | namespace storage { 11 | 12 | void test_pmem() { 13 | const char* path = "./zfile"; 14 | 15 | // cleanup 16 | unlink(path); 17 | 18 | long pmp_size = 1024 * 1024 * 1024; 19 | if ((pmp = pmemalloc_init(path, pmp_size)) == NULL) 20 | std::cout << "pmemalloc_init on :" << path << std::endl; 21 | 22 | sp = (struct static_info *) pmemalloc_static_area(); 23 | 24 | int ops = 1024; 25 | size_t sz; 26 | 27 | for (int i = 0; i < ops; i++) { 28 | sz = rand() % 1024; 29 | 30 | char* vc = new char[sz]; 31 | if (sz % 4 == 0) 32 | pmemalloc_activate(vc); 33 | 34 | if (sz % 16 == 0) 35 | delete vc; 36 | } 37 | } 38 | 39 | } 40 | 41 | extern struct static_info *sp; 42 | 43 | int main(int argc, char *argv[]) { 44 | storage::test_pmem(); 45 | return 0; 46 | } 47 | 48 | --------------------------------------------------------------------------------