From 4a1dde3148e0e84b47c884bc0bb69c60678b4558 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Mon, 22 Apr 2024 15:09:07 -0400 Subject: Benchmark update+reorganization The Alex benchmark isn't updated yet. --- benchmarks/vldb/alex_bench.cpp | 205 ++++++++++++++++++++++++++++++++++ benchmarks/vldb/btree_bench.cpp | 90 +++++++++++++++ benchmarks/vldb/dynamic_pgm_bench.cpp | 77 +++++++++++++ benchmarks/vldb/irs_bench.cpp | 97 ++++++++++++++++ benchmarks/vldb/mtree_bench.cpp | 80 +++++++++++++ benchmarks/vldb/pgm_bench.cpp | 94 ++++++++++++++++ benchmarks/vldb/ts_bench.cpp | 94 ++++++++++++++++ benchmarks/vldb/ts_bsm_bench.cpp | 70 ++++++++++++ benchmarks/vldb/ts_mdsp_bench.cpp | 70 ++++++++++++ benchmarks/vldb/vptree_bench.cpp | 100 +++++++++++++++++ 10 files changed, 977 insertions(+) create mode 100644 benchmarks/vldb/alex_bench.cpp create mode 100644 benchmarks/vldb/btree_bench.cpp create mode 100644 benchmarks/vldb/dynamic_pgm_bench.cpp create mode 100644 benchmarks/vldb/irs_bench.cpp create mode 100644 benchmarks/vldb/mtree_bench.cpp create mode 100644 benchmarks/vldb/pgm_bench.cpp create mode 100644 benchmarks/vldb/ts_bench.cpp create mode 100644 benchmarks/vldb/ts_bsm_bench.cpp create mode 100644 benchmarks/vldb/ts_mdsp_bench.cpp create mode 100644 benchmarks/vldb/vptree_bench.cpp (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/alex_bench.cpp b/benchmarks/vldb/alex_bench.cpp new file mode 100644 index 0000000..f75afa6 --- /dev/null +++ b/benchmarks/vldb/alex_bench.cpp @@ -0,0 +1,205 @@ +#include "alex.h" +#include "include/standalone_utility.h" + +typedef uint64_t key_type; +typedef uint64_t value_type; + +typedef alex::Alex Alex; + +struct record { + key_type key; + value_type value; +}; + +struct query { + key_type lower_bound; + key_type upper_bound; +}; + +template +static bool build_insert_vec(std::fstream &file, std::vector &vec, size_t n, + double delete_prop, std::vector &to_delete, bool binary=false) { + vec.clear(); + for (size_t i=0; i to_delete, bool progress=true, bool binary=false) { + size_t batch = std::min(.1 * count, 25000.0); + + std::pair *insert_vec = new std::pair[count]; + Alex *alex = new Alex(); + + size_t cnt = 0; + record rec; + while (cnt < count && next_record(file, rec)) { + insert_vec[cnt] = {rec.key, rec.value}; + cnt++; + } + + std::sort(insert_vec, insert_vec + count); + + alex->bulk_load(insert_vec, count); + delete[] insert_vec; + + return alex; +} + + +static void alex_rq_insert(Alex &alex, std::fstream &file, size_t insert_cnt, double delete_prop, std::vector &to_delete, bool binary=false) { + size_t delete_cnt = insert_cnt * delete_prop; + + size_t applied_deletes = 0; + size_t applied_inserts = 0; + + size_t BATCH=1000; + + std::vector insert_vec; + std::vector delete_vec; + insert_vec.reserve(BATCH); + delete_vec.reserve(BATCH*delete_prop); + + size_t delete_idx = 0; + + bool continue_benchmark = true; + + size_t total_time = 0; + + while (applied_inserts < insert_cnt && continue_benchmark) { + continue_benchmark = build_insert_vec(file, insert_vec, BATCH, delete_prop, to_delete, binary); + progress_update((double) applied_inserts / (double) insert_cnt, "inserting:"); + if (applied_deletes < delete_cnt) { + build_delete_vec(to_delete, delete_vec, BATCH*delete_prop); + delete_idx = 0; + } + + if (insert_vec.size() == 0) { + break; + } + + auto insert_start = std::chrono::high_resolution_clock::now(); + for (size_t i=0; i(insert_stop - insert_start).count(); + } + + progress_update(1.0, "inserting:"); + + size_t throughput = (((double) (applied_inserts + applied_deletes) / (double) total_time) * 1e9); + + fprintf(stdout, "%ld\t", throughput); +} + + + +static void alex_rq_bench(Alex &alex, std::vector queries, size_t trial_cnt=1) +{ + char progbuf[25]; + sprintf(progbuf, "sampling:"); + + size_t batch_size = 100; + size_t batches = trial_cnt / batch_size; + size_t total_time = 0; + + std::vector result_set; + + for (int i=0; i(stop - start).count(); + } + + size_t latency = total_time / (trial_cnt * queries.size()); + + fprintf(stdout, "%ld\t", latency); +} + +int main(int argc, char **argv) +{ + if (argc < 5) { + fprintf(stderr, "Usage: alex_rq_bench \n"); + exit(EXIT_FAILURE); + } + + std::string filename = std::string(argv[1]); + size_t record_count = atol(argv[2]); + double delete_prop = atof(argv[3]); + std::string qfilename = std::string(argv[4]); + + size_t buffer_cap = 12000; + size_t scale_factor = 6; + double max_delete_prop = delete_prop; + bool use_osm = false; + + double insert_batch = 0.8; + + init_bench_env(record_count, true, use_osm); + auto queries = read_range_queries(qfilename, .0001); + + std::fstream datafile; + datafile.open(filename, std::ios::in | std::ios::binary); + + std::vector to_delete; + + // warm up the tree with initial_insertions number of initially inserted + // records + size_t warmup_cnt = insert_batch * record_count; + auto alex = warmup(datafile, warmup_cnt, delete_prop, to_delete, true, true); + + fprintf(stderr, "Size: %ld\n", alex->size()); + size_t insert_cnt = record_count - warmup_cnt; + + alex_rq_insert(*alex, datafile, insert_cnt, delete_prop, to_delete, true); + size_t memory_usage = alex->model_size() + alex->data_size(); + + fprintf(stderr, "Size: %ld\n", alex->size()); + fprintf(stdout, "%ld\t", memory_usage); + + alex_rq_bench(*alex, queries); + fprintf(stdout, "\n"); + + delete_bench_env(); + delete alex; + fflush(stdout); + fflush(stderr); + + exit(EXIT_SUCCESS); +} diff --git a/benchmarks/vldb/btree_bench.cpp b/benchmarks/vldb/btree_bench.cpp new file mode 100644 index 0000000..12107c6 --- /dev/null +++ b/benchmarks/vldb/btree_bench.cpp @@ -0,0 +1,90 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include "shard/ISAMTree.h" +#include "query/irs.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "benchmark_types.h" + +#include + +#include "psu-util/timer.h" +#include "standard_benchmarks.h" +#include "psu-ds/BTree.h" + +typedef btree_record Rec; + +typedef de::ISAMTree Shard; +typedef de::irs::Query Q; +typedef de::irs::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto btree = BenchBTree(); + + gsl_rng *rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto data = read_sosd_file(d_fname, n); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, .001); + for (auto &q : queries) { + q.sample_size = 1000; + q.rng = rng; + } + + /* warmup structure w/ 10% of records */ + size_t warmup = .3 * n; + size_t delete_idx = 0; + insert_records(&btree, 0, warmup, data, to_delete, delete_idx, false, rng); + + TIMER_INIT(); + + TIMER_START(); + insert_records(&btree, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_btree_queries(&btree, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto btree_size = btree.get_stats().inner_nodes * psudb::btree_default_traits::inner_slots * (sizeof(int64_t) + sizeof(void*)); + + /* account for memory wasted on gaps in the structure */ + btree_size += btree.get_stats().leaves * psudb::btree_default_traits::leaf_slots * sizeof(Rec); + btree_size -= btree.size() * sizeof(Rec); + + fprintf(stdout, "%ld\t%ld\t%ld\n", insert_throughput, query_latency, btree_size); + + gsl_rng_free(rng); + fflush(stderr); +} + diff --git a/benchmarks/vldb/dynamic_pgm_bench.cpp b/benchmarks/vldb/dynamic_pgm_bench.cpp new file mode 100644 index 0000000..249bc92 --- /dev/null +++ b/benchmarks/vldb/dynamic_pgm_bench.cpp @@ -0,0 +1,77 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include + +#include "query/rangecount.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "standard_benchmarks.h" +#include + +#include "psu-util/timer.h" + + +typedef de::Record Rec; +typedef de::rc::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + std::vector> tmp_data; + PGM pgm(tmp_data.begin(), tmp_data.end()); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto data = read_sosd_file(d_fname, n); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, .001); + + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(&pgm, 0, warmup, data, to_delete, delete_idx, false, rng); + + TIMER_INIT(); + + TIMER_START(); + insert_records(&pgm, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(&pgm, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = pgm.size_in_bytes(); + + fprintf(stdout, "%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size); + + gsl_rng_free(rng); + fflush(stderr); +} + diff --git a/benchmarks/vldb/irs_bench.cpp b/benchmarks/vldb/irs_bench.cpp new file mode 100644 index 0000000..ca1e555 --- /dev/null +++ b/benchmarks/vldb/irs_bench.cpp @@ -0,0 +1,97 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include "framework/DynamicExtension.h" +#include "shard/ISAMTree.h" +#include "query/irs.h" +#include "framework/interface/Record.h" +#include "file_util.h" + +#include + +#include "psu-util/timer.h" +#include "standard_benchmarks.h" + + +typedef de::Record Rec; +typedef de::ISAMTree Shard; +typedef de::irs::Query Q; +typedef de::DynamicExtension Ext; +typedef de::irs::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto extension = new Ext(12000, 12001, 8, 0, 64); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto data = read_sosd_file(d_fname, n); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, .001); + for (auto &q : queries) { + q.sample_size = 1000; + q.rng = rng; + } + + /* warmup structure w/ 10% of records */ + size_t warmup = .3 * n; + size_t delete_idx = 0; + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto shard = extension->create_static_structure(); + + TIMER_START(); + run_static_queries(shard, queries); + TIMER_STOP(); + + auto static_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + auto static_size = shard->get_memory_usage();// + shard->get_aux_memory_usage(); + + fprintf(stdout, "%ld\t%ld\t%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size, static_latency, static_size); + + gsl_rng_free(rng); + delete extension; + fflush(stderr); +} + diff --git a/benchmarks/vldb/mtree_bench.cpp b/benchmarks/vldb/mtree_bench.cpp new file mode 100644 index 0000000..35f56be --- /dev/null +++ b/benchmarks/vldb/mtree_bench.cpp @@ -0,0 +1,80 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include "query/knn.h" +#include "file_util.h" +#include "standard_benchmarks.h" + +#include + +#include "psu-util/timer.h" + + +typedef Word2VecRec Rec; +typedef de::knn::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto mtree = new MTree(); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + fprintf(stderr, "[I] Reading data file...\n"); + auto data = read_vector_file(d_fname, n); + + fprintf(stderr, "[I] Generating delete vector\n"); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, 10); + + fprintf(stderr, "[I] Warming up structure...\n"); + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(mtree, 0, warmup, data, to_delete, delete_idx, false, rng); + + TIMER_INIT(); + + fprintf(stderr, "[I] Running Insertion Benchmark\n"); + TIMER_START(); + insert_records(mtree, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + fprintf(stderr, "[I] Running Query Benchmark\n"); + TIMER_START(); + run_queries(mtree, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + fprintf(stdout, "%ld\t%ld\n", insert_throughput, query_latency); + + gsl_rng_free(rng); + delete mtree; + fflush(stderr); +} + diff --git a/benchmarks/vldb/pgm_bench.cpp b/benchmarks/vldb/pgm_bench.cpp new file mode 100644 index 0000000..f63ec8e --- /dev/null +++ b/benchmarks/vldb/pgm_bench.cpp @@ -0,0 +1,94 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include + +#include "framework/DynamicExtension.h" +#include "shard/PGM.h" +#include "query/rangecount.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "standard_benchmarks.h" + +#include + +#include "psu-util/timer.h" + + +typedef de::Record Rec; +typedef de::PGM Shard; +typedef de::rc::Query Q; +typedef de::DynamicExtension Ext; +typedef de::rc::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto extension = new Ext(12000, 12001, 8, 0, 64); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto data = read_sosd_file(d_fname, n); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, .001); + + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto shard = extension->create_static_structure(); + + TIMER_START(); + run_static_queries(shard, queries); + TIMER_STOP(); + + auto static_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + auto static_size = shard->get_memory_usage(); // + shard->get_aux_memory_usage(); + + fprintf(stdout, "%ld\t%ld\t%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size, static_latency, static_size); + + gsl_rng_free(rng); + delete extension; + fflush(stderr); +} + diff --git a/benchmarks/vldb/ts_bench.cpp b/benchmarks/vldb/ts_bench.cpp new file mode 100644 index 0000000..a84635f --- /dev/null +++ b/benchmarks/vldb/ts_bench.cpp @@ -0,0 +1,94 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include + +#include "framework/DynamicExtension.h" +#include "shard/TrieSpline.h" +#include "query/rangecount.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "standard_benchmarks.h" + +#include + +#include "psu-util/timer.h" + + +typedef de::Record Rec; +typedef de::TrieSpline Shard; +typedef de::rc::Query Q; +typedef de::DynamicExtension Ext; +typedef de::rc::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto extension = new Ext(12000, 12001, 8, 0, 64); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto data = read_sosd_file(d_fname, n); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, .001); + + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto shard = extension->create_static_structure(); + + TIMER_START(); + run_static_queries(shard, queries); + TIMER_STOP(); + + auto static_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + auto static_size = shard->get_memory_usage(); //+ shard->get_aux_memory_usage(); + + fprintf(stdout, "%ld\t%ld\t%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size, static_latency, static_size); + + gsl_rng_free(rng); + delete extension; + fflush(stderr); +} + diff --git a/benchmarks/vldb/ts_bsm_bench.cpp b/benchmarks/vldb/ts_bsm_bench.cpp new file mode 100644 index 0000000..706433d --- /dev/null +++ b/benchmarks/vldb/ts_bsm_bench.cpp @@ -0,0 +1,70 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include + +#include "triespline_bsm.h" +#include "psu-util/bentley-saxe.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "query/rangecount.h" +#include "psu-util/timer.h" +#include "standard_benchmarks.h" + +typedef std::pair Rec; +typedef de::Record FRec; + +typedef BSMTrieSpline Shard; +typedef de::rc::Parms QP; +typedef psudb::bsm::BentleySaxe Ext; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto extension = new psudb::bsm::BentleySaxe(); + gsl_rng *rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto data = read_sosd_file_pair(d_fname, n); + auto queries = read_range_queries(q_fname, .001); + + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + insert_records(extension, 0, warmup, data); + + TIMER_INIT(); + + TIMER_START(); + insert_records(extension, warmup, data.size(), data); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + fprintf(stdout, "%ld\t%ld\n", insert_throughput, query_latency); + + gsl_rng_free(rng); + delete extension; + fflush(stderr); +} + diff --git a/benchmarks/vldb/ts_mdsp_bench.cpp b/benchmarks/vldb/ts_mdsp_bench.cpp new file mode 100644 index 0000000..4c5bf1e --- /dev/null +++ b/benchmarks/vldb/ts_mdsp_bench.cpp @@ -0,0 +1,70 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include + +#include "triespline_bsm.h" +#include "psu-util/bentley-saxe.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "query/rangecount.h" +#include "psu-util/timer.h" +#include "standard_benchmarks.h" + +typedef std::pair Rec; +typedef de::Record FRec; + +typedef BSMTrieSpline Shard; +typedef de::rc::Parms QP; +typedef psudb::bsm::BentleySaxe Ext; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto extension = new psudb::bsm::BentleySaxe(); + gsl_rng *rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto data = read_sosd_file_pair(d_fname, n); + auto queries = read_range_queries(q_fname, .001); + + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + insert_records(extension, 0, warmup, data); + + TIMER_INIT(); + + TIMER_START(); + insert_records(extension, warmup, data.size(), data); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + fprintf(stdout, "%ld\t%ld\n", insert_throughput, query_latency); + + gsl_rng_free(rng); + delete extension; + fflush(stderr); +} + diff --git a/benchmarks/vldb/vptree_bench.cpp b/benchmarks/vldb/vptree_bench.cpp new file mode 100644 index 0000000..613c556 --- /dev/null +++ b/benchmarks/vldb/vptree_bench.cpp @@ -0,0 +1,100 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include "framework/DynamicExtension.h" +#include "shard/VPTree.h" +#include "query/knn.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "standard_benchmarks.h" + +#include + +#include "psu-util/timer.h" + + +typedef Word2VecRec Rec; + +typedef de::VPTree Shard; +typedef de::knn::Query Q; +typedef de::DynamicExtension Ext; +typedef de::knn::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto extension = new Ext(100, 1000, 8, 0, 64); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + fprintf(stderr, "[I] Reading data file...\n"); + auto data = read_vector_file(d_fname, n); + + fprintf(stderr, "[I] Generating delete vector\n"); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, 10); + + fprintf(stderr, "[I] Warming up structure...\n"); + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + fprintf(stderr, "[I] Running Insertion Benchmark\n"); + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + fprintf(stderr, "[I] Running Query Benchmark\n"); + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto shard = extension->create_static_structure(); + + TIMER_START(); + run_static_queries(shard, queries); + TIMER_STOP(); + + auto static_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + auto static_size = shard->get_memory_usage(); // + shard->get_aux_memory_usage(); + + fprintf(stdout, "%ld\t%ld\t%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size, static_latency, static_size); + + gsl_rng_free(rng); + delete extension; + fflush(stderr); +} + -- cgit v1.2.3 From 4d6a164f85352ca9f297b28bd1b677c8fc6ab4f3 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Mon, 22 Apr 2024 15:31:03 -0400 Subject: TS Parameter sweep benchmark --- benchmarks/vldb/ts_parmsweep.cpp | 124 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 124 insertions(+) create mode 100644 benchmarks/vldb/ts_parmsweep.cpp (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/ts_parmsweep.cpp b/benchmarks/vldb/ts_parmsweep.cpp new file mode 100644 index 0000000..fd71e11 --- /dev/null +++ b/benchmarks/vldb/ts_parmsweep.cpp @@ -0,0 +1,124 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include "framework/DynamicExtension.h" +#include "shard/TrieSpline.h" +#include "query/rangecount.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "standard_benchmarks.h" + +#include + +#include "psu-util/timer.h" + + +typedef de::Record Rec; +typedef de::TrieSpline Shard; +typedef de::rc::Query Q; +typedef de::DynamicExtension Ext; +typedef de::DynamicExtension Ext2; +typedef de::rc::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto data = read_sosd_file(d_fname, n); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, .001); + + const std::vector policies = {de::LayoutPolicy::LEVELING, de::LayoutPolicy::TEIRING}; + const std::vector buffer_sizes = {1000, 4000, 8000, 12000, 15000, 20000}; + const std::vector scale_factors = {2, 4, 6, 8, 10, 12}; + + for (const auto &bs : buffer_sizes) { + for (const auto &sf : scale_factors) { + auto extension = new Ext(bs, bs, sf, 0, 64); + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + + fprintf(stdout, "TIERING\t%ld\t%ld\t%ld\t%ld\t%ld\n", bs, sf, insert_throughput, query_latency, ext_size); + delete extension; + } + } + + for (const auto &bs : buffer_sizes) { + for (const auto &sf : scale_factors) { + auto extension = new Ext2(bs, bs, sf, 0, 64); + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + + fprintf(stdout, "LEVELING\t%ld\t%ld\t%ld\t%ld\t%ld\n", bs, sf, insert_throughput, query_latency, ext_size); + delete extension; + } + } + + gsl_rng_free(rng); + fflush(stderr); +} + -- cgit v1.2.3 From e65edcf4030afdaef6955f366fd29d7518aa7352 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Mon, 22 Apr 2024 15:31:14 -0400 Subject: Fixed usage printf() in benchmarks --- benchmarks/vldb/btree_bench.cpp | 2 +- benchmarks/vldb/dynamic_pgm_bench.cpp | 2 +- benchmarks/vldb/irs_bench.cpp | 2 +- benchmarks/vldb/pgm_bench.cpp | 2 +- benchmarks/vldb/ts_bench.cpp | 2 +- benchmarks/vldb/ts_bsm_bench.cpp | 2 +- benchmarks/vldb/ts_mdsp_bench.cpp | 2 +- benchmarks/vldb/vptree_bench.cpp | 2 +- 8 files changed, 8 insertions(+), 8 deletions(-) (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/btree_bench.cpp b/benchmarks/vldb/btree_bench.cpp index 12107c6..6d1be9f 100644 --- a/benchmarks/vldb/btree_bench.cpp +++ b/benchmarks/vldb/btree_bench.cpp @@ -23,7 +23,7 @@ typedef de::irs::Query Q; typedef de::irs::Parms QP; void usage(char *progname) { - fprintf(stderr, "%s reccnt datafile queryfile", progname); + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); } int main(int argc, char **argv) { diff --git a/benchmarks/vldb/dynamic_pgm_bench.cpp b/benchmarks/vldb/dynamic_pgm_bench.cpp index 249bc92..8d2f4dd 100644 --- a/benchmarks/vldb/dynamic_pgm_bench.cpp +++ b/benchmarks/vldb/dynamic_pgm_bench.cpp @@ -19,7 +19,7 @@ typedef de::Record Rec; typedef de::rc::Parms QP; void usage(char *progname) { - fprintf(stderr, "%s reccnt datafile queryfile", progname); + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); } int main(int argc, char **argv) { diff --git a/benchmarks/vldb/irs_bench.cpp b/benchmarks/vldb/irs_bench.cpp index ca1e555..dabe79e 100644 --- a/benchmarks/vldb/irs_bench.cpp +++ b/benchmarks/vldb/irs_bench.cpp @@ -23,7 +23,7 @@ typedef de::DynamicExtension QP; void usage(char *progname) { - fprintf(stderr, "%s reccnt datafile queryfile", progname); + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); } int main(int argc, char **argv) { diff --git a/benchmarks/vldb/pgm_bench.cpp b/benchmarks/vldb/pgm_bench.cpp index f63ec8e..498ef8f 100644 --- a/benchmarks/vldb/pgm_bench.cpp +++ b/benchmarks/vldb/pgm_bench.cpp @@ -25,7 +25,7 @@ typedef de::DynamicExtension QP; void usage(char *progname) { - fprintf(stderr, "%s reccnt datafile queryfile", progname); + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); } int main(int argc, char **argv) { diff --git a/benchmarks/vldb/ts_bench.cpp b/benchmarks/vldb/ts_bench.cpp index a84635f..5a4cc13 100644 --- a/benchmarks/vldb/ts_bench.cpp +++ b/benchmarks/vldb/ts_bench.cpp @@ -25,7 +25,7 @@ typedef de::DynamicExtension QP; void usage(char *progname) { - fprintf(stderr, "%s reccnt datafile queryfile", progname); + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); } int main(int argc, char **argv) { diff --git a/benchmarks/vldb/ts_bsm_bench.cpp b/benchmarks/vldb/ts_bsm_bench.cpp index 706433d..941e3da 100644 --- a/benchmarks/vldb/ts_bsm_bench.cpp +++ b/benchmarks/vldb/ts_bsm_bench.cpp @@ -22,7 +22,7 @@ typedef de::rc::Parms QP; typedef psudb::bsm::BentleySaxe Ext; void usage(char *progname) { - fprintf(stderr, "%s reccnt datafile queryfile", progname); + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); } int main(int argc, char **argv) { diff --git a/benchmarks/vldb/ts_mdsp_bench.cpp b/benchmarks/vldb/ts_mdsp_bench.cpp index 4c5bf1e..44c641d 100644 --- a/benchmarks/vldb/ts_mdsp_bench.cpp +++ b/benchmarks/vldb/ts_mdsp_bench.cpp @@ -22,7 +22,7 @@ typedef de::rc::Parms QP; typedef psudb::bsm::BentleySaxe Ext; void usage(char *progname) { - fprintf(stderr, "%s reccnt datafile queryfile", progname); + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); } int main(int argc, char **argv) { diff --git a/benchmarks/vldb/vptree_bench.cpp b/benchmarks/vldb/vptree_bench.cpp index 613c556..b17a57b 100644 --- a/benchmarks/vldb/vptree_bench.cpp +++ b/benchmarks/vldb/vptree_bench.cpp @@ -24,7 +24,7 @@ typedef de::DynamicExtension QP; void usage(char *progname) { - fprintf(stderr, "%s reccnt datafile queryfile", progname); + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); } int main(int argc, char **argv) { -- cgit v1.2.3 From 909ba1e59ce654db3ea9294201dec2bc826b0b72 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Tue, 23 Apr 2024 13:25:17 -0400 Subject: Added vptree parmsweep benchmark and fixed some CMake issues --- benchmarks/vldb/vptree_parmsweep.cpp | 129 +++++++++++++++++++++++++++++++++++ 1 file changed, 129 insertions(+) create mode 100644 benchmarks/vldb/vptree_parmsweep.cpp (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/vptree_parmsweep.cpp b/benchmarks/vldb/vptree_parmsweep.cpp new file mode 100644 index 0000000..2cbd521 --- /dev/null +++ b/benchmarks/vldb/vptree_parmsweep.cpp @@ -0,0 +1,129 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include "framework/DynamicExtension.h" +#include "shard/VPTree.h" +#include "query/knn.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "standard_benchmarks.h" + +#include + +#include "psu-util/timer.h" + + +typedef Word2VecRec Rec; + +typedef de::VPTree Shard; +typedef de::knn::Query Q; +typedef de::DynamicExtension Ext; +typedef de::DynamicExtension Ext2; +typedef de::knn::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto data = read_vector_file(d_fname, n); + + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, 10); + + + const std::vector policies = {de::LayoutPolicy::LEVELING, de::LayoutPolicy::TEIRING}; + const std::vector buffer_sizes = {100, 400, 800, 1200, 1500, 2000}; + const std::vector scale_factors = {2, 4, 6, 8, 10, 12}; + + for (const auto &bs : buffer_sizes) { + for (const auto &sf : scale_factors) { + auto extension = new Ext(bs, bs, sf, 0, 64); + + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + + fprintf(stdout, "TIERING\t%ld\t%ld\t%ld\t%ld\t%ld\n", bs, sf, insert_throughput, query_latency, ext_size); + delete extension; + } + } + + for (const auto &bs : buffer_sizes) { + for (const auto &sf : scale_factors) { + auto extension = new Ext2(bs, bs, sf, 0, 64); + + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + + fprintf(stdout, "LEVELING\t%ld\t%ld\t%ld\t%ld\t%ld\n", bs, sf, insert_throughput, query_latency, ext_size); + delete extension; + } + } + + gsl_rng_free(rng); + fflush(stderr); +} + -- cgit v1.2.3 From e801222023330cf36602d37be64091565172bd2d Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Mon, 29 Apr 2024 13:56:23 -0400 Subject: Updated dynamic PGM benchmark to use index size --- benchmarks/vldb/dynamic_pgm_bench.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/dynamic_pgm_bench.cpp b/benchmarks/vldb/dynamic_pgm_bench.cpp index 8d2f4dd..580fa93 100644 --- a/benchmarks/vldb/dynamic_pgm_bench.cpp +++ b/benchmarks/vldb/dynamic_pgm_bench.cpp @@ -67,7 +67,7 @@ int main(int argc, char **argv) { auto query_latency = TIMER_RESULT() / queries.size(); - auto ext_size = pgm.size_in_bytes(); + auto ext_size = pgm.index_size_in_bytes(); fprintf(stdout, "%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size); -- cgit v1.2.3 From c61164545f4c113fb17eb993e393bbf97373cfb3 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Mon, 29 Apr 2024 14:43:10 -0400 Subject: Alex benchmark --- benchmarks/vldb/alex_bench.cpp | 231 +++++++++++++++-------------------------- 1 file changed, 85 insertions(+), 146 deletions(-) (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/alex_bench.cpp b/benchmarks/vldb/alex_bench.cpp index f75afa6..76df410 100644 --- a/benchmarks/vldb/alex_bench.cpp +++ b/benchmarks/vldb/alex_bench.cpp @@ -1,5 +1,10 @@ +#define ENABLE_TIMER + #include "alex.h" -#include "include/standalone_utility.h" + +#include "file_util.h" +#include "psu-util/progress.h" +#include "psu-util/timer.h" typedef uint64_t key_type; typedef uint64_t value_type; @@ -16,190 +21,124 @@ struct query { key_type upper_bound; }; -template -static bool build_insert_vec(std::fstream &file, std::vector &vec, size_t n, - double delete_prop, std::vector &to_delete, bool binary=false) { - vec.clear(); - for (size_t i=0; i to_delete, bool progress=true, bool binary=false) { - size_t batch = std::min(.1 * count, 25000.0); - - std::pair *insert_vec = new std::pair[count]; - Alex *alex = new Alex(); +static void insert_records(Alex *structure, size_t start, size_t stop, + std::vector &records, std::vector &to_delete, + size_t &delete_idx, bool delete_records, gsl_rng *rng) { - size_t cnt = 0; - record rec; - while (cnt < count && next_record(file, rec)) { - insert_vec[cnt] = {rec.key, rec.value}; - cnt++; - } + psudb::progress_update(0, "Insert Progress"); + size_t reccnt = 0; + for (size_t i=start; iinsert(records[i].key, records[i].value); - std::sort(insert_vec, insert_vec + count); + if (delete_records && gsl_rng_uniform(rng) <= + delete_proportion && to_delete[delete_idx] <= i) { - alex->bulk_load(insert_vec, count); - delete[] insert_vec; + structure->erase_one(records[i].key); + delete_idx++; + g_deleted_records++; + } + } - return alex; + psudb::progress_update(1, "Insert Progress"); } +size_t g_global_cnt = 0; -static void alex_rq_insert(Alex &alex, std::fstream &file, size_t insert_cnt, double delete_prop, std::vector &to_delete, bool binary=false) { - size_t delete_cnt = insert_cnt * delete_prop; - - size_t applied_deletes = 0; - size_t applied_inserts = 0; - - size_t BATCH=1000; - - std::vector insert_vec; - std::vector delete_vec; - insert_vec.reserve(BATCH); - delete_vec.reserve(BATCH*delete_prop); - - size_t delete_idx = 0; - - bool continue_benchmark = true; - - size_t total_time = 0; - - while (applied_inserts < insert_cnt && continue_benchmark) { - continue_benchmark = build_insert_vec(file, insert_vec, BATCH, delete_prop, to_delete, binary); - progress_update((double) applied_inserts / (double) insert_cnt, "inserting:"); - if (applied_deletes < delete_cnt) { - build_delete_vec(to_delete, delete_vec, BATCH*delete_prop); - delete_idx = 0; - } - - if (insert_vec.size() == 0) { - break; - } - - auto insert_start = std::chrono::high_resolution_clock::now(); - for (size_t i=0; i &queries) { + for (size_t i=0; ifind(queries[i].lower_bound); + while (ptr != alex->end() && ptr.key() <= queries[i].upper_bound) { + cnt++; + ptr++; } - auto insert_stop = std::chrono::high_resolution_clock::now(); - - total_time += std::chrono::duration_cast(insert_stop - insert_start).count(); - } - - progress_update(1.0, "inserting:"); - - size_t throughput = (((double) (applied_inserts + applied_deletes) / (double) total_time) * 1e9); - fprintf(stdout, "%ld\t", throughput); + g_global_cnt += cnt; + } } +Alex *warmup_alex(std::vector records, size_t cnt) { + if (cnt >= records.size()) { + fprintf(stderr, "[E] Requesting warmup with more records than are available.\n"); + exit(EXIT_FAILURE); + } + auto alex = new Alex(); + std::pair *insert_vec = new std::pair[cnt]; -static void alex_rq_bench(Alex &alex, std::vector queries, size_t trial_cnt=1) -{ - char progbuf[25]; - sprintf(progbuf, "sampling:"); - - size_t batch_size = 100; - size_t batches = trial_cnt / batch_size; - size_t total_time = 0; - - std::vector result_set; - - for (int i=0; i(stop - start).count(); + for (size_t i=0; ibulk_load(insert_vec, cnt); + delete[] insert_vec; - fprintf(stdout, "%ld\t", latency); + return alex; } int main(int argc, char **argv) { - if (argc < 5) { - fprintf(stderr, "Usage: alex_rq_bench \n"); + if (argc < 4) { + usage(argv[0]); exit(EXIT_FAILURE); } - std::string filename = std::string(argv[1]); - size_t record_count = atol(argv[2]); - double delete_prop = atof(argv[3]); - std::string qfilename = std::string(argv[4]); + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + gsl_rng *rng = gsl_rng_alloc(gsl_rng_mt19937); - size_t buffer_cap = 12000; - size_t scale_factor = 6; - double max_delete_prop = delete_prop; - bool use_osm = false; - double insert_batch = 0.8; + auto data = read_sosd_file(d_fname, n); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(qfilename, .0001); + auto queries = read_range_queries(q_fname, .001); - std::fstream datafile; - datafile.open(filename, std::ios::in | std::ios::binary); - std::vector to_delete; + size_t warmup = .1 * n; + size_t delete_idx = 0; - // warm up the tree with initial_insertions number of initially inserted - // records - size_t warmup_cnt = insert_batch * record_count; - auto alex = warmup(datafile, warmup_cnt, delete_prop, to_delete, true, true); + auto alex = warmup_alex(data, warmup); - fprintf(stderr, "Size: %ld\n", alex->size()); - size_t insert_cnt = record_count - warmup_cnt; + TIMER_INIT(); - alex_rq_insert(*alex, datafile, insert_cnt, delete_prop, to_delete, true); - size_t memory_usage = alex->model_size() + alex->data_size(); + TIMER_START(); + insert_records(alex, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); - fprintf(stderr, "Size: %ld\n", alex->size()); - fprintf(stdout, "%ld\t", memory_usage); + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); - alex_rq_bench(*alex, queries); - fprintf(stdout, "\n"); + TIMER_START(); + run_queries(alex, queries); + TIMER_STOP(); - delete_bench_env(); - delete alex; + auto query_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = alex->model_size() + alex->data_size() - (alex->size() * sizeof(record)); + + fprintf(stdout, "%ld\t%ld\t%lld\t%ld\n", insert_throughput, query_latency, ext_size, g_global_cnt); fflush(stdout); + + gsl_rng_free(rng); fflush(stderr); + delete alex; + exit(EXIT_SUCCESS); } -- cgit v1.2.3 From 47a386b50d904d3f1b7ce3cfc13c29ea96dd1e43 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Tue, 30 Apr 2024 14:18:08 -0400 Subject: Added VPTree BSM benchmark --- benchmarks/vldb/mtree_bench.cpp | 2 +- benchmarks/vldb/vptree_bench.cpp | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/mtree_bench.cpp b/benchmarks/vldb/mtree_bench.cpp index 35f56be..60425da 100644 --- a/benchmarks/vldb/mtree_bench.cpp +++ b/benchmarks/vldb/mtree_bench.cpp @@ -46,7 +46,7 @@ int main(int argc, char **argv) { } } fprintf(stderr, "[I] Reading Queries\n"); - auto queries = read_knn_queries(q_fname, 10); + auto queries = read_knn_queries(q_fname, 1000); fprintf(stderr, "[I] Warming up structure...\n"); /* warmup structure w/ 10% of records */ diff --git a/benchmarks/vldb/vptree_bench.cpp b/benchmarks/vldb/vptree_bench.cpp index b17a57b..0b98a52 100644 --- a/benchmarks/vldb/vptree_bench.cpp +++ b/benchmarks/vldb/vptree_bench.cpp @@ -38,7 +38,7 @@ int main(int argc, char **argv) { std::string d_fname = std::string(argv[2]); std::string q_fname = std::string(argv[3]); - auto extension = new Ext(100, 1000, 8, 0, 64); + auto extension = new Ext(1400, 1400, 8, 0, 64); gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); fprintf(stderr, "[I] Reading data file...\n"); @@ -53,7 +53,7 @@ int main(int argc, char **argv) { } } fprintf(stderr, "[I] Reading Queries\n"); - auto queries = read_knn_queries(q_fname, 10); + auto queries = read_knn_queries(q_fname, 1000); fprintf(stderr, "[I] Warming up structure...\n"); /* warmup structure w/ 10% of records */ @@ -82,6 +82,7 @@ int main(int argc, char **argv) { auto shard = extension->create_static_structure(); + fprintf(stderr, "Running Static query tests\n\n"); TIMER_START(); run_static_queries(shard, queries); TIMER_STOP(); @@ -96,5 +97,6 @@ int main(int argc, char **argv) { gsl_rng_free(rng); delete extension; fflush(stderr); + fflush(stdout); } -- cgit v1.2.3 From 56e7a202b492fa26137b381eea73e4c773df069d Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Tue, 30 Apr 2024 14:50:53 -0400 Subject: VPTree BSM Benchmark --- benchmarks/vldb/vptree_bsm_bench.cpp | 74 ++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 benchmarks/vldb/vptree_bsm_bench.cpp (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/vptree_bsm_bench.cpp b/benchmarks/vldb/vptree_bsm_bench.cpp new file mode 100644 index 0000000..0798ec2 --- /dev/null +++ b/benchmarks/vldb/vptree_bsm_bench.cpp @@ -0,0 +1,74 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include "vptree_bsm.h" +#include "file_util.h" +#include "standard_benchmarks.h" +#include "query/knn.h" + +#include + +#include "psu-util/timer.h" + + +typedef Word2VecRec Rec; + +typedef BSMVPTree Shard; +typedef de::knn::Parms QP; +typedef psudb::bsm::BentleySaxe Ext; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto extension = new Ext(); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + fprintf(stderr, "[I] Reading data file...\n"); + auto data = read_vector_file(d_fname, n); + auto queries = read_knn_queries(q_fname, 1000); + + fprintf(stderr, "[I] Warming up structure...\n"); + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + insert_records(extension, 0, warmup, data); + + TIMER_INIT(); + + fprintf(stderr, "[I] Running Insertion Benchmark\n"); + TIMER_START(); + insert_records(extension, warmup, data.size(), data); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + fprintf(stderr, "[I] Running Query Benchmark\n"); + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + fprintf(stdout, "%ld\t%ld\n", insert_throughput, query_latency); + + gsl_rng_free(rng); + delete extension; + fflush(stderr); + fflush(stdout); +} + -- cgit v1.2.3 From 349cfd5090f586b7ec189b72c00786522199fe34 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Wed, 1 May 2024 16:03:19 -0400 Subject: TS BSM Adjustments --- benchmarks/vldb/ts_bsm_bench.cpp | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/ts_bsm_bench.cpp b/benchmarks/vldb/ts_bsm_bench.cpp index 941e3da..049fd35 100644 --- a/benchmarks/vldb/ts_bsm_bench.cpp +++ b/benchmarks/vldb/ts_bsm_bench.cpp @@ -37,26 +37,37 @@ int main(int argc, char **argv) { std::string q_fname = std::string(argv[3]); auto extension = new psudb::bsm::BentleySaxe(); + auto ghost = new psudb::bsm::BentleySaxe(); gsl_rng *rng = gsl_rng_alloc(gsl_rng_mt19937); auto data = read_sosd_file_pair(d_fname, n); - auto queries = read_range_queries(q_fname, .001); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, .0001); /* warmup structure w/ 10% of records */ size_t warmup = .1 * n; - insert_records(extension, 0, warmup, data); + size_t delete_idx = 0; + insert_records(extension, ghost, 0, warmup, data, to_delete, + delete_idx, rng); TIMER_INIT(); TIMER_START(); - insert_records(extension, warmup, data.size(), data); + insert_records(extension, ghost, warmup, data.size(), data, + to_delete, delete_idx, rng); TIMER_STOP(); auto insert_latency = TIMER_RESULT(); size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); TIMER_START(); - run_queries(extension, queries); + run_queries(extension, ghost, queries); TIMER_STOP(); auto query_latency = TIMER_RESULT() / queries.size(); -- cgit v1.2.3 From ef2ec17c21cb331c37f25501394b009282604fcf Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Wed, 1 May 2024 16:06:20 -0400 Subject: Adjusted selectivity for range benches down to .0001 --- benchmarks/vldb/alex_bench.cpp | 2 +- benchmarks/vldb/btree_bench.cpp | 2 +- benchmarks/vldb/dynamic_pgm_bench.cpp | 2 +- benchmarks/vldb/irs_bench.cpp | 2 +- benchmarks/vldb/pgm_bench.cpp | 2 +- benchmarks/vldb/ts_bench.cpp | 5 +++-- benchmarks/vldb/ts_mdsp_bench.cpp | 2 +- 7 files changed, 9 insertions(+), 8 deletions(-) (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/alex_bench.cpp b/benchmarks/vldb/alex_bench.cpp index 76df410..ba687f3 100644 --- a/benchmarks/vldb/alex_bench.cpp +++ b/benchmarks/vldb/alex_bench.cpp @@ -107,7 +107,7 @@ int main(int argc, char **argv) } } - auto queries = read_range_queries(q_fname, .001); + auto queries = read_range_queries(q_fname, .0001); size_t warmup = .1 * n; diff --git a/benchmarks/vldb/btree_bench.cpp b/benchmarks/vldb/btree_bench.cpp index 6d1be9f..673da33 100644 --- a/benchmarks/vldb/btree_bench.cpp +++ b/benchmarks/vldb/btree_bench.cpp @@ -50,7 +50,7 @@ int main(int argc, char **argv) { } } /* read in the range queries and add sample size and rng for sampling */ - auto queries = read_range_queries(q_fname, .001); + auto queries = read_range_queries(q_fname, .0001); for (auto &q : queries) { q.sample_size = 1000; q.rng = rng; diff --git a/benchmarks/vldb/dynamic_pgm_bench.cpp b/benchmarks/vldb/dynamic_pgm_bench.cpp index 580fa93..15b130f 100644 --- a/benchmarks/vldb/dynamic_pgm_bench.cpp +++ b/benchmarks/vldb/dynamic_pgm_bench.cpp @@ -45,7 +45,7 @@ int main(int argc, char **argv) { to_delete[j++] = i; } } - auto queries = read_range_queries(q_fname, .001); + auto queries = read_range_queries(q_fname, .0001); /* warmup structure w/ 10% of records */ size_t warmup = .1 * n; diff --git a/benchmarks/vldb/irs_bench.cpp b/benchmarks/vldb/irs_bench.cpp index dabe79e..f68de63 100644 --- a/benchmarks/vldb/irs_bench.cpp +++ b/benchmarks/vldb/irs_bench.cpp @@ -49,7 +49,7 @@ int main(int argc, char **argv) { } } /* read in the range queries and add sample size and rng for sampling */ - auto queries = read_range_queries(q_fname, .001); + auto queries = read_range_queries(q_fname, .0001); for (auto &q : queries) { q.sample_size = 1000; q.rng = rng; diff --git a/benchmarks/vldb/pgm_bench.cpp b/benchmarks/vldb/pgm_bench.cpp index 498ef8f..cec95df 100644 --- a/benchmarks/vldb/pgm_bench.cpp +++ b/benchmarks/vldb/pgm_bench.cpp @@ -50,7 +50,7 @@ int main(int argc, char **argv) { to_delete[j++] = i; } } - auto queries = read_range_queries(q_fname, .001); + auto queries = read_range_queries(q_fname, .0001); /* warmup structure w/ 10% of records */ size_t warmup = .1 * n; diff --git a/benchmarks/vldb/ts_bench.cpp b/benchmarks/vldb/ts_bench.cpp index 5a4cc13..81a430a 100644 --- a/benchmarks/vldb/ts_bench.cpp +++ b/benchmarks/vldb/ts_bench.cpp @@ -3,6 +3,7 @@ */ #define ENABLE_TIMER +#define TS_TEST #include @@ -39,7 +40,7 @@ int main(int argc, char **argv) { std::string d_fname = std::string(argv[2]); std::string q_fname = std::string(argv[3]); - auto extension = new Ext(12000, 12001, 8, 0, 64); + auto extension = new Ext(8000, 12001, 8, 0, 64); gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); auto data = read_sosd_file(d_fname, n); @@ -50,7 +51,7 @@ int main(int argc, char **argv) { to_delete[j++] = i; } } - auto queries = read_range_queries(q_fname, .001); + auto queries = read_range_queries(q_fname, .0001); /* warmup structure w/ 10% of records */ size_t warmup = .1 * n; diff --git a/benchmarks/vldb/ts_mdsp_bench.cpp b/benchmarks/vldb/ts_mdsp_bench.cpp index 44c641d..cc0cd99 100644 --- a/benchmarks/vldb/ts_mdsp_bench.cpp +++ b/benchmarks/vldb/ts_mdsp_bench.cpp @@ -40,7 +40,7 @@ int main(int argc, char **argv) { gsl_rng *rng = gsl_rng_alloc(gsl_rng_mt19937); auto data = read_sosd_file_pair(d_fname, n); - auto queries = read_range_queries(q_fname, .001); + auto queries = read_range_queries(q_fname, .0001); /* warmup structure w/ 10% of records */ size_t warmup = .1 * n; -- cgit v1.2.3 From e198d64ca87f6fc05e8d62efdf720f7b2e8a8004 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Fri, 3 May 2024 09:58:13 -0400 Subject: Switched to using framework-BSM mode for Bentley-Saxe benchmarks --- benchmarks/vldb/ts_bsm_bench.cpp | 52 +++++++++++++++++++++++------------- benchmarks/vldb/vptree_bsm_bench.cpp | 46 ++++++++++++++++++++++++------- 2 files changed, 70 insertions(+), 28 deletions(-) (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/ts_bsm_bench.cpp b/benchmarks/vldb/ts_bsm_bench.cpp index 049fd35..4511350 100644 --- a/benchmarks/vldb/ts_bsm_bench.cpp +++ b/benchmarks/vldb/ts_bsm_bench.cpp @@ -3,23 +3,27 @@ */ #define ENABLE_TIMER +#define TS_TEST #include -#include "triespline_bsm.h" -#include "psu-util/bentley-saxe.h" +#include "framework/DynamicExtension.h" +#include "shard/TrieSpline.h" +#include "query/rangecount.h" #include "framework/interface/Record.h" #include "file_util.h" -#include "query/rangecount.h" -#include "psu-util/timer.h" #include "standard_benchmarks.h" -typedef std::pair Rec; -typedef de::Record FRec; +#include -typedef BSMTrieSpline Shard; -typedef de::rc::Parms QP; -typedef psudb::bsm::BentleySaxe Ext; +#include "psu-util/timer.h" + + +typedef de::Record Rec; +typedef de::TrieSpline Shard; +typedef de::rc::Query Q; +typedef de::DynamicExtension Ext; +typedef de::rc::Parms QP; void usage(char *progname) { fprintf(stderr, "%s reccnt datafile queryfile\n", progname); @@ -36,11 +40,10 @@ int main(int argc, char **argv) { std::string d_fname = std::string(argv[2]); std::string q_fname = std::string(argv[3]); - auto extension = new psudb::bsm::BentleySaxe(); - auto ghost = new psudb::bsm::BentleySaxe(); - gsl_rng *rng = gsl_rng_alloc(gsl_rng_mt19937); + auto extension = new Ext(1, 12001, 2, 0, 64); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); - auto data = read_sosd_file_pair(d_fname, n); + auto data = read_sosd_file(d_fname, n); std::vector to_delete(n * delete_proportion); size_t j=0; for (size_t i=0; i(extension, ghost, 0, warmup, data, to_delete, - delete_idx, rng); + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); TIMER_INIT(); TIMER_START(); - insert_records(extension, ghost, warmup, data.size(), data, - to_delete, delete_idx, rng); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); TIMER_STOP(); auto insert_latency = TIMER_RESULT(); size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); TIMER_START(); - run_queries(extension, ghost, queries); + run_queries(extension, queries); TIMER_STOP(); auto query_latency = TIMER_RESULT() / queries.size(); - fprintf(stdout, "%ld\t%ld\n", insert_throughput, query_latency); + auto shard = extension->create_static_structure(); + + TIMER_START(); + run_static_queries(shard, queries); + TIMER_STOP(); + + auto static_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + auto static_size = shard->get_memory_usage(); //+ shard->get_aux_memory_usage(); + + fprintf(stdout, "%ld\t%ld\t%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size, static_latency, static_size); gsl_rng_free(rng); delete extension; diff --git a/benchmarks/vldb/vptree_bsm_bench.cpp b/benchmarks/vldb/vptree_bsm_bench.cpp index 0798ec2..8e6f795 100644 --- a/benchmarks/vldb/vptree_bsm_bench.cpp +++ b/benchmarks/vldb/vptree_bsm_bench.cpp @@ -4,10 +4,12 @@ #define ENABLE_TIMER -#include "vptree_bsm.h" +#include "framework/DynamicExtension.h" +#include "shard/VPTree.h" +#include "query/knn.h" +#include "framework/interface/Record.h" #include "file_util.h" #include "standard_benchmarks.h" -#include "query/knn.h" #include @@ -16,9 +18,10 @@ typedef Word2VecRec Rec; -typedef BSMVPTree Shard; +typedef de::VPTree Shard; +typedef de::knn::Query Q; +typedef de::DynamicExtension Ext; typedef de::knn::Parms QP; -typedef psudb::bsm::BentleySaxe Ext; void usage(char *progname) { fprintf(stderr, "%s reccnt datafile queryfile\n", progname); @@ -35,23 +38,36 @@ int main(int argc, char **argv) { std::string d_fname = std::string(argv[2]); std::string q_fname = std::string(argv[3]); - auto extension = new Ext(); + auto extension = new Ext(1, 1400, 2, 0, 64); gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); fprintf(stderr, "[I] Reading data file...\n"); auto data = read_vector_file(d_fname, n); + + fprintf(stderr, "[I] Generating delete vector\n"); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, 1000); fprintf(stderr, "[I] Warming up structure...\n"); /* warmup structure w/ 10% of records */ size_t warmup = .1 * n; - insert_records(extension, 0, warmup, data); + size_t delete_idx = 0; + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); TIMER_INIT(); fprintf(stderr, "[I] Running Insertion Benchmark\n"); TIMER_START(); - insert_records(extension, warmup, data.size(), data); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); TIMER_STOP(); auto insert_latency = TIMER_RESULT(); @@ -59,12 +75,24 @@ int main(int argc, char **argv) { fprintf(stderr, "[I] Running Query Benchmark\n"); TIMER_START(); - run_queries(extension, queries); + run_queries(extension, queries); TIMER_STOP(); auto query_latency = TIMER_RESULT() / queries.size(); - fprintf(stdout, "%ld\t%ld\n", insert_throughput, query_latency); + auto shard = extension->create_static_structure(); + + fprintf(stderr, "Running Static query tests\n\n"); + TIMER_START(); + run_static_queries(shard, queries); + TIMER_STOP(); + + auto static_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + auto static_size = shard->get_memory_usage(); // + shard->get_aux_memory_usage(); + + fprintf(stdout, "%ld\t%ld\t%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size, static_latency, static_size); gsl_rng_free(rng); delete extension; -- cgit v1.2.3 From 675cf7f7558ebaef15f398d90cc3d1d91457b219 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Fri, 3 May 2024 11:01:47 -0400 Subject: FST benchmarks --- benchmarks/vldb/fst_bench.cpp | 100 ++++++++++++++++++++++++++++++++++++++ benchmarks/vldb/fst_bsm_bench.cpp | 100 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 200 insertions(+) create mode 100644 benchmarks/vldb/fst_bench.cpp create mode 100644 benchmarks/vldb/fst_bsm_bench.cpp (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/fst_bench.cpp b/benchmarks/vldb/fst_bench.cpp new file mode 100644 index 0000000..276a922 --- /dev/null +++ b/benchmarks/vldb/fst_bench.cpp @@ -0,0 +1,100 @@ +/* + * + */ + +#define ENABLE_TIMER +#define TS_TEST + +#include + +#include "framework/DynamicExtension.h" +#include "shard/FSTrie.h" +#include "query/pointlookup.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "standard_benchmarks.h" + +#include + +#include "psu-util/timer.h" + + +typedef de::Record Rec; +typedef de::FSTrie Shard; +typedef de::pl::Query Q; +typedef de::DynamicExtension Ext; +typedef de::pl::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile\n", progname); +} + +int main(int argc, char **argv) { + + if (argc < 3) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + + auto extension = new Ext(12000, 12001, 8, 0, 64); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto strings = read_string_file(d_fname, n); + auto queries = generate_string_lookup_queries(strings, 1000, rng); + + std::vector data; + for (size_t i=0; i to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto shard = extension->create_static_structure(); + + TIMER_START(); + run_static_queries(shard, queries); + TIMER_STOP(); + + auto static_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + auto static_size = shard->get_memory_usage(); //+ shard->get_aux_memory_usage(); + + fprintf(stdout, "%ld\t%ld\t%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size, static_latency, static_size); + + gsl_rng_free(rng); + delete extension; + fflush(stderr); +} + diff --git a/benchmarks/vldb/fst_bsm_bench.cpp b/benchmarks/vldb/fst_bsm_bench.cpp new file mode 100644 index 0000000..15a441a --- /dev/null +++ b/benchmarks/vldb/fst_bsm_bench.cpp @@ -0,0 +1,100 @@ +/* + * + */ + +#define ENABLE_TIMER +#define TS_TEST + +#include + +#include "framework/DynamicExtension.h" +#include "shard/FSTrie.h" +#include "query/pointlookup.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "standard_benchmarks.h" + +#include + +#include "psu-util/timer.h" + + +typedef de::Record Rec; +typedef de::FSTrie Shard; +typedef de::pl::Query Q; +typedef de::DynamicExtension Ext; +typedef de::pl::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile\n", progname); +} + +int main(int argc, char **argv) { + + if (argc < 3) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + + auto extension = new Ext(1, 12001, 2, 0, 64); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto strings = read_string_file(d_fname, n); + auto queries = generate_string_lookup_queries(strings, 1000, rng); + + std::vector data; + for (size_t i=0; i to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto shard = extension->create_static_structure(); + + TIMER_START(); + run_static_queries(shard, queries); + TIMER_STOP(); + + auto static_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + auto static_size = shard->get_memory_usage(); //+ shard->get_aux_memory_usage(); + + fprintf(stdout, "%ld\t%ld\t%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size, static_latency, static_size); + + gsl_rng_free(rng); + delete extension; + fflush(stderr); +} + -- cgit v1.2.3 From 01729c8772f3e25bce18f0b1fbfeee308b4c4d9f Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Wed, 8 May 2024 13:11:32 -0400 Subject: VPTree BSM: Added extra tab to keep numbers from running together --- benchmarks/vldb/vptree_bsm_bench.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/vptree_bsm_bench.cpp b/benchmarks/vldb/vptree_bsm_bench.cpp index 8e6f795..4a7fcb6 100644 --- a/benchmarks/vldb/vptree_bsm_bench.cpp +++ b/benchmarks/vldb/vptree_bsm_bench.cpp @@ -92,7 +92,7 @@ int main(int argc, char **argv) { auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); auto static_size = shard->get_memory_usage(); // + shard->get_aux_memory_usage(); - fprintf(stdout, "%ld\t%ld\t%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size, static_latency, static_size); + fprintf(stdout, "%ld\t%ld\t\t%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size, static_latency, static_size); gsl_rng_free(rng); delete extension; -- cgit v1.2.3 From a23bc3341923509be9b2f587ece8cd5a650f6386 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Wed, 8 May 2024 13:20:44 -0400 Subject: TSParmsweep: enabled forcing a full buffer scan --- benchmarks/vldb/ts_parmsweep.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/ts_parmsweep.cpp b/benchmarks/vldb/ts_parmsweep.cpp index fd71e11..2c9412a 100644 --- a/benchmarks/vldb/ts_parmsweep.cpp +++ b/benchmarks/vldb/ts_parmsweep.cpp @@ -18,7 +18,7 @@ typedef de::Record Rec; typedef de::TrieSpline Shard; -typedef de::rc::Query Q; +typedef de::rc::Query Q; typedef de::DynamicExtension Ext; typedef de::DynamicExtension Ext2; typedef de::rc::Parms QP; -- cgit v1.2.3 From 265610435e1164a9acc39ca02ea1139acd37c46c Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Thu, 9 May 2024 14:10:29 -0400 Subject: Added benchmarks for BigANN --- benchmarks/vldb/btree_bench.cpp | 2 +- benchmarks/vldb/irs_bench.cpp | 2 +- benchmarks/vldb/mtree_bench_alt.cpp | 80 ++++++++++++++++++++++++ benchmarks/vldb/vptree_bench_alt.cpp | 102 +++++++++++++++++++++++++++++++ benchmarks/vldb/vptree_bsm_bench_alt.cpp | 92 ++++++++++++++++++++++++++++ 5 files changed, 276 insertions(+), 2 deletions(-) create mode 100644 benchmarks/vldb/mtree_bench_alt.cpp create mode 100644 benchmarks/vldb/vptree_bench_alt.cpp create mode 100644 benchmarks/vldb/vptree_bsm_bench_alt.cpp (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/btree_bench.cpp b/benchmarks/vldb/btree_bench.cpp index 673da33..fa72831 100644 --- a/benchmarks/vldb/btree_bench.cpp +++ b/benchmarks/vldb/btree_bench.cpp @@ -57,7 +57,7 @@ int main(int argc, char **argv) { } /* warmup structure w/ 10% of records */ - size_t warmup = .3 * n; + size_t warmup = .1 * n; size_t delete_idx = 0; insert_records(&btree, 0, warmup, data, to_delete, delete_idx, false, rng); diff --git a/benchmarks/vldb/irs_bench.cpp b/benchmarks/vldb/irs_bench.cpp index f68de63..e062e80 100644 --- a/benchmarks/vldb/irs_bench.cpp +++ b/benchmarks/vldb/irs_bench.cpp @@ -56,7 +56,7 @@ int main(int argc, char **argv) { } /* warmup structure w/ 10% of records */ - size_t warmup = .3 * n; + size_t warmup = .1 * n; size_t delete_idx = 0; insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); diff --git a/benchmarks/vldb/mtree_bench_alt.cpp b/benchmarks/vldb/mtree_bench_alt.cpp new file mode 100644 index 0000000..6b08df7 --- /dev/null +++ b/benchmarks/vldb/mtree_bench_alt.cpp @@ -0,0 +1,80 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include "query/knn.h" +#include "file_util.h" +#include "standard_benchmarks.h" + +#include + +#include "psu-util/timer.h" + + +typedef ANNRec Rec; +typedef de::knn::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto mtree = new MTree_alt(); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + fprintf(stderr, "[I] Reading data file...\n"); + auto data = read_binary_vector_file(d_fname, n); + + fprintf(stderr, "[I] Generating delete vector\n"); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, 1000, 100); + + fprintf(stderr, "[I] Warming up structure...\n"); + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(mtree, 0, warmup, data, to_delete, delete_idx, false, rng); + + TIMER_INIT(); + + fprintf(stderr, "[I] Running Insertion Benchmark\n"); + TIMER_START(); + insert_records(mtree, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + fprintf(stderr, "[I] Running Query Benchmark\n"); + TIMER_START(); + run_queries(mtree, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + fprintf(stdout, "%ld\t%ld\n", insert_throughput, query_latency); + + gsl_rng_free(rng); + delete mtree; + fflush(stderr); +} + diff --git a/benchmarks/vldb/vptree_bench_alt.cpp b/benchmarks/vldb/vptree_bench_alt.cpp new file mode 100644 index 0000000..b09ee7d --- /dev/null +++ b/benchmarks/vldb/vptree_bench_alt.cpp @@ -0,0 +1,102 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include "framework/DynamicExtension.h" +#include "shard/VPTree.h" +#include "query/knn.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "standard_benchmarks.h" + +#include + +#include "psu-util/timer.h" + + +typedef ANNRec Rec; + +typedef de::VPTree Shard; +typedef de::knn::Query Q; +typedef de::DynamicExtension Ext; +typedef de::knn::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto extension = new Ext(1400, 1400, 8, 0, 64); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + fprintf(stderr, "[I] Reading data file...\n"); + auto data = read_binary_vector_file(d_fname, n); + + fprintf(stderr, "[I] Generating delete vector\n"); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, 1000, 100); + + fprintf(stderr, "[I] Warming up structure...\n"); + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + fprintf(stderr, "[I] Running Insertion Benchmark\n"); + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + fprintf(stderr, "[I] Running Query Benchmark\n"); + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto shard = extension->create_static_structure(); + + fprintf(stderr, "Running Static query tests\n\n"); + TIMER_START(); + run_static_queries(shard, queries); + TIMER_STOP(); + + auto static_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + auto static_size = shard->get_memory_usage(); // + shard->get_aux_memory_usage(); + + fprintf(stdout, "%ld\t%ld\t%ld\t%ld\t%ld\n", insert_throughput, query_latency, ext_size, static_latency, static_size); + + gsl_rng_free(rng); + delete extension; + fflush(stderr); + fflush(stdout); +} + diff --git a/benchmarks/vldb/vptree_bsm_bench_alt.cpp b/benchmarks/vldb/vptree_bsm_bench_alt.cpp new file mode 100644 index 0000000..63baf8b --- /dev/null +++ b/benchmarks/vldb/vptree_bsm_bench_alt.cpp @@ -0,0 +1,92 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include "framework/DynamicExtension.h" +#include "shard/VPTree.h" +#include "query/knn.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include "standard_benchmarks.h" + +#include + +#include "psu-util/timer.h" + + +typedef ANNRec Rec; + +typedef de::VPTree Shard; +typedef de::knn::Query Q; +typedef de::DynamicExtension Ext; +typedef de::knn::Parms QP; + +void usage(char *progname) { + fprintf(stderr, "%s reccnt datafile queryfile\n", progname); +} + +int main(int argc, char **argv) { + + if (argc < 4) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + std::string d_fname = std::string(argv[2]); + std::string q_fname = std::string(argv[3]); + + auto extension = new Ext(1, 1400, 2, 0, 64); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + fprintf(stderr, "[I] Reading data file...\n"); + auto data = read_binary_vector_file(d_fname, n); + + fprintf(stderr, "[I] Generating delete vector\n"); + std::vector to_delete(n * delete_proportion); + size_t j=0; + for (size_t i=0; i(q_fname, 1000, 100); + + fprintf(stderr, "[I] Warming up structure...\n"); + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + size_t delete_idx = 0; + insert_records(extension, 0, warmup, data, to_delete, delete_idx, false, rng); + + extension->await_next_epoch(); + + TIMER_INIT(); + + fprintf(stderr, "[I] Running Insertion Benchmark\n"); + TIMER_START(); + insert_records(extension, warmup, data.size(), data, to_delete, delete_idx, true, rng); + TIMER_STOP(); + + auto insert_latency = TIMER_RESULT(); + size_t insert_throughput = (size_t) ((double) (n - warmup) / (double) insert_latency * 1e9); + + fprintf(stderr, "[I] Running Query Benchmark\n"); + TIMER_START(); + run_queries(extension, queries); + TIMER_STOP(); + + auto query_latency = TIMER_RESULT() / queries.size(); + + auto ext_size = extension->get_memory_usage() + extension->get_aux_memory_usage(); + + fprintf(stdout, "%ld\t%ld\t\t%ld\n", insert_throughput, query_latency, ext_size); + + gsl_rng_free(rng); + delete extension; + fflush(stderr); + fflush(stdout); +} + -- cgit v1.2.3 From ab0ab297959fcca370e80670e17f90a780607a80 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Fri, 10 May 2024 18:35:30 -0400 Subject: MTree structure size --- benchmarks/vldb/mtree_bench.cpp | 4 +++- benchmarks/vldb/mtree_bench_alt.cpp | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/mtree_bench.cpp b/benchmarks/vldb/mtree_bench.cpp index 60425da..cc2f41f 100644 --- a/benchmarks/vldb/mtree_bench.cpp +++ b/benchmarks/vldb/mtree_bench.cpp @@ -71,7 +71,9 @@ int main(int argc, char **argv) { auto query_latency = TIMER_RESULT() / queries.size(); - fprintf(stdout, "%ld\t%ld\n", insert_throughput, query_latency); + auto size = mtree->size() - sizeof(Rec)*(data.size() - to_delete.size()); + + fprintf(stdout, "%ld\t%ld\t%ld\n", insert_throughput, query_latency, size); gsl_rng_free(rng); delete mtree; diff --git a/benchmarks/vldb/mtree_bench_alt.cpp b/benchmarks/vldb/mtree_bench_alt.cpp index 6b08df7..50c6117 100644 --- a/benchmarks/vldb/mtree_bench_alt.cpp +++ b/benchmarks/vldb/mtree_bench_alt.cpp @@ -71,7 +71,9 @@ int main(int argc, char **argv) { auto query_latency = TIMER_RESULT() / queries.size(); - fprintf(stdout, "%ld\t%ld\n", insert_throughput, query_latency); + auto size = mtree->size() - sizeof(Rec)*(data.size() - to_delete.size()); + + fprintf(stdout, "%ld\t%ld\t%ld\n", insert_throughput, query_latency, size); gsl_rng_free(rng); delete mtree; -- cgit v1.2.3 From 096d2e3be15361af90257b69dae4b24f751dcab8 Mon Sep 17 00:00:00 2001 From: Douglas Rumbaugh Date: Tue, 14 May 2024 16:18:16 -0400 Subject: Moved thread scalability bench to vldb folder --- benchmarks/vldb/thread_scaling_bench.cpp | 128 +++++++++++++++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 benchmarks/vldb/thread_scaling_bench.cpp (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/thread_scaling_bench.cpp b/benchmarks/vldb/thread_scaling_bench.cpp new file mode 100644 index 0000000..b679e92 --- /dev/null +++ b/benchmarks/vldb/thread_scaling_bench.cpp @@ -0,0 +1,128 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include + +#include "framework/DynamicExtension.h" +#include "shard/ISAMTree.h" +#include "query/irs.h" +#include "framework/interface/Record.h" +#include "file_util.h" +#include + +#include + +#include "psu-util/timer.h" + + +typedef de::Record Rec; +typedef de::ISAMTree ISAM; +typedef de::irs::Query Q; +typedef de::DynamicExtension Ext; +typedef de::irs::Parms QP; + +std::atomic inserts_done = false; + +struct timespec delay = {0, 500}; + +void query_thread(Ext *extension, std::vector *queries) { + gsl_rng *rng = gsl_rng_alloc(gsl_rng_mt19937); + size_t total = 0; + + while (!inserts_done.load()) { + auto q_idx = gsl_rng_uniform_int(rng, queries->size()); + + auto q = (*queries)[q_idx]; + q.rng = rng; + q.sample_size = 1000; + + auto res = extension->query(&q); + auto r = res.get(); + total += r.size(); + nanosleep(&delay, nullptr); + } + + fprintf(stderr, "%ld\n", total); + + gsl_rng_free(rng); +} + +void insert_thread(Ext *extension, size_t start, size_t stop, std::vector *records) { + fprintf(stderr, "%ld\t%ld\n", start, stop); + for (size_t i=start; iinsert((*records)[i])) { + nanosleep(&delay, nullptr); + } + } +} + +int main(int argc, char **argv) { + + if (argc < 6) { + fprintf(stderr, "Usage:\n"); + fprintf(stderr, "%s reccnt insert_threads query_threads datafile queryfile\n", argv[0]); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + size_t ithread_cnt = atol(argv[2]); + size_t qthread_cnt = atol(argv[3]); + std::string d_fname = std::string(argv[4]); + std::string q_fname = std::string(argv[5]); + + auto extension = new Ext(1000, 12000, 8, 0, 64); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto data = read_sosd_file(d_fname, n); + auto queries = read_range_queries(q_fname, .001); + + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + for (size_t i=0; iinsert(data[i])) { + usleep(1); + } + } + + extension->await_next_epoch(); + + TIMER_INIT(); + + std::vector ithreads(ithread_cnt); + std::vector qthreads(qthread_cnt); + + TIMER_START(); + size_t start = warmup; + size_t per_thread = (n - warmup) / ithread_cnt; + for (size_t i=0; i Date: Tue, 14 May 2024 16:27:42 -0400 Subject: Added btree thread scaling benchmark --- benchmarks/vldb/btree_thread_scaling_bench.cpp | 120 +++++++++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 benchmarks/vldb/btree_thread_scaling_bench.cpp (limited to 'benchmarks/vldb') diff --git a/benchmarks/vldb/btree_thread_scaling_bench.cpp b/benchmarks/vldb/btree_thread_scaling_bench.cpp new file mode 100644 index 0000000..557e966 --- /dev/null +++ b/benchmarks/vldb/btree_thread_scaling_bench.cpp @@ -0,0 +1,120 @@ +/* + * + */ + +#define ENABLE_TIMER + +#include + +#include "query/irs.h" +#include "benchmark_types.h" +#include "file_util.h" +#include + +#include + +#include "psu-util/timer.h" + + +typedef btree_record Rec; +typedef de::irs::Parms QP; + +std::atomic inserts_done = false; + +std::mutex g_btree_lock; + +void query_thread(BenchBTree *tree, std::vector *queries) { + gsl_rng *rng = gsl_rng_alloc(gsl_rng_mt19937); + size_t total = 0; + + while (!inserts_done.load()) { + auto q_idx = gsl_rng_uniform_int(rng, queries->size()); + + auto q = (*queries)[q_idx]; + + std::vector result; + g_btree_lock.lock(); + tree->range_sample(q.lower_bound, q.upper_bound, 1000, result, rng); + g_btree_lock.unlock(); + + total += result.size(); + usleep(1); + } + + fprintf(stderr, "%ld\n", total); + + gsl_rng_free(rng); +} + +void insert_thread(BenchBTree *tree, size_t start, std::vector *records) { + size_t reccnt = 0; + for (size_t i=start; isize(); i++) { + btree_record r; + r.key = (*records)[i].key; + r.value = i; + + g_btree_lock.lock(); + tree->insert(r); + g_btree_lock.unlock(); + + if (i % 100000 == 0) { + fprintf(stderr, "Inserted %ld records\n", i); + } + } + + inserts_done.store(true); +} + +int main(int argc, char **argv) { + + if (argc < 5) { + fprintf(stderr, "btree_insert_query_tput reccnt query_threads datafile queryfile\n"); + exit(EXIT_FAILURE); + } + + size_t n = atol(argv[1]); + size_t qthread_cnt = atol(argv[2]); + std::string d_fname = std::string(argv[3]); + std::string q_fname = std::string(argv[4]); + + auto tree = new BenchBTree(); + gsl_rng * rng = gsl_rng_alloc(gsl_rng_mt19937); + + auto data = read_sosd_file(d_fname, n); + auto queries = read_range_queries(q_fname, .001); + + /* warmup structure w/ 10% of records */ + size_t warmup = .1 * n; + for (size_t i=0; i r; + r.key = data[i].key; + r.value = data[i].value; + + tree->insert(r); + } + + TIMER_INIT(); + + std::vector qthreads(qthread_cnt); + + TIMER_START(); + std::thread i_thrd(insert_thread, tree, warmup, &data); + for (size_t i=0; i