summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorgabor@google.com <gabor@google.com@62dab493-f737-651d-591e-8d6aee1b9529>2011-07-27 01:46:25 +0000
committergabor@google.com <gabor@google.com@62dab493-f737-651d-591e-8d6aee1b9529>2011-07-27 01:46:25 +0000
commitf122c6dfbb4afacd0ac39f95106da81f8a714e72 (patch)
tree330b6d7f4d0c90541a67394d098bf19ff45fd967
parent60bd8015f21fdb63d5409b1191f8ea9d8f1a1b87 (diff)
downloadleveldb-f122c6dfbb4afacd0ac39f95106da81f8a714e72.tar.gz
Adding FreeBSD support, removing Chromium files, adding benchmark.
- LevelDB patch for FreeBSD. This resolves Issue 22. Contributed by dforsythe (thanks!). - Removing Chromium-specific files. They are now going to live in the Chromium repository. - Adding a benchmark page comparing LevelDB performance to SQLite and Kyoto Cabinet's TreeDB, along with code to generate the benchmarks. Thanks to Kevin Tseng for compiling the benchmarks, and Scott Hess and Mikio Hirabayashi for their help and advice. git-svn-id: https://leveldb.googlecode.com/svn/trunk@40 62dab493-f737-651d-591e-8d6aee1b9529
Diffstat
-rw-r--r--Makefile9
-rw-r--r--build_detect_platform5
-rw-r--r--doc/bench/db_bench_sqlite3.cc682
-rw-r--r--doc/bench/db_bench_tree_db.cc506
-rw-r--r--doc/benchmark.html466
-rw-r--r--leveldb.gyp325
-rw-r--r--port/port_chromium.cc84
-rw-r--r--port/port_chromium.h99
-rw-r--r--port/port_posix.h6
-rw-r--r--util/env_chromium.cc564
10 files changed, 1670 insertions, 1076 deletions
diff --git a/Makefile b/Makefile
index ca0dabc..d198d9d 100644
--- a/Makefile
+++ b/Makefile
@@ -97,6 +97,7 @@ TESTS = \
write_batch_test
PROGRAMS = db_bench $(TESTS)
+BENCHMARKS = db_bench_sqlite3 db_bench_tree_db
LIBRARY = libleveldb.a
@@ -106,7 +107,7 @@ check: $(PROGRAMS) $(TESTS)
for t in $(TESTS); do echo "***** Running $$t"; ./$$t || exit 1; done
clean:
- -rm -f $(PROGRAMS) $(LIBRARY) */*.o ios-x86/*/*.o ios-arm/*/*.o
+ -rm -f $(PROGRAMS) $(BENCHMARKS) $(LIBRARY) */*.o */*/*.o ios-x86/*/*.o ios-arm/*/*.o
-rm -rf ios-x86/* ios-arm/*
-rm build_config.mk
@@ -117,6 +118,12 @@ $(LIBRARY): $(LIBOBJECTS)
db_bench: db/db_bench.o $(LIBOBJECTS) $(TESTUTIL)
$(CC) $(LDFLAGS) db/db_bench.o $(LIBOBJECTS) $(TESTUTIL) -o $@
+db_bench_sqlite3: doc/bench/db_bench_sqlite3.o $(LIBOBJECTS) $(TESTUTIL)
+ $(CC) $(LDFLAGS) -lsqlite3 doc/bench/db_bench_sqlite3.o $(LIBOBJECTS) $(TESTUTIL) -o $@
+
+db_bench_tree_db: doc/bench/db_bench_tree_db.o $(LIBOBJECTS) $(TESTUTIL)
+ $(CC) $(LDFLAGS) -lkyotocabinet doc/bench/db_bench_tree_db.o $(LIBOBJECTS) $(TESTUTIL) -o $@
+
arena_test: util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS)
$(CC) $(LDFLAGS) util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
diff --git a/build_detect_platform b/build_detect_platform
index bb108f7..d1804e0 100644
--- a/build_detect_platform
+++ b/build_detect_platform
@@ -30,6 +30,11 @@ case `uname -s` in
echo "PLATFORM_CFLAGS=-D_REENTRANT -DOS_SOLARIS" >> build_config.mk
echo "PLATFORM_LDFLAGS=-lpthread -lrt" >> build_config.mk
;;
+ FreeBSD)
+ PLATFORM=OS_FREEBSD
+ echo "PLATFORM_CFLAGS=-D_REENTRANT -DOS_FREEBSD" >> build_config.mk
+ echo "PLATFORM_LDFLAGS=-lpthread" >> build_config.mk
+ ;;
*)
echo "Unknown platform!"
exit 1
diff --git a/doc/bench/db_bench_sqlite3.cc b/doc/bench/db_bench_sqlite3.cc
new file mode 100644
index 0000000..a6f9a75
--- /dev/null
+++ b/doc/bench/db_bench_sqlite3.cc
@@ -0,0 +1,682 @@
+// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file. See the AUTHORS file for names of contributors.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sqlite3.h>
+#include "util/histogram.h"
+#include "util/random.h"
+#include "util/testutil.h"
+
+// Comma-separated list of operations to run in the specified order
+// Actual benchmarks:
+//
+// fillseq -- write N values in sequential key order in async mode
+// fillseqsync -- write N/100 values in sequential key order in sync mode
+// fillseqbatch -- batch write N values in sequential key order in async mode
+// fillrandom -- write N values in random key order in async mode
+// fillrandsync -- write N/100 values in random key order in sync mode
+// fillrandbatch -- batch write N values in sequential key order in async mode
+// overwrite -- overwrite N values in random key order in async mode
+// fillrand100K -- write N/1000 100K values in random order in async mode
+// fillseq100K -- write N/1000 100K values in sequential order in async mode
+// readseq -- read N times sequentially
+// readrandom -- read N times in random order
+// readseq100K -- read N/1000 100K values in sequential order in async mode
+// readrand100K -- read N/1000 100K values in sequential order in async mode
+static const char* FLAGS_benchmarks =
+ "fillseq,"
+ "fillseqsync,"
+ "fillseqbatch,"
+ "fillrandom,"
+ "fillrandsync,"
+ "fillrandbatch,"
+ "overwrite,"
+ "overwritebatch,"
+ "readrandom,"
+ "readseq,"
+ "fillrand100K,"
+ "fillseq100K,"
+ "readseq100K,"
+ "readrand100K,"
+ ;
+
+// Number of key/values to place in database
+static int FLAGS_num = 1000000;
+
+// Number of read operations to do. If negative, do FLAGS_num reads.
+static int FLAGS_reads = -1;
+
+// Size of each value
+static int FLAGS_value_size = 100;
+
+// Print histogram of operation timings
+static bool FLAGS_histogram = false;
+
+// Arrange to generate values that shrink to this fraction of
+// their original size after compression
+static double FLAGS_compression_ratio = 0.5;
+
+// Page size. Default 1 KB.
+static int FLAGS_page_size = 1024;
+
+// Number of pages.
+// Default cache size = FLAGS_page_size * FLAGS_num_pages = 4 MB.
+static int FLAGS_num_pages = 4096;
+
+// If true, do not destroy the existing database. If you set this
+// flag and also specify a benchmark that wants a fresh database, that
+// benchmark will fail.
+static bool FLAGS_use_existing_db = false;
+
+// If true, we allow batch writes to occur
+static bool FLAGS_transaction = true;
+
+// If true, we enable Write-Ahead Logging
+static bool FLAGS_WAL_enabled = false;
+
+inline
+static void ExecErrorCheck(int status, char *err_msg) {
+ if (status != SQLITE_OK) {
+ fprintf(stderr, "SQL error: %s\n", err_msg);
+ sqlite3_free(err_msg);
+ exit(1);
+ }
+}
+
+inline
+static void StepErrorCheck(int status) {
+ if (status != SQLITE_DONE) {
+ fprintf(stderr, "SQL step error: status = %d\n", status);
+ exit(1);
+ }
+}
+
+inline
+static void ErrorCheck(int status) {
+ if (status != SQLITE_OK) {
+ fprintf(stderr, "sqlite3 error: status = %d\n", status);
+ exit(1);
+ }
+}
+
+inline
+static void WalCheckpoint(sqlite3* db_) {
+ // Flush all writes to disk
+ if (FLAGS_WAL_enabled) {
+ sqlite3_wal_checkpoint_v2(db_, NULL, SQLITE_CHECKPOINT_FULL, NULL, NULL);
+ }
+}
+
+namespace leveldb {
+
+// Helper for quickly generating random data.
+namespace {
+class RandomGenerator {
+ private:
+ std::string data_;
+ int pos_;
+
+ public:
+ RandomGenerator() {
+ // We use a limited amount of data over and over again and ensure
+ // that it is larger than the compression window (32KB), and also
+ // large enough to serve all typical value sizes we want to write.
+ Random rnd(301);
+ std::string piece;
+ while (data_.size() < 1048576) {
+ // Add a short fragment that is as compressible as specified
+ // by FLAGS_compression_ratio.
+ test::CompressibleString(&rnd, FLAGS_compression_ratio, 100, &piece);
+ data_.append(piece);
+ }
+ pos_ = 0;
+ }
+
+ Slice Generate(int len) {
+ if (pos_ + len > data_.size()) {
+ pos_ = 0;
+ assert(len < data_.size());
+ }
+ pos_ += len;
+ return Slice(data_.data() + pos_ - len, len);
+ }
+};
+
+static Slice TrimSpace(Slice s) {
+ int start = 0;
+ while (start < s.size() && isspace(s[start])) {
+ start++;
+ }
+ int limit = s.size();
+ while (limit > start && isspace(s[limit-1])) {
+ limit--;
+ }
+ return Slice(s.data() + start, limit - start);
+}
+
+}
+
+class Benchmark {
+ private:
+ sqlite3* db_;
+ int db_num_;
+ int num_;
+ int reads_;
+ double start_;
+ double last_op_finish_;
+ int64_t bytes_;
+ std::string message_;
+ Histogram hist_;
+ RandomGenerator gen_;
+ Random rand_;
+
+ // State kept for progress messages
+ int done_;
+ int next_report_; // When to report next
+
+ void PrintHeader() {
+ const int kKeySize = 16;
+ PrintEnvironment();
+ fprintf(stdout, "Keys: %d bytes each\n", kKeySize);
+ fprintf(stdout, "Values: %d bytes each\n", FLAGS_value_size);
+ fprintf(stdout, "Entries: %d\n", num_);
+ fprintf(stdout, "RawSize: %.1f MB (estimated)\n",
+ ((static_cast<int64_t>(kKeySize + FLAGS_value_size) * num_)
+ / 1048576.0));
+ PrintWarnings();
+ fprintf(stdout, "------------------------------------------------\n");
+ }
+
+ void PrintWarnings() {
+#if defined(__GNUC__) && !defined(__OPTIMIZE__)
+ fprintf(stdout,
+ "WARNING: Optimization is disabled: benchmarks unnecessarily slow\n"
+ );
+#endif
+#ifndef NDEBUG
+ fprintf(stdout,
+ "WARNING: Assertions are enabled; benchmarks unnecessarily slow\n");
+#endif
+ }
+
+ void PrintEnvironment() {
+ fprintf(stderr, "SQLite: version %s\n", SQLITE_VERSION);
+
+#if defined(__linux)
+ time_t now = time(NULL);
+ fprintf(stderr, "Date: %s", ctime(&now)); // ctime() adds newline
+
+ FILE* cpuinfo = fopen("/proc/cpuinfo", "r");
+ if (cpuinfo != NULL) {
+ char line[1000];
+ int num_cpus = 0;
+ std::string cpu_type;
+ std::string cache_size;
+ while (fgets(line, sizeof(line), cpuinfo) != NULL) {
+ const char* sep = strchr(line, ':');
+ if (sep == NULL) {
+ continue;
+ }
+ Slice key = TrimSpace(Slice(line, sep - 1 - line));
+ Slice val = TrimSpace(Slice(sep + 1));
+ if (key == "model name") {
+ ++num_cpus;
+ cpu_type = val.ToString();
+ } else if (key == "cache size") {
+ cache_size = val.ToString();
+ }
+ }
+ fclose(cpuinfo);
+ fprintf(stderr, "CPU: %d * %s\n", num_cpus, cpu_type.c_str());
+ fprintf(stderr, "CPUCache: %s\n", cache_size.c_str());
+ }
+#endif
+ }
+
+ void Start() {
+ start_ = Env::Default()->NowMicros() * 1e-6;
+ bytes_ = 0;
+ message_.clear();
+ last_op_finish_ = start_;
+ hist_.Clear();
+ done_ = 0;
+ next_report_ = 100;
+ }
+
+ void FinishedSingleOp() {
+ if (FLAGS_histogram) {
+ double now = Env::Default()->NowMicros() * 1e-6;
+ double micros = (now - last_op_finish_) * 1e6;
+ hist_.Add(micros);
+ if (micros > 20000) {
+ fprintf(stderr, "long op: %.1f micros%30s\r", micros, "");
+ fflush(stderr);
+ }
+ last_op_finish_ = now;
+ }
+
+ done_++;
+ if (done_ >= next_report_) {
+ if (next_report_ < 1000) next_report_ += 100;
+ else if (next_report_ < 5000) next_report_ += 500;
+ else if (next_report_ < 10000) next_report_ += 1000;
+ else if (next_report_ < 50000) next_report_ += 5000;
+ else if (next_report_ < 100000) next_report_ += 10000;
+ else if (next_report_ < 500000) next_report_ += 50000;
+ else next_report_ += 100000;
+ fprintf(stderr, "... finished %d ops%30s\r", done_, "");
+ fflush(stderr);
+ }
+ }
+
+ void Stop(const Slice& name) {
+ double finish = Env::Default()->NowMicros() * 1e-6;
+
+ // Pretend at least one op was done in case we are running a benchmark
+ // that does not call FinishedSingleOp().
+ if (done_ < 1) done_ = 1;
+
+ if (bytes_ > 0) {
+ char rate[100];
+ snprintf(rate, sizeof(rate), "%6.1f MB/s",
+ (bytes_ / 1048576.0) / (finish - start_));
+ if (!message_.empty()) {
+ message_ = std::string(rate) + " " + message_;
+ } else {
+ message_ = rate;
+ }
+ }
+
+ fprintf(stdout, "%-12s : %11.3f micros/op;%s%s\n",
+ name.ToString().c_str(),
+ (finish - start_) * 1e6 / done_,
+ (message_.empty() ? "" : " "),
+ message_.c_str());
+ if (FLAGS_histogram) {
+ fprintf(stdout, "Microseconds per op:\n%s\n", hist_.ToString().c_str());
+ }
+ fflush(stdout);
+ }
+
+ public:
+ enum Order {
+ SEQUENTIAL,
+ RANDOM
+ };
+ enum DBState {
+ FRESH,
+ EXISTING
+ };
+
+ Benchmark()
+ : db_(NULL),
+ db_num_(0),
+ num_(FLAGS_num),
+ reads_(FLAGS_reads < 0 ? FLAGS_num : FLAGS_reads),
+ bytes_(0),
+ rand_(301) {
+ std::vector<std::string> files;
+ Env::Default()->GetChildren("/tmp", &files);
+ if (!FLAGS_use_existing_db) {
+ for (int i = 0; i < files.size(); i++) {
+ if (Slice(files[i]).starts_with("dbbench_sqlite3")) {
+ Env::Default()->DeleteFile("/tmp/" + files[i]);
+ }
+ }
+ }
+ }
+
+ ~Benchmark() {
+ int status = sqlite3_close(db_);
+ ErrorCheck(status);
+ }
+
+ void Run() {
+ PrintHeader();
+ Open();
+
+ const char* benchmarks = FLAGS_benchmarks;
+ while (benchmarks != NULL) {
+ const char* sep = strchr(benchmarks, ',');
+ Slice name;
+ if (sep == NULL) {
+ name = benchmarks;
+ benchmarks = NULL;
+ } else {
+ name = Slice(benchmarks, sep - benchmarks);
+ benchmarks = sep + 1;
+ }
+
+ bytes_ = 0;
+ Start();
+
+ bool known = true;
+ bool write_sync = false;
+ if (name == Slice("fillseq")) {
+ Write(write_sync, SEQUENTIAL, FRESH, num_, FLAGS_value_size, 1);
+ WalCheckpoint(db_);
+ } else if (name == Slice("fillseqbatch")) {
+ Write(write_sync, SEQUENTIAL, FRESH, num_, FLAGS_value_size, 1000);
+ WalCheckpoint(db_);
+ } else if (name == Slice("fillrandom")) {
+ Write(write_sync, RANDOM, FRESH, num_, FLAGS_value_size, 1);
+ WalCheckpoint(db_);
+ } else if (name == Slice("fillrandbatch")) {
+ Write(write_sync, RANDOM, FRESH, num_, FLAGS_value_size, 1000);
+ WalCheckpoint(db_);
+ } else if (name == Slice("overwrite")) {
+ Write(write_sync, RANDOM, EXISTING, num_, FLAGS_value_size, 1);
+ WalCheckpoint(db_);
+ } else if (name == Slice("overwritebatch")) {
+ Write(write_sync, RANDOM, EXISTING, num_, FLAGS_value_size, 1000);
+ WalCheckpoint(db_);
+ } else if (name == Slice("fillrandsync")) {
+ write_sync = true;
+ Write(write_sync, RANDOM, FRESH, num_ / 100, FLAGS_value_size, 1);
+ WalCheckpoint(db_);
+ } else if (name == Slice("fillseqsync")) {
+ write_sync = true;
+ Write(write_sync, SEQUENTIAL, FRESH, num_ / 100, FLAGS_value_size, 1);
+ WalCheckpoint(db_);
+ } else if (name == Slice("fillrand100K")) {
+ Write(write_sync, RANDOM, FRESH, num_ / 1000, 100 * 1000, 1);
+ WalCheckpoint(db_);
+ } else if (name == Slice("fillseq100K")) {
+ Write(write_sync, SEQUENTIAL, FRESH, num_ / 1000, 100 * 1000, 1);
+ WalCheckpoint(db_);
+ } else if (name == Slice("readseq")) {
+ Read(SEQUENTIAL, 1);
+ } else if (name == Slice("readrandom")) {
+ Read(RANDOM, 1);
+ } else if (name == Slice("readrand100K")) {
+ int n = reads_;
+ reads_ /= 1000;
+ Read(RANDOM, 1);
+ reads_ = n;
+ } else if (name == Slice("readseq100K")) {
+ int n = reads_;
+ reads_ /= 1000;
+ Read(SEQUENTIAL, 1);
+ reads_ = n;
+ } else {
+ known = false;
+ if (name != Slice()) { // No error message for empty name
+ fprintf(stderr, "unknown benchmark '%s'\n", name.ToString().c_str());
+ }
+ }
+ if (known) {
+ Stop(name);
+ }
+ }
+ }
+
+ void Open() {
+ assert(db_ == NULL);
+
+ int status;
+ char file_name[100];
+ char* err_msg = NULL;
+ db_num_++;
+
+ // Open database
+ snprintf(file_name, sizeof(file_name), "/tmp/dbbench_sqlite3-%d.db",
+ db_num_);
+ status = sqlite3_open(file_name, &db_);
+ if (status) {
+ fprintf(stderr, "open error: %s\n", sqlite3_errmsg(db_));
+ exit(1);
+ }
+
+ // Change SQLite cache size
+ char cache_size[100];
+ snprintf(cache_size, sizeof(cache_size), "PRAGMA cache_size = %d",
+ FLAGS_num_pages);
+ status = sqlite3_exec(db_, cache_size, NULL, NULL, &err_msg);
+ ExecErrorCheck(status, err_msg);
+
+ // FLAGS_page_size is defaulted to 1024
+ if (FLAGS_page_size != 1024) {
+ char page_size[100];
+ snprintf(page_size, sizeof(page_size), "PRAGMA page_size = %d",
+ FLAGS_page_size);
+ status = sqlite3_exec(db_, page_size, NULL, NULL, &err_msg);
+ ExecErrorCheck(status, err_msg);
+ }
+
+ // Change journal mode to WAL if WAL enabled flag is on
+ if (FLAGS_WAL_enabled) {
+ std::string WAL_stmt = "PRAGMA journal_mode = WAL";
+ status = sqlite3_exec(db_, WAL_stmt.c_str(), NULL, NULL, &err_msg);
+ ExecErrorCheck(status, err_msg);
+ }
+
+ // Change locking mode to exclusive and create tables/index for database
+ std::string locking_stmt = "PRAGMA locking_mode = EXCLUSIVE";
+ std::string create_stmt =
+ "CREATE TABLE test (key blob, value blob, PRIMARY KEY(key))";
+ std::string index_stmt = "CREATE INDEX keyindex ON test (key)";
+ std::string stmt_array[] = { locking_stmt, create_stmt, index_stmt };
+ int stmt_array_length = sizeof(stmt_array) / sizeof(std::string);
+ for (int i = 0; i < stmt_array_length; i++) {
+ status = sqlite3_exec(db_, stmt_array[i].c_str(), NULL, NULL, &err_msg);
+ ExecErrorCheck(status, err_msg);
+ }
+ }
+
+ void Write(bool write_sync, Order order, DBState state,
+ int num_entries, int value_size, int entries_per_batch) {
+ // Create new database if state == FRESH
+ if (state == FRESH) {
+ if (FLAGS_use_existing_db) {
+ message_ = "skipping (--use_existing_db is true)";
+ return;
+ }
+ sqlite3_close(db_);
+ db_ = NULL;
+ Open();
+ Start();
+ }
+
+ if (num_entries != num_) {
+ char msg[100];
+ snprintf(msg, sizeof(msg), "(%d ops)", num_entries);
+ message_ = msg;
+ }
+
+ char* err_msg = NULL;
+ int status;
+
+ sqlite3_stmt *replace_stmt, *begin_trans_stmt, *end_trans_stmt;
+ std::string replace_str = "REPLACE INTO test (key, value) VALUES (?, ?)";
+ std::string begin_trans_str = "BEGIN TRANSACTION;";
+ std::string end_trans_str = "END TRANSACTION;";
+
+ // Check for synchronous flag in options
+ std::string sync_stmt = (write_sync) ? "PRAGMA synchronous = FULL" :
+ "PRAGMA synchronous = OFF";
+ status = sqlite3_exec(db_, sync_stmt.c_str(), NULL, NULL, &err_msg);
+ ExecErrorCheck(status, err_msg);
+
+ // Preparing sqlite3 statements
+ status = sqlite3_prepare_v2(db_, replace_str.c_str(), -1,
+ &replace_stmt, NULL);
+ ErrorCheck(status);
+ status = sqlite3_prepare_v2(db_, begin_trans_str.c_str(), -1,
+ &begin_trans_stmt, NULL);
+ ErrorCheck(status);
+ status = sqlite3_prepare_v2(db_, end_trans_str.c_str(), -1,
+ &end_trans_stmt, NULL);
+ ErrorCheck(status);
+
+ bool transaction = (entries_per_batch > 1);
+ for (int i = 0; i < num_entries; i += entries_per_batch) {
+ // Begin write transaction
+ if (FLAGS_transaction && transaction) {
+ status = sqlite3_step(begin_trans_stmt);
+ StepErrorCheck(status);
+ status = sqlite3_reset(begin_trans_stmt);
+ ErrorCheck(status);
+ }
+
+ // Create and execute SQL statements
+ for (int j = 0; j < entries_per_batch; j++) {
+ const char* value = gen_.Generate(value_size).data();
+
+ // Create values for key-value pair
+ const int k = (order == SEQUENTIAL) ? i + j :
+ (rand_.Next() % num_entries);
+ char key[100];
+ snprintf(key, sizeof(key), "%016d", k);
+
+ // Bind KV values into replace_stmt
+ status = sqlite3_bind_blob(replace_stmt, 1, key, 16, SQLITE_STATIC);
+ ErrorCheck(status);
+ status = sqlite3_bind_blob(replace_stmt, 2, value,
+ value_size, SQLITE_STATIC);
+ ErrorCheck(status);
+
+ // Execute replace_stmt
+ bytes_ += value_size + strlen(key);
+ status = sqlite3_step(replace_stmt);
+ StepErrorCheck(status);
+
+ // Reset SQLite statement for another use
+ status = sqlite3_clear_bindings(replace_stmt);
+ ErrorCheck(status);
+ status = sqlite3_reset(replace_stmt);
+ ErrorCheck(status);
+
+ FinishedSingleOp();
+ }
+
+ // End write transaction
+ if (FLAGS_transaction && transaction) {
+ status = sqlite3_step(end_trans_stmt);
+ StepErrorCheck(status);
+ status = sqlite3_reset(end_trans_stmt);
+ ErrorCheck(status);
+ }
+ }
+
+ status = sqlite3_finalize(replace_stmt);
+ ErrorCheck(status);
+ status = sqlite3_finalize(begin_trans_stmt);
+ ErrorCheck(status);
+ status = sqlite3_finalize(end_trans_stmt);
+ ErrorCheck(status);
+ }
+
+ void Read(Order order, int entries_per_batch) {
+ int status;
+ sqlite3_stmt *read_stmt, *begin_trans_stmt, *end_trans_stmt;
+
+ std::string read_str = "SELECT * FROM test WHERE key = ?";
+ std::string begin_trans_str = "BEGIN TRANSACTION;";
+ std::string end_trans_str = "END TRANSACTION;";
+
+ // Preparing sqlite3 statements
+ status = sqlite3_prepare_v2(db_, begin_trans_str.c_str(), -1,
+ &begin_trans_stmt, NULL);
+ ErrorCheck(status);
+ status = sqlite3_prepare_v2(db_, end_trans_str.c_str(), -1,
+ &end_trans_stmt, NULL);
+ ErrorCheck(status);
+ status = sqlite3_prepare_v2(db_, read_str.c_str(), -1, &read_stmt, NULL);
+ ErrorCheck(status);
+
+ bool transaction = (entries_per_batch > 1);
+ for (int i = 0; i < reads_; i += entries_per_batch) {
+ // Begin read transaction
+ if (FLAGS_transaction && transaction) {
+ status = sqlite3_step(begin_trans_stmt);
+ StepErrorCheck(status);
+ status = sqlite3_reset(begin_trans_stmt);
+ ErrorCheck(status);
+ }
+
+ // Create and execute SQL statements
+ for (int j = 0; j < entries_per_batch; j++) {
+ // Create key value
+ char key[100];
+ int k = (order == SEQUENTIAL) ? i + j : (rand_.Next() % reads_);
+ snprintf(key, sizeof(key), "%016d", k);
+
+ // Bind key value into read_stmt
+ status = sqlite3_bind_blob(read_stmt, 1, key, 16, SQLITE_STATIC);
+ ErrorCheck(status);
+
+ // Execute read statement
+ while ((status = sqlite3_step(read_stmt)) == SQLITE_ROW);
+ StepErrorCheck(status);
+
+ // Reset SQLite statement for another use
+ status = sqlite3_clear_bindings(read_stmt);
+ ErrorCheck(status);
+ status = sqlite3_reset(read_stmt);
+ ErrorCheck(status);
+ FinishedSingleOp();
+ }
+
+ // End read transaction
+ if (FLAGS_transaction && transaction) {
+ status = sqlite3_step(end_trans_stmt);
+ StepErrorCheck(status);
+ status = sqlite3_reset(end_trans_stmt);
+ ErrorCheck(status);
+ }
+ }
+
+ status = sqlite3_finalize(read_stmt);
+ ErrorCheck(status);
+ status = sqlite3_finalize(begin_trans_stmt);
+ ErrorCheck(status);
+ status = sqlite3_finalize(end_trans_stmt);
+ ErrorCheck(status);
+ }
+
+};
+
+}
+
+int main(int argc, char** argv) {
+ for (int i = 1; i < argc; i++) {
+ double d;
+ int n;
+ char junk;
+ if (leveldb::Slice(argv[i]).starts_with("--benchmarks=")) {
+ FLAGS_benchmarks = argv[i] + strlen("--benchmarks=");
+ } else if (sscanf(argv[i], "--histogram=%d%c", &n, &junk) == 1 &&
+ (n == 0 || n == 1)) {
+ FLAGS_histogram = n;
+ } else if (sscanf(argv[i], "--compression_ratio=%lf%c", &d, &junk) == 1) {
+ FLAGS_compression_ratio = d;
+ } else if (sscanf(argv[i], "--use_existing_db=%d%c", &n, &junk) == 1 &&
+ (n == 0 || n == 1)) {
+ FLAGS_use_existing_db = n;
+ } else if (sscanf(argv[i], "--num=%d%c", &n, &junk) == 1) {
+ FLAGS_num = n;
+ } else if (sscanf(argv[i], "--reads=%d%c", &n, &junk) == 1) {
+ FLAGS_reads = n;
+ } else if (sscanf(argv[i], "--value_size=%d%c", &n, &junk) == 1) {
+ FLAGS_value_size = n;
+ } else if (leveldb::Slice(argv[i]) == leveldb::Slice("--no_transaction")) {
+ FLAGS_transaction = false;
+ } else if (sscanf(argv[i], "--page_size=%d%c", &n, &junk) == 1) {
+ FLAGS_page_size = n;
+ } else if (sscanf(argv[i], "--num_pages=%d%c", &n, &junk) == 1) {
+ FLAGS_num_pages = n;
+ } else if (sscanf(argv[i], "--WAL_enabled=%d%c", &n, &junk) == 1 &&
+ (n == 0 || n == 1)) {
+ FLAGS_WAL_enabled = n;
+ } else {
+ fprintf(stderr, "Invalid flag '%s'\n", argv[i]);
+ exit(1);
+ }
+ }
+
+ leveldb::Benchmark benchmark;
+ benchmark.Run();
+ return 0;
+}
diff --git a/doc/bench/db_bench_tree_db.cc b/doc/bench/db_bench_tree_db.cc
new file mode 100644
index 0000000..d42e306
--- /dev/null
+++ b/doc/bench/db_bench_tree_db.cc
@@ -0,0 +1,506 @@
+// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file. See the AUTHORS file for names of contributors.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <kcpolydb.h>
+#include "util/histogram.h"
+#include "util/random.h"
+#include "util/testutil.h"
+
+// Comma-separated list of operations to run in the specified order
+// Actual benchmarks:
+//
+// fillseq -- write N values in sequential key order in async mode
+// fillrandom -- write N values in random key order in async mode
+// overwrite -- overwrite N values in random key order in async mode
+// fillseqsync -- write N/100 values in sequential key order in sync mode
+// fillrandsync -- write N/100 values in random key order in sync mode
+// fillrand100K -- write N/1000 100K values in random order in async mode
+// fillseq100K -- write N/1000 100K values in seq order in async mode
+// readseq -- read N times sequentially
+// readseq100K -- read N/1000 100K values in sequential order in async mode
+// readrand100K -- read N/1000 100K values in sequential order in async mode
+// readrandom -- read N times in random order
+static const char* FLAGS_benchmarks =
+ "fillseq,"
+ "fillseqsync,"
+ "fillrandsync,"
+ "fillrandom,"
+ "overwrite,"
+ "readrandom,"
+ "readseq,"
+ "fillrand100K,"
+ "fillseq100K,"
+ "readseq100K,"
+ "readrand100K,"
+ ;
+
+// Number of key/values to place in database
+static int FLAGS_num = 1000000;
+
+// Number of read operations to do. If negative, do FLAGS_num reads.
+static int FLAGS_reads = -1;
+
+// Size of each value
+static int FLAGS_value_size = 100;
+
+// Arrange to generate values that shrink to this fraction of
+// their original size after compression
+static double FLAGS_compression_ratio = 0.5;
+
+// Print histogram of operation timings
+static bool FLAGS_histogram = false;
+
+// Cache size. Default 4 MB
+static int FLAGS_cache_size = 4194304;
+
+// Page size. Default 1 KB
+static int FLAGS_page_size = 1024;
+
+// If true, do not destroy the existing database. If you set this
+// flag and also specify a benchmark that wants a fresh database, that
+// benchmark will fail.
+static bool FLAGS_use_existing_db = false;
+
+// Compression flag. If true, compression is on. If false, compression
+// is off.
+static bool FLAGS_compression = true;
+
+inline
+static void DBSynchronize(kyotocabinet::TreeDB* db_)
+{
+ // Synchronize will flush writes to disk
+ if (!db_->synchronize()) {
+ fprintf(stderr, "synchronize error: %s\n", db_->error().name());
+ }
+}
+
+namespace leveldb {
+
+// Helper for quickly generating random data.
+namespace {
+class RandomGenerator {
+ private:
+ std::string data_;
+ int pos_;
+
+ public:
+ RandomGenerator() {
+ // We use a limited amount of data over and over again and ensure
+ // that it is larger than the compression window (32KB), and also
+ // large enough to serve all typical value sizes we want to write.
+ Random rnd(301);
+ std::string piece;
+ while (data_.size() < 1048576) {
+ // Add a short fragment that is as compressible as specified
+ // by FLAGS_compression_ratio.
+ test::CompressibleString(&rnd, FLAGS_compression_ratio, 100, &piece);
+ data_.append(piece);
+ }
+ pos_ = 0;
+ }
+
+ Slice Generate(int len) {
+ if (pos_ + len > data_.size()) {
+ pos_ = 0;
+ assert(len < data_.size());
+ }
+ pos_ += len;
+ return Slice(data_.data() + pos_ - len, len);
+ }
+};
+
+static Slice TrimSpace(Slice s) {
+ int start = 0;
+ while (start < s.size() && isspace(s[start])) {
+ start++;
+ }
+ int limit = s.size();
+ while (limit > start && isspace(s[limit-1])) {
+ limit--;
+ }
+ return Slice(s.data() + start, limit - start);
+}
+
+}
+
+class Benchmark {
+ private:
+ kyotocabinet::TreeDB* db_;
+ int db_num_;
+ int num_;
+ int reads_;
+ double start_;
+ double last_op_finish_;
+ int64_t bytes_;
+ std::string message_;
+ Histogram hist_;
+ RandomGenerator gen_;
+ Random rand_;
+ kyotocabinet::LZOCompressor<kyotocabinet::LZO::RAW> comp_;
+
+ // State kept for progress messages
+ int done_;
+ int next_report_; // When to report next
+
+ void PrintHeader() {
+ const int kKeySize = 16;
+ PrintEnvironment();
+ fprintf(stdout, "Keys: %d bytes each\n", kKeySize);
+ fprintf(stdout, "Values: %d bytes each (%d bytes after compression)\n",
+ FLAGS_value_size,
+ static_cast<int>(FLAGS_value_size * FLAGS_compression_ratio + 0.5));
+ fprintf(stdout, "Entries: %d\n", num_);
+ fprintf(stdout, "RawSize: %.1f MB (estimated)\n",
+ ((static_cast<int64_t>(kKeySize + FLAGS_value_size) * num_)
+ / 1048576.0));
+ fprintf(stdout, "FileSize: %.1f MB (estimated)\n",
+ (((kKeySize + FLAGS_value_size * FLAGS_compression_ratio) * num_)
+ / 1048576.0));
+ PrintWarnings();
+ fprintf(stdout, "------------------------------------------------\n");
+ }
+
+ void PrintWarnings() {
+#if defined(__GNUC__) && !defined(__OPTIMIZE__)
+ fprintf(stdout,
+ "WARNING: Optimization is disabled: benchmarks unnecessarily slow\n"
+ );
+#endif
+#ifndef NDEBUG
+ fprintf(stdout,
+ "WARNING: Assertions are enabled; benchmarks unnecessarily slow\n");
+#endif
+ }
+
+ void PrintEnvironment() {
+ fprintf(stderr, "Kyoto Cabinet: version %s, lib ver %d, lib rev %d\n",
+ kyotocabinet::VERSION, kyotocabinet::LIBVER, kyotocabinet::LIBREV);
+
+#if defined(__linux)
+ time_t now = time(NULL);
+ fprintf(stderr, "Date: %s", ctime(&now)); // ctime() adds newline
+
+ FILE* cpuinfo = fopen("/proc/cpuinfo", "r");
+ if (cpuinfo != NULL) {
+ char line[1000];
+ int num_cpus = 0;
+ std::string cpu_type;
+ std::string cache_size;
+ while (fgets(line, sizeof(line), cpuinfo) != NULL) {
+ const char* sep = strchr(line, ':');
+ if (sep == NULL) {
+ continue;
+ }
+ Slice key = TrimSpace(Slice(line, sep - 1 - line));
+ Slice val = TrimSpace(Slice(sep + 1));
+ if (key == "model name") {
+ ++num_cpus;
+ cpu_type = val.ToString();
+ } else if (key == "cache size") {
+ cache_size = val.ToString();
+ }
+ }
+ fclose(cpuinfo);
+ fprintf(stderr, "CPU: %d * %s\n", num_cpus, cpu_type.c_str());
+ fprintf(stderr, "CPUCache: %s\n", cache_size.c_str());
+ }
+#endif
+ }
+
+ void Start() {
+ start_ = Env::Default()->NowMicros() * 1e-6;
+ bytes_ = 0;
+ message_.clear();
+ last_op_finish_ = start_;
+ hist_.Clear();
+ done_ = 0;
+ next_report_ = 100;
+ }
+
+ void FinishedSingleOp() {
+ if (FLAGS_histogram) {
+ double now = Env::Default()->NowMicros() * 1e-6;
+ double micros = (now - last_op_finish_) * 1e6;
+ hist_.Add(micros);
+ if (micros > 20000) {
+ fprintf(stderr, "long op: %.1f micros%30s\r", micros, "");
+ fflush(stderr);
+ }
+ last_op_finish_ = now;
+ }
+
+ done_++;
+ if (done_ >= next_report_) {
+ if (next_report_ < 1000) next_report_ += 100;
+ else if (next_report_ < 5000) next_report_ += 500;
+ else if (next_report_ < 10000) next_report_ += 1000;
+ else if (next_report_ < 50000) next_report_ += 5000;
+ else if (next_report_ < 100000) next_report_ += 10000;
+ else if (next_report_ < 500000) next_report_ += 50000;
+ else next_report_ += 100000;
+ fprintf(stderr, "... finished %d ops%30s\r", done_, "");
+ fflush(stderr);
+ }
+ }
+
+ void Stop(const Slice& name) {
+ double finish = Env::Default()->NowMicros() * 1e-6;
+
+ // Pretend at least one op was done in case we are running a benchmark
+ // that does not call FinishedSingleOp().
+ if (done_ < 1) done_ = 1;
+
+ if (bytes_ > 0) {
+ char rate[100];
+ snprintf(rate, sizeof(rate), "%6.1f MB/s",
+ (bytes_ / 1048576.0) / (finish - start_));
+ if (!message_.empty()) {
+ message_ = std::string(rate) + " " + message_;
+ } else {
+ message_ = rate;
+ }
+ }
+
+ fprintf(stdout, "%-12s : %11.3f micros/op;%s%s\n",
+ name.ToString().c_str(),
+ (finish - start_) * 1e6 / done_,
+ (message_.empty() ? "" : " "),
+ message_.c_str());
+ if (FLAGS_histogram) {
+ fprintf(stdout, "Microseconds per op:\n%s\n", hist_.ToString().c_str());
+ }
+ fflush(stdout);
+ }
+
+ public:
+ enum Order {
+ SEQUENTIAL,
+ RANDOM
+ };
+ enum DBState {
+ FRESH,
+ EXISTING
+ };
+
+ Benchmark()
+ : db_(NULL),
+ num_(FLAGS_num),
+ reads_(FLAGS_reads < 0 ? FLAGS_num : FLAGS_reads),
+ bytes_(0),
+ rand_(301) {
+ std::vector<std::string> files;
+ Env::Default()->GetChildren("/tmp", &files);
+ if (!FLAGS_use_existing_db) {
+ for (int i = 0; i < files.size(); i++) {
+ if (Slice(files[i]).starts_with("dbbench_polyDB")) {
+ Env::Default()->DeleteFile("/tmp/" + files[i]);
+ }
+ }
+ }
+ }
+
+ ~Benchmark() {
+ if (!db_->close()) {
+ fprintf(stderr, "close error: %s\n", db_->error().name());
+ }
+ }
+
+ void Run() {
+ PrintHeader();
+ Open(false);
+
+ const char* benchmarks = FLAGS_benchmarks;
+ while (benchmarks != NULL) {
+ const char* sep = strchr(benchmarks, ',');
+ Slice name;
+ if (sep == NULL) {
+ name = benchmarks;
+ benchmarks = NULL;
+ } else {
+ name = Slice(benchmarks, sep - benchmarks);
+ benchmarks = sep + 1;
+ }
+
+ Start();
+
+ bool known = true;
+ bool write_sync = false;
+ if (name == Slice("fillseq")) {
+ Write(write_sync, SEQUENTIAL, FRESH, num_, FLAGS_value_size, 1);
+
+ } else if (name == Slice("fillrandom")) {
+ Write(write_sync, RANDOM, FRESH, num_, FLAGS_value_size, 1);
+ DBSynchronize(db_);
+ } else if (name == Slice("overwrite")) {
+ Write(write_sync, RANDOM, EXISTING, num_, FLAGS_value_size, 1);
+ DBSynchronize(db_);
+ } else if (name == Slice("fillrandsync")) {
+ write_sync = true;
+ Write(write_sync, RANDOM, FRESH, num_ / 100, FLAGS_value_size, 1);
+ DBSynchronize(db_);
+ } else if (name == Slice("fillseqsync")) {
+ write_sync = true;
+ Write(write_sync, SEQUENTIAL, FRESH, num_ / 100, FLAGS_value_size, 1);
+ DBSynchronize(db_);
+ } else if (name == Slice("fillrand100K")) {
+ Write(write_sync, RANDOM, FRESH, num_ / 1000, 100 * 1000, 1);
+ DBSynchronize(db_);
+ } else if (name == Slice("fillseq100K")) {
+ Write(write_sync, SEQUENTIAL, FRESH, num_ / 1000, 100 * 1000, 1);
+ DBSynchronize(db_);
+ } else if (name == Slice("readseq")) {
+ ReadSequential();
+ } else if (name == Slice("readrandom")) {
+ ReadRandom();
+ } else if (name == Slice("readrand100K")) {
+ int n = reads_;
+ reads_ /= 1000;
+ ReadRandom();
+ reads_ = n;
+ } else if (name == Slice("readseq100K")) {
+ int n = reads_;
+ reads_ /= 1000;
+ ReadSequential();
+ reads_ = n;
+ } else {
+ known = false;
+ if (name != Slice()) { // No error message for empty name
+ fprintf(stderr, "unknown benchmark '%s'\n", name.ToString().c_str());
+ }
+ }
+ if (known) {
+ Stop(name);
+ }
+ }
+ }
+
+ private:
+ void Open(bool sync) {
+ assert(db_ == NULL);
+
+ // Initialize db_
+ db_ = new kyotocabinet::TreeDB();
+ char file_name[100];
+ db_num_++;
+ snprintf(file_name, sizeof(file_name), "/tmp/dbbench_polyDB-%d.kct",
+ db_num_);
+
+ // Create tuning options and open the database
+ int open_options = kyotocabinet::PolyDB::OWRITER |
+ kyotocabinet::PolyDB::OCREATE;
+ int tune_options = kyotocabinet::TreeDB::TSMALL |
+ kyotocabinet::TreeDB::TLINEAR;
+ if (FLAGS_compression) {
+ tune_options |= kyotocabinet::TreeDB::TCOMPRESS;
+ db_->tune_compressor(&comp_);
+ }
+ db_->tune_options(tune_options);
+ db_->tune_page_cache(FLAGS_cache_size);
+ db_->tune_page(FLAGS_page_size);
+ db_->tune_map(256LL<<20);
+ if (sync) {
+ open_options |= kyotocabinet::PolyDB::OAUTOSYNC;
+ }
+ if (!db_->open(file_name, open_options)) {
+ fprintf(stderr, "open error: %s\n", db_->error().name());
+ }
+ }
+
+ void Write(bool sync, Order order, DBState state,
+ int num_entries, int value_size, int entries_per_batch) {
+ // Create new database if state == FRESH
+ if (state == FRESH) {
+ if (FLAGS_use_existing_db) {
+ message_ = "skipping (--use_existing_db is true)";
+ return;
+ }
+ delete db_;
+ db_ = NULL;
+ Open(sync);
+ Start(); // Do not count time taken to destroy/open
+ }
+
+ if (num_entries != num_) {
+ char msg[100];
+ snprintf(msg, sizeof(msg), "(%d ops)", num_entries);
+ message_ = msg;
+ }
+
+ // Write to database
+ for (int i = 0; i < num_entries; i++)
+ {
+ const int k = (order == SEQUENTIAL) ? i : (rand_.Next() % num_entries);
+ char key[100];
+ snprintf(key, sizeof(key), "%016d", k);
+ bytes_ += value_size + strlen(key);
+ std::string cpp_key = key;
+ if (!db_->set(cpp_key, gen_.Generate(value_size).ToString())) {
+ fprintf(stderr, "set error: %s\n", db_->error().name());
+ }
+ FinishedSingleOp();
+ }
+ }
+
+ void ReadSequential() {
+ kyotocabinet::DB::Cursor* cur = db_->cursor();
+ cur->jump();
+ std::string ckey, cvalue;
+ while (cur->get(&ckey, &cvalue, true)) {
+ bytes_ += ckey.size() + cvalue.size();
+ FinishedSingleOp();
+ }
+ delete cur;
+ }
+
+ void ReadRandom() {
+ std::string value;
+ for (int i = 0; i < reads_; i++) {
+ char key[100];
+ const int k = rand_.Next() % reads_;
+ snprintf(key, sizeof(key), "%016d", k);
+ db_->get(key, &value);
+ FinishedSingleOp();
+ }
+ }
+};
+
+}
+
+int main(int argc, char** argv) {
+ for (int i = 1; i < argc; i++) {
+ double d;
+ int n;
+ char junk;
+ if (leveldb::Slice(argv[i]).starts_with("--benchmarks=")) {
+ FLAGS_benchmarks = argv[i] + strlen("--benchmarks=");
+ } else if (sscanf(argv[i], "--compression_ratio=%lf%c", &d, &junk) == 1) {
+ FLAGS_compression_ratio = d;
+ } else if (sscanf(argv[i], "--histogram=%d%c", &n, &junk) == 1 &&
+ (n == 0 || n == 1)) {
+ FLAGS_histogram = n;
+ } else if (sscanf(argv[i], "--num=%d%c", &n, &junk) == 1) {
+ FLAGS_num = n;
+ } else if (sscanf(argv[i], "--reads=%d%c", &n, &junk) == 1) {
+ FLAGS_reads = n;
+ } else if (sscanf(argv[i], "--value_size=%d%c", &n, &junk) == 1) {
+ FLAGS_value_size = n;
+ } else if (sscanf(argv[i], "--cache_size=%d%c", &n, &junk) == 1) {
+ FLAGS_cache_size = n;
+ } else if (sscanf(argv[i], "--page_size=%d%c", &n, &junk) == 1) {
+ FLAGS_page_size = n;
+ } else if (sscanf(argv[i], "--compression=%d%c", &n, &junk) == 1 &&
+ (n == 0 || n == 1)) {
+ FLAGS_compression = (n == 1) ? true : false;
+ } else {
+ fprintf(stderr, "Invalid flag '%s'\n", argv[i]);
+ exit(1);
+ }
+ }
+
+ leveldb::Benchmark benchmark;
+ benchmark.Run();
+ return 0;
+}
diff --git a/doc/benchmark.html b/doc/benchmark.html
new file mode 100644
index 0000000..f07c04b
--- /dev/null
+++ b/doc/benchmark.html
@@ -0,0 +1,466 @@
+<html>
+<head>
+<title>LevelDB Benchmarks</title>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+<style>
+body {
+ font-family:Helvetica,sans-serif;
+ padding:20px;
+}
+
+h2 {
+ padding-top:30px;
+}
+
+table.bn {
+ width:800px;
+ border-collapse:collapse;
+ border:0;
+ padding:0;
+}
+
+table.bnbase {
+ width:650px;
+}
+
+table.bn td {
+ padding:2px 0;
+}
+
+table.bn td.c1 {
+ font-weight:bold;
+ width:150px;
+}
+
+table.bn td.c1 div.e {
+ float:right;
+ font-weight:normal;
+}
+
+table.bn td.c2 {
+ width:150px;
+ text-align:right;
+ padding:2px;
+}
+
+table.bn td.c3 {
+ width:350px;
+}
+
+table.bn td.c4 {
+ width:150px;
+ font-size:small;
+ padding-left:4px;
+}
+
+/* chart bars */
+div.bldb {
+ background-color:#0255df;
+}
+
+div.bkct {
+ background-color:#df5555;
+}
+
+div.bsql {
+ background-color:#aadf55;
+}
+
+.code {
+ font-family:monospace;
+ font-size:large;
+}
+
+.todo {
+ color: red;
+}
+
+</style>
+</head>
+<body>
+<h1>LevelDB Benchmarks</h1>
+<p>Google, July 2011</p>
+<hr>
+
+<p>In order to test LevelDB's performance, we benchmark it against other well-established database implementations. We compare LevelDB (revision 39) against <a href="http://www.sqlite.org/">SQLite3</a> (version 3.7.6.3) and <a href="http://fallabs.com/kyotocabinet/spex.html">Kyoto Cabinet's</a> (version 1.2.67) TreeDB (a B+Tree based key-value store). We would like to acknowledge Scott Hess and Mikio Hirabayashi for their suggestions and contributions to the SQLite3 and Kyoto Cabinet benchmarks, respectively.</p>
+
+<p>Benchmarks were all performed on a six-core Intel(R) Xeon(R) CPU X5650 @ 2.67GHz, with 12288 KB of total L3 cache and 12 GB of DDR3 RAM at 1333 MHz. (Note that LevelDB uses at most two CPUs since the benchmarks are single threaded: one to run the benchmark, and one for background compactions.) We ran the benchmarks on two machines (with identical processors), one with an Ext3 file system and one with an Ext4 file system. The machine with the Ext3 file system has a SATA Hitachi HDS721050CLA362 hard drive. The machine with the Ext4 file system has a SATA Samsung HD502HJ hard drive. Both hard drives spin at 7200 RPM. The numbers reported below are the median of three measurements.</p>
+
+<h4>Benchmark Source Code</h4>
+<p>We wrote benchmark tools for SQLite and Kyoto TreeDB based on LevelDB's <span class="code">db_bench</span>. The code for each of the benchmarks resides here:</p>
+<ul>
+ <li> <b>LevelDB:</b> <a href="http://code.google.com/p/leveldb/source/browse/trunk/db/db_bench.cc">db/db_bench.cc</a>.</li>
+ <li> <b>SQLite:</b> <a href="http://code.google.com/p/leveldb/source/browse/#svn%2Ftrunk%2Fdoc%2Fbench%2Fdb_bench_sqlite3.cc">doc/bench/db_bench_sqlite3.cc</a>.</li>
+ <li> <b>Kyoto TreeDB:</b> <a href="http://code.google.com/p/leveldb/source/browse/#svn%2Ftrunk%2Fdoc%2Fbench%2Fdb_bench_tree_db.cc">doc/bench/db_bench_tree_db.cc</a>.</li>
+</ul>
+
+<h4>Custom Build Specifications</h4>
+<ul>
+<li>LevelDB: LevelDB was compiled with the <a href="http://code.google.com/p/google-perftools">tcmalloc</a> library and the <a href="http://code.google.com/p/snappy/">Snappy</a> compression library. Assertions were disabled.</li>
+<li>TreeDB: TreeDB was compiled using the <a href="http://www.oberhumer.com/opensource/lzo/">LZO</a> compression library. Furthermore, we enabled the TSMALL and TLINEAR options when opening the database in order to reduce the footprint of each record.</li>
+<li>SQLite: We tuned SQLite's performance, by setting its locking mode to exclusive. We left SQLite's <a href="http://www.sqlite.org/draft/wal.html">write-ahead logging</a> disabled since that is the default configuration. (Enabling write-ahead-logging improves SQLite's write performance by roughly 30%, but the character of the comparisons below does not change significantly.)</li>
+</ul>
+
+<h2>1. Baseline Performance</h2>
+<p>This section gives the baseline performance of a all of the
+databases. Following sections show how performance changes as various
+parameters are varied. For the baseline:</p>
+<ul>
+ <li> Each database is allowed 4 MB of cache memory.</li>
+ <li> Databases are opened in <em>asynchronous</em> write mode.
+ (LevelDB's sync option, TreeDB's OAUTOSYNC option, and
+ SQLite3's synchronous options are all turned off). I.e.,
+ every write is pushed to the operating system, but the
+ benchmark does not wait for the write to reach the disk.</li>
+ <li> Keys are 16 bytes each.</li>
+ <li> Value are 100 bytes each (with enough redundancy so that
+ a simple compressor shrinks them to 50% of their original
+ size).</li>
+ <li> Sequential reads/writes traverse the key space in increasing order.</li>
+ <li> Random reads/writes traverse the key space in random order.</li>
+</ul>
+
+<h3>A. Sequential Reads</h3>
+<table class="bn bnbase">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">4,030,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">1,010,000 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:95px">&nbsp;</div></td>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">186,000 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:16px">&nbsp;</div></td>
+</table>
+<h3>B. Random Reads</h3>
+<table class="bn bnbase">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">129,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:298px">&nbsp;</div></td>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">151,000 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:350px">&nbsp;</div></td>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">146,000 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:337px">&nbsp;</div></td>
+</table>
+<h3>C. Sequential Writes</h3>
+<table class="bn bnbase">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">779,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">342,000 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:154px">&nbsp;</div></td>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">26,900 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:12px">&nbsp;</div></td>
+</table>
+<h3>D. Random Writes</h3>
+<table class="bn bnbase">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">164,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">88,500 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:188px">&nbsp;</div></td>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">420 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:1px">&nbsp;</div></td>
+</table>
+
+<p>LevelDB outperforms both SQLite3 and TreeDB in sequential and random write operations and sequential read operations. Kyoto Cabinet has the fastest random read operations.</p>
+
+<h2>2. Write Performance under Different Configurations</h2>
+<h3>A. Large Values </h3>
+<p>For this benchmark, we start with an empty database, and write 100,000 byte values (~50% compressible). To keep the benchmark running time reasonable, we stop after writing 1000 values.</p>
+<h4>Sequential Writes</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">1,060 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:127px">&nbsp;</div>
+ <td class="c4">(1.17x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">1,020 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:122px">&nbsp;</div></td>
+ <td class="c4">(2.57x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">2,910 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(93.3x baseline)</td></tr>
+</table>
+<h4>Random Writes</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">480 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:77px">&nbsp;</div></td>
+ <td class="c4">(2.52x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">1,100 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(10.72x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">2,200 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:175px">&nbsp;</div></td>
+ <td class="c4">(4,516x baseline)</td></tr>
+</table>
+<p>LevelDB doesn't perform as well with large values of 100,000 bytes each. This is because LevelDB writes keys and values at least twice: first time to the transaction log, and second time (during a compaction) to a sorted file.
+With larger values, LevelDB's per-operation efficiency is swamped by the
+cost of extra copies of large values.</p>
+<h3>B. Batch Writes</h3>
+<p>A batch write is a set of writes that are applied atomically to the underlying database. A single batch of N writes may be significantly faster than N individual writes. The following benchmark writes one thousand batches where each batch contains one thousand 100-byte values. TreeDB does not support batch writes and is omitted from this benchmark.</p>
+<h4>Sequential Writes</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">840,000 entries/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(1.08x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">100,000 entries/sec</td>
+ <td class="c3"><div class="bsql" style="width:43px">&nbsp;</div></td>
+ <td class="c4">(3.72x baseline)</td></tr>
+</table>
+<h4>Random Writes</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">221,000 entries/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(1.35x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">1,000 entries/sec</td>
+ <td class="c3"><div class="bsql" style="width:2px">&nbsp;</div></td>
+ <td class="c4">(2.38x baseline)</td></tr>
+</table>
+
+<p>Because of the way LevelDB persistent storage is organized, batches of
+random writes are not much slower (only a factor of 4x) than batches
+of sequential writes. However SQLite3 sees a significant slowdown
+(factor of 100x) when switching from sequential to random batch
+writes. This is because each random batch write in SQLite3 has to
+update approximately as many pages as there are keys in the batch.</p>
+
+<h3>C. Synchronous writes</h3>
+<p>In the following benchmark, we enable the synchronous writing modes
+of all of the databases. Since this change significantly slows down the
+benchmark, we stop after 10,000 writes.</p>
+<ul>
+ <li>For LevelDB, we set WriteOptions.sync = true.</li>
+ <li>In TreeDB, we enabled TreeDB's OAUTOSYNC option.</li>
+ <li>For SQLite3, we set "PRAGMA synchronous = FULL".</li>
+</ul>
+<h4>Sequential Writes</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">2,400 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(0.003x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">140 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:21px">&nbsp;</div></td>
+ <td class="c4">(0.0004x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">430 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:61px">&nbsp;</div></td>
+ <td class="c4">(0.016x baseline)</td></tr>
+</table>
+<h4>Random Writes</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">2,400 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(0.015x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">100 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:14px">&nbsp;</div></td>
+ <td class="c4">(0.001x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">110 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:16px">&nbsp;</div></td>
+ <td class="c4">(0.26x baseline)</td></tr>
+</table>
+
+<p>Also see the <code>ext4</code> performance numbers below
+since synchronous writes behave significantly differently
+on <code>ext3</code> and <code>ext4</code>.</p>
+
+<h3>D. Turning Compression Off</h3>
+
+<p>In the baseline measurements, LevelDB and TreeDB were using
+light-weight compression
+(<a href="http://code.google.com/p/snappy/">Snappy</a> for LevelDB,
+and <a href="http://www.oberhumer.com/opensource/lzo/">LZO</a> for
+TreeDB). SQLite3, by default does not use compression. The
+experiments below show what happens when compression is disabled in
+all of the databases (the SQLite3 numbers are just a copy of
+its baseline measurements):</p>
+
+<h4>Sequential Writes</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">594,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(0.76x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">485,000 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:239px">&nbsp;</div></td>
+ <td class="c4">(1.42x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">26,900 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:13px">&nbsp;</div></td>
+ <td class="c4">(1.00x baseline)</td></tr>
+</table>
+<h4>Random Writes</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">135,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:296px">&nbsp;</div></td>
+ <td class="c4">(0.82x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">159,000 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(1.80x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">420 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:1px">&nbsp;</div></td>
+ <td class="c4">(1.00x baseline)</td></tr>
+</table>
+
+<p>LevelDB's write performance is better with compression than without
+since compression decreases the amount of data that has to be written
+to disk. Therefore LevelDB users can leave compression enabled in
+most scenarios without having worry about a tradeoff between space
+usage and performance. TreeDB's performance on the other hand is
+better without compression than with compression. Presumably this is
+because TreeDB's compression library (LZO) is more expensive than
+LevelDB's compression library (Snappy).<p>
+
+<h3>E. Using more memory</h3>
+<p>We increased the overall cache size for each database to 128 MB. For LevelDB, we partitioned 128 MB into a 120 MB write buffer and 8 MB of cache (up from 2 MB of write buffer and 2 MB of cache). For SQLite3, we kept the page size at 1024 bytes, but increased the number of pages to 131,072 (up from 4096). For TreeDB, we also kept the page size at 1024 bytes, but increased the cache size to 128 MB (up from 4 MB).</p>
+<h4>Sequential Writes</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">812,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(1.04x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">321,000 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:138px">&nbsp;</div></td>
+ <td class="c4">(0.94x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">26,200 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:11px">&nbsp;</div></td>
+ <td class="c4">(0.97x baseline)</td></tr>
+</table>
+<h4>Random Writes</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">355,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(2.16x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">284,000 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:280px">&nbsp;</div></td>
+ <td class="c4">(3.21x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">450 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:0px">&nbsp;</div></td>
+ <td class="c4">(1.07x baseline)</td></tr>
+</table>
+
+<p>SQLite's performance does not change substantially when compared to
+the baseline, but the random write performance for both LevelDB and
+TreeDB increases significantly. LevelDB's performance improves
+because a larger write buffer reduces the need to merge sorted files
+(since it creates a smaller number of larger sorted files). TreeDB's
+performance goes up because the entire database is available in memory
+for fast in-place updates.</p>
+
+ <h2>2. Read Performance under Different Configurations</h2>
+<h3>A. Larger caches</h3>
+<p>We increased the overall memory usage to 128 MB for each database.
+For LevelDB, we allocated 8 MB to LevelDB's write buffer and 120 MB
+to LevelDB's cache. The other databases don't differentiate between a
+write buffer and a cache, so we simply set their cache size to 128
+MB.</p>
+<h4>Sequential Reads</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">5,210,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(1.29x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">1,070,000 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:72px">&nbsp;</div></td>
+ <td class="c4">(1.06x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">221,000 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:15px">&nbsp;</div></td>
+ <td class="c4">(1.19x baseline)</td></tr>
+</table>
+
+<h4>Random Reads</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">190,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:144px">&nbsp;</div></td>
+ <td class="c4">(1.47x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">463,000 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(3.07x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">197,000 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:149px">&nbsp;</div></td>
+ <td class="c4">(1.35x baseline)</td></tr>
+</table>
+
+<p>As expected, the read performance of all of the databases increases
+when the caches are enlarged. In particular, TreeDB seems to make
+very effective use of a cache that is large enough to hold the entire
+database.</p>
+
+<h3>B. No compression reads </h3>
+<p>For this benchmark, we populated a database with 1 million entries consisting of 16 byte keys and 100 byte values. We compiled LevelDB and Kyoto Cabinet without compression support, so results that are read out from the database are already uncompressed. We've listed the SQLite3 baseline read performance as a point of comparison.</p>
+<h4>Sequential Reads</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">4,880,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(1.21x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">1,230,000 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:88px">&nbsp;</div></td>
+ <td class="c4">(3.60x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">186,000 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:13px">&nbsp;</div></td>
+ <td class="c4">(1.00x baseline)</td></tr>
+</table>
+<h4>Random Reads</h4>
+<table class="bn">
+<tr><td class="c1">LevelDB</td>
+ <td class="c2">149,000 ops/sec</td>
+ <td class="c3"><div class="bldb" style="width:300px">&nbsp;</div></td>
+ <td class="c4">(1.16x baseline)</td></tr>
+<tr><td class="c1">Kyoto TreeDB</td>
+ <td class="c2">175,000 ops/sec</td>
+ <td class="c3"><div class="bkct" style="width:350px">&nbsp;</div></td>
+ <td class="c4">(1.16x baseline)</td></tr>
+<tr><td class="c1">SQLite3</td>
+ <td class="c2">146,000 ops/sec</td>
+ <td class="c3"><div class="bsql" style="width:292px">&nbsp;</div></td>
+ <td class="c4">(1.00x baseline)</td></tr>
+</table>
+
+<p>Performance of both LevelDB and TreeDB improves a small amount when
+compression is disabled. Note however that under different workloads,
+performance may very well be better with compression if it allows more
+of the working set to fit in memory.</p>
+
+<h2>Note about Ext4 Filesystems</h2>
+<p>The preceding numbers are for an ext3 file system. Synchronous writes are much slower under <a href="http://en.wikipedia.org/wiki/Ext4">ext4</a> (LevelDB drops to ~34 writes / second, TreeDB drops to ~5 writes / second; SQLite3 drops to ~24 writes / second) due to ext4's different handling of <span class="code">fsync</span> / <span class="code">msync</span> calls. Even LevelDB's asynchronous write performance drops somewhat since it spreads its storage across multiple files and issues <span class="code">fsync</span> calls when switching to a new file.</p>
+
+<h2>Acknowledgements</h2>
+<p>Jeff Dean and Sanjay Ghemawat wrote LevelDB. Kevin Tseng wrote and compiled these benchmarks. Mikio Hirabayashi, Scott Hess, and Gabor Cselle provided help and advice.</p>
+</body>
+</html>
diff --git a/leveldb.gyp b/leveldb.gyp
deleted file mode 100644
index ea634a2..0000000
--- a/leveldb.gyp
+++ /dev/null
@@ -1,325 +0,0 @@
-# Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-{
- 'variables': {
- 'use_snappy%': 0,
- },
- 'target_defaults': {
- 'defines': [
- 'LEVELDB_PLATFORM_CHROMIUM=1',
- ],
- 'include_dirs': [
- '.',
- 'include/',
- ],
- 'conditions': [
- ['OS == "win"', {
- 'include_dirs': [
- 'port/win',
- ],
- }],
- ['use_snappy', {
- 'defines': [
- 'USE_SNAPPY=1',
- ],
- }],
- ],
- },
- 'targets': [
- {
- 'target_name': 'leveldb',
- 'type': '<(library)',
- 'dependencies': [
- # The base libary is a lightweight abstraction layer for things like
- # threads and IO. http://src.chromium.org/viewvc/chrome/trunk/src/base/
- '../../base/base.gyp:base',
- # base::LazyInstance is a template that pulls in dynamic_annotations so
- # we need to explictly link in the code for dynamic_annotations.
- '../../base/third_party/dynamic_annotations/dynamic_annotations.gyp:dynamic_annotations',
- ],
- 'conditions': [
- ['use_snappy', {
- 'dependencies': [
- '../../third_party/snappy/snappy.gyp:snappy',
- ],
- }],
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- 'include/',
- ],
- 'conditions': [
- ['OS == "win"', {
- 'include_dirs': [
- 'port/win',
- ],
- }],
- ],
- },
- 'sources': [
- # Include and then exclude so that all files show up in IDEs, even if
- # they don't build.
- 'db/builder.cc',
- 'db/builder.h',
- 'db/db_impl.cc',
- 'db/db_impl.h',
- 'db/db_iter.cc',
- 'db/db_iter.h',
- 'db/filename.cc',
- 'db/filename.h',
- 'db/dbformat.cc',
- 'db/dbformat.h',
- 'db/log_format.h',
- 'db/log_reader.cc',
- 'db/log_reader.h',
- 'db/log_writer.cc',
- 'db/log_writer.h',
- 'db/memtable.cc',
- 'db/memtable.h',
- 'db/repair.cc',
- 'db/skiplist.h',
- 'db/snapshot.h',
- 'db/table_cache.cc',
- 'db/table_cache.h',
- 'db/version_edit.cc',
- 'db/version_edit.h',
- 'db/version_set.cc',
- 'db/version_set.h',
- 'db/write_batch.cc',
- 'db/write_batch_internal.h',
- 'include/leveldb/cache.h',
- 'include/leveldb/comparator.h',
- 'include/leveldb/db.h',
- 'include/leveldb/env.h',
- 'include/leveldb/iterator.h',
- 'include/leveldb/options.h',
- 'include/leveldb/slice.h',
- 'include/leveldb/status.h',
- 'include/leveldb/table.h',
- 'include/leveldb/table_builder.h',
- 'include/leveldb/write_batch.h',
- 'port/port.h',
- 'port/port_chromium.cc',
- 'port/port_chromium.h',
- 'port/port_example.h',
- 'port/port_posix.cc',
- 'port/port_posix.h',
- 'table/block.cc',
- 'table/block.h',
- 'table/block_builder.cc',
- 'table/block_builder.h',
- 'table/format.cc',
- 'table/format.h',
- 'table/iterator.cc',
- 'table/iterator_wrapper.h',
- 'table/merger.cc',
- 'table/merger.h',
- 'table/table.cc',
- 'table/table_builder.cc',
- 'table/two_level_iterator.cc',
- 'table/two_level_iterator.h',
- 'util/arena.cc',
- 'util/arena.h',
- 'util/cache.cc',
- 'util/coding.cc',
- 'util/coding.h',
- 'util/comparator.cc',
- 'util/crc32c.cc',
- 'util/crc32c.h',
- 'util/env.cc',
- 'util/env_chromium.cc',
- 'util/env_posix.cc',
- 'util/hash.cc',
- 'util/hash.h',
- 'util/logging.cc',
- 'util/logging.h',
- 'util/mutexlock.h',
- 'util/options.cc',
- 'util/random.h',
- 'util/status.cc',
- ],
- 'sources/': [
- ['exclude', '_(android|example|portable|posix)\\.cc$'],
- ],
- },
- {
- 'target_name': 'leveldb_testutil',
- 'type': '<(library)',
- 'dependencies': [
- '../../base/base.gyp:base',
- 'leveldb',
- ],
- 'export_dependent_settings': [
- # The tests use include directories from these projects.
- '../../base/base.gyp:base',
- 'leveldb',
- ],
- 'sources': [
- 'util/histogram.cc',
- 'util/histogram.h',
- 'util/testharness.cc',
- 'util/testharness.h',
- 'util/testutil.cc',
- 'util/testutil.h',
- ],
- },
- {
- 'target_name': 'leveldb_arena_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'util/arena_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_cache_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'util/cache_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_coding_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'util/coding_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_corruption_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'db/corruption_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_crc32c_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'util/crc32c_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_db_bench',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'db/db_bench.cc',
- ],
- },
- {
- 'target_name': 'leveldb_db_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'db/db_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_dbformat_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'db/dbformat_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_env_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'util/env_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_filename_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'db/filename_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_log_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'db/log_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_skiplist_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'db/skiplist_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_table_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'table/table_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_version_edit_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'db/version_edit_test.cc',
- ],
- },
- {
- 'target_name': 'leveldb_write_batch_test',
- 'type': 'executable',
- 'dependencies': [
- 'leveldb_testutil',
- ],
- 'sources': [
- 'db/write_batch_test.cc',
- ],
- },
- ],
-}
-
-# Local Variables:
-# tab-width:2
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=2 shiftwidth=2:
diff --git a/port/port_chromium.cc b/port/port_chromium.cc
deleted file mode 100644
index 7f6de92..0000000
--- a/port/port_chromium.cc
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include "port/port_chromium.h"
-
-#include "util/logging.h"
-
-#if defined(USE_SNAPPY)
-# include "third_party/snappy/src/snappy.h"
-#endif
-
-namespace leveldb {
-namespace port {
-
-Mutex::Mutex() {
-}
-
-Mutex::~Mutex() {
-}
-
-void Mutex::Lock() {
- mu_.Acquire();
-}
-
-void Mutex::Unlock() {
- mu_.Release();
-}
-
-void Mutex::AssertHeld() {
- mu_.AssertAcquired();
-}
-
-CondVar::CondVar(Mutex* mu)
- : cv_(&mu->mu_) {
-}
-
-CondVar::~CondVar() { }
-
-void CondVar::Wait() {
- cv_.Wait();
-}
-
-void CondVar::Signal(){
- cv_.Signal();
-}
-
-void CondVar::SignalAll() {
- cv_.Broadcast();
-}
-
-bool Snappy_Compress(const char* input, size_t input_length,
- std::string* output) {
-#if defined(USE_SNAPPY)
- output->resize(snappy::MaxCompressedLength(input_length));
- size_t outlen;
- snappy::RawCompress(input, input_length, &(*output)[0], &outlen);
- output->resize(outlen);
- return true;
-#else
- return false;
-#endif
-}
-
-bool Snappy_GetUncompressedLength(const char* input, size_t length,
- size_t* result) {
-#if defined(USE_SNAPPY)
- return snappy::GetUncompressedLength(input_data, input_length, result);
-#else
- return false;
-#endif
-}
-
-bool Snappy_Uncompress(const char* input_data, size_t input_length,
- char* output) {
-#if defined(USE_SNAPPY)
- return snappy::RawUncompress(input_data, input_length, output);
-#else
- return false;
-#endif
-}
-
-}
-}
diff --git a/port/port_chromium.h b/port/port_chromium.h
deleted file mode 100644
index feecd5b..0000000
--- a/port/port_chromium.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// See port_example.h for documentation for the following types/functions.
-
-#ifndef STORAGE_LEVELDB_PORT_PORT_CHROMIUM_H_
-#define STORAGE_LEVELDB_PORT_PORT_CHROMIUM_H_
-
-#include <stdint.h>
-#include <string>
-#include <cstring>
-#include "base/atomicops.h"
-#include "base/basictypes.h"
-#include "base/logging.h"
-#include "base/synchronization/condition_variable.h"
-#include "base/synchronization/lock.h"
-
-// Linux's ThreadIdentifier() needs this.
-#if defined(OS_LINUX)
-# include <linux/unistd.h>
-#endif
-
-#if defined(OS_WIN)
-#define snprintf _snprintf
-#define va_copy(a, b) do { (a) = (b); } while (0)
-#endif
-
-namespace leveldb {
-namespace port {
-
-// Chromium only supports little endian.
-static const bool kLittleEndian = true;
-
-class Mutex {
- public:
- Mutex();
- ~Mutex();
- void Lock();
- void Unlock();
- void AssertHeld();
-
- private:
- base::Lock mu_;
-
- friend class CondVar;
- DISALLOW_COPY_AND_ASSIGN(Mutex);
-};
-
-class CondVar {
- public:
- explicit CondVar(Mutex* mu);
- ~CondVar();
- void Wait();
- void Signal();
- void SignalAll();
-
- private:
- base::ConditionVariable cv_;
-
- DISALLOW_COPY_AND_ASSIGN(CondVar);
-};
-
-class AtomicPointer {
- private:
- typedef base::subtle::AtomicWord Rep;
- Rep rep_;
- public:
- AtomicPointer() { }
- explicit AtomicPointer(void* p) : rep_(reinterpret_cast<Rep>(p)) {}
- inline void* Acquire_Load() const {
- return reinterpret_cast<void*>(::base::subtle::Acquire_Load(&rep_));
- }
- inline void Release_Store(void* v) {
- ::base::subtle::Release_Store(&rep_, reinterpret_cast<Rep>(v));
- }
- inline void* NoBarrier_Load() const {
- return reinterpret_cast<void*>(::base::subtle::NoBarrier_Load(&rep_));
- }
- inline void NoBarrier_Store(void* v) {
- ::base::subtle::NoBarrier_Store(&rep_, reinterpret_cast<Rep>(v));
- }
-};
-
-bool Snappy_Compress(const char* input, size_t input_length,
- std::string* output);
-bool Snappy_GetUncompressedLength(const char* input, size_t length,
- size_t* result);
-bool Snappy_Uncompress(const char* input_data, size_t input_length,
- char* output);
-
-inline bool GetHeapProfile(void (*func)(void*, const char*, int), void* arg) {
- return false;
-}
-
-}
-}
-
-#endif // STORAGE_LEVELDB_PORT_PORT_CHROMIUM_H_
diff --git a/port/port_posix.h b/port/port_posix.h
index ef01de3..9666391 100644
--- a/port/port_posix.h
+++ b/port/port_posix.h
@@ -7,7 +7,7 @@
#ifndef STORAGE_LEVELDB_PORT_PORT_POSIX_H_
#define STORAGE_LEVELDB_PORT_PORT_POSIX_H_
-#if defined(OS_MACOSX)
+#if defined(OS_MACOSX) || defined(OS_FREEBSD)
#include <machine/endian.h>
#elif defined(OS_SOLARIS)
#include <sys/isa_defs.h>
@@ -33,13 +33,13 @@
#define IS_LITTLE_ENDIAN (__BYTE_ORDER == __LITTLE_ENDIAN)
#endif
-#if defined(OS_MACOSX) || defined(OS_SOLARIS)
+#if defined(OS_MACOSX) || defined(OS_SOLARIS) || defined(OS_FREEBSD)
#define fread_unlocked fread
#define fwrite_unlocked fwrite
#define fflush_unlocked fflush
#endif
-#if defined(OS_MACOSX)
+#if defined(OS_MACOSX) || defined(OS_FREEBSD)
#define fdatasync fsync
#endif
diff --git a/util/env_chromium.cc b/util/env_chromium.cc
deleted file mode 100644
index 975386b..0000000
--- a/util/env_chromium.cc
+++ /dev/null
@@ -1,564 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include <deque>
-#include <errno.h>
-#include <stdio.h>
-#include "base/at_exit.h"
-#include "base/file_path.h"
-#include "base/file_util.h"
-#include "base/lazy_instance.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop.h"
-#include "base/platform_file.h"
-#include "base/process_util.h"
-#include "base/synchronization/lock.h"
-#include "base/sys_info.h"
-#include "base/task.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread.h"
-#include "base/utf_string_conversions.h"
-#include "leveldb/env.h"
-#include "leveldb/slice.h"
-#include "port/port.h"
-#include "util/logging.h"
-#include "util/posix_logger.h"
-
-#if defined(OS_WIN)
-#include <io.h>
-#include "base/win/win_util.h"
-#endif
-
-#if defined(OS_MACOSX) || defined(OS_WIN)
-// The following are glibc-specific
-namespace {
-
-size_t fread_unlocked(void *ptr, size_t size, size_t n, FILE *file) {
- return fread(ptr, size, n, file);
-}
-
-size_t fwrite_unlocked(const void *ptr, size_t size, size_t n, FILE *file) {
- return fwrite(ptr, size, n, file);
-}
-
-int fflush_unlocked(FILE *file) {
- return fflush(file);
-}
-
-int fdatasync(int fildes) {
-#if defined(OS_WIN)
- return _commit(fildes);
-#else
- return fsync(fildes);
-#endif
-}
-
-}
-#endif
-
-namespace leveldb {
-
-namespace {
-
-class Thread;
-
-static const ::FilePath::CharType kLevelDBTestDirectoryPrefix[]
- = FILE_PATH_LITERAL("leveldb-test-");
-
-::FilePath CreateFilePath(const std::string& file_path) {
-#if defined(OS_WIN)
- return FilePath(UTF8ToUTF16(file_path));
-#else
- return FilePath(file_path);
-#endif
-}
-
-std::string FilePathToString(const ::FilePath& file_path) {
-#if defined(OS_WIN)
- return UTF16ToUTF8(file_path.value());
-#else
- return file_path.value();
-#endif
-}
-
-// TODO(jorlow): This should be moved into Chromium's base.
-const char* PlatformFileErrorString(const ::base::PlatformFileError& error) {
- switch (error) {
- case ::base::PLATFORM_FILE_ERROR_FAILED:
- return "Opening file failed.";
- case ::base::PLATFORM_FILE_ERROR_IN_USE:
- return "File currently in use.";
- case ::base::PLATFORM_FILE_ERROR_EXISTS:
- return "File already exists.";
- case ::base::PLATFORM_FILE_ERROR_NOT_FOUND:
- return "File not found.";
- case ::base::PLATFORM_FILE_ERROR_ACCESS_DENIED:
- return "Access denied.";
- case ::base::PLATFORM_FILE_ERROR_TOO_MANY_OPENED:
- return "Too many files open.";
- case ::base::PLATFORM_FILE_ERROR_NO_MEMORY:
- return "Out of memory.";
- case ::base::PLATFORM_FILE_ERROR_NO_SPACE:
- return "No space left on drive.";
- case ::base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY:
- return "Not a directory.";
- case ::base::PLATFORM_FILE_ERROR_INVALID_OPERATION:
- return "Invalid operation.";
- case ::base::PLATFORM_FILE_ERROR_SECURITY:
- return "Security error.";
- case ::base::PLATFORM_FILE_ERROR_ABORT:
- return "File operation aborted.";
- case ::base::PLATFORM_FILE_ERROR_NOT_A_FILE:
- return "The supplied path was not a file.";
- case ::base::PLATFORM_FILE_ERROR_NOT_EMPTY:
- return "The file was not empty.";
- }
- NOTIMPLEMENTED();
- return "Unknown error.";
-}
-
-class ChromiumSequentialFile: public SequentialFile {
- private:
- std::string filename_;
- FILE* file_;
-
- public:
- ChromiumSequentialFile(const std::string& fname, FILE* f)
- : filename_(fname), file_(f) { }
- virtual ~ChromiumSequentialFile() { fclose(file_); }
-
- virtual Status Read(size_t n, Slice* result, char* scratch) {
- Status s;
- size_t r = fread_unlocked(scratch, 1, n, file_);
- *result = Slice(scratch, r);
- if (r < n) {
- if (feof(file_)) {
- // We leave status as ok if we hit the end of the file
- } else {
- // A partial read with an error: return a non-ok status
- s = Status::IOError(filename_, strerror(errno));
- }
- }
- return s;
- }
-
- virtual Status Skip(uint64_t n) {
- if (fseek(file_, n, SEEK_CUR)) {
- return Status::IOError(filename_, strerror(errno));
- }
- return Status::OK();
- }
-};
-
-class ChromiumRandomAccessFile: public RandomAccessFile {
- private:
- std::string filename_;
- ::base::PlatformFile file_;
-
- public:
- ChromiumRandomAccessFile(const std::string& fname, ::base::PlatformFile file)
- : filename_(fname), file_(file) { }
- virtual ~ChromiumRandomAccessFile() { ::base::ClosePlatformFile(file_); }
-
- virtual Status Read(uint64_t offset, size_t n, Slice* result,
- char* scratch) const {
- Status s;
- int r = ::base::ReadPlatformFile(file_, offset, scratch, n);
- *result = Slice(scratch, (r < 0) ? 0 : r);
- if (r < 0) {
- // An error: return a non-ok status
- s = Status::IOError(filename_, "Could not preform read");
- }
- return s;
- }
-};
-
-class ChromiumWritableFile : public WritableFile {
- private:
- std::string filename_;
- FILE* file_;
-
- public:
- ChromiumWritableFile(const std::string& fname, FILE* f)
- : filename_(fname), file_(f) { }
-
- ~ChromiumWritableFile() {
- if (file_ != NULL) {
- // Ignoring any potential errors
- fclose(file_);
- }
- }
-
- virtual Status Append(const Slice& data) {
- size_t r = fwrite_unlocked(data.data(), 1, data.size(), file_);
- Status result;
- if (r != data.size()) {
- result = Status::IOError(filename_, strerror(errno));
- }
- return result;
- }
-
- virtual Status Close() {
- Status result;
- if (fclose(file_) != 0) {
- result = Status::IOError(filename_, strerror(errno));
- }
- file_ = NULL;
- return result;
- }
-
- virtual Status Flush() {
- Status result;
- if (fflush_unlocked(file_) != 0) {
- result = Status::IOError(filename_, strerror(errno));
- }
- return result;
- }
-
- virtual Status Sync() {
- Status result;
- if ((fflush_unlocked(file_) != 0) ||
- (fdatasync(fileno(file_)) != 0)) {
- result = Status::IOError(filename_, strerror(errno));
- }
- return result;
- }
-};
-
-class ChromiumFileLock : public FileLock {
- public:
- ::base::PlatformFile file_;
-};
-
-class ChromiumEnv : public Env {
- public:
- ChromiumEnv();
- virtual ~ChromiumEnv() {
- fprintf(stderr, "Destroying Env::Default()\n");
- exit(1);
- }
-
- virtual Status NewSequentialFile(const std::string& fname,
- SequentialFile** result) {
- FILE* f = fopen(fname.c_str(), "rb");
- if (f == NULL) {
- *result = NULL;
- return Status::IOError(fname, strerror(errno));
- } else {
- *result = new ChromiumSequentialFile(fname, f);
- return Status::OK();
- }
- }
-
- virtual Status NewRandomAccessFile(const std::string& fname,
- RandomAccessFile** result) {
- int flags = ::base::PLATFORM_FILE_READ | ::base::PLATFORM_FILE_OPEN;
- bool created;
- ::base::PlatformFileError error_code;
- ::base::PlatformFile file = ::base::CreatePlatformFile(
- CreateFilePath(fname), flags, &created, &error_code);
- if (error_code != ::base::PLATFORM_FILE_OK) {
- *result = NULL;
- return Status::IOError(fname, PlatformFileErrorString(error_code));
- }
- *result = new ChromiumRandomAccessFile(fname, file);
- return Status::OK();
- }
-
- virtual Status NewWritableFile(const std::string& fname,
- WritableFile** result) {
- *result = NULL;
- FILE* f = fopen(fname.c_str(), "wb");
- if (f == NULL) {
- return Status::IOError(fname, strerror(errno));
- } else {
- *result = new ChromiumWritableFile(fname, f);
- return Status::OK();
- }
- }
-
- virtual bool FileExists(const std::string& fname) {
- return ::file_util::PathExists(CreateFilePath(fname));
- }
-
- virtual Status GetChildren(const std::string& dir,
- std::vector<std::string>* result) {
- result->clear();
- ::file_util::FileEnumerator iter(
- CreateFilePath(dir), false, ::file_util::FileEnumerator::FILES);
- ::FilePath current = iter.Next();
- while (!current.empty()) {
- result->push_back(FilePathToString(current.BaseName()));
- current = iter.Next();
- }
- // TODO(jorlow): Unfortunately, the FileEnumerator swallows errors, so
- // we'll always return OK. Maybe manually check for error
- // conditions like the file not existing?
- return Status::OK();
- }
-
- virtual Status DeleteFile(const std::string& fname) {
- Status result;
- // TODO(jorlow): Should we assert this is a file?
- if (!::file_util::Delete(CreateFilePath(fname), false)) {
- result = Status::IOError(fname, "Could not delete file.");
- }
- return result;
- };
-
- virtual Status CreateDir(const std::string& name) {
- Status result;
- if (!::file_util::CreateDirectory(CreateFilePath(name))) {
- result = Status::IOError(name, "Could not create directory.");
- }
- return result;
- };
-
- virtual Status DeleteDir(const std::string& name) {
- Status result;
- // TODO(jorlow): Should we assert this is a directory?
- if (!::file_util::Delete(CreateFilePath(name), false)) {
- result = Status::IOError(name, "Could not delete directory.");
- }
- return result;
- };
-
- virtual Status GetFileSize(const std::string& fname, uint64_t* size) {
- Status s;
- int64_t signed_size;
- if (!::file_util::GetFileSize(CreateFilePath(fname), &signed_size)) {
- *size = 0;
- s = Status::IOError(fname, "Could not determine file size.");
- } else {
- *size = static_cast<uint64_t>(signed_size);
- }
- return s;
- }
-
- virtual Status RenameFile(const std::string& src, const std::string& dst) {
- Status result;
- if (!::file_util::ReplaceFile(CreateFilePath(src), CreateFilePath(dst))) {
- result = Status::IOError(src, "Could not rename file.");
- }
- return result;
- }
-
- virtual Status LockFile(const std::string& fname, FileLock** lock) {
- *lock = NULL;
- Status result;
- int flags = ::base::PLATFORM_FILE_OPEN_ALWAYS |
- ::base::PLATFORM_FILE_READ |
- ::base::PLATFORM_FILE_WRITE |
- ::base::PLATFORM_FILE_EXCLUSIVE_READ |
- ::base::PLATFORM_FILE_EXCLUSIVE_WRITE;
- bool created;
- ::base::PlatformFileError error_code;
- ::base::PlatformFile file = ::base::CreatePlatformFile(
- CreateFilePath(fname), flags, &created, &error_code);
- if (error_code != ::base::PLATFORM_FILE_OK) {
- result = Status::IOError(fname, PlatformFileErrorString(error_code));
- } else {
- ChromiumFileLock* my_lock = new ChromiumFileLock;
- my_lock->file_ = file;
- *lock = my_lock;
- }
- return result;
- }
-
- virtual Status UnlockFile(FileLock* lock) {
- ChromiumFileLock* my_lock = reinterpret_cast<ChromiumFileLock*>(lock);
- Status result;
- if (!::base::ClosePlatformFile(my_lock->file_)) {
- result = Status::IOError("Could not close lock file.");
- }
- delete my_lock;
- return result;
- }
-
- virtual void Schedule(void (*function)(void*), void* arg);
-
- virtual void StartThread(void (*function)(void* arg), void* arg);
-
- virtual std::string UserIdentifier() {
-#if defined(OS_WIN)
- std::wstring user_sid;
- bool ret = ::base::win::GetUserSidString(&user_sid);
- DCHECK(ret);
- return UTF16ToUTF8(user_sid);
-#else
- char buf[100];
- snprintf(buf, sizeof(buf), "%d", int(geteuid()));
- return buf;
-#endif
- }
-
- virtual Status GetTestDirectory(std::string* path) {
- mu_.Acquire();
- if (test_directory_.empty()) {
- if (!::file_util::CreateNewTempDirectory(kLevelDBTestDirectoryPrefix,
- &test_directory_)) {
- mu_.Release();
- return Status::IOError("Could not create temp directory.");
- }
- }
- *path = FilePathToString(test_directory_);
- mu_.Release();
- return Status::OK();
- }
-
- // TODO(user,user): Use Chromium's built-in logging?
- static uint64_t gettid() {
- uint64_t thread_id = 0;
- // Coppied from base/logging.cc.
-#if defined(OS_WIN)
- thread_id = GetCurrentThreadId();
-#elif defined(OS_MACOSX)
- thread_id = mach_thread_self();
-#elif defined(OS_LINUX)
- thread_id = syscall(__NR_gettid);
-#elif defined(OS_FREEBSD) || defined(OS_NACL)
- // TODO(BSD): find a better thread ID
- pthread_t tid = pthread_self();
- memcpy(&thread_id, &tid, min(sizeof(r), sizeof(tid)));
-#endif
- return thread_id;
- }
-
- virtual Status NewLogger(const std::string& fname, Logger** result) {
- FILE* f = fopen(fname.c_str(), "w");
- if (f == NULL) {
- *result = NULL;
- return Status::IOError(fname, strerror(errno));
- } else {
- *result = new PosixLogger(f, &ChromiumEnv::gettid);
- return Status::OK();
- }
- }
-
- virtual int AppendLocalTimeToBuffer(char* buffer, size_t size) {
- ::base::Time::Exploded t;
- ::base::Time::Now().LocalExplode(&t);
- return snprintf(buffer, size,
- "%04d/%02d/%02d-%02d:%02d:%02d.%06d",
- t.year,
- t.month,
- t.day_of_month,
- t.hour,
- t.minute,
- t.second,
- static_cast<int>(t.millisecond) * 1000);
- }
-
- virtual uint64_t NowMicros() {
- return ::base::TimeTicks::HighResNow().ToInternalValue();
- }
-
- virtual void SleepForMicroseconds(int micros) {
- // Round up to the next millisecond.
- ::base::PlatformThread::Sleep((micros + 999) / 1000);
- }
-
- private:
- // BGThread() is the body of the background thread
- void BGThread();
- static void BGThreadWrapper(void* arg) {
- reinterpret_cast<ChromiumEnv*>(arg)->BGThread();
- }
-
- FilePath test_directory_;
-
- size_t page_size_;
- ::base::Lock mu_;
- ::base::ConditionVariable bgsignal_;
- bool started_bgthread_;
-
- // Entry per Schedule() call
- struct BGItem { void* arg; void (*function)(void*); };
- typedef std::deque<BGItem> BGQueue;
- BGQueue queue_;
-};
-
-ChromiumEnv::ChromiumEnv()
- : page_size_(::base::SysInfo::VMAllocationGranularity()),
- bgsignal_(&mu_),
- started_bgthread_(false) {
-#if defined(OS_MACOSX)
- ::base::EnableTerminationOnHeapCorruption();
- ::base::EnableTerminationOnOutOfMemory();
-#endif // OS_MACOSX
-}
-
-class Thread : public ::base::PlatformThread::Delegate {
- public:
- Thread(void (*function)(void* arg), void* arg)
- : function_(function), arg_(arg) {
- ::base::PlatformThreadHandle handle;
- bool success = ::base::PlatformThread::Create(0, this, &handle);
- DCHECK(success);
- }
- virtual ~Thread() {}
- virtual void ThreadMain() {
- (*function_)(arg_);
- delete this;
- }
-
- private:
- void (*function_)(void* arg);
- void* arg_;
-};
-
-void ChromiumEnv::Schedule(void (*function)(void*), void* arg) {
- mu_.Acquire();
-
- // Start background thread if necessary
- if (!started_bgthread_) {
- started_bgthread_ = true;
- StartThread(&ChromiumEnv::BGThreadWrapper, this);
- }
-
- // If the queue is currently empty, the background thread may currently be
- // waiting.
- if (queue_.empty()) {
- bgsignal_.Signal();
- }
-
- // Add to priority queue
- queue_.push_back(BGItem());
- queue_.back().function = function;
- queue_.back().arg = arg;
-
- mu_.Release();
-}
-
-void ChromiumEnv::BGThread() {
- while (true) {
- // Wait until there is an item that is ready to run
- mu_.Acquire();
- while (queue_.empty()) {
- bgsignal_.Wait();
- }
-
- void (*function)(void*) = queue_.front().function;
- void* arg = queue_.front().arg;
- queue_.pop_front();
-
- mu_.Release();
- (*function)(arg);
- }
-}
-
-void ChromiumEnv::StartThread(void (*function)(void* arg), void* arg) {
- new Thread(function, arg); // Will self-delete.
-}
-
-::base::LazyInstance<ChromiumEnv, ::base::LeakyLazyInstanceTraits<ChromiumEnv> >
- default_env(::base::LINKER_INITIALIZED);
-
-}
-
-Env* Env::Default() {
- return default_env.Pointer();
-}
-
-}
View Lorry Controller Status