2015-07-02 01:13:49 +02:00
|
|
|
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
|
|
|
// This source code is licensed under the BSD-style license found in the
|
|
|
|
// LICENSE file in the root directory of this source tree. An additional grant
|
|
|
|
// of patent rights can be found in the PATENTS file in the same 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.
|
|
|
|
//
|
|
|
|
// See port_example.h for documentation for the following types/functions.
|
|
|
|
|
|
|
|
#ifndef STORAGE_LEVELDB_PORT_PORT_WIN_H_
|
|
|
|
#define STORAGE_LEVELDB_PORT_PORT_WIN_H_
|
|
|
|
|
|
|
|
// Always want minimum headers
|
|
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
2015-07-13 21:11:05 +02:00
|
|
|
#define WIN32_LEAN_AND_MEAN
|
2015-07-02 01:13:49 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// Assume that for everywhere
|
|
|
|
#undef PLATFORM_IS_LITTLE_ENDIAN
|
|
|
|
#define PLATFORM_IS_LITTLE_ENDIAN true
|
|
|
|
|
|
|
|
#include <windows.h>
|
|
|
|
#include <string>
|
|
|
|
#include <string.h>
|
|
|
|
#include <mutex>
|
2015-11-21 00:31:47 +01:00
|
|
|
#include <limits>
|
2015-07-02 01:13:49 +02:00
|
|
|
#include <condition_variable>
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
|
|
|
|
#include "rocksdb/options.h"
|
|
|
|
|
2015-07-16 21:10:16 +02:00
|
|
|
#undef min
|
|
|
|
#undef max
|
|
|
|
#undef DeleteFile
|
|
|
|
#undef GetCurrentTime
|
|
|
|
|
|
|
|
|
2015-07-02 01:13:49 +02:00
|
|
|
#ifndef strcasecmp
|
|
|
|
#define strcasecmp _stricmp
|
|
|
|
#endif
|
|
|
|
|
2015-07-16 21:10:16 +02:00
|
|
|
#undef GetCurrentTime
|
|
|
|
#undef DeleteFile
|
|
|
|
|
2015-07-02 01:13:49 +02:00
|
|
|
typedef SSIZE_T ssize_t;
|
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
// size_t printf formatting named in the manner of C99 standard formatting
|
|
|
|
// strings such as PRIu64
|
2015-07-02 01:13:49 +02:00
|
|
|
// in fact, we could use that one
|
2015-07-16 21:10:16 +02:00
|
|
|
#ifndef ROCKSDB_PRIszt
|
2015-07-02 01:13:49 +02:00
|
|
|
#define ROCKSDB_PRIszt "Iu"
|
2015-07-16 21:10:16 +02:00
|
|
|
#endif
|
2015-07-02 01:13:49 +02:00
|
|
|
|
|
|
|
#define __attribute__(A)
|
|
|
|
|
|
|
|
#ifdef ZLIB
|
|
|
|
#include <zlib.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef BZIP2
|
|
|
|
#include <bzlib.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(LZ4)
|
|
|
|
#include <lz4.h>
|
|
|
|
#include <lz4hc.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef SNAPPY
|
2015-07-08 01:58:20 +02:00
|
|
|
#include <snappy.h>
|
2015-07-02 01:13:49 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// Thread local storage on Linux
|
|
|
|
// There is thread_local in C++11
|
2015-07-16 21:10:16 +02:00
|
|
|
#ifndef __thread
|
2015-07-02 01:13:49 +02:00
|
|
|
#define __thread __declspec(thread)
|
2015-07-16 21:10:16 +02:00
|
|
|
#endif
|
2015-07-02 01:13:49 +02:00
|
|
|
|
|
|
|
#ifndef PLATFORM_IS_LITTLE_ENDIAN
|
|
|
|
#define PLATFORM_IS_LITTLE_ENDIAN (__BYTE_ORDER == __LITTLE_ENDIAN)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
namespace rocksdb {
|
|
|
|
|
|
|
|
#define PREFETCH(addr, rw, locality)
|
2015-08-27 03:51:18 +02:00
|
|
|
std::string GetWindowsErrSz(DWORD err);
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
namespace port {
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-11-21 00:31:47 +01:00
|
|
|
// VS 15
|
|
|
|
#if (defined _MSC_VER) && (_MSC_VER >= 1900)
|
|
|
|
|
|
|
|
#define ROCKSDB_NOEXCEPT noexcept
|
|
|
|
|
2015-07-08 01:58:20 +02:00
|
|
|
// For use at db/file_indexer.h kLevelMaxIndex
|
2015-11-21 00:31:47 +01:00
|
|
|
const int kMaxInt32 = std::numeric_limits<int>::max();
|
|
|
|
const uint64_t kMaxUint64 = std::numeric_limits<uint64_t>::max();
|
|
|
|
|
|
|
|
const size_t kMaxSizet = std::numeric_limits<size_t>::max();
|
|
|
|
|
|
|
|
#else //_MSC_VER
|
|
|
|
|
2015-12-08 17:38:21 +01:00
|
|
|
// VS 15 has snprintf
|
|
|
|
#define snprintf _snprintf
|
|
|
|
|
2015-11-21 00:31:47 +01:00
|
|
|
#define ROCKSDB_NOEXCEPT
|
2015-09-22 19:34:21 +02:00
|
|
|
// std::numeric_limits<size_t>::max() is not constexpr just yet
|
|
|
|
// therefore, use the same limits
|
2015-11-21 00:31:47 +01:00
|
|
|
|
|
|
|
// For use at db/file_indexer.h kLevelMaxIndex
|
|
|
|
const int kMaxInt32 = INT32_MAX;
|
|
|
|
const uint64_t kMaxUint64 = UINT64_MAX;
|
|
|
|
|
2015-09-22 19:34:21 +02:00
|
|
|
#ifdef _WIN64
|
|
|
|
const size_t kMaxSizet = UINT64_MAX;
|
|
|
|
#else
|
|
|
|
const size_t kMaxSizet = UINT_MAX;
|
|
|
|
#endif
|
2015-07-08 01:58:20 +02:00
|
|
|
|
2015-11-21 00:31:47 +01:00
|
|
|
#endif //_MSC_VER
|
|
|
|
|
2015-07-02 01:13:49 +02:00
|
|
|
const bool kLittleEndian = true;
|
|
|
|
|
|
|
|
class CondVar;
|
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
class Mutex {
|
|
|
|
public:
|
2015-10-13 00:41:20 +02:00
|
|
|
|
2015-10-13 23:28:11 +02:00
|
|
|
/* implicit */ Mutex(bool adaptive = false)
|
|
|
|
#ifndef NDEBUG
|
|
|
|
: locked_(false)
|
|
|
|
#endif
|
|
|
|
{ }
|
2015-10-13 00:41:20 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
~Mutex();
|
|
|
|
|
2015-10-13 00:41:20 +02:00
|
|
|
void Lock() {
|
|
|
|
mutex_.lock();
|
|
|
|
#ifndef NDEBUG
|
|
|
|
locked_ = true;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void Unlock() {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
locked_ = false;
|
|
|
|
#endif
|
|
|
|
mutex_.unlock();
|
|
|
|
}
|
2015-07-13 21:11:05 +02:00
|
|
|
|
|
|
|
// this will assert if the mutex is not locked
|
|
|
|
// it does NOT verify that mutex is held by a calling thread
|
2015-10-13 00:41:20 +02:00
|
|
|
void AssertHeld() {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
assert(locked_);
|
|
|
|
#endif
|
|
|
|
}
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-10-13 00:41:20 +02:00
|
|
|
// Mutex is move only with lock ownership transfer
|
|
|
|
Mutex(const Mutex&) = delete;
|
|
|
|
void operator=(const Mutex&) = delete;
|
2015-07-13 21:11:05 +02:00
|
|
|
|
|
|
|
private:
|
2015-10-13 00:41:20 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
friend class CondVar;
|
2015-10-13 00:41:20 +02:00
|
|
|
|
|
|
|
std::mutex& getLock() {
|
|
|
|
return mutex_;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::mutex mutex_;
|
2015-07-02 01:13:49 +02:00
|
|
|
#ifndef NDEBUG
|
2015-07-13 21:11:05 +02:00
|
|
|
bool locked_;
|
2015-07-02 01:13:49 +02:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
class RWMutex {
|
|
|
|
public:
|
|
|
|
RWMutex() { InitializeSRWLock(&srwLock_); }
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
void ReadLock() { AcquireSRWLockShared(&srwLock_); }
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
void WriteLock() { AcquireSRWLockExclusive(&srwLock_); }
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
void ReadUnlock() { ReleaseSRWLockShared(&srwLock_); }
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
void WriteUnlock() { ReleaseSRWLockExclusive(&srwLock_); }
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
// Empty as in POSIX
|
|
|
|
void AssertHeld() {}
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
private:
|
2015-07-08 01:58:20 +02:00
|
|
|
SRWLOCK srwLock_;
|
|
|
|
// No copying allowed
|
|
|
|
RWMutex(const RWMutex&);
|
|
|
|
void operator=(const RWMutex&);
|
2015-07-02 01:13:49 +02:00
|
|
|
};
|
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
class CondVar {
|
|
|
|
public:
|
2015-10-13 00:41:20 +02:00
|
|
|
explicit CondVar(Mutex* mu) : mu_(mu) {
|
|
|
|
}
|
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
~CondVar();
|
|
|
|
void Wait();
|
|
|
|
bool TimedWait(uint64_t expiration_time);
|
|
|
|
void Signal();
|
|
|
|
void SignalAll();
|
|
|
|
|
2015-10-13 00:41:20 +02:00
|
|
|
// Condition var is not copy/move constructible
|
|
|
|
CondVar(const CondVar&) = delete;
|
|
|
|
CondVar& operator=(const CondVar&) = delete;
|
|
|
|
|
|
|
|
CondVar(CondVar&&) = delete;
|
|
|
|
CondVar& operator=(CondVar&&) = delete;
|
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
private:
|
|
|
|
std::condition_variable cv_;
|
|
|
|
Mutex* mu_;
|
2015-07-02 01:13:49 +02:00
|
|
|
};
|
|
|
|
|
2015-11-21 00:31:47 +01:00
|
|
|
|
|
|
|
// OnceInit type helps emulate
|
|
|
|
// Posix semantics with initialization
|
|
|
|
// adopted in the project
|
|
|
|
struct OnceType {
|
|
|
|
|
|
|
|
struct Init {};
|
|
|
|
|
|
|
|
OnceType() {}
|
|
|
|
OnceType(const Init&) {}
|
|
|
|
OnceType(const OnceType&) = delete;
|
|
|
|
OnceType& operator=(const OnceType&) = delete;
|
|
|
|
|
|
|
|
std::once_flag flag_;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define LEVELDB_ONCE_INIT port::OnceType::Init()
|
2015-07-02 01:13:49 +02:00
|
|
|
extern void InitOnce(OnceType* once, void (*initializer)());
|
|
|
|
|
|
|
|
#define CACHE_LINE_SIZE 64U
|
|
|
|
|
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
2015-08-15 01:59:07 +02:00
|
|
|
static inline void AsmVolatilePause() {
|
|
|
|
#if defined(_M_IX86) || defined(_M_X64)
|
2016-01-13 23:51:58 +01:00
|
|
|
YieldProcessor();
|
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
2015-08-15 01:59:07 +02:00
|
|
|
#endif
|
|
|
|
// it would be nice to get "wfe" on ARM here
|
|
|
|
}
|
|
|
|
|
|
|
|
extern int PhysicalCoreID();
|
|
|
|
|
2015-07-02 01:13:49 +02:00
|
|
|
// For Thread Local Storage abstraction
|
|
|
|
typedef DWORD pthread_key_t;
|
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
inline int pthread_key_create(pthread_key_t* key, void (*destructor)(void*)) {
|
|
|
|
// Not used
|
|
|
|
(void)destructor;
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
pthread_key_t k = TlsAlloc();
|
|
|
|
if (TLS_OUT_OF_INDEXES == k) {
|
|
|
|
return ENOMEM;
|
|
|
|
}
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
*key = k;
|
|
|
|
return 0;
|
2015-07-02 01:13:49 +02:00
|
|
|
}
|
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
inline int pthread_key_delete(pthread_key_t key) {
|
|
|
|
if (!TlsFree(key)) {
|
|
|
|
return EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
2015-07-02 01:13:49 +02:00
|
|
|
}
|
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
inline int pthread_setspecific(pthread_key_t key, const void* value) {
|
|
|
|
if (!TlsSetValue(key, const_cast<void*>(value))) {
|
|
|
|
return ENOMEM;
|
|
|
|
}
|
|
|
|
return 0;
|
2015-07-02 01:13:49 +02:00
|
|
|
}
|
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
inline void* pthread_getspecific(pthread_key_t key) {
|
|
|
|
void* result = TlsGetValue(key);
|
|
|
|
if (!result) {
|
|
|
|
if (GetLastError() != ERROR_SUCCESS) {
|
|
|
|
errno = EINVAL;
|
|
|
|
} else {
|
|
|
|
errno = NOERROR;
|
2015-07-02 01:13:49 +02:00
|
|
|
}
|
2015-07-13 21:11:05 +02:00
|
|
|
}
|
|
|
|
return result;
|
2015-07-02 01:13:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// UNIX equiv although errno numbers will be off
|
|
|
|
// using C-runtime to implement. Note, this does not
|
|
|
|
// feel space with zeros in case the file is extended.
|
|
|
|
int truncate(const char* path, int64_t length);
|
2015-07-22 02:20:57 +02:00
|
|
|
void Crash(const std::string& srcfile, int srcline);
|
2015-09-10 19:49:28 +02:00
|
|
|
extern int GetMaxOpenFiles();
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
} // namespace port
|
2015-07-02 01:13:49 +02:00
|
|
|
|
|
|
|
using port::pthread_key_t;
|
|
|
|
using port::pthread_key_create;
|
|
|
|
using port::pthread_key_delete;
|
|
|
|
using port::pthread_setspecific;
|
|
|
|
using port::pthread_getspecific;
|
|
|
|
using port::truncate;
|
|
|
|
|
2015-07-13 21:11:05 +02:00
|
|
|
} // namespace rocksdb
|
2015-07-02 01:13:49 +02:00
|
|
|
|
2015-11-21 00:31:47 +01:00
|
|
|
#endif // STORAGE_LEVELDB_PORT_PORT_WIN_H_
|