2016-02-10 00:12:00 +01:00
|
|
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
2017-07-16 01:03:42 +02:00
|
|
|
// 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).
|
2013-10-16 23:59:46 +02:00
|
|
|
//
|
2011-03-18 23:37:00 +01:00
|
|
|
// 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.
|
|
|
|
|
2019-05-31 02:39:43 +02:00
|
|
|
#include "memory/arena.h"
|
2015-07-03 02:41:05 +02:00
|
|
|
#ifndef OS_WIN
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#endif
|
2014-01-09 00:06:07 +01:00
|
|
|
#include <algorithm>
|
2019-06-01 02:19:43 +02:00
|
|
|
#include "logging/logging.h"
|
2019-09-17 00:14:51 +02:00
|
|
|
#include "port/malloc.h"
|
2017-03-16 03:22:52 +01:00
|
|
|
#include "port/port.h"
|
2014-05-05 00:52:23 +02:00
|
|
|
#include "rocksdb/env.h"
|
2019-05-30 20:21:38 +02:00
|
|
|
#include "test_util/sync_point.h"
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2020-02-20 21:07:53 +01:00
|
|
|
namespace ROCKSDB_NAMESPACE {
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2015-07-08 01:58:20 +02:00
|
|
|
// MSVC complains that it is already defined since it is static in the header.
|
2017-03-31 01:47:19 +02:00
|
|
|
#ifndef _MSC_VER
|
2015-07-08 01:58:20 +02:00
|
|
|
const size_t Arena::kInlineSize;
|
|
|
|
#endif
|
|
|
|
|
2014-01-31 02:18:17 +01:00
|
|
|
const size_t Arena::kMinBlockSize = 4096;
|
2016-03-16 22:57:57 +01:00
|
|
|
const size_t Arena::kMaxBlockSize = 2u << 30;
|
arena: derive alignment unit from std::max_align_t
Summary:
As raised in #2265, the arena allocator will return memory that is improperly aligned to store a `std::function` on macOS. Oddly, I'm unable to tickle this bug without adding a `std::function` field to `struct ReadOptions`—but my proposal in #2265 does exactly that.
In any case, here's a simple reproduction. Apply this bogus patch to get a `std::function` into `struct ReadOptions`
```
--- a/include/rocksdb/options.h
+++ b/include/rocksdb/options.h
@@ -1035,6 +1035,8 @@ struct ReadOptions {
// Default: 0
uint64_t max_skippable_internal_keys;
+ std::function<void()> foo;
+
ReadOptions();
ReadOptions(bool cksum, bool cache);
};
```
then compile `db_properties_test` *with ubsan* and run `ReadLatencyHistogramByLevel`:
```
$ make COMPILE_WITH_UBSAN=1 db_properties_test
$ ./db_properties_test --gtest_filter=DBPropertiesTest.ReadLatencyHistogramByLevel
```
ubsan will complain about several misaligned accesses:
```
Note: Google Test filter = DBPropertiesTest.ReadLatencyHistogramByLevel
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from DBPropertiesTest
[ RUN ] DBPropertiesTest.ReadLatencyHistogramByLevel
util/coding.h:372:12: runtime error: load of misaligned address 0x00010d85516c for type 'const unsigned long', which requires 8 byte alignment
0x00010d85516c: note: pointer points here
01 00 34 57 00 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 78 24 82 0a 01 00 00 00
^
util/coding.h:362:3: runtime error: store to misaligned address 0x7fff5733fac4 for type 'unsigned long', which requires 8 byte alignment
0x7fff5733fac4: note: pointer points here
01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 80 1d 96 0d 01 00 00 00
^
util/coding.h:372:12: runtime error: load of misaligned address 0x00010d85516c for type 'const unsigned long', which requires 8 byte alignment
0x00010d85516c: note: pointer points here
01 00 34 57 00 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 78 24 82 0a 01 00 00 00
^
version_set.cc:854: runtime error: constructor call on misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
version_set.cc:512: runtime error: constructor call on misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
version_set.cc:505: runtime error: constructor call on misaligned address 0x00010dbfa5e8 for type 'rocksdb::ReadOptions', which requires 16 byte alignment
0x00010dbfa5e8: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
options.h:931: runtime error: constructor call on misaligned address 0x00010dbfa5e8 for type 'rocksdb::ReadOptions', which requires 16 byte alignment
0x00010dbfa5e8: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
options.h:931: runtime error: constructor call on misaligned address 0x00010dbfa628 for type 'std::__1::function<void ()>', which requires 16 byte alignment
0x00010dbfa628: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
functional:1583: runtime error: constructor call on misaligned address 0x00010dbfa628 for type 'std::__1::function<void ()>', which requires 16 byte alignment
0x00010dbfa628: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/functional:1585:9: runtime error: member access within misaligned address 0x00010dbfa628 for type 'std::__1::function<void ()>', which requires 16 byte alignment
0x00010dbfa628: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/functional:1585:9: runtime error: store to misaligned address 0x00010dbfa648 for type '__base *' (aka '__base<void ()> *'), which requires 16 byte alignment
0x00010dbfa648: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
db/version_set.cc:864:29: runtime error: upcast of misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
db/version_set.cc:521:12: runtime error: member access within misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
db/version_set.cc:521:12: runtime error: load of misaligned address 0x00010dbfa5d8 for type 'rocksdb::TableCache *', which requires 16 byte alignment
0x00010dbfa5d8: note: pointer points here
00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00 00 00 00 00 01 01 ff ff ff ff ff ff 00 00 00 00
^
db/version_set.cc:522:9: runtime error: member access within misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
db/version_set.cc:522:9: runtime error: reference binding to misaligned address 0x00010dbfa5e8 for type 'const rocksdb::ReadOptions', which requires 16 byte alignment
0x00010dbfa5e8: note: pointer points here
00 00 00 00 01 01 ff ff ff ff ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
db/version_set.cc:522:24: runtime error: member access within misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
db/version_set.cc:522:38: runtime error: member access within misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
db/version_set.cc:522:57: runtime error: member access within misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
db/version_set.cc:522:57: runtime error: load of misaligned address 0x00010dbfa678 for type 'rocksdb::RangeDelAggregator *', which requires 16 byte alignment
0x00010dbfa678: note: pointer points here
01 00 00 00 d0 a1 bf 0d 01 00 00 00 00 00 00 00 00 00 00 00 f8 db 70 0a 01 00 00 00 00 00 00 00
^
db/version_set.cc:523:54: runtime error: member access within misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
db/version_set.cc:523:54: runtime error: load of misaligned address 0x00010dbfa668 for type 'rocksdb::HistogramImpl *', which requires 16 byte alignment
0x00010dbfa668: note: pointer points here
01 00 00 00 c8 88 a5 0d 01 00 00 00 00 00 00 00 01 00 00 00 d0 a1 bf 0d 01 00 00 00 00 00 00 00
^
db/version_set.cc:524:9: runtime error: member access within misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
db/version_set.cc:524:47: runtime error: member access within misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
db/version_set.cc:524:62: runtime error: member access within misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
db/table_cache.cc:228:33: runtime error: reference binding to misaligned address 0x00010dbfa5e8 for type 'const rocksdb::ReadOptions', which requires 16 byte alignment
0x00010dbfa5e8: note: pointer points here
00 00 00 00 01 01 ff ff ff ff ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
table/block_based_table_reader.cc:1554:41: runtime error: reference binding to misaligned address 0x00010dbfa5e8 for type 'const rocksdb::ReadOptions', which requires 16 byte alignment
0x00010dbfa5e8: note: pointer points here
00 00 00 00 01 01 ff ff ff ff ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
table/block_based_table_reader.cc:1396:21: runtime error: reference binding to misaligned address 0x00010dbfa5e8 for type 'const rocksdb::ReadOptions', which requires 16 byte alignment
0x00010dbfa5e8: note: pointer points here
00 00 00 00 01 01 ff ff ff ff ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
include/rocksdb/options.h:931:8: runtime error: reference binding to misaligned address 0x00010dbfa628 for type 'const std::function<void ()>', which requires 16 byte alignment
0x00010dbfa628: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/functional:1584:13: runtime error: load of misaligned address 0x00010dbfa648 for type '__base *const' (aka '__base<void ()> *const'), which requires 16 byte alignment
0x00010dbfa648: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 c8 a5 97 0d 01 00 00 00 38 36 9b 0d
^
table/block_based_table_reader.cc:1555:24: runtime error: reference binding to misaligned address 0x00010dbfa5e8 for type 'const rocksdb::ReadOptions', which requires 16 byte alignment
0x00010dbfa5e8: note: pointer points here
00 00 00 00 01 01 ff ff ff ff ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
db/table_cache.cc:244:54: runtime error: load of misaligned address 0x00010dbfa618 for type 'const bool', which requires 16 byte alignment
0x00010dbfa618: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
db/table_cache.cc:246:49: runtime error: reference binding to misaligned address 0x00010dbfa5e8 for type 'const rocksdb::ReadOptions', which requires 16 byte alignment
0x00010dbfa5e8: note: pointer points here
00 00 00 00 01 01 ff ff ff ff ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
db/version_set.cc:532:12: runtime error: member access within misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
db/version_set.cc:532:12: runtime error: member access within misaligned address 0x00010dbfa5e8 for type 'const rocksdb::ReadOptions', which requires 16 byte alignment
0x00010dbfa5e8: note: pointer points here
00 00 00 00 01 01 ff ff ff ff ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
db/version_set.cc:532:26: runtime error: load of misaligned address 0x00010dbfa5f8 for type 'const rocksdb::Slice *const', which requires 16 byte alignment
0x00010dbfa5f8: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
version_set.cc:493: runtime error: member call on misaligned address 0x00010dbfa5c8 for type 'rocksdb::(anonymous namespace)::LevelFileIteratorState', which requires 16 byte alignment
0x00010dbfa5c8: note: pointer points here
00 00 00 00 a0 db 70 0a 01 00 00 00 00 00 00 00 00 00 00 00 90 14 98 0d 01 00 00 00 00 00 00 00
^
version_set.cc:493: runtime error: member call on misaligned address 0x00010dbfa5e8 for type 'rocksdb::ReadOptions', which requires 16 byte alignment
0x00010dbfa5e8: note: pointer points here
00 00 00 00 01 01 ff ff ff ff ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
options.h:931: runtime error: member call on misaligned address 0x00010dbfa5e8 for type 'rocksdb::ReadOptions', which requires 16 byte alignment
0x00010dbfa5e8: note: pointer points here
00 00 00 00 01 01 ff ff ff ff ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
options.h:931: runtime error: member call on misaligned address 0x00010dbfa628 for type 'std::__1::function<void ()>', which requires 16 byte alignment
0x00010dbfa628: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
functional:1765: runtime error: member call on misaligned address 0x00010dbfa628 for type 'std::__1::function<void ()>', which requires 16 byte alignment
0x00010dbfa628: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/functional:1766:9: runtime error: member access within misaligned address 0x00010dbfa628 for type 'std::__1::function<void ()>', which requires 16 byte alignment
0x00010dbfa628: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/functional:1766:9: runtime error: load of misaligned address 0x00010dbfa648 for type '__base *' (aka '__base<void ()> *'), which requires 16 byte alignment
0x00010dbfa648: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 c8 a5 97 0d 01 00 00 00 38 36 9b 0d
^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/functional:1766:27: runtime error: member access within misaligned address 0x00010dbfa628 for type 'std::__1::function<void ()>', which requires 16 byte alignment
0x00010dbfa628: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/functional:1768:14: runtime error: member access within misaligned address 0x00010dbfa628 for type 'std::__1::function<void ()>', which requires 16 byte alignment
0x00010dbfa628: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/functional:1768:14: runtime error: load of misaligned address 0x00010dbfa648 for type '__base *' (aka '__base<void ()> *'), which requires 16 byte alignment
0x00010dbfa648: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 c8 a5 97 0d 01 00 00 00 38 36 9b 0d
^
[ OK ] DBPropertiesTest.ReadLatencyHistogramByLevel (1599 ms)
[----------] 1 test from DBPropertiesTest (1599 ms total)
[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran. (1599 ms total)
[ PASSED ] 1 test.
```
So it seems the root cause is that the internal implementation of `std::function` on macOS (and perhaps with libc++ generally?) requires 16-byte aligned memory, but the arena allocator only guarantees that the returned memory will be `sizeof(void*)` aligned, which is only 8-byte alignment on my machine. This patch solves the problem by adjusting the allocator to derive the necessary alignment from `alignof(std::max_align_t)`, which is properly 16 bytes on my machine.
As I mentioned in #2265, none of RocksDB's tests will cause this unaligned access to actually abort the process, but, on macOS, linking CockroachDB against a version of RocksDB with the above patch and letting it run for just a few seconds will cause a SIGABRT.
```
Process 19792 stopped
* thread #2, stop reason = EXC_BAD_ACCESS (code=EXC_I386_GPFLT)
frame #0: 0x0000000004f5e78f cockroach`DBNewIter + 95
cockroach`DBNewIter:
-> 0x4f5e78f <+95>: callq *0x28(%rax)
0x4f5e792 <+98>: jmp 0x4f5e79e ; <+110>
0x4f5e794 <+100>: movq -0x50(%rbp), %rcx
0x4f5e798 <+104>: movq %rax, %rdi
(lldb) bt
* thread #2, stop reason = EXC_BAD_ACCESS (code=EXC_I386_GPFLT)
* frame #0: 0x0000000004f5e78f cockroach`DBNewIter + 95
```
I'd get you a backtrace, but [Go doesn't include cgo debug information on macOS](https://github.com/golang/go/issues/6942). I've also tried building against libc++ on Linux, where debug information would be available, but I can't seem to trigger the bug there.
In any case, this PR both fixes the segfault in CockroachDB and fixes the warnings reported by ubsan.
Closes https://github.com/facebook/rocksdb/pull/2347
Differential Revision: D5108596
Pulled By: yiwu-arbug
fbshipit-source-id: bd5e4323b2ce915ed4fe78e123cb8996aec75a00
2017-10-17 20:07:35 +02:00
|
|
|
static const int kAlignUnit = alignof(max_align_t);
|
2014-01-09 00:06:07 +01:00
|
|
|
|
|
|
|
size_t OptimizeBlockSize(size_t block_size) {
|
|
|
|
// Make sure block_size is in optimal range
|
2014-01-31 02:18:17 +01:00
|
|
|
block_size = std::max(Arena::kMinBlockSize, block_size);
|
|
|
|
block_size = std::min(Arena::kMaxBlockSize, block_size);
|
2014-01-09 00:06:07 +01:00
|
|
|
|
|
|
|
// make sure block_size is the multiple of kAlignUnit
|
|
|
|
if (block_size % kAlignUnit != 0) {
|
|
|
|
block_size = (1 + block_size / kAlignUnit) * kAlignUnit;
|
Make arena block size configurable
Summary:
Add an option for arena block size, default value 4096 bytes. Arena will allocate blocks with such size.
I am not sure about passing parameter to skiplist in the new virtualized framework, though I talked to Jim a bit. So add Jim as reviewer.
Test Plan:
new unit test, I am running db_test.
For passing paramter from configured option to Arena, I tried tests like:
TEST(DBTest, Arena_Option) {
std::string dbname = test::TmpDir() + "/db_arena_option_test";
DestroyDB(dbname, Options());
DB* db = nullptr;
Options opts;
opts.create_if_missing = true;
opts.arena_block_size = 1000000; // tested 99, 999999
Status s = DB::Open(opts, dbname, &db);
db->Put(WriteOptions(), "a", "123");
}
and printed some debug info. The results look good. Any suggestion for such a unit-test?
Reviewers: haobo, dhruba, emayanke, jpaton
Reviewed By: dhruba
CC: leveldb, zshao
Differential Revision: https://reviews.facebook.net/D11799
2013-07-31 21:42:23 +02:00
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2014-01-09 00:06:07 +01:00
|
|
|
return block_size;
|
|
|
|
}
|
|
|
|
|
2017-06-02 23:13:59 +02:00
|
|
|
Arena::Arena(size_t block_size, AllocTracker* tracker, size_t huge_page_size)
|
|
|
|
: kBlockSize(OptimizeBlockSize(block_size)), tracker_(tracker) {
|
2014-01-09 00:06:07 +01:00
|
|
|
assert(kBlockSize >= kMinBlockSize && kBlockSize <= kMaxBlockSize &&
|
|
|
|
kBlockSize % kAlignUnit == 0);
|
2017-06-02 23:13:59 +02:00
|
|
|
TEST_SYNC_POINT_CALLBACK("Arena::Arena:0", const_cast<size_t*>(&kBlockSize));
|
2014-05-09 20:01:54 +02:00
|
|
|
alloc_bytes_remaining_ = sizeof(inline_block_);
|
|
|
|
blocks_memory_ += alloc_bytes_remaining_;
|
|
|
|
aligned_alloc_ptr_ = inline_block_;
|
|
|
|
unaligned_alloc_ptr_ = inline_block_ + alloc_bytes_remaining_;
|
2014-11-21 23:11:22 +01:00
|
|
|
#ifdef MAP_HUGETLB
|
|
|
|
hugetlb_size_ = huge_page_size;
|
|
|
|
if (hugetlb_size_ && kBlockSize > hugetlb_size_) {
|
|
|
|
hugetlb_size_ = ((kBlockSize - 1U) / hugetlb_size_ + 1U) * hugetlb_size_;
|
|
|
|
}
|
2018-04-13 02:55:14 +02:00
|
|
|
#else
|
|
|
|
(void)huge_page_size;
|
2014-11-21 23:11:22 +01:00
|
|
|
#endif
|
2017-06-02 23:13:59 +02:00
|
|
|
if (tracker_ != nullptr) {
|
|
|
|
tracker_->Allocate(kInlineSize);
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2014-01-31 02:18:17 +01:00
|
|
|
Arena::~Arena() {
|
2017-06-02 23:13:59 +02:00
|
|
|
if (tracker_ != nullptr) {
|
|
|
|
assert(tracker_->is_freed());
|
|
|
|
tracker_->FreeMem();
|
|
|
|
}
|
2014-01-09 00:06:07 +01:00
|
|
|
for (const auto& block : blocks_) {
|
|
|
|
delete[] block;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2015-07-08 01:58:20 +02:00
|
|
|
|
|
|
|
#ifdef MAP_HUGETLB
|
2014-05-04 22:55:53 +02:00
|
|
|
for (const auto& mmap_info : huge_blocks_) {
|
2018-02-16 04:30:52 +01:00
|
|
|
if (mmap_info.addr_ == nullptr) {
|
|
|
|
continue;
|
|
|
|
}
|
2014-05-04 22:55:53 +02:00
|
|
|
auto ret = munmap(mmap_info.addr_, mmap_info.length_);
|
|
|
|
if (ret != 0) {
|
|
|
|
// TODO(sdong): Better handling
|
|
|
|
}
|
|
|
|
}
|
2015-07-02 01:13:49 +02:00
|
|
|
#endif
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2014-01-31 02:18:17 +01:00
|
|
|
char* Arena::AllocateFallback(size_t bytes, bool aligned) {
|
2014-01-09 00:06:07 +01:00
|
|
|
if (bytes > kBlockSize / 4) {
|
2014-03-13 00:40:14 +01:00
|
|
|
++irregular_block_num;
|
2011-03-18 23:37:00 +01:00
|
|
|
// Object is more than a quarter of our block size. Allocate it separately
|
|
|
|
// to avoid wasting too much space in leftover bytes.
|
2014-01-09 00:06:07 +01:00
|
|
|
return AllocateNewBlock(bytes);
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// We waste the remaining space in the current block.
|
2015-09-25 22:17:19 +02:00
|
|
|
size_t size = 0;
|
2014-11-21 23:11:22 +01:00
|
|
|
char* block_head = nullptr;
|
2015-09-25 21:23:40 +02:00
|
|
|
#ifdef MAP_HUGETLB
|
2014-11-21 23:11:22 +01:00
|
|
|
if (hugetlb_size_) {
|
|
|
|
size = hugetlb_size_;
|
|
|
|
block_head = AllocateFromHugePage(size);
|
|
|
|
}
|
2015-09-25 21:23:40 +02:00
|
|
|
#endif
|
2015-09-25 22:55:11 +02:00
|
|
|
if (!block_head) {
|
2014-11-21 23:11:22 +01:00
|
|
|
size = kBlockSize;
|
|
|
|
block_head = AllocateNewBlock(size);
|
|
|
|
}
|
|
|
|
alloc_bytes_remaining_ = size - bytes;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2014-01-09 00:06:07 +01:00
|
|
|
if (aligned) {
|
|
|
|
aligned_alloc_ptr_ = block_head + bytes;
|
2014-11-21 23:11:22 +01:00
|
|
|
unaligned_alloc_ptr_ = block_head + size;
|
2014-01-09 00:06:07 +01:00
|
|
|
return block_head;
|
|
|
|
} else {
|
|
|
|
aligned_alloc_ptr_ = block_head;
|
2014-11-21 23:11:22 +01:00
|
|
|
unaligned_alloc_ptr_ = block_head + size - bytes;
|
2014-01-09 00:06:07 +01:00
|
|
|
return unaligned_alloc_ptr_;
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2014-11-21 23:11:22 +01:00
|
|
|
char* Arena::AllocateFromHugePage(size_t bytes) {
|
|
|
|
#ifdef MAP_HUGETLB
|
|
|
|
if (hugetlb_size_ == 0) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
2018-02-16 04:30:52 +01:00
|
|
|
// Reserve space in `huge_blocks_` before calling `mmap`.
|
|
|
|
// Use `emplace_back()` instead of `reserve()` to let std::vector manage its
|
|
|
|
// own memory and do fewer reallocations.
|
|
|
|
//
|
|
|
|
// - If `emplace_back` throws, no memory leaks because we haven't called
|
|
|
|
// `mmap` yet.
|
|
|
|
// - If `mmap` throws, no memory leaks because the vector will be cleaned up
|
|
|
|
// via RAII.
|
|
|
|
huge_blocks_.emplace_back(nullptr /* addr */, 0 /* length */);
|
2014-11-21 23:11:22 +01:00
|
|
|
|
|
|
|
void* addr = mmap(nullptr, bytes, (PROT_READ | PROT_WRITE),
|
2016-08-10 22:52:23 +02:00
|
|
|
(MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB), -1, 0);
|
2014-11-21 23:11:22 +01:00
|
|
|
|
|
|
|
if (addr == MAP_FAILED) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
2018-02-16 04:30:52 +01:00
|
|
|
huge_blocks_.back() = MmapInfo(addr, bytes);
|
2014-11-21 23:11:22 +01:00
|
|
|
blocks_memory_ += bytes;
|
2017-06-02 23:13:59 +02:00
|
|
|
if (tracker_ != nullptr) {
|
|
|
|
tracker_->Allocate(bytes);
|
|
|
|
}
|
2014-11-21 23:11:22 +01:00
|
|
|
return reinterpret_cast<char*>(addr);
|
|
|
|
#else
|
2018-04-13 02:55:14 +02:00
|
|
|
(void)bytes;
|
2014-11-21 23:11:22 +01:00
|
|
|
return nullptr;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-08-15 02:01:20 +02:00
|
|
|
char* Arena::AllocateAligned(size_t bytes, size_t huge_page_size,
|
2014-05-05 00:52:23 +02:00
|
|
|
Logger* logger) {
|
2014-01-09 00:06:07 +01:00
|
|
|
assert((kAlignUnit & (kAlignUnit - 1)) ==
|
|
|
|
0); // Pointer size should be a power of 2
|
2014-05-04 22:55:53 +02:00
|
|
|
|
2014-05-10 00:58:39 +02:00
|
|
|
#ifdef MAP_HUGETLB
|
2014-08-15 02:01:20 +02:00
|
|
|
if (huge_page_size > 0 && bytes > 0) {
|
2020-10-28 19:09:52 +01:00
|
|
|
// Allocate from a huge page TLB table.
|
2014-05-05 00:52:23 +02:00
|
|
|
assert(logger != nullptr); // logger need to be passed in.
|
2014-05-04 22:55:53 +02:00
|
|
|
size_t reserved_size =
|
2014-08-15 02:01:20 +02:00
|
|
|
((bytes - 1U) / huge_page_size + 1U) * huge_page_size;
|
2014-05-04 22:55:53 +02:00
|
|
|
assert(reserved_size >= bytes);
|
2014-05-08 17:45:44 +02:00
|
|
|
|
2014-11-21 23:11:22 +01:00
|
|
|
char* addr = AllocateFromHugePage(reserved_size);
|
|
|
|
if (addr == nullptr) {
|
2017-03-16 03:22:52 +01:00
|
|
|
ROCKS_LOG_WARN(logger,
|
|
|
|
"AllocateAligned fail to allocate huge TLB pages: %s",
|
|
|
|
strerror(errno));
|
2014-05-04 22:55:53 +02:00
|
|
|
// fail back to malloc
|
|
|
|
} else {
|
2014-11-21 23:11:22 +01:00
|
|
|
return addr;
|
2014-05-04 22:55:53 +02:00
|
|
|
}
|
|
|
|
}
|
2018-04-13 02:55:14 +02:00
|
|
|
#else
|
|
|
|
(void)huge_page_size;
|
|
|
|
(void)logger;
|
2014-05-04 22:55:53 +02:00
|
|
|
#endif
|
|
|
|
|
2014-01-09 00:06:07 +01:00
|
|
|
size_t current_mod =
|
|
|
|
reinterpret_cast<uintptr_t>(aligned_alloc_ptr_) & (kAlignUnit - 1);
|
|
|
|
size_t slop = (current_mod == 0 ? 0 : kAlignUnit - current_mod);
|
2011-03-18 23:37:00 +01:00
|
|
|
size_t needed = bytes + slop;
|
|
|
|
char* result;
|
|
|
|
if (needed <= alloc_bytes_remaining_) {
|
2014-01-09 00:06:07 +01:00
|
|
|
result = aligned_alloc_ptr_ + slop;
|
|
|
|
aligned_alloc_ptr_ += needed;
|
2011-03-18 23:37:00 +01:00
|
|
|
alloc_bytes_remaining_ -= needed;
|
|
|
|
} else {
|
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
|
|
|
// AllocateFallback always returns aligned memory
|
2014-01-09 00:06:07 +01:00
|
|
|
result = AllocateFallback(bytes, true /* aligned */);
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2014-01-09 00:06:07 +01:00
|
|
|
assert((reinterpret_cast<uintptr_t>(result) & (kAlignUnit - 1)) == 0);
|
2011-03-18 23:37:00 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2014-01-31 02:18:17 +01:00
|
|
|
char* Arena::AllocateNewBlock(size_t block_bytes) {
|
2018-02-16 04:30:52 +01:00
|
|
|
// Reserve space in `blocks_` before allocating memory via new.
|
|
|
|
// Use `emplace_back()` instead of `reserve()` to let std::vector manage its
|
|
|
|
// own memory and do fewer reallocations.
|
|
|
|
//
|
|
|
|
// - If `emplace_back` throws, no memory leaks because we haven't called `new`
|
|
|
|
// yet.
|
|
|
|
// - If `new` throws, no memory leaks because the vector will be cleaned up
|
|
|
|
// via RAII.
|
|
|
|
blocks_.emplace_back(nullptr);
|
2015-09-25 21:23:40 +02:00
|
|
|
|
2014-01-09 00:06:07 +01:00
|
|
|
char* block = new char[block_bytes];
|
2017-06-02 23:13:59 +02:00
|
|
|
size_t allocated_size;
|
2015-08-26 23:19:31 +02:00
|
|
|
#ifdef ROCKSDB_MALLOC_USABLE_SIZE
|
2017-06-02 23:13:59 +02:00
|
|
|
allocated_size = malloc_usable_size(block);
|
|
|
|
#ifndef NDEBUG
|
|
|
|
// It's hard to predict what malloc_usable_size() returns.
|
|
|
|
// A callback can allow users to change the costed size.
|
|
|
|
std::pair<size_t*, size_t*> pair(&allocated_size, &block_bytes);
|
|
|
|
TEST_SYNC_POINT_CALLBACK("Arena::AllocateNewBlock:0", &pair);
|
|
|
|
#endif // NDEBUG
|
2015-08-26 23:19:31 +02:00
|
|
|
#else
|
2017-06-02 23:13:59 +02:00
|
|
|
allocated_size = block_bytes;
|
2015-08-26 23:19:31 +02:00
|
|
|
#endif // ROCKSDB_MALLOC_USABLE_SIZE
|
2017-06-02 23:13:59 +02:00
|
|
|
blocks_memory_ += allocated_size;
|
|
|
|
if (tracker_ != nullptr) {
|
|
|
|
tracker_->Allocate(allocated_size);
|
|
|
|
}
|
2018-02-16 04:30:52 +01:00
|
|
|
blocks_.back() = block;
|
2014-01-09 00:06:07 +01:00
|
|
|
return block;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2020-02-20 21:07:53 +01:00
|
|
|
} // namespace ROCKSDB_NAMESPACE
|