|
|
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
|
|
// (found in the LICENSE.Apache file in the root directory).
|
|
|
|
//
|
|
|
|
// 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.
|
|
|
|
|
|
|
|
#if !defined(OS_WIN)
|
|
|
|
|
|
|
|
#include "port/port_posix.h"
|
|
|
|
|
|
|
|
#include <assert.h>
|
support for concurrent adds to memtable
Summary:
This diff adds support for concurrent adds to the skiplist memtable
implementations. Memory allocation is made thread-safe by the addition of
a spinlock, with small per-core buffers to avoid contention. Concurrent
memtable writes are made via an additional method and don't impose a
performance overhead on the non-concurrent case, so parallelism can be
selected on a per-batch basis.
Write thread synchronization is an increasing bottleneck for higher levels
of concurrency, so this diff adds --enable_write_thread_adaptive_yield
(default off). This feature causes threads joining a write batch
group to spin for a short time (default 100 usec) using sched_yield,
rather than going to sleep on a mutex. If the timing of the yield calls
indicates that another thread has actually run during the yield then
spinning is avoided. This option improves performance for concurrent
situations even without parallel adds, although it has the potential to
increase CPU usage (and the heuristic adaptation is not yet mature).
Parallel writes are not currently compatible with
inplace updates, update callbacks, or delete filtering.
Enable it with --allow_concurrent_memtable_write (and
--enable_write_thread_adaptive_yield). Parallel memtable writes
are performance neutral when there is no actual parallelism, and in
my experiments (SSD server-class Linux and varying contention and key
sizes for fillrandom) they are always a performance win when there is
more than one thread.
Statistics are updated earlier in the write path, dropping the number
of DB mutex acquisitions from 2 to 1 for almost all cases.
This diff was motivated and inspired by Yahoo's cLSM work. It is more
conservative than cLSM: RocksDB's write batch group leader role is
preserved (along with all of the existing flush and write throttling
logic) and concurrent writers are blocked until all memtable insertions
have completed and the sequence number has been advanced, to preserve
linearizability.
My test config is "db_bench -benchmarks=fillrandom -threads=$T
-batch_size=1 -memtablerep=skip_list -value_size=100 --num=1000000/$T
-level0_slowdown_writes_trigger=9999 -level0_stop_writes_trigger=9999
-disable_auto_compactions --max_write_buffer_number=8
-max_background_flushes=8 --disable_wal --write_buffer_size=160000000
--block_size=16384 --allow_concurrent_memtable_write" on a two-socket
Xeon E5-2660 @ 2.2Ghz with lots of memory and an SSD hard drive. With 1
thread I get ~440Kops/sec. Peak performance for 1 socket (numactl
-N1) is slightly more than 1Mops/sec, at 16 threads. Peak performance
across both sockets happens at 30 threads, and is ~900Kops/sec, although
with fewer threads there is less performance loss when the system has
background work.
Test Plan:
1. concurrent stress tests for InlineSkipList and DynamicBloom
2. make clean; make check
3. make clean; DISABLE_JEMALLOC=1 make valgrind_check; valgrind db_bench
4. make clean; COMPILE_WITH_TSAN=1 make all check; db_bench
5. make clean; COMPILE_WITH_ASAN=1 make all check; db_bench
6. make clean; OPT=-DROCKSDB_LITE make check
7. verify no perf regressions when disabled
Reviewers: igor, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, IslamAbdelRahman, anthony, yhchiang, rven, sdong, guyg8, kradhakrishnan, dhruba
Differential Revision: https://reviews.facebook.net/D50589
9 years ago
|
|
|
#if defined(__i386__) || defined(__x86_64__)
|
|
|
|
#include <cpuid.h>
|
|
|
|
#endif
|
|
|
|
#include <errno.h>
|
|
|
|
#include <sched.h>
|
Move rate_limiter, write buffering, most perf context instrumentation and most random kill out of Env
Summary: We want to keep Env a think layer for better portability. Less platform dependent codes should be moved out of Env. In this patch, I create a wrapper of file readers and writers, and put rate limiting, write buffering, as well as most perf context instrumentation and random kill out of Env. It will make it easier to maintain multiple Env in the future.
Test Plan: Run all existing unit tests.
Reviewers: anthony, kradhakrishnan, IslamAbdelRahman, yhchiang, igor
Reviewed By: igor
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D42321
10 years ago
|
|
|
#include <signal.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <sys/resource.h>
|
|
|
|
#include <sys/time.h>
|
Move rate_limiter, write buffering, most perf context instrumentation and most random kill out of Env
Summary: We want to keep Env a think layer for better portability. Less platform dependent codes should be moved out of Env. In this patch, I create a wrapper of file readers and writers, and put rate limiting, write buffering, as well as most perf context instrumentation and random kill out of Env. It will make it easier to maintain multiple Env in the future.
Test Plan: Run all existing unit tests.
Reviewers: anthony, kradhakrishnan, IslamAbdelRahman, yhchiang, igor
Reviewed By: igor
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D42321
10 years ago
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include <cstdlib>
|
Built-in support for generating unique IDs, bug fix (#8708)
Summary:
Env::GenerateUniqueId() works fine on Windows and on POSIX
where /proc/sys/kernel/random/uuid exists. Our other implementation is
flawed and easily produces collision in a new multi-threaded test.
As we rely more heavily on DB session ID uniqueness, this becomes a
serious issue.
This change combines several individually suitable entropy sources
for reliable generation of random unique IDs, with goal of uniqueness
and portability, not cryptographic strength nor maximum speed.
Specifically:
* Moves code for getting UUIDs from the OS to port::GenerateRfcUuid
rather than in Env implementation details. Callers are now told whether
the operation fails or succeeds.
* Adds an internal API GenerateRawUniqueId for generating high-quality
128-bit unique identifiers, by combining entropy from three "tracks":
* Lots of info from default Env like time, process id, and hostname.
* std::random_device
* port::GenerateRfcUuid (when working)
* Built-in implementations of Env::GenerateUniqueId() will now always
produce an RFC 4122 UUID string, either from platform-specific API or
by converting the output of GenerateRawUniqueId.
DB session IDs now use GenerateRawUniqueId while DB IDs (not as
critical) try to use port::GenerateRfcUuid but fall back on
GenerateRawUniqueId with conversion to an RFC 4122 UUID.
GenerateRawUniqueId is declared and defined under env/ rather than util/
or even port/ because of the Env dependency.
Likely follow-up: enhance GenerateRawUniqueId to be faster after the
first call and to guarantee uniqueness within the lifetime of a single
process (imparting the same property onto DB session IDs).
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8708
Test Plan:
A new mini-stress test in env_test checks the various public
and internal APIs for uniqueness, including each track of
GenerateRawUniqueId individually. We can't hope to verify anywhere close
to 128 bits of entropy, but it can at least detect flaws as bad as the
old code. Serial execution of the new tests takes about 350 ms on
my machine.
Reviewed By: zhichao-cao, mrambacher
Differential Revision: D30563780
Pulled By: pdillinger
fbshipit-source-id: de4c9ff4b2f581cf784fcedb5f39f16e5185c364
3 years ago
|
|
|
#include <fstream>
|
|
|
|
#include <string>
|
|
|
|
|
|
|
|
#include "util/string_util.h"
|
|
|
|
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
|
|
|
|
|
|
// We want to give users opportunity to default all the mutexes to adaptive if
|
|
|
|
// not specified otherwise. This enables a quick way to conduct various
|
|
|
|
// performance related experiements.
|
|
|
|
//
|
|
|
|
// NB! Support for adaptive mutexes is turned on by definining
|
|
|
|
// ROCKSDB_PTHREAD_ADAPTIVE_MUTEX during the compilation. If you use RocksDB
|
|
|
|
// build environment then this happens automatically; otherwise it's up to the
|
|
|
|
// consumer to define the identifier.
|
|
|
|
#ifdef ROCKSDB_DEFAULT_TO_ADAPTIVE_MUTEX
|
|
|
|
extern const bool kDefaultToAdaptiveMutex = true;
|
|
|
|
#else
|
|
|
|
extern const bool kDefaultToAdaptiveMutex = false;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
namespace port {
|
|
|
|
|
|
|
|
static int PthreadCall(const char* label, int result) {
|
|
|
|
if (result != 0 && result != ETIMEDOUT && result != EBUSY) {
|
|
|
|
fprintf(stderr, "pthread %s: %s\n", label, errnoStr(result).c_str());
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
Mutex::Mutex(bool adaptive) {
|
|
|
|
(void)adaptive;
|
|
|
|
#ifdef ROCKSDB_PTHREAD_ADAPTIVE_MUTEX
|
|
|
|
if (!adaptive) {
|
generic rate limiter
Summary:
A generic rate limiter that can be shared by threads and rocksdb
instances. Will use this to smooth out write traffic generated by
compaction and flush. This will help us get better p99 behavior on flash
storage.
Test Plan:
unit test output
==== Test RateLimiterTest.Rate
request size [1 - 1023], limit 10 KB/sec, actual rate: 10.374969 KB/sec, elapsed 2002265
request size [1 - 2047], limit 20 KB/sec, actual rate: 20.771242 KB/sec, elapsed 2002139
request size [1 - 4095], limit 40 KB/sec, actual rate: 41.285299 KB/sec, elapsed 2202424
request size [1 - 8191], limit 80 KB/sec, actual rate: 81.371605 KB/sec, elapsed 2402558
request size [1 - 16383], limit 160 KB/sec, actual rate: 162.541268 KB/sec, elapsed 3303500
Reviewers: yhchiang, igor, sdong
Reviewed By: sdong
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D19359
11 years ago
|
|
|
PthreadCall("init mutex", pthread_mutex_init(&mu_, nullptr));
|
|
|
|
} else {
|
|
|
|
pthread_mutexattr_t mutex_attr;
|
|
|
|
PthreadCall("init mutex attr", pthread_mutexattr_init(&mutex_attr));
|
|
|
|
PthreadCall("set mutex attr", pthread_mutexattr_settype(
|
|
|
|
&mutex_attr, PTHREAD_MUTEX_ADAPTIVE_NP));
|
|
|
|
PthreadCall("init mutex", pthread_mutex_init(&mu_, &mutex_attr));
|
|
|
|
PthreadCall("destroy mutex attr", pthread_mutexattr_destroy(&mutex_attr));
|
|
|
|
}
|
|
|
|
#else
|
generic rate limiter
Summary:
A generic rate limiter that can be shared by threads and rocksdb
instances. Will use this to smooth out write traffic generated by
compaction and flush. This will help us get better p99 behavior on flash
storage.
Test Plan:
unit test output
==== Test RateLimiterTest.Rate
request size [1 - 1023], limit 10 KB/sec, actual rate: 10.374969 KB/sec, elapsed 2002265
request size [1 - 2047], limit 20 KB/sec, actual rate: 20.771242 KB/sec, elapsed 2002139
request size [1 - 4095], limit 40 KB/sec, actual rate: 41.285299 KB/sec, elapsed 2202424
request size [1 - 8191], limit 80 KB/sec, actual rate: 81.371605 KB/sec, elapsed 2402558
request size [1 - 16383], limit 160 KB/sec, actual rate: 162.541268 KB/sec, elapsed 3303500
Reviewers: yhchiang, igor, sdong
Reviewed By: sdong
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D19359
11 years ago
|
|
|
PthreadCall("init mutex", pthread_mutex_init(&mu_, nullptr));
|
|
|
|
#endif // ROCKSDB_PTHREAD_ADAPTIVE_MUTEX
|
|
|
|
}
|
|
|
|
|
|
|
|
Mutex::~Mutex() { PthreadCall("destroy mutex", pthread_mutex_destroy(&mu_)); }
|
|
|
|
|
|
|
|
void Mutex::Lock() {
|
|
|
|
PthreadCall("lock", pthread_mutex_lock(&mu_));
|
|
|
|
#ifndef NDEBUG
|
|
|
|
locked_ = true;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void Mutex::Unlock() {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
locked_ = false;
|
|
|
|
#endif
|
|
|
|
PthreadCall("unlock", pthread_mutex_unlock(&mu_));
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Mutex::TryLock() {
|
|
|
|
bool ret = PthreadCall("trylock", pthread_mutex_trylock(&mu_)) == 0;
|
|
|
|
#ifndef NDEBUG
|
|
|
|
if (ret) {
|
|
|
|
locked_ = true;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Mutex::AssertHeld() {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
assert(locked_);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
CondVar::CondVar(Mutex* mu) : mu_(mu) {
|
|
|
|
PthreadCall("init cv", pthread_cond_init(&cv_, nullptr));
|
|
|
|
}
|
|
|
|
|
|
|
|
CondVar::~CondVar() { PthreadCall("destroy cv", pthread_cond_destroy(&cv_)); }
|
|
|
|
|
|
|
|
void CondVar::Wait() {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
mu_->locked_ = false;
|
|
|
|
#endif
|
|
|
|
PthreadCall("wait", pthread_cond_wait(&cv_, &mu_->mu_));
|
|
|
|
#ifndef NDEBUG
|
|
|
|
mu_->locked_ = true;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CondVar::TimedWait(uint64_t abs_time_us) {
|
|
|
|
struct timespec ts;
|
|
|
|
ts.tv_sec = static_cast<time_t>(abs_time_us / 1000000);
|
|
|
|
ts.tv_nsec = static_cast<suseconds_t>((abs_time_us % 1000000) * 1000);
|
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
mu_->locked_ = false;
|
|
|
|
#endif
|
|
|
|
int err = pthread_cond_timedwait(&cv_, &mu_->mu_, &ts);
|
|
|
|
#ifndef NDEBUG
|
|
|
|
mu_->locked_ = true;
|
|
|
|
#endif
|
|
|
|
if (err == ETIMEDOUT) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (err != 0) {
|
|
|
|
PthreadCall("timedwait", err);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CondVar::Signal() { PthreadCall("signal", pthread_cond_signal(&cv_)); }
|
|
|
|
|
|
|
|
void CondVar::SignalAll() {
|
|
|
|
PthreadCall("broadcast", pthread_cond_broadcast(&cv_));
|
|
|
|
}
|
|
|
|
|
generic rate limiter
Summary:
A generic rate limiter that can be shared by threads and rocksdb
instances. Will use this to smooth out write traffic generated by
compaction and flush. This will help us get better p99 behavior on flash
storage.
Test Plan:
unit test output
==== Test RateLimiterTest.Rate
request size [1 - 1023], limit 10 KB/sec, actual rate: 10.374969 KB/sec, elapsed 2002265
request size [1 - 2047], limit 20 KB/sec, actual rate: 20.771242 KB/sec, elapsed 2002139
request size [1 - 4095], limit 40 KB/sec, actual rate: 41.285299 KB/sec, elapsed 2202424
request size [1 - 8191], limit 80 KB/sec, actual rate: 81.371605 KB/sec, elapsed 2402558
request size [1 - 16383], limit 160 KB/sec, actual rate: 162.541268 KB/sec, elapsed 3303500
Reviewers: yhchiang, igor, sdong
Reviewed By: sdong
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D19359
11 years ago
|
|
|
RWMutex::RWMutex() {
|
|
|
|
PthreadCall("init mutex", pthread_rwlock_init(&mu_, nullptr));
|
|
|
|
}
|
|
|
|
|
|
|
|
RWMutex::~RWMutex() {
|
|
|
|
PthreadCall("destroy mutex", pthread_rwlock_destroy(&mu_));
|
|
|
|
}
|
|
|
|
|
|
|
|
void RWMutex::ReadLock() {
|
|
|
|
PthreadCall("read lock", pthread_rwlock_rdlock(&mu_));
|
|
|
|
}
|
|
|
|
|
|
|
|
void RWMutex::WriteLock() {
|
|
|
|
PthreadCall("write lock", pthread_rwlock_wrlock(&mu_));
|
|
|
|
}
|
|
|
|
|
|
|
|
void RWMutex::ReadUnlock() {
|
|
|
|
PthreadCall("read unlock", pthread_rwlock_unlock(&mu_));
|
|
|
|
}
|
|
|
|
|
|
|
|
void RWMutex::WriteUnlock() {
|
|
|
|
PthreadCall("write unlock", pthread_rwlock_unlock(&mu_));
|
|
|
|
}
|
|
|
|
|
|
|
|
int PhysicalCoreID() {
|
|
|
|
#if defined(ROCKSDB_SCHED_GETCPU_PRESENT) && defined(__x86_64__) && \
|
|
|
|
(__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 22))
|
|
|
|
// sched_getcpu uses VDSO getcpu() syscall since 2.22. I believe Linux offers
|
|
|
|
// VDSO support only on x86_64. This is the fastest/preferred method if
|
|
|
|
// available.
|
|
|
|
int cpuno = sched_getcpu();
|
|
|
|
if (cpuno < 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return cpuno;
|
|
|
|
#elif defined(__x86_64__) || defined(__i386__)
|
|
|
|
// clang/gcc both provide cpuid.h, which defines __get_cpuid(), for x86_64 and
|
|
|
|
// i386.
|
support for concurrent adds to memtable
Summary:
This diff adds support for concurrent adds to the skiplist memtable
implementations. Memory allocation is made thread-safe by the addition of
a spinlock, with small per-core buffers to avoid contention. Concurrent
memtable writes are made via an additional method and don't impose a
performance overhead on the non-concurrent case, so parallelism can be
selected on a per-batch basis.
Write thread synchronization is an increasing bottleneck for higher levels
of concurrency, so this diff adds --enable_write_thread_adaptive_yield
(default off). This feature causes threads joining a write batch
group to spin for a short time (default 100 usec) using sched_yield,
rather than going to sleep on a mutex. If the timing of the yield calls
indicates that another thread has actually run during the yield then
spinning is avoided. This option improves performance for concurrent
situations even without parallel adds, although it has the potential to
increase CPU usage (and the heuristic adaptation is not yet mature).
Parallel writes are not currently compatible with
inplace updates, update callbacks, or delete filtering.
Enable it with --allow_concurrent_memtable_write (and
--enable_write_thread_adaptive_yield). Parallel memtable writes
are performance neutral when there is no actual parallelism, and in
my experiments (SSD server-class Linux and varying contention and key
sizes for fillrandom) they are always a performance win when there is
more than one thread.
Statistics are updated earlier in the write path, dropping the number
of DB mutex acquisitions from 2 to 1 for almost all cases.
This diff was motivated and inspired by Yahoo's cLSM work. It is more
conservative than cLSM: RocksDB's write batch group leader role is
preserved (along with all of the existing flush and write throttling
logic) and concurrent writers are blocked until all memtable insertions
have completed and the sequence number has been advanced, to preserve
linearizability.
My test config is "db_bench -benchmarks=fillrandom -threads=$T
-batch_size=1 -memtablerep=skip_list -value_size=100 --num=1000000/$T
-level0_slowdown_writes_trigger=9999 -level0_stop_writes_trigger=9999
-disable_auto_compactions --max_write_buffer_number=8
-max_background_flushes=8 --disable_wal --write_buffer_size=160000000
--block_size=16384 --allow_concurrent_memtable_write" on a two-socket
Xeon E5-2660 @ 2.2Ghz with lots of memory and an SSD hard drive. With 1
thread I get ~440Kops/sec. Peak performance for 1 socket (numactl
-N1) is slightly more than 1Mops/sec, at 16 threads. Peak performance
across both sockets happens at 30 threads, and is ~900Kops/sec, although
with fewer threads there is less performance loss when the system has
background work.
Test Plan:
1. concurrent stress tests for InlineSkipList and DynamicBloom
2. make clean; make check
3. make clean; DISABLE_JEMALLOC=1 make valgrind_check; valgrind db_bench
4. make clean; COMPILE_WITH_TSAN=1 make all check; db_bench
5. make clean; COMPILE_WITH_ASAN=1 make all check; db_bench
6. make clean; OPT=-DROCKSDB_LITE make check
7. verify no perf regressions when disabled
Reviewers: igor, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, IslamAbdelRahman, anthony, yhchiang, rven, sdong, guyg8, kradhakrishnan, dhruba
Differential Revision: https://reviews.facebook.net/D50589
9 years ago
|
|
|
unsigned eax, ebx = 0, ecx, edx;
|
|
|
|
if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx)) {
|
|
|
|
return -1;
|
|
|
|
}
|
support for concurrent adds to memtable
Summary:
This diff adds support for concurrent adds to the skiplist memtable
implementations. Memory allocation is made thread-safe by the addition of
a spinlock, with small per-core buffers to avoid contention. Concurrent
memtable writes are made via an additional method and don't impose a
performance overhead on the non-concurrent case, so parallelism can be
selected on a per-batch basis.
Write thread synchronization is an increasing bottleneck for higher levels
of concurrency, so this diff adds --enable_write_thread_adaptive_yield
(default off). This feature causes threads joining a write batch
group to spin for a short time (default 100 usec) using sched_yield,
rather than going to sleep on a mutex. If the timing of the yield calls
indicates that another thread has actually run during the yield then
spinning is avoided. This option improves performance for concurrent
situations even without parallel adds, although it has the potential to
increase CPU usage (and the heuristic adaptation is not yet mature).
Parallel writes are not currently compatible with
inplace updates, update callbacks, or delete filtering.
Enable it with --allow_concurrent_memtable_write (and
--enable_write_thread_adaptive_yield). Parallel memtable writes
are performance neutral when there is no actual parallelism, and in
my experiments (SSD server-class Linux and varying contention and key
sizes for fillrandom) they are always a performance win when there is
more than one thread.
Statistics are updated earlier in the write path, dropping the number
of DB mutex acquisitions from 2 to 1 for almost all cases.
This diff was motivated and inspired by Yahoo's cLSM work. It is more
conservative than cLSM: RocksDB's write batch group leader role is
preserved (along with all of the existing flush and write throttling
logic) and concurrent writers are blocked until all memtable insertions
have completed and the sequence number has been advanced, to preserve
linearizability.
My test config is "db_bench -benchmarks=fillrandom -threads=$T
-batch_size=1 -memtablerep=skip_list -value_size=100 --num=1000000/$T
-level0_slowdown_writes_trigger=9999 -level0_stop_writes_trigger=9999
-disable_auto_compactions --max_write_buffer_number=8
-max_background_flushes=8 --disable_wal --write_buffer_size=160000000
--block_size=16384 --allow_concurrent_memtable_write" on a two-socket
Xeon E5-2660 @ 2.2Ghz with lots of memory and an SSD hard drive. With 1
thread I get ~440Kops/sec. Peak performance for 1 socket (numactl
-N1) is slightly more than 1Mops/sec, at 16 threads. Peak performance
across both sockets happens at 30 threads, and is ~900Kops/sec, although
with fewer threads there is less performance loss when the system has
background work.
Test Plan:
1. concurrent stress tests for InlineSkipList and DynamicBloom
2. make clean; make check
3. make clean; DISABLE_JEMALLOC=1 make valgrind_check; valgrind db_bench
4. make clean; COMPILE_WITH_TSAN=1 make all check; db_bench
5. make clean; COMPILE_WITH_ASAN=1 make all check; db_bench
6. make clean; OPT=-DROCKSDB_LITE make check
7. verify no perf regressions when disabled
Reviewers: igor, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, IslamAbdelRahman, anthony, yhchiang, rven, sdong, guyg8, kradhakrishnan, dhruba
Differential Revision: https://reviews.facebook.net/D50589
9 years ago
|
|
|
return ebx >> 24;
|
|
|
|
#else
|
|
|
|
// give up, the caller can generate a random number or something.
|
|
|
|
return -1;
|
support for concurrent adds to memtable
Summary:
This diff adds support for concurrent adds to the skiplist memtable
implementations. Memory allocation is made thread-safe by the addition of
a spinlock, with small per-core buffers to avoid contention. Concurrent
memtable writes are made via an additional method and don't impose a
performance overhead on the non-concurrent case, so parallelism can be
selected on a per-batch basis.
Write thread synchronization is an increasing bottleneck for higher levels
of concurrency, so this diff adds --enable_write_thread_adaptive_yield
(default off). This feature causes threads joining a write batch
group to spin for a short time (default 100 usec) using sched_yield,
rather than going to sleep on a mutex. If the timing of the yield calls
indicates that another thread has actually run during the yield then
spinning is avoided. This option improves performance for concurrent
situations even without parallel adds, although it has the potential to
increase CPU usage (and the heuristic adaptation is not yet mature).
Parallel writes are not currently compatible with
inplace updates, update callbacks, or delete filtering.
Enable it with --allow_concurrent_memtable_write (and
--enable_write_thread_adaptive_yield). Parallel memtable writes
are performance neutral when there is no actual parallelism, and in
my experiments (SSD server-class Linux and varying contention and key
sizes for fillrandom) they are always a performance win when there is
more than one thread.
Statistics are updated earlier in the write path, dropping the number
of DB mutex acquisitions from 2 to 1 for almost all cases.
This diff was motivated and inspired by Yahoo's cLSM work. It is more
conservative than cLSM: RocksDB's write batch group leader role is
preserved (along with all of the existing flush and write throttling
logic) and concurrent writers are blocked until all memtable insertions
have completed and the sequence number has been advanced, to preserve
linearizability.
My test config is "db_bench -benchmarks=fillrandom -threads=$T
-batch_size=1 -memtablerep=skip_list -value_size=100 --num=1000000/$T
-level0_slowdown_writes_trigger=9999 -level0_stop_writes_trigger=9999
-disable_auto_compactions --max_write_buffer_number=8
-max_background_flushes=8 --disable_wal --write_buffer_size=160000000
--block_size=16384 --allow_concurrent_memtable_write" on a two-socket
Xeon E5-2660 @ 2.2Ghz with lots of memory and an SSD hard drive. With 1
thread I get ~440Kops/sec. Peak performance for 1 socket (numactl
-N1) is slightly more than 1Mops/sec, at 16 threads. Peak performance
across both sockets happens at 30 threads, and is ~900Kops/sec, although
with fewer threads there is less performance loss when the system has
background work.
Test Plan:
1. concurrent stress tests for InlineSkipList and DynamicBloom
2. make clean; make check
3. make clean; DISABLE_JEMALLOC=1 make valgrind_check; valgrind db_bench
4. make clean; COMPILE_WITH_TSAN=1 make all check; db_bench
5. make clean; COMPILE_WITH_ASAN=1 make all check; db_bench
6. make clean; OPT=-DROCKSDB_LITE make check
7. verify no perf regressions when disabled
Reviewers: igor, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, IslamAbdelRahman, anthony, yhchiang, rven, sdong, guyg8, kradhakrishnan, dhruba
Differential Revision: https://reviews.facebook.net/D50589
9 years ago
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void InitOnce(OnceType* once, void (*initializer)()) {
|
|
|
|
PthreadCall("once", pthread_once(once, initializer));
|
|
|
|
}
|
|
|
|
|
Move rate_limiter, write buffering, most perf context instrumentation and most random kill out of Env
Summary: We want to keep Env a think layer for better portability. Less platform dependent codes should be moved out of Env. In this patch, I create a wrapper of file readers and writers, and put rate limiting, write buffering, as well as most perf context instrumentation and random kill out of Env. It will make it easier to maintain multiple Env in the future.
Test Plan: Run all existing unit tests.
Reviewers: anthony, kradhakrishnan, IslamAbdelRahman, yhchiang, igor
Reviewed By: igor
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D42321
10 years ago
|
|
|
void Crash(const std::string& srcfile, int srcline) {
|
|
|
|
fprintf(stdout, "Crashing at %s:%d\n", srcfile.c_str(), srcline);
|
|
|
|
fflush(stdout);
|
|
|
|
kill(getpid(), SIGTERM);
|
|
|
|
}
|
|
|
|
|
|
|
|
int GetMaxOpenFiles() {
|
|
|
|
#if defined(RLIMIT_NOFILE)
|
|
|
|
struct rlimit no_files_limit;
|
|
|
|
if (getrlimit(RLIMIT_NOFILE, &no_files_limit) != 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
// protect against overflow
|
|
|
|
if (static_cast<uintmax_t>(no_files_limit.rlim_cur) >=
|
|
|
|
static_cast<uintmax_t>(std::numeric_limits<int>::max())) {
|
|
|
|
return std::numeric_limits<int>::max();
|
|
|
|
}
|
|
|
|
return static_cast<int>(no_files_limit.rlim_cur);
|
|
|
|
#endif
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void* cacheline_aligned_alloc(size_t size) {
|
|
|
|
#if __GNUC__ < 5 && defined(__SANITIZE_ADDRESS__)
|
|
|
|
return malloc(size);
|
|
|
|
#elif (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || defined(__APPLE__))
|
|
|
|
void* m;
|
|
|
|
errno = posix_memalign(&m, CACHE_LINE_SIZE, size);
|
|
|
|
return errno ? nullptr : m;
|
|
|
|
#else
|
|
|
|
return malloc(size);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void cacheline_aligned_free(void* memblock) { free(memblock); }
|
|
|
|
|
|
|
|
static size_t GetPageSize() {
|
|
|
|
#if defined(OS_LINUX) || defined(_SC_PAGESIZE)
|
|
|
|
long v = sysconf(_SC_PAGESIZE);
|
|
|
|
if (v >= 1024) {
|
|
|
|
return static_cast<size_t>(v);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
// Default assume 4KB
|
|
|
|
return 4U * 1024U;
|
|
|
|
}
|
|
|
|
|
|
|
|
const size_t kPageSize = GetPageSize();
|
|
|
|
|
|
|
|
void SetCpuPriority(ThreadId id, CpuPriority priority) {
|
|
|
|
#ifdef OS_LINUX
|
|
|
|
sched_param param;
|
|
|
|
param.sched_priority = 0;
|
|
|
|
switch (priority) {
|
|
|
|
case CpuPriority::kHigh:
|
|
|
|
sched_setscheduler(id, SCHED_OTHER, ¶m);
|
|
|
|
setpriority(PRIO_PROCESS, id, -20);
|
|
|
|
break;
|
|
|
|
case CpuPriority::kNormal:
|
|
|
|
sched_setscheduler(id, SCHED_OTHER, ¶m);
|
|
|
|
setpriority(PRIO_PROCESS, id, 0);
|
|
|
|
break;
|
|
|
|
case CpuPriority::kLow:
|
|
|
|
sched_setscheduler(id, SCHED_OTHER, ¶m);
|
|
|
|
setpriority(PRIO_PROCESS, id, 19);
|
|
|
|
break;
|
|
|
|
case CpuPriority::kIdle:
|
|
|
|
sched_setscheduler(id, SCHED_IDLE, ¶m);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(false);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
(void)id;
|
|
|
|
(void)priority;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t GetProcessID() { return getpid(); }
|
|
|
|
|
Built-in support for generating unique IDs, bug fix (#8708)
Summary:
Env::GenerateUniqueId() works fine on Windows and on POSIX
where /proc/sys/kernel/random/uuid exists. Our other implementation is
flawed and easily produces collision in a new multi-threaded test.
As we rely more heavily on DB session ID uniqueness, this becomes a
serious issue.
This change combines several individually suitable entropy sources
for reliable generation of random unique IDs, with goal of uniqueness
and portability, not cryptographic strength nor maximum speed.
Specifically:
* Moves code for getting UUIDs from the OS to port::GenerateRfcUuid
rather than in Env implementation details. Callers are now told whether
the operation fails or succeeds.
* Adds an internal API GenerateRawUniqueId for generating high-quality
128-bit unique identifiers, by combining entropy from three "tracks":
* Lots of info from default Env like time, process id, and hostname.
* std::random_device
* port::GenerateRfcUuid (when working)
* Built-in implementations of Env::GenerateUniqueId() will now always
produce an RFC 4122 UUID string, either from platform-specific API or
by converting the output of GenerateRawUniqueId.
DB session IDs now use GenerateRawUniqueId while DB IDs (not as
critical) try to use port::GenerateRfcUuid but fall back on
GenerateRawUniqueId with conversion to an RFC 4122 UUID.
GenerateRawUniqueId is declared and defined under env/ rather than util/
or even port/ because of the Env dependency.
Likely follow-up: enhance GenerateRawUniqueId to be faster after the
first call and to guarantee uniqueness within the lifetime of a single
process (imparting the same property onto DB session IDs).
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8708
Test Plan:
A new mini-stress test in env_test checks the various public
and internal APIs for uniqueness, including each track of
GenerateRawUniqueId individually. We can't hope to verify anywhere close
to 128 bits of entropy, but it can at least detect flaws as bad as the
old code. Serial execution of the new tests takes about 350 ms on
my machine.
Reviewed By: zhichao-cao, mrambacher
Differential Revision: D30563780
Pulled By: pdillinger
fbshipit-source-id: de4c9ff4b2f581cf784fcedb5f39f16e5185c364
3 years ago
|
|
|
bool GenerateRfcUuid(std::string* output) {
|
|
|
|
output->clear();
|
|
|
|
std::ifstream f("/proc/sys/kernel/random/uuid");
|
|
|
|
std::getline(f, /*&*/ *output);
|
|
|
|
if (output->size() == 36) {
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
output->clear();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace port
|
|
|
|
} // namespace ROCKSDB_NAMESPACE
|
|
|
|
|
|
|
|
#endif
|