RUST-611 direct copy of benchmarks from unreviewed-impl

Author: benjirewis

benchmarks/.gitignore

@@ -0,0 +1,3 @@
+/target
+**/*.rs.bk
+/data

benchmarks/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "rust-driver-bench"
+version = "0.1.0"
+authors = ["benjirewis <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+mongodb = { path = ".." }
+bson = "0.13.0"
+serde_json = "1.0.39"
+lazy_static = "1.3.0"
+num_cpus = "1.10.1"
+clap = "2.33.0"
+indicatif = "0.11.0"

benchmarks/README.md

@@ -0,0 +1,40 @@
+# Rust Driver Benchmark Suite
+
+This suite implements the benchmarks described in this (spec)[https://github.com/mongodb/specifications/blob/master/source/benchmarking/benchmarking.rst].
+
+In order to run the microbenchmarks, first run `../etc/microbenchmark-test-data.sh` to download the data.
+
+Note: make sure you run the download script and the microbenchmarks binary from the benchmark root (the directory containing this README).
+
+To execute all benchmarks, run `cargo run --release` with a mongod instance running on port 27017 (or, you can specify a custom
+connection string by setting the `MONGODB_URI` environment variable). You can specify a custom name for the used database or
+collection by setting the `DATABASE_NAME` or `COLL_NAME` environment variables respectively.
+
+Additionally, you can specify custom time frames for the benchmarks by setting the `MAX_EXECUTION_TIME`, `MIN_EXECUTION_TIME`
+and `MAX_ITERATIONS` environment variables.
+
+Run `cargo run --release -- --help` to see a full list of testing options.
+
+When running the benchmarks with the `--ids` flag, you can refer to each benchmark by their unique id. You can refer to multiple 
+benchmarks by separating each benchmark's id with a comma. For example `cargo run --release -- --ids 1,2,3,4` would run all 
+the single-doc benchmarks. By default, all benchmarks are executed. The table below lists each benchmark's id.
+
+| Benchmark                      | ID |
+|--------------------------------|----|
+| Run command                    | 1  |
+| Find one by ID                 | 2  |
+| Small doc insertOne            | 3  |
+| Large doc insertOne            | 4  |
+| Find many and empty the cursor | 5  |
+| Small doc bulk insert          | 6  |
+| Large doc bulk insert          | 7  |
+| LDJSON multi-file import       | 8  |
+| LDJSON multi-file export       | 9  |
+| All benchmarks                 | all|
+
+Note that in order to compare against the other drivers, an inMemory mongod instance should be used.
+
+At this point, BSON and GridFS benchmarks are not implemented because we do not own the Rust BSON library, and GridFS has not been implemented
+in the driver.
+
+Also note that the parallel benchmarks are implemented to mirror the C++ driver's interpretation of the spec.

benchmarks/rustfmt.toml

@@ -0,0 +1 @@
+../rustfmt.toml

benchmarks/src/bench/find_many.rs

@@ -0,0 +1,61 @@
+use std::{fs::File, path::PathBuf};
+
+use bson::Bson;
+use mongodb::{Client, Collection, Database};
+use serde_json::Value;
+
+use crate::{
+    bench::{Benchmark, COLL_NAME, DATABASE_NAME},
+    error::{Error, Result},
+};
+
+pub struct FindManyBenchmark {
+    db: Database,
+    coll: Collection,
+}
+
+// Specifies the options to `FindManyBenchmark::setup` operation.
+pub struct Options {
+    pub num_iter: usize,
+    pub path: PathBuf,
+    pub uri: String,
+}
+
+impl Benchmark for FindManyBenchmark {
+    type Options = Options;
+
+    fn setup(options: Self::Options) -> Result<Self> {
+        let client = Client::with_uri_str(&options.uri)?;
+        let db = client.database(&DATABASE_NAME);
+        db.drop()?;
+
+        let mut file = File::open(options.path)?;
+
+        let json: Value = serde_json::from_reader(&mut file)?;
+        let doc = match json.into() {
+            Bson::Document(doc) => doc,
+            _ => return Err(Error::UnexpectedJson("invalid json test file".to_string())),
+        };
+
+        let coll = db.collection(&COLL_NAME);
+        let docs = vec![doc.clone(); options.num_iter];
+        coll.insert_many(docs, None)?;
+
+        Ok(FindManyBenchmark { db, coll })
+    }
+
+    fn do_task(&self) -> Result<()> {
+        let cursor = self.coll.find(None, None)?;
+        for doc in cursor {
+            doc?;
+        }
+
+        Ok(())
+    }
+
+    fn teardown(&self) -> Result<()> {
+        self.db.drop()?;
+
+        Ok(())
+    }
+}

benchmarks/src/bench/find_one.rs

@@ -0,0 +1,71 @@
+use std::{fs::File, path::PathBuf};
+
+use bson::Bson;
+use mongodb::{options::FindOptions, Client, Collection, Database};
+use serde_json::Value;
+
+use crate::{
+    bench::{Benchmark, COLL_NAME, DATABASE_NAME},
+    error::{Error, Result},
+};
+
+pub struct FindOneBenchmark {
+    db: Database,
+    num_iter: usize,
+    coll: Collection,
+}
+
+// Specifies the options to a `FindOneBenchmark::setup` operation.
+pub struct Options {
+    pub num_iter: usize,
+    pub path: PathBuf,
+    pub uri: String,
+}
+
+impl Benchmark for FindOneBenchmark {
+    type Options = Options;
+
+    fn setup(options: Self::Options) -> Result<Self> {
+        let client = Client::with_uri_str(&options.uri)?;
+        let db = client.database(&DATABASE_NAME);
+        db.drop()?;
+
+        let mut file = File::open(options.path)?;
+
+        let json: Value = serde_json::from_reader(&mut file)?;
+        let mut doc = match json.into() {
+            Bson::Document(doc) => doc,
+            _ => return Err(Error::UnexpectedJson("invalid json test file".to_string())),
+        };
+
+        let coll = db.collection(&COLL_NAME);
+        for i in 0..options.num_iter {
+            doc.insert("_id", i as i32);
+            coll.insert_one(doc.clone(), None)?;
+        }
+
+        Ok(FindOneBenchmark {
+            db,
+            num_iter: options.num_iter,
+            coll,
+        })
+    }
+
+    fn do_task(&self) -> Result<()> {
+        let find_options = FindOptions::builder().limit(Some(1)).build();
+        for i in 0..self.num_iter {
+            let mut cursor = self
+                .coll
+                .find(Some(doc! { "_id": i as i32 }), Some(find_options.clone()))?;
+            let _doc = cursor.next();
+        }
+
+        Ok(())
+    }
+
+    fn teardown(&self) -> Result<()> {
+        self.db.drop()?;
+
+        Ok(())
+    }
+}

benchmarks/src/bench/insert_many.rs

@@ -0,0 +1,70 @@
+use std::{fs::File, path::PathBuf};
+
+use bson::{Bson, Document};
+use mongodb::{Client, Collection, Database};
+use serde_json::Value;
+
+use crate::{
+    bench::{Benchmark, COLL_NAME, DATABASE_NAME},
+    error::{Error, Result},
+};
+
+pub struct InsertManyBenchmark {
+    db: Database,
+    num_copies: usize,
+    coll: Collection,
+    doc: Document,
+}
+
+// Specifies the options to a `InsertManyBenchmark::setup` operation.
+pub struct Options {
+    pub num_copies: usize,
+    pub path: PathBuf,
+    pub uri: String,
+}
+
+impl Benchmark for InsertManyBenchmark {
+    type Options = Options;
+
+    fn setup(options: Self::Options) -> Result<Self> {
+        let client = Client::with_uri_str(&options.uri)?;
+        let db = client.database(&DATABASE_NAME);
+        db.drop()?;
+
+        let mut file = File::open(options.path)?;
+
+        let json: Value = serde_json::from_reader(&mut file)?;
+
+        let coll = db.collection(&COLL_NAME);
+
+        Ok(InsertManyBenchmark {
+            db,
+            num_copies: options.num_copies,
+            coll,
+            doc: match json.into() {
+                Bson::Document(doc) => doc,
+                _ => return Err(Error::UnexpectedJson("invalid json test file".to_string())),
+            },
+        })
+    }
+
+    fn before_task(&mut self) -> Result<()> {
+        self.coll.drop()?;
+        self.db.create_collection(&COLL_NAME, None)?;
+
+        Ok(())
+    }
+
+    fn do_task(&self) -> Result<()> {
+        let insertions = vec![self.doc.clone(); self.num_copies];
+        self.coll.insert_many(insertions, None)?;
+
+        Ok(())
+    }
+
+    fn teardown(&self) -> Result<()> {
+        self.db.drop()?;
+
+        Ok(())
+    }
+}

benchmarks/src/bench/insert_one.rs

@@ -0,0 +1,71 @@
+use std::{fs::File, path::PathBuf};
+
+use bson::{Bson, Document};
+use mongodb::{Client, Collection, Database};
+use serde_json::Value;
+
+use crate::{
+    bench::{Benchmark, COLL_NAME, DATABASE_NAME},
+    error::{Error, Result},
+};
+
+pub struct InsertOneBenchmark {
+    db: Database,
+    num_iter: usize,
+    coll: Collection,
+    doc: Document,
+}
+
+// Specifies the options to a `InsertOneBenchmark::setup` operation.
+pub struct Options {
+    pub num_iter: usize,
+    pub path: PathBuf,
+    pub uri: String,
+}
+
+impl Benchmark for InsertOneBenchmark {
+    type Options = Options;
+
+    fn setup(options: Self::Options) -> Result<Self> {
+        let client = Client::with_uri_str(&options.uri)?;
+        let db = client.database(&DATABASE_NAME);
+        db.drop()?;
+
+        let mut file = File::open(options.path)?;
+
+        let json: Value = serde_json::from_reader(&mut file)?;
+
+        let coll = db.collection(&COLL_NAME);
+
+        Ok(InsertOneBenchmark {
+            db,
+            num_iter: options.num_iter,
+            coll,
+            doc: match json.into() {
+                Bson::Document(doc) => doc,
+                _ => return Err(Error::UnexpectedJson("invalid json test file".to_string())),
+            },
+        })
+    }
+
+    fn before_task(&mut self) -> Result<()> {
+        self.coll.drop()?;
+        self.db.create_collection(&COLL_NAME, None)?;
+
+        Ok(())
+    }
+
+    fn do_task(&self) -> Result<()> {
+        for _ in 0..self.num_iter {
+            self.coll.insert_one(self.doc.clone(), None)?;
+        }
+
+        Ok(())
+    }
+
+    fn teardown(&self) -> Result<()> {
+        self.db.drop()?;
+
+        Ok(())
+    }
+}