|
|
|
|
# This file @generated by:
|
|
|
|
|
#$ python3 buckifier/buckify_rocksdb.py
|
|
|
|
|
# --> DO NOT EDIT MANUALLY <--
|
|
|
|
|
# This file is a Facebook-specific integration for buck builds, so can
|
|
|
|
|
# only be validated by Facebook employees.
|
|
|
|
|
#
|
|
|
|
|
# @noautodeps @nocodemods
|
|
|
|
|
load("//rocks/buckifier:defs.bzl", "cpp_library_wrapper","rocks_cpp_library_wrapper","cpp_binary_wrapper","cpp_unittest_wrapper","fancy_bench_wrapper","add_c_test_wrapper")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_library_wrapper(name="rocksdb_lib", srcs=[
|
|
|
|
|
"cache/cache.cc",
|
Use deleters to label cache entries and collect stats (#8297)
Summary:
This change gathers and publishes statistics about the
kinds of items in block cache. This is especially important for
profiling relative usage of cache by index vs. filter vs. data blocks.
It works by iterating over the cache during periodic stats dump
(InternalStats, stats_dump_period_sec) or on demand when
DB::Get(Map)Property(kBlockCacheEntryStats), except that for
efficiency and sharing among column families, saved data from
the last scan is used when the data is not considered too old.
The new information can be seen in info LOG, for example:
Block cache LRUCache@0x7fca62229330 capacity: 95.37 MB collections: 8 last_copies: 0 last_secs: 0.00178 secs_since: 0
Block cache entry stats(count,size,portion): DataBlock(7092,28.24 MB,29.6136%) FilterBlock(215,867.90 KB,0.888728%) FilterMetaBlock(2,5.31 KB,0.00544%) IndexBlock(217,180.11 KB,0.184432%) WriteBuffer(1,256.00 KB,0.262144%) Misc(1,0.00 KB,0%)
And also through DB::GetProperty and GetMapProperty (here using
ldb just for demonstration):
$ ./ldb --db=/dev/shm/dbbench/ get_property rocksdb.block-cache-entry-stats
rocksdb.block-cache-entry-stats.bytes.data-block: 0
rocksdb.block-cache-entry-stats.bytes.deprecated-filter-block: 0
rocksdb.block-cache-entry-stats.bytes.filter-block: 0
rocksdb.block-cache-entry-stats.bytes.filter-meta-block: 0
rocksdb.block-cache-entry-stats.bytes.index-block: 178992
rocksdb.block-cache-entry-stats.bytes.misc: 0
rocksdb.block-cache-entry-stats.bytes.other-block: 0
rocksdb.block-cache-entry-stats.bytes.write-buffer: 0
rocksdb.block-cache-entry-stats.capacity: 8388608
rocksdb.block-cache-entry-stats.count.data-block: 0
rocksdb.block-cache-entry-stats.count.deprecated-filter-block: 0
rocksdb.block-cache-entry-stats.count.filter-block: 0
rocksdb.block-cache-entry-stats.count.filter-meta-block: 0
rocksdb.block-cache-entry-stats.count.index-block: 215
rocksdb.block-cache-entry-stats.count.misc: 1
rocksdb.block-cache-entry-stats.count.other-block: 0
rocksdb.block-cache-entry-stats.count.write-buffer: 0
rocksdb.block-cache-entry-stats.id: LRUCache@0x7f3636661290
rocksdb.block-cache-entry-stats.percent.data-block: 0.000000
rocksdb.block-cache-entry-stats.percent.deprecated-filter-block: 0.000000
rocksdb.block-cache-entry-stats.percent.filter-block: 0.000000
rocksdb.block-cache-entry-stats.percent.filter-meta-block: 0.000000
rocksdb.block-cache-entry-stats.percent.index-block: 2.133751
rocksdb.block-cache-entry-stats.percent.misc: 0.000000
rocksdb.block-cache-entry-stats.percent.other-block: 0.000000
rocksdb.block-cache-entry-stats.percent.write-buffer: 0.000000
rocksdb.block-cache-entry-stats.secs_for_last_collection: 0.000052
rocksdb.block-cache-entry-stats.secs_since_last_collection: 0
Solution detail - We need some way to flag what kind of blocks each
entry belongs to, preferably without changing the Cache API.
One of the complications is that Cache is a general interface that could
have other users that don't adhere to whichever convention we decide
on for keys and values. Or we would pay for an extra field in the Handle
that would only be used for this purpose.
This change uses a back-door approach, the deleter, to indicate the
"role" of a Cache entry (in addition to the value type, implicitly).
This has the added benefit of ensuring proper code origin whenever we
recognize a particular role for a cache entry; if the entry came from
some other part of the code, it will use an unrecognized deleter, which
we simply attribute to the "Misc" role.
An internal API makes for simple instantiation and automatic
registration of Cache deleters for a given value type and "role".
Another internal API, CacheEntryStatsCollector, solves the problem of
caching the results of a scan and sharing them, to ensure scans are
neither excessive nor redundant so as not to harm Cache performance.
Because code is added to BlocklikeTraits, it is pulled out of
block_based_table_reader.cc into its own file.
This is a reformulation of https://github.com/facebook/rocksdb/issues/8276, without the type checking option
(could still be added), and with actual stat gathering.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8297
Test Plan: manual testing with db_bench, and a couple of basic unit tests
Reviewed By: ltamasi
Differential Revision: D28488721
Pulled By: pdillinger
fbshipit-source-id: 472f524a9691b5afb107934be2d41d84f2b129fb
4 years ago
|
|
|
"cache/cache_entry_roles.cc",
|
New stable, fixed-length cache keys (#9126)
Summary:
This change standardizes on a new 16-byte cache key format for
block cache (incl compressed and secondary) and persistent cache (but
not table cache and row cache).
The goal is a really fast cache key with practically ideal stability and
uniqueness properties without external dependencies (e.g. from FileSystem).
A fixed key size of 16 bytes should enable future optimizations to the
concurrent hash table for block cache, which is a heavy CPU user /
bottleneck, but there appears to be measurable performance improvement
even with no changes to LRUCache.
This change replaces a lot of disjointed and ugly code handling cache
keys with calls to a simple, clean new internal API (cache_key.h).
(Preserving the old cache key logic under an option would be very ugly
and likely negate the performance gain of the new approach. Complete
replacement carries some inherent risk, but I think that's acceptable
with sufficient analysis and testing.)
The scheme for encoding new cache keys is complicated but explained
in cache_key.cc.
Also: EndianSwapValue is moved to math.h to be next to other bit
operations. (Explains some new include "math.h".) ReverseBits operation
added and unit tests added to hash_test for both.
Fixes https://github.com/facebook/rocksdb/issues/7405 (presuming a root cause)
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9126
Test Plan:
### Basic correctness
Several tests needed updates to work with the new functionality, mostly
because we are no longer relying on filesystem for stable cache keys
so table builders & readers need more context info to agree on cache
keys. This functionality is so core, a huge number of existing tests
exercise the cache key functionality.
### Performance
Create db with
`TEST_TMPDIR=/dev/shm ./db_bench -bloom_bits=10 -benchmarks=fillrandom -num=3000000 -partition_index_and_filters`
And test performance with
`TEST_TMPDIR=/dev/shm ./db_bench -readonly -use_existing_db -bloom_bits=10 -benchmarks=readrandom -num=3000000 -duration=30 -cache_index_and_filter_blocks -cache_size=250000 -threads=4`
using DEBUG_LEVEL=0 and simultaneous before & after runs.
Before ops/sec, avg over 100 runs: 121924
After ops/sec, avg over 100 runs: 125385 (+2.8%)
### Collision probability
I have built a tool, ./cache_bench -stress_cache_key to broadly simulate host-wide cache activity
over many months, by making some pessimistic simplifying assumptions:
* Every generated file has a cache entry for every byte offset in the file (contiguous range of cache keys)
* All of every file is cached for its entire lifetime
We use a simple table with skewed address assignment and replacement on address collision
to simulate files coming & going, with quite a variance (super-Poisson) in ages. Some output
with `./cache_bench -stress_cache_key -sck_keep_bits=40`:
```
Total cache or DBs size: 32TiB Writing 925.926 MiB/s or 76.2939TiB/day
Multiply by 9.22337e+18 to correct for simulation losses (but still assume whole file cached)
```
These come from default settings of 2.5M files per day of 32 MB each, and
`-sck_keep_bits=40` means that to represent a single file, we are only keeping 40 bits of
the 128-bit cache key. With file size of 2\*\*25 contiguous keys (pessimistic), our simulation
is about 2\*\*(128-40-25) or about 9 billion billion times more prone to collision than reality.
More default assumptions, relatively pessimistic:
* 100 DBs in same process (doesn't matter much)
* Re-open DB in same process (new session ID related to old session ID) on average
every 100 files generated
* Restart process (all new session IDs unrelated to old) 24 times per day
After enough data, we get a result at the end:
```
(keep 40 bits) 17 collisions after 2 x 90 days, est 10.5882 days between (9.76592e+19 corrected)
```
If we believe the (pessimistic) simulation and the mathematical generalization, we would need to run a billion machines all for 97 billion days to expect a cache key collision. To help verify that our generalization ("corrected") is robust, we can make our simulation more precise with `-sck_keep_bits=41` and `42`, which takes more running time to get enough data:
```
(keep 41 bits) 16 collisions after 4 x 90 days, est 22.5 days between (1.03763e+20 corrected)
(keep 42 bits) 19 collisions after 10 x 90 days, est 47.3684 days between (1.09224e+20 corrected)
```
The generalized prediction still holds. With the `-sck_randomize` option, we can see that we are beating "random" cache keys (except offsets still non-randomized) by a modest amount (roughly 20x less collision prone than random), which should make us reasonably comfortable even in "degenerate" cases:
```
197 collisions after 1 x 90 days, est 0.456853 days between (4.21372e+18 corrected)
```
I've run other tests to validate other conditions behave as expected, never behaving "worse than random" unless we start chopping off structured data.
Reviewed By: zhichao-cao
Differential Revision: D33171746
Pulled By: pdillinger
fbshipit-source-id: f16a57e369ed37be5e7e33525ace848d0537c88f
3 years ago
|
|
|
"cache/cache_key.cc",
|
|
|
|
|
"cache/cache_reservation_manager.cc",
|
|
|
|
|
"cache/charged_cache.cc",
|
|
|
|
|
"cache/clock_cache.cc",
|
|
|
|
|
"cache/compressed_secondary_cache.cc",
|
|
|
|
|
"cache/fast_lru_cache.cc",
|
|
|
|
|
"cache/lru_cache.cc",
|
|
|
|
|
"cache/sharded_cache.cc",
|
|
|
|
|
"db/arena_wrapped_db_iter.cc",
|
|
|
|
|
"db/blob/blob_contents.cc",
|
|
|
|
|
"db/blob/blob_fetcher.cc",
|
|
|
|
|
"db/blob/blob_file_addition.cc",
|
|
|
|
|
"db/blob/blob_file_builder.cc",
|
|
|
|
|
"db/blob/blob_file_cache.cc",
|
|
|
|
|
"db/blob/blob_file_garbage.cc",
|
Add blob files to VersionStorageInfo/VersionBuilder (#6597)
Summary:
The patch adds a couple of classes to represent metadata about
blob files: `SharedBlobFileMetaData` contains the information elements
that are immutable (once the blob file is closed), e.g. blob file number,
total number and size of blob files, checksum method/value, while
`BlobFileMetaData` contains attributes that can vary across versions like
the amount of garbage in the file. There is a single `SharedBlobFileMetaData`
for each blob file, which is jointly owned by the `BlobFileMetaData` objects
that point to it; `BlobFileMetaData` objects, in turn, are owned by `Version`s
and can also be shared if the (immutable _and_ mutable) state of the blob file
is the same in two versions.
In addition, the patch adds the blob file metadata to `VersionStorageInfo`, and extends
`VersionBuilder` so that it can apply blob file related `VersionEdit`s (i.e. those
containing `BlobFileAddition`s and/or `BlobFileGarbage`), and save blob file metadata
to a new `VersionStorageInfo`. Consistency checks are also extended to ensure
that table files point to blob files that are part of the `Version`, and that all blob files
that are part of any given `Version` have at least some _non_-garbage data in them.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6597
Test Plan: `make check`
Reviewed By: riversand963
Differential Revision: D20656803
Pulled By: ltamasi
fbshipit-source-id: f1f74d135045b3b42d0146f03ee576ef0a4bfd80
5 years ago
|
|
|
"db/blob/blob_file_meta.cc",
|
Introduce a blob file reader class (#7461)
Summary:
The patch adds a class called `BlobFileReader` that can be used to retrieve blobs
using the information available in blob references (e.g. blob file number, offset, and
size). This will come in handy when implementing blob support for `Get`, `MultiGet`,
and iterators, and also for compaction/garbage collection.
When a `BlobFileReader` object is created (using the factory method `Create`),
it first checks whether the specified file is potentially valid by comparing the file
size against the combined size of the blob file header and footer (files smaller than
the threshold are considered malformed). Then, it opens the file, and reads and verifies
the header and footer. The verification involves magic number/CRC checks
as well as checking for unexpected header/footer fields, e.g. incorrect column family ID
or TTL blob files.
Blobs can be retrieved using `GetBlob`. `GetBlob` validates the offset and compression
type passed by the caller (because of the presence of the header and footer, the
specified offset cannot be too close to the start/end of the file; also, the compression type
has to match the one in the blob file header), and retrieves and potentially verifies and
uncompresses the blob. In particular, when `ReadOptions::verify_checksums` is set,
`BlobFileReader` reads the blob record header as well (as opposed to just the blob itself)
and verifies the key/value size, the key itself, as well as the CRC of the blob record header
and the key/value pair.
In addition, the patch exposes the compression type from `BlobIndex` (both using an
accessor and via `DebugString`), and adds a blob file read latency histogram to
`InternalStats` that can be used with `BlobFileReader`.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/7461
Test Plan: `make check`
Reviewed By: riversand963
Differential Revision: D23999219
Pulled By: ltamasi
fbshipit-source-id: deb6b1160d251258b308d5156e2ec063c3e12e5e
4 years ago
|
|
|
"db/blob/blob_file_reader.cc",
|
|
|
|
|
"db/blob/blob_garbage_meter.cc",
|
|
|
|
|
"db/blob/blob_log_format.cc",
|
|
|
|
|
"db/blob/blob_log_sequential_reader.cc",
|
|
|
|
|
"db/blob/blob_log_writer.cc",
|
|
|
|
|
"db/blob/blob_source.cc",
|
|
|
|
|
"db/blob/prefetch_buffer_collection.cc",
|
|
|
|
|
"db/builder.cc",
|
|
|
|
|
"db/c.cc",
|
|
|
|
|
"db/column_family.cc",
|
|
|
|
|
"db/compaction/compaction.cc",
|
|
|
|
|
"db/compaction/compaction_iterator.cc",
|
|
|
|
|
"db/compaction/compaction_job.cc",
|
|
|
|
|
"db/compaction/compaction_outputs.cc",
|
|
|
|
|
"db/compaction/compaction_picker.cc",
|
|
|
|
|
"db/compaction/compaction_picker_fifo.cc",
|
|
|
|
|
"db/compaction/compaction_picker_level.cc",
|
|
|
|
|
"db/compaction/compaction_picker_universal.cc",
|
|
|
|
|
"db/compaction/compaction_service_job.cc",
|
|
|
|
|
"db/compaction/compaction_state.cc",
|
|
|
|
|
"db/compaction/sst_partitioner.cc",
|
|
|
|
|
"db/compaction/subcompaction_state.cc",
|
|
|
|
|
"db/convenience.cc",
|
|
|
|
|
"db/db_filesnapshot.cc",
|
|
|
|
|
"db/db_impl/compacted_db_impl.cc",
|
|
|
|
|
"db/db_impl/db_impl.cc",
|
|
|
|
|
"db/db_impl/db_impl_compaction_flush.cc",
|
|
|
|
|
"db/db_impl/db_impl_debug.cc",
|
|
|
|
|
"db/db_impl/db_impl_experimental.cc",
|
|
|
|
|
"db/db_impl/db_impl_files.cc",
|
|
|
|
|
"db/db_impl/db_impl_open.cc",
|
|
|
|
|
"db/db_impl/db_impl_readonly.cc",
|
|
|
|
|
"db/db_impl/db_impl_secondary.cc",
|
|
|
|
|
"db/db_impl/db_impl_write.cc",
|
|
|
|
|
"db/db_info_dumper.cc",
|
|
|
|
|
"db/db_iter.cc",
|
|
|
|
|
"db/dbformat.cc",
|
|
|
|
|
"db/error_handler.cc",
|
|
|
|
|
"db/event_helpers.cc",
|
|
|
|
|
"db/experimental.cc",
|
|
|
|
|
"db/external_sst_file_ingestion_job.cc",
|
|
|
|
|
"db/file_indexer.cc",
|
|
|
|
|
"db/flush_job.cc",
|
|
|
|
|
"db/flush_scheduler.cc",
|
|
|
|
|
"db/forward_iterator.cc",
|
Export Import sst files (#5495)
Summary:
Refresh of the earlier change here - https://github.com/facebook/rocksdb/issues/5135
This is a review request for code change needed for - https://github.com/facebook/rocksdb/issues/3469
"Add support for taking snapshot of a column family and creating column family from a given CF snapshot"
We have an implementation for this that we have been testing internally. We have two new APIs that together provide this functionality.
(1) ExportColumnFamily() - This API is modelled after CreateCheckpoint() as below.
// Exports all live SST files of a specified Column Family onto export_dir,
// returning SST files information in metadata.
// - SST files will be created as hard links when the directory specified
// is in the same partition as the db directory, copied otherwise.
// - export_dir should not already exist and will be created by this API.
// - Always triggers a flush.
virtual Status ExportColumnFamily(ColumnFamilyHandle* handle,
const std::string& export_dir,
ExportImportFilesMetaData** metadata);
Internally, the API will DisableFileDeletions(), GetColumnFamilyMetaData(), Parse through
metadata, creating links/copies of all the sst files, EnableFileDeletions() and complete the call by
returning the list of file metadata.
(2) CreateColumnFamilyWithImport() - This API is modeled after IngestExternalFile(), but invoked only during a CF creation as below.
// CreateColumnFamilyWithImport() will create a new column family with
// column_family_name and import external SST files specified in metadata into
// this column family.
// (1) External SST files can be created using SstFileWriter.
// (2) External SST files can be exported from a particular column family in
// an existing DB.
// Option in import_options specifies whether the external files are copied or
// moved (default is copy). When option specifies copy, managing files at
// external_file_path is caller's responsibility. When option specifies a
// move, the call ensures that the specified files at external_file_path are
// deleted on successful return and files are not modified on any error
// return.
// On error return, column family handle returned will be nullptr.
// ColumnFamily will be present on successful return and will not be present
// on error return. ColumnFamily may be present on any crash during this call.
virtual Status CreateColumnFamilyWithImport(
const ColumnFamilyOptions& options, const std::string& column_family_name,
const ImportColumnFamilyOptions& import_options,
const ExportImportFilesMetaData& metadata,
ColumnFamilyHandle** handle);
Internally, this API creates a new CF, parses all the sst files and adds it to the specified column family, at the same level and with same sequence number as in the metadata. Also performs safety checks with respect to overlaps between the sst files being imported.
If incoming sequence number is higher than current local sequence number, local sequence
number is updated to reflect this.
Note, as the sst files is are being moved across Column Families, Column Family name in sst file
will no longer match the actual column family on destination DB. The API does not modify Column
Family name or id in the sst files being imported.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5495
Differential Revision: D16018881
fbshipit-source-id: 9ae2251025d5916d35a9fc4ea4d6707f6be16ff9
6 years ago
|
|
|
"db/import_column_family_job.cc",
|
|
|
|
|
"db/internal_stats.cc",
|
|
|
|
|
"db/log_reader.cc",
|
|
|
|
|
"db/log_writer.cc",
|
Skip deleted WALs during recovery
Summary:
This patch record min log number to keep to the manifest while flushing SST files to ignore them and any WAL older than them during recovery. This is to avoid scenarios when we have a gap between the WAL files are fed to the recovery procedure. The gap could happen by for example out-of-order WAL deletion. Such gap could cause problems in 2PC recovery where the prepared and commit entry are placed into two separate WAL and gap in the WALs could result into not processing the WAL with the commit entry and hence breaking the 2PC recovery logic.
Before the commit, for 2PC case, we determined which log number to keep in FindObsoleteFiles(). We looked at the earliest logs with outstanding prepare entries, or prepare entries whose respective commit or abort are in memtable. With the commit, the same calculation is done while we apply the SST flush. Just before installing the flush file, we precompute the earliest log file to keep after the flush finishes using the same logic (but skipping the memtables just flushed), record this information to the manifest entry for this new flushed SST file. This pre-computed value is also remembered in memory, and will later be used to determine whether a log file can be deleted. This value is unlikely to change until next flush because the commit entry will stay in memtable. (In WritePrepared, we could have removed the older log files as soon as all prepared entries are committed. It's not yet done anyway. Even if we do it, the only thing we loss with this new approach is earlier log deletion between two flushes, which does not guarantee to happen anyway because the obsolete file clean-up function is only executed after flush or compaction)
This min log number to keep is stored in the manifest using the safely-ignore customized field of AddFile entry, in order to guarantee that the DB generated using newer release can be opened by previous releases no older than 4.2.
Closes https://github.com/facebook/rocksdb/pull/3765
Differential Revision: D7747618
Pulled By: siying
fbshipit-source-id: d00c92105b4f83852e9754a1b70d6b64cb590729
7 years ago
|
|
|
"db/logs_with_prep_tracker.cc",
|
|
|
|
|
"db/malloc_stats.cc",
|
|
|
|
|
"db/memtable.cc",
|
|
|
|
|
"db/memtable_list.cc",
|
|
|
|
|
"db/merge_helper.cc",
|
|
|
|
|
"db/merge_operator.cc",
|
|
|
|
|
"db/output_validator.cc",
|
|
|
|
|
"db/periodic_task_scheduler.cc",
|
|
|
|
|
"db/range_del_aggregator.cc",
|
Use only "local" range tombstones during Get (#4449)
Summary:
Previously, range tombstones were accumulated from every level, which
was necessary if a range tombstone in a higher level covered a key in a lower
level. However, RangeDelAggregator::AddTombstones's complexity is based on
the number of tombstones that are currently stored in it, which is wasteful in
the Get case, where we only need to know the highest sequence number of range
tombstones that cover the key from higher levels, and compute the highest covering
sequence number at the current level. This change introduces this optimization, and
removes the use of RangeDelAggregator from the Get path.
In the benchmark results, the following command was used to initialize the database:
```
./db_bench -db=/dev/shm/5k-rts -use_existing_db=false -benchmarks=filluniquerandom -write_buffer_size=1048576 -compression_type=lz4 -target_file_size_base=1048576 -max_bytes_for_level_base=4194304 -value_size=112 -key_size=16 -block_size=4096 -level_compaction_dynamic_level_bytes=true -num=5000000 -max_background_jobs=12 -benchmark_write_rate_limit=20971520 -range_tombstone_width=100 -writes_per_range_tombstone=100 -max_num_range_tombstones=50000 -bloom_bits=8
```
...and the following command was used to measure read throughput:
```
./db_bench -db=/dev/shm/5k-rts/ -use_existing_db=true -benchmarks=readrandom -disable_auto_compactions=true -num=5000000 -reads=100000 -threads=32
```
The filluniquerandom command was only run once, and the resulting database was used
to measure read performance before and after the PR. Both binaries were compiled with
`DEBUG_LEVEL=0`.
Readrandom results before PR:
```
readrandom : 4.544 micros/op 220090 ops/sec; 16.9 MB/s (63103 of 100000 found)
```
Readrandom results after PR:
```
readrandom : 11.147 micros/op 89707 ops/sec; 6.9 MB/s (63103 of 100000 found)
```
So it's actually slower right now, but this PR paves the way for future optimizations (see #4493).
----
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4449
Differential Revision: D10370575
Pulled By: abhimadan
fbshipit-source-id: 9a2e152be1ef36969055c0e9eb4beb0d96c11f4d
6 years ago
|
|
|
"db/range_tombstone_fragmenter.cc",
|
|
|
|
|
"db/repair.cc",
|
|
|
|
|
"db/seqno_to_time_mapping.cc",
|
|
|
|
|
"db/snapshot_impl.cc",
|
|
|
|
|
"db/table_cache.cc",
|
|
|
|
|
"db/table_properties_collector.cc",
|
|
|
|
|
"db/transaction_log_impl.cc",
|
Refactor trimming logic for immutable memtables (#5022)
Summary:
MyRocks currently sets `max_write_buffer_number_to_maintain` in order to maintain enough history for transaction conflict checking. The effectiveness of this approach depends on the size of memtables. When memtables are small, it may not keep enough history; when memtables are large, this may consume too much memory.
We are proposing a new way to configure memtable list history: by limiting the memory usage of immutable memtables. The new option is `max_write_buffer_size_to_maintain` and it will take precedence over the old `max_write_buffer_number_to_maintain` if they are both set to non-zero values. The new option accounts for the total memory usage of flushed immutable memtables and mutable memtable. When the total usage exceeds the limit, RocksDB may start dropping immutable memtables (which is also called trimming history), starting from the oldest one.
The semantics of the old option actually works both as an upper bound and lower bound. History trimming will start if number of immutable memtables exceeds the limit, but it will never go below (limit-1) due to history trimming.
In order the mimic the behavior with the new option, history trimming will stop if dropping the next immutable memtable causes the total memory usage go below the size limit. For example, assuming the size limit is set to 64MB, and there are 3 immutable memtables with sizes of 20, 30, 30. Although the total memory usage is 80MB > 64MB, dropping the oldest memtable will reduce the memory usage to 60MB < 64MB, so in this case no memtable will be dropped.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5022
Differential Revision: D14394062
Pulled By: miasantreble
fbshipit-source-id: 60457a509c6af89d0993f988c9b5c2aa9e45f5c5
5 years ago
|
|
|
"db/trim_history_scheduler.cc",
|
|
|
|
|
"db/version_builder.cc",
|
|
|
|
|
"db/version_edit.cc",
|
|
|
|
|
"db/version_edit_handler.cc",
|
|
|
|
|
"db/version_set.cc",
|
Define WAL related classes to be used in VersionEdit and VersionSet (#7164)
Summary:
`WalAddition`, `WalDeletion` are defined in `wal_version.h` and used in `VersionEdit`.
`WalAddition` is used to represent events of creating a new WAL (no size, just log number), or closing a WAL (with size).
`WalDeletion` is used to represent events of deleting or archiving a WAL, it means the WAL is no longer alive (won't be replayed during recovery).
`WalSet` is the set of alive WALs kept in `VersionSet`.
1. Why use `WalDeletion` instead of relying on `MinLogNumber` to identify outdated WALs
On recovery, we can compute `MinLogNumber()` based on the log numbers kept in MANIFEST, any log with number < MinLogNumber can be ignored. So it seems that we don't need to persist `WalDeletion` to MANIFEST, since we can ignore the WALs based on MinLogNumber.
But the `MinLogNumber()` is actually a lower bound, it does not exactly mean that logs starting from MinLogNumber must exist. This is because in a corner case, when a column family is empty and never flushed, its log number is set to the largest log number, but not persisted in MANIFEST. So let's say there are 2 column families, when creating the DB, the first WAL has log number 1, so it's persisted to MANIFEST for both column families. Then CF 0 is empty and never flushed, CF 1 is updated and flushed, so a new WAL with log number 2 is created and persisted to MANIFEST for CF 1. But CF 0's log number in MANIFEST is still 1. So on recovery, MinLogNumber is 1, but since log 1 only contains data for CF 1, and CF 1 is flushed, log 1 might have already been deleted from disk.
We can make `MinLogNumber()` be the exactly minimum log number that must exist, by persisting the most recent log number for empty column families that are not flushed. But if there are N such column families, then every time a new WAL is created, we need to add N records to MANIFEST.
In current design, a record is persisted to MANIFEST only when WAL is created, closed, or deleted/archived, so the number of WAL related records are bounded to 3x number of WALs.
2. Why keep `WalSet` in `VersionSet` instead of applying the `VersionEdit`s to `VersionStorageInfo`
`VersionEdit`s are originally designed to track the addition and deletion of SST files. The SST files are related to column families, each column family has a list of `Version`s, and each `Version` keeps the set of active SST files in `VersionStorageInfo`.
But WALs are a concept of DB, they are not bounded to specific column families. So logically it does not make sense to store WALs in a column family's `Version`s.
Also, `Version`'s purpose is to keep reference to SST / blob files, so that they are not deleted until there is no version referencing them. But a WAL is deleted regardless of version references.
So we keep the WALs in `VersionSet` for the purpose of writing out the DB state's snapshot when creating new MANIFESTs.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/7164
Test Plan:
make version_edit_test && ./version_edit_test
make wal_edit_test && ./wal_edit_test
Reviewed By: ltamasi
Differential Revision: D22677936
Pulled By: cheng-chang
fbshipit-source-id: 5a3b6890140e572ffd79eb37e6e4c3c32361a859
4 years ago
|
|
|
"db/wal_edit.cc",
|
|
|
|
|
"db/wal_manager.cc",
|
|
|
|
|
"db/wide/wide_column_serialization.cc",
|
Add support for wide-column point lookups (#10540)
Summary:
The patch adds a new API `GetEntity` that can be used to perform
wide-column point lookups. It also extends the `Get` code path and
the `MemTable` / `MemTableList` and `Version` / `GetContext` logic
accordingly so that wide-column entities can be served from both
memtables and SSTs. If the result of a lookup is a wide-column entity
(`kTypeWideColumnEntity`), it is passed to the application in deserialized
form; if it is a plain old key-value (`kTypeValue`), it is presented as a
wide-column entity with a single default (anonymous) column.
(In contrast, regular `Get` returns plain old key-values as-is, and
returns the value of the default column for wide-column entities, see
https://github.com/facebook/rocksdb/issues/10483 .)
The result of `GetEntity` is a self-contained `PinnableWideColumns` object.
`PinnableWideColumns` contains a `PinnableSlice`, which either stores the
underlying data in its own buffer or holds on to a cache handle. It also contains
a `WideColumns` instance, which indexes the contents of the `PinnableSlice`,
so applications can access the values of columns efficiently.
There are several pieces of functionality which are currently not supported
for wide-column entities: there is currently no `MultiGetEntity` or wide-column
iterator; also, `Merge` and `GetMergeOperands` are not supported, and there
is no `GetEntity` implementation for read-only and secondary instances.
We plan to implement these in future PRs.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/10540
Test Plan: `make check`
Reviewed By: akankshamahajan15
Differential Revision: D38847474
Pulled By: ltamasi
fbshipit-source-id: 42311a34ccdfe88b3775e847a5e2a5296e002b5b
2 years ago
|
|
|
"db/wide/wide_columns.cc",
|
|
|
|
|
"db/write_batch.cc",
|
|
|
|
|
"db/write_batch_base.cc",
|
|
|
|
|
"db/write_controller.cc",
|
|
|
|
|
"db/write_thread.cc",
|
|
|
|
|
"env/composite_env.cc",
|
|
|
|
|
"env/env.cc",
|
|
|
|
|
"env/env_chroot.cc",
|
|
|
|
|
"env/env_encryption.cc",
|
|
|
|
|
"env/env_posix.cc",
|
Introduce a new storage specific Env API (#5761)
Summary:
The current Env API encompasses both storage/file operations, as well as OS related operations. Most of the APIs return a Status, which does not have enough metadata about an error, such as whether its retry-able or not, scope (i.e fault domain) of the error etc., that may be required in order to properly handle a storage error. The file APIs also do not provide enough control over the IO SLA, such as timeout, prioritization, hinting about placement and redundancy etc.
This PR separates out the file/storage APIs from Env into a new FileSystem class. The APIs are updated to return an IOStatus with metadata about the error, as well as to take an IOOptions structure as input in order to allow more control over the IO.
The user can set both ```options.env``` and ```options.file_system``` to specify that RocksDB should use the former for OS related operations and the latter for storage operations. Internally, a ```CompositeEnvWrapper``` has been introduced that inherits from ```Env``` and redirects individual methods to either an ```Env``` implementation or the ```FileSystem``` as appropriate. When options are sanitized during ```DB::Open```, ```options.env``` is replaced with a newly allocated ```CompositeEnvWrapper``` instance if both env and file_system have been specified. This way, the rest of the RocksDB code can continue to function as before.
This PR also ports PosixEnv to the new API by splitting it into two - PosixEnv and PosixFileSystem. PosixEnv is defined as a sub-class of CompositeEnvWrapper, and threading/time functions are overridden with Posix specific implementations in order to avoid an extra level of indirection.
The ```CompositeEnvWrapper``` translates ```IOStatus``` return code to ```Status```, and sets the severity to ```kSoftError``` if the io_status is retryable. The error handling code in RocksDB can then recover the DB automatically.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5761
Differential Revision: D18868376
Pulled By: anand1976
fbshipit-source-id: 39efe18a162ea746fabac6360ff529baba48486f
5 years ago
|
|
|
"env/file_system.cc",
|
|
|
|
|
"env/file_system_tracer.cc",
|
Introduce a new storage specific Env API (#5761)
Summary:
The current Env API encompasses both storage/file operations, as well as OS related operations. Most of the APIs return a Status, which does not have enough metadata about an error, such as whether its retry-able or not, scope (i.e fault domain) of the error etc., that may be required in order to properly handle a storage error. The file APIs also do not provide enough control over the IO SLA, such as timeout, prioritization, hinting about placement and redundancy etc.
This PR separates out the file/storage APIs from Env into a new FileSystem class. The APIs are updated to return an IOStatus with metadata about the error, as well as to take an IOOptions structure as input in order to allow more control over the IO.
The user can set both ```options.env``` and ```options.file_system``` to specify that RocksDB should use the former for OS related operations and the latter for storage operations. Internally, a ```CompositeEnvWrapper``` has been introduced that inherits from ```Env``` and redirects individual methods to either an ```Env``` implementation or the ```FileSystem``` as appropriate. When options are sanitized during ```DB::Open```, ```options.env``` is replaced with a newly allocated ```CompositeEnvWrapper``` instance if both env and file_system have been specified. This way, the rest of the RocksDB code can continue to function as before.
This PR also ports PosixEnv to the new API by splitting it into two - PosixEnv and PosixFileSystem. PosixEnv is defined as a sub-class of CompositeEnvWrapper, and threading/time functions are overridden with Posix specific implementations in order to avoid an extra level of indirection.
The ```CompositeEnvWrapper``` translates ```IOStatus``` return code to ```Status```, and sets the severity to ```kSoftError``` if the io_status is retryable. The error handling code in RocksDB can then recover the DB automatically.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5761
Differential Revision: D18868376
Pulled By: anand1976
fbshipit-source-id: 39efe18a162ea746fabac6360ff529baba48486f
5 years ago
|
|
|
"env/fs_posix.cc",
|
Make backups openable as read-only DBs (#8142)
Summary:
A current limitation of backups is that you don't know the
exact database state of when the backup was taken. With this new
feature, you can at least inspect the backup's DB state without
restoring it by opening it as a read-only DB.
Rather than add something like OpenAsReadOnlyDB to the BackupEngine API,
which would inhibit opening stackable DB implementations read-only
(if/when their APIs support it), we instead provide a DB name and Env
that can be used to open as a read-only DB.
Possible follow-up work:
* Add a version of GetBackupInfo for a single backup.
* Let CreateNewBackup return the BackupID of the newly-created backup.
Implementation details:
Refactored ChrootFileSystem to split off new base class RemapFileSystem,
which allows more general remapping of files. We use this base class to
implement BackupEngineImpl::RemapSharedFileSystem.
To minimize API impact, I decided to just add these fields `name_for_open`
and `env_for_open` to those set by GetBackupInfo when
include_file_details=true. Creating the RemapSharedFileSystem adds a bit
to the memory consumption, perhaps unnecessarily in some cases, but this
has been mitigated by (a) only initialize the RemapSharedFileSystem
lazily when GetBackupInfo with include_file_details=true is called, and
(b) using the existing `shared_ptr<FileInfo>` objects to hold most of the
mapping data.
To enhance API safety, RemapSharedFileSystem is wrapped by new
ReadOnlyFileSystem which rejects any attempts to write. This uncovered a
couple of places in which DB::OpenForReadOnly would write to the
filesystem, so I fixed these. Added a release note because this affects
logging.
Additional minor refactoring in backupable_db.cc to support the new
functionality.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8142
Test Plan:
new test (run with ASAN and UBSAN), added to stress test and
ran it for a while with amplified backup_one_in
Reviewed By: ajkr
Differential Revision: D27535408
Pulled By: pdillinger
fbshipit-source-id: 04666d310aa0261ef6b2385c43ca793ce1dfd148
4 years ago
|
|
|
"env/fs_remap.cc",
|
|
|
|
|
"env/io_posix.cc",
|
|
|
|
|
"env/mock_env.cc",
|
Experimental support for SST unique IDs (#8990)
Summary:
* New public header unique_id.h and function GetUniqueIdFromTableProperties
which computes a universally unique identifier based on table properties
of table files from recent RocksDB versions.
* Generation of DB session IDs is refactored so that they are
guaranteed unique in the lifetime of a process running RocksDB.
(SemiStructuredUniqueIdGen, new test included.) Along with file numbers,
this enables SST unique IDs to be guaranteed unique among SSTs generated
in a single process, and "better than random" between processes.
See https://github.com/pdillinger/unique_id
* In addition to public API producing 'external' unique IDs, there is a function
for producing 'internal' unique IDs, with functions for converting between the
two. In short, the external ID is "safe" for things people might do with it, and
the internal ID enables more "power user" features for the future. Specifically,
the external ID goes through a hashing layer so that any subset of bits in the
external ID can be used as a hash of the full ID, while also preserving
uniqueness guarantees in the first 128 bits (bijective both on first 128 bits
and on full 192 bits).
Intended follow-up:
* Use the internal unique IDs in cache keys. (Avoid conflicts with https://github.com/facebook/rocksdb/issues/8912) (The file offset can be XORed into
the third 64-bit value of the unique ID.)
* Publish the external unique IDs in FileStorageInfo (https://github.com/facebook/rocksdb/issues/8968)
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8990
Test Plan:
Unit tests added, and checking of unique ids in stress test.
NOTE in stress test we do not generate nearly enough files to thoroughly
stress uniqueness, but the test trims off pieces of the ID to check for
uniqueness so that we can infer (with some assumptions) stronger
properties in the aggregate.
Reviewed By: zhichao-cao, mrambacher
Differential Revision: D31582865
Pulled By: pdillinger
fbshipit-source-id: 1f620c4c86af9abe2a8d177b9ccf2ad2b9f48243
3 years ago
|
|
|
"env/unique_id_gen.cc",
|
|
|
|
|
"file/delete_scheduler.cc",
|
|
|
|
|
"file/file_prefetch_buffer.cc",
|
|
|
|
|
"file/file_util.cc",
|
|
|
|
|
"file/filename.cc",
|
|
|
|
|
"file/line_file_reader.cc",
|
|
|
|
|
"file/random_access_file_reader.cc",
|
|
|
|
|
"file/read_write_util.cc",
|
|
|
|
|
"file/readahead_raf.cc",
|
|
|
|
|
"file/sequence_file_reader.cc",
|
|
|
|
|
"file/sst_file_manager_impl.cc",
|
|
|
|
|
"file/writable_file_writer.cc",
|
|
|
|
|
"logging/auto_roll_logger.cc",
|
|
|
|
|
"logging/event_logger.cc",
|
|
|
|
|
"logging/log_buffer.cc",
|
|
|
|
|
"memory/arena.cc",
|
|
|
|
|
"memory/concurrent_arena.cc",
|
|
|
|
|
"memory/jemalloc_nodump_allocator.cc",
|
|
|
|
|
"memory/memkind_kmem_allocator.cc",
|
|
|
|
|
"memory/memory_allocator.cc",
|
|
|
|
|
"memtable/alloc_tracker.cc",
|
|
|
|
|
"memtable/hash_linklist_rep.cc",
|
|
|
|
|
"memtable/hash_skiplist_rep.cc",
|
|
|
|
|
"memtable/skiplistrep.cc",
|
|
|
|
|
"memtable/vectorrep.cc",
|
|
|
|
|
"memtable/write_buffer_manager.cc",
|
|
|
|
|
"monitoring/histogram.cc",
|
|
|
|
|
"monitoring/histogram_windowing.cc",
|
|
|
|
|
"monitoring/in_memory_stats_history.cc",
|
|
|
|
|
"monitoring/instrumented_mutex.cc",
|
|
|
|
|
"monitoring/iostats_context.cc",
|
|
|
|
|
"monitoring/perf_context.cc",
|
|
|
|
|
"monitoring/perf_level.cc",
|
|
|
|
|
"monitoring/persistent_stats_history.cc",
|
|
|
|
|
"monitoring/statistics.cc",
|
|
|
|
|
"monitoring/thread_status_impl.cc",
|
|
|
|
|
"monitoring/thread_status_updater.cc",
|
|
|
|
|
"monitoring/thread_status_updater_debug.cc",
|
|
|
|
|
"monitoring/thread_status_util.cc",
|
|
|
|
|
"monitoring/thread_status_util_debug.cc",
|
|
|
|
|
"options/cf_options.cc",
|
|
|
|
|
"options/configurable.cc",
|
|
|
|
|
"options/customizable.cc",
|
|
|
|
|
"options/db_options.cc",
|
|
|
|
|
"options/options.cc",
|
|
|
|
|
"options/options_helper.cc",
|
|
|
|
|
"options/options_parser.cc",
|
|
|
|
|
"port/port_posix.cc",
|
|
|
|
|
"port/stack_trace.cc",
|
|
|
|
|
"port/win/env_default.cc",
|
|
|
|
|
"port/win/env_win.cc",
|
|
|
|
|
"port/win/io_win.cc",
|
|
|
|
|
"port/win/port_win.cc",
|
|
|
|
|
"port/win/win_logger.cc",
|
|
|
|
|
"port/win/win_thread.cc",
|
|
|
|
|
"table/adaptive/adaptive_table_factory.cc",
|
|
|
|
|
"table/block_based/binary_search_index_reader.cc",
|
|
|
|
|
"table/block_based/block.cc",
|
|
|
|
|
"table/block_based/block_based_table_builder.cc",
|
|
|
|
|
"table/block_based/block_based_table_factory.cc",
|
De-template block based table iterator (#6531)
Summary:
Right now block based table iterator is used as both of iterating data for block based table, and for the index iterator for partitioend index. This was initially convenient for introducing a new iterator and block type for new index format, while reducing code change. However, these two usage doesn't go with each other very well. For example, Prev() is never called for partitioned index iterator, and some other complexity is maintained in block based iterators, which is not needed for index iterator but maintainers will always need to reason about it. Furthermore, the template usage is not following Google C++ Style which we are following, and makes a large chunk of code tangled together. This commit separate the two iterators. Right now, here is what it is done:
1. Copy the block based iterator code into partitioned index iterator, and de-template them.
2. Remove some code not needed for partitioned index. The upper bound check and tricks are removed. We never tested performance for those tricks when partitioned index is enabled in the first place. It's unlikelyl to generate performance regression, as creating new partitioned index block is much rarer than data blocks.
3. Separate out the prefetch logic to a helper class and both classes call them.
This commit will enable future follow-ups. One direction is that we might separate index iterator interface for data blocks and index blocks, as they are quite different.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6531
Test Plan: build using make and cmake. And build release
Differential Revision: D20473108
fbshipit-source-id: e48011783b339a4257c204cc07507b171b834b0f
5 years ago
|
|
|
"table/block_based/block_based_table_iterator.cc",
|
|
|
|
|
"table/block_based/block_based_table_reader.cc",
|
|
|
|
|
"table/block_based/block_builder.cc",
|
De-template block based table iterator (#6531)
Summary:
Right now block based table iterator is used as both of iterating data for block based table, and for the index iterator for partitioend index. This was initially convenient for introducing a new iterator and block type for new index format, while reducing code change. However, these two usage doesn't go with each other very well. For example, Prev() is never called for partitioned index iterator, and some other complexity is maintained in block based iterators, which is not needed for index iterator but maintainers will always need to reason about it. Furthermore, the template usage is not following Google C++ Style which we are following, and makes a large chunk of code tangled together. This commit separate the two iterators. Right now, here is what it is done:
1. Copy the block based iterator code into partitioned index iterator, and de-template them.
2. Remove some code not needed for partitioned index. The upper bound check and tricks are removed. We never tested performance for those tricks when partitioned index is enabled in the first place. It's unlikelyl to generate performance regression, as creating new partitioned index block is much rarer than data blocks.
3. Separate out the prefetch logic to a helper class and both classes call them.
This commit will enable future follow-ups. One direction is that we might separate index iterator interface for data blocks and index blocks, as they are quite different.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6531
Test Plan: build using make and cmake. And build release
Differential Revision: D20473108
fbshipit-source-id: e48011783b339a4257c204cc07507b171b834b0f
5 years ago
|
|
|
"table/block_based/block_prefetcher.cc",
|
|
|
|
|
"table/block_based/block_prefix_index.cc",
|
|
|
|
|
"table/block_based/data_block_footer.cc",
|
|
|
|
|
"table/block_based/data_block_hash_index.cc",
|
Move the filter readers out of the block cache (#5504)
Summary:
Currently, when the block cache is used for the filter block, it is not
really the block itself that is stored in the cache but a FilterBlockReader
object. Since this object is not pure data (it has, for instance, pointers that
might dangle, including in one case a back pointer to the TableReader), it's not
really sharable. To avoid the issues around this, the current code erases the
cache entries when the TableReader is closed (which, BTW, is not sufficient
since a concurrent TableReader might have picked up the object in the meantime).
Instead of doing this, the patch moves the FilterBlockReader out of the cache
altogether, and decouples the filter reader object from the filter block.
In particular, instead of the TableReader owning, or caching/pinning the
FilterBlockReader (based on the customer's settings), with the change the
TableReader unconditionally owns the FilterBlockReader, which in turn
owns/caches/pins the filter block. This change also enables us to reuse the code
paths historically used for data blocks for filters as well.
Note:
Eviction statistics for filter blocks are temporarily broken. We plan to fix this in a
separate phase.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5504
Test Plan: make asan_check
Differential Revision: D16036974
Pulled By: ltamasi
fbshipit-source-id: 770f543c5fb4ed126fd1e04bfd3809cf4ff9c091
6 years ago
|
|
|
"table/block_based/filter_block_reader_common.cc",
|
|
|
|
|
"table/block_based/filter_policy.cc",
|
|
|
|
|
"table/block_based/flush_block_policy.cc",
|
|
|
|
|
"table/block_based/full_filter_block.cc",
|
|
|
|
|
"table/block_based/hash_index_reader.cc",
|
|
|
|
|
"table/block_based/index_builder.cc",
|
|
|
|
|
"table/block_based/index_reader_common.cc",
|
|
|
|
|
"table/block_based/parsed_full_filter_block.cc",
|
|
|
|
|
"table/block_based/partitioned_filter_block.cc",
|
De-template block based table iterator (#6531)
Summary:
Right now block based table iterator is used as both of iterating data for block based table, and for the index iterator for partitioend index. This was initially convenient for introducing a new iterator and block type for new index format, while reducing code change. However, these two usage doesn't go with each other very well. For example, Prev() is never called for partitioned index iterator, and some other complexity is maintained in block based iterators, which is not needed for index iterator but maintainers will always need to reason about it. Furthermore, the template usage is not following Google C++ Style which we are following, and makes a large chunk of code tangled together. This commit separate the two iterators. Right now, here is what it is done:
1. Copy the block based iterator code into partitioned index iterator, and de-template them.
2. Remove some code not needed for partitioned index. The upper bound check and tricks are removed. We never tested performance for those tricks when partitioned index is enabled in the first place. It's unlikelyl to generate performance regression, as creating new partitioned index block is much rarer than data blocks.
3. Separate out the prefetch logic to a helper class and both classes call them.
This commit will enable future follow-ups. One direction is that we might separate index iterator interface for data blocks and index blocks, as they are quite different.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6531
Test Plan: build using make and cmake. And build release
Differential Revision: D20473108
fbshipit-source-id: e48011783b339a4257c204cc07507b171b834b0f
5 years ago
|
|
|
"table/block_based/partitioned_index_iterator.cc",
|
|
|
|
|
"table/block_based/partitioned_index_reader.cc",
|
|
|
|
|
"table/block_based/reader_common.cc",
|
|
|
|
|
"table/block_based/uncompression_dict_reader.cc",
|
|
|
|
|
"table/block_fetcher.cc",
|
|
|
|
|
"table/cuckoo/cuckoo_table_builder.cc",
|
|
|
|
|
"table/cuckoo/cuckoo_table_factory.cc",
|
|
|
|
|
"table/cuckoo/cuckoo_table_reader.cc",
|
|
|
|
|
"table/format.cc",
|
|
|
|
|
"table/get_context.cc",
|
|
|
|
|
"table/iterator.cc",
|
|
|
|
|
"table/merging_iterator.cc",
|
|
|
|
|
"table/meta_blocks.cc",
|
|
|
|
|
"table/persistent_cache_helper.cc",
|
|
|
|
|
"table/plain/plain_table_bloom.cc",
|
|
|
|
|
"table/plain/plain_table_builder.cc",
|
|
|
|
|
"table/plain/plain_table_factory.cc",
|
|
|
|
|
"table/plain/plain_table_index.cc",
|
|
|
|
|
"table/plain/plain_table_key_coding.cc",
|
|
|
|
|
"table/plain/plain_table_reader.cc",
|
|
|
|
|
"table/sst_file_dumper.cc",
|
|
|
|
|
"table/sst_file_reader.cc",
|
|
|
|
|
"table/sst_file_writer.cc",
|
|
|
|
|
"table/table_factory.cc",
|
|
|
|
|
"table/table_properties.cc",
|
|
|
|
|
"table/two_level_iterator.cc",
|
Experimental support for SST unique IDs (#8990)
Summary:
* New public header unique_id.h and function GetUniqueIdFromTableProperties
which computes a universally unique identifier based on table properties
of table files from recent RocksDB versions.
* Generation of DB session IDs is refactored so that they are
guaranteed unique in the lifetime of a process running RocksDB.
(SemiStructuredUniqueIdGen, new test included.) Along with file numbers,
this enables SST unique IDs to be guaranteed unique among SSTs generated
in a single process, and "better than random" between processes.
See https://github.com/pdillinger/unique_id
* In addition to public API producing 'external' unique IDs, there is a function
for producing 'internal' unique IDs, with functions for converting between the
two. In short, the external ID is "safe" for things people might do with it, and
the internal ID enables more "power user" features for the future. Specifically,
the external ID goes through a hashing layer so that any subset of bits in the
external ID can be used as a hash of the full ID, while also preserving
uniqueness guarantees in the first 128 bits (bijective both on first 128 bits
and on full 192 bits).
Intended follow-up:
* Use the internal unique IDs in cache keys. (Avoid conflicts with https://github.com/facebook/rocksdb/issues/8912) (The file offset can be XORed into
the third 64-bit value of the unique ID.)
* Publish the external unique IDs in FileStorageInfo (https://github.com/facebook/rocksdb/issues/8968)
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8990
Test Plan:
Unit tests added, and checking of unique ids in stress test.
NOTE in stress test we do not generate nearly enough files to thoroughly
stress uniqueness, but the test trims off pieces of the ID to check for
uniqueness so that we can infer (with some assumptions) stronger
properties in the aggregate.
Reviewed By: zhichao-cao, mrambacher
Differential Revision: D31582865
Pulled By: pdillinger
fbshipit-source-id: 1f620c4c86af9abe2a8d177b9ccf2ad2b9f48243
3 years ago
|
|
|
"table/unique_id.cc",
|
|
|
|
|
"test_util/sync_point.cc",
|
|
|
|
|
"test_util/sync_point_impl.cc",
|
|
|
|
|
"test_util/transaction_test_util.cc",
|
|
|
|
|
"tools/dump/db_dump_tool.cc",
|
|
|
|
|
"tools/io_tracer_parser_tool.cc",
|
|
|
|
|
"tools/ldb_cmd.cc",
|
|
|
|
|
"tools/ldb_tool.cc",
|
|
|
|
|
"tools/sst_dump_tool.cc",
|
|
|
|
|
"trace_replay/block_cache_tracer.cc",
|
|
|
|
|
"trace_replay/io_tracer.cc",
|
|
|
|
|
"trace_replay/trace_record.cc",
|
|
|
|
|
"trace_replay/trace_record_handler.cc",
|
|
|
|
|
"trace_replay/trace_record_result.cc",
|
|
|
|
|
"trace_replay/trace_replay.cc",
|
Multi file concurrency in MultiGet using coroutines and async IO (#9968)
Summary:
This PR implements a coroutine version of batched MultiGet in order to concurrently read from multiple SST files in a level using async IO, thus reducing the latency of the MultiGet. The API from the user perspective is still synchronous and single threaded, with the RocksDB part of the processing happening in the context of the caller's thread. In Version::MultiGet, the decision is made whether to call synchronous or coroutine code.
A good way to review this PR is to review the first 4 commits in order - de773b3, 70c2f70, 10b50e1, and 377a597 - before reviewing the rest.
TODO:
1. Figure out how to build it in CircleCI (requires some dependencies to be installed)
2. Do some stress testing with coroutines enabled
No regression in synchronous MultiGet between this branch and main -
```
./db_bench -use_existing_db=true --db=/data/mysql/rocksdb/prefix_scan -benchmarks="readseq,multireadrandom" -key_size=32 -value_size=512 -num=5000000 -batch_size=64 -multiread_batched=true -use_direct_reads=false -duration=60 -ops_between_duration_checks=1 -readonly=true -adaptive_readahead=true -threads=16 -cache_size=10485760000 -async_io=false -multiread_stride=40000 -statistics
```
Branch - ```multireadrandom : 4.025 micros/op 3975111 ops/sec 60.001 seconds 238509056 operations; 2062.3 MB/s (14767808 of 14767808 found)```
Main - ```multireadrandom : 3.987 micros/op 4013216 ops/sec 60.001 seconds 240795392 operations; 2082.1 MB/s (15231040 of 15231040 found)```
More benchmarks in various scenarios are given below. The measurements were taken with ```async_io=false``` (no coroutines) and ```async_io=true``` (use coroutines). For an IO bound workload (with every key requiring an IO), the coroutines version shows a clear benefit, being ~2.6X faster. For CPU bound workloads, the coroutines version has ~6-15% higher CPU utilization, depending on how many keys overlap an SST file.
1. Single thread IO bound workload on remote storage with sparse MultiGet batch keys (~1 key overlap/file) -
No coroutines - ```multireadrandom : 831.774 micros/op 1202 ops/sec 60.001 seconds 72136 operations; 0.6 MB/s (72136 of 72136 found)```
Using coroutines - ```multireadrandom : 318.742 micros/op 3137 ops/sec 60.003 seconds 188248 operations; 1.6 MB/s (188248 of 188248 found)```
2. Single thread CPU bound workload (all data cached) with ~1 key overlap/file -
No coroutines - ```multireadrandom : 4.127 micros/op 242322 ops/sec 60.000 seconds 14539384 operations; 125.7 MB/s (14539384 of 14539384 found)```
Using coroutines - ```multireadrandom : 4.741 micros/op 210935 ops/sec 60.000 seconds 12656176 operations; 109.4 MB/s (12656176 of 12656176 found)```
3. Single thread CPU bound workload with ~2 key overlap/file -
No coroutines - ```multireadrandom : 3.717 micros/op 269000 ops/sec 60.000 seconds 16140024 operations; 139.6 MB/s (16140024 of 16140024 found)```
Using coroutines - ```multireadrandom : 4.146 micros/op 241204 ops/sec 60.000 seconds 14472296 operations; 125.1 MB/s (14472296 of 14472296 found)```
4. CPU bound multi-threaded (16 threads) with ~4 key overlap/file -
No coroutines - ```multireadrandom : 4.534 micros/op 3528792 ops/sec 60.000 seconds 211728728 operations; 1830.7 MB/s (12737024 of 12737024 found) ```
Using coroutines - ```multireadrandom : 4.872 micros/op 3283812 ops/sec 60.000 seconds 197030096 operations; 1703.6 MB/s (12548032 of 12548032 found) ```
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9968
Reviewed By: akankshamahajan15
Differential Revision: D36348563
Pulled By: anand1976
fbshipit-source-id: c0ce85a505fd26ebfbb09786cbd7f25202038696
3 years ago
|
|
|
"util/async_file_reader.cc",
|
|
|
|
|
"util/build_version.cc",
|
Eliminate unnecessary (slow) block cache Ref()ing in MultiGet (#9899)
Summary:
When MultiGet() determines that multiple query keys can be
served by examining the same data block in block cache (one Lookup()),
each PinnableSlice referring to data in that data block needs to hold
on to the block in cache so that they can be released at arbitrary
times by the API user. Historically this is accomplished with extra
calls to Ref() on the Handle from Lookup(), with each PinnableSlice
cleanup calling Release() on the Handle, but this creates extra
contention on the block cache for the extra Ref()s and Release()es,
especially because they hit the same cache shard repeatedly.
In the case of merge operands (possibly more cases?), the problem was
compounded by doing an extra Ref()+eventual Release() for each merge
operand for a key reusing a block (which could be the same key!), rather
than one Ref() per key. (Note: the non-shared case with `biter` was
already one per key.)
This change optimizes MultiGet not to rely on these extra, contentious
Ref()+Release() calls by instead, in the shared block case, wrapping
the cache Release() cleanup in a refcounted object referenced by the
PinnableSlices, such that after the last wrapped reference is released,
the cache entry is Release()ed. Relaxed atomic refcounts should be
much faster than mutex-guarded Ref() and Release(), and much less prone
to a performance cliff when MultiGet() does a lot of block sharing.
Note that I did not use std::shared_ptr, because that would require an
extra indirection object (shared_ptr itself new/delete) in order to
associate a ref increment/decrement with a Cleanable cleanup entry. (If
I assumed it was the size of two pointers, I could do some hackery to
make it work without the extra indirection, but that's too fragile.)
Some details:
* Fixed (removed) extra block cache tracing entries in cases of cache
entry reuse in MultiGet, but it's likely that in some other cases traces
are missing (XXX comment inserted)
* Moved existing implementations for cleanable.h from iterator.cc to
new cleanable.cc
* Improved API comments on Cleanable
* Added a public SharedCleanablePtr class to cleanable.h in case others
could benefit from the same pattern (potentially many Cleanables and/or
smart pointers referencing a shared Cleanable)
* Add a typedef for MultiGetContext::Mask
* Some variable renaming for clarity
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9899
Test Plan:
Added unit tests for SharedCleanablePtr.
Greatly enhanced ability of existing tests to detect cache use-after-free.
* Release PinnableSlices from MultiGet as they are read rather than in
bulk (in db_test_util wrapper).
* In ASAN build, default to using a trivially small LRUCache for block_cache
so that entries are immediately erased when unreferenced. (Updated two
tests that depend on caching.) New ASAN testsuite running time seems
OK to me.
If I introduce a bug into my implementation where we skip the shared
cleanups on block reuse, ASAN detects the bug in
`db_basic_test *MultiGet*`. If I remove either of the above testing
enhancements, the bug is not detected.
Consider for follow-up work: manipulate or randomize ordering of
PinnableSlice use and release from MultiGet db_test_util wrapper. But in
typical cases, natural ordering gives pretty good functional coverage.
Performance test:
In the extreme (but possible) case of MultiGetting the same or adjacent keys
in a batch, throughput can improve by an order of magnitude.
`./db_bench -benchmarks=multireadrandom -db=/dev/shm/testdb -readonly -num=5 -duration=10 -threads=20 -multiread_batched -batch_size=200`
Before ops/sec, num=5: 1,384,394
Before ops/sec, num=500: 6,423,720
After ops/sec, num=500: 10,658,794
After ops/sec, num=5: 16,027,257
Also note that previously, with high parallelism, having query keys
concentrated in a single block was worse than spreading them out a bit. Now
concentrated in a single block is faster than spread out, which is hopefully
consistent with natural expectation.
Random query performance: with num=1000000, over 999 x 10s runs running before & after simultaneously (each -threads=12):
Before: multireadrandom [AVG 999 runs] : 1088699 (± 7344) ops/sec; 120.4 (± 0.8 ) MB/sec
After: multireadrandom [AVG 999 runs] : 1090402 (± 7230) ops/sec; 120.6 (± 0.8 ) MB/sec
Possibly better, possibly in the noise.
Reviewed By: anand1976
Differential Revision: D35907003
Pulled By: pdillinger
fbshipit-source-id: bbd244d703649a8ca12d476f2d03853ed9d1a17e
3 years ago
|
|
|
"util/cleanable.cc",
|
|
|
|
|
"util/coding.cc",
|
|
|
|
|
"util/compaction_job_stats_impl.cc",
|
|
|
|
|
"util/comparator.cc",
|
|
|
|
|
"util/compression.cc",
|
|
|
|
|
"util/compression_context_cache.cc",
|
Concurrent task limiter for compaction thread control (#4332)
Summary:
The PR is targeting to resolve the issue of:
https://github.com/facebook/rocksdb/issues/3972#issue-330771918
We have a rocksdb created with leveled-compaction with multiple column families (CFs), some of CFs are using HDD to store big and less frequently accessed data and others are using SSD.
When there are continuously write traffics going on to all CFs, the compaction thread pool is mostly occupied by those slow HDD compactions, which blocks fully utilize SSD bandwidth.
Since atomic write and transaction is needed across CFs, so splitting it to multiple rocksdb instance is not an option for us.
With the compaction thread control, we got 30%+ HDD write throughput gain, and also a lot smooth SSD write since less write stall happening.
ConcurrentTaskLimiter can be shared with multi-CFs across rocksdb instances, so the feature does not only work for multi-CFs scenarios, but also for multi-rocksdbs scenarios, who need disk IO resource control per tenant.
The usage is straight forward:
e.g.:
//
// Enable compaction thread limiter thru ColumnFamilyOptions
//
std::shared_ptr<ConcurrentTaskLimiter> ctl(NewConcurrentTaskLimiter("foo_limiter", 4));
Options options;
ColumnFamilyOptions cf_opt(options);
cf_opt.compaction_thread_limiter = ctl;
...
//
// Compaction thread limiter can be tuned or disabled on-the-fly
//
ctl->SetMaxOutstandingTask(12); // enlarge to 12 tasks
...
ctl->ResetMaxOutstandingTask(); // disable (bypass) thread limiter
ctl->SetMaxOutstandingTask(-1); // Same as above
...
ctl->SetMaxOutstandingTask(0); // full throttle (0 task)
//
// Sharing compaction thread limiter among CFs (to resolve multiple storage perf issue)
//
std::shared_ptr<ConcurrentTaskLimiter> ctl_ssd(NewConcurrentTaskLimiter("ssd_limiter", 8));
std::shared_ptr<ConcurrentTaskLimiter> ctl_hdd(NewConcurrentTaskLimiter("hdd_limiter", 4));
Options options;
ColumnFamilyOptions cf_opt_ssd1(options);
ColumnFamilyOptions cf_opt_ssd2(options);
ColumnFamilyOptions cf_opt_hdd1(options);
ColumnFamilyOptions cf_opt_hdd2(options);
ColumnFamilyOptions cf_opt_hdd3(options);
// SSD CFs
cf_opt_ssd1.compaction_thread_limiter = ctl_ssd;
cf_opt_ssd2.compaction_thread_limiter = ctl_ssd;
// HDD CFs
cf_opt_hdd1.compaction_thread_limiter = ctl_hdd;
cf_opt_hdd2.compaction_thread_limiter = ctl_hdd;
cf_opt_hdd3.compaction_thread_limiter = ctl_hdd;
...
//
// The limiter is disabled by default (or set to nullptr explicitly)
//
Options options;
ColumnFamilyOptions cf_opt(options);
cf_opt.compaction_thread_limiter = nullptr;
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4332
Differential Revision: D13226590
Pulled By: siying
fbshipit-source-id: 14307aec55b8bd59c8223d04aa6db3c03d1b0c1d
6 years ago
|
|
|
"util/concurrent_task_limiter_impl.cc",
|
|
|
|
|
"util/crc32c.cc",
|
|
|
|
|
"util/crc32c_arm64.cc",
|
|
|
|
|
"util/dynamic_bloom.cc",
|
|
|
|
|
"util/file_checksum_helper.cc",
|
|
|
|
|
"util/hash.cc",
|
|
|
|
|
"util/murmurhash.cc",
|
|
|
|
|
"util/random.cc",
|
|
|
|
|
"util/rate_limiter.cc",
|
Refine Ribbon configuration, improve testing, add Homogeneous (#7879)
Summary:
This change only affects non-schema-critical aspects of the production candidate Ribbon filter. Specifically, it refines choice of internal configuration parameters based on inputs. The changes are minor enough that the schema tests in bloom_test, some of which depend on this, are unaffected. There are also some minor optimizations and refactorings.
This would be a schema change for "smash" Ribbon, to fix some known issues with small filters, but "smash" Ribbon is not accessible in public APIs. Unit test CompactnessAndBacktrackAndFpRate updated to test small and medium-large filters. Run with --thoroughness=100 or so for much better detection power (not appropriate for continuous regression testing).
Homogenous Ribbon:
This change adds internally a Ribbon filter variant we call Homogeneous Ribbon, in collaboration with Stefan Walzer. The expected "result" value for every key is zero, instead of computed from a hash. Entropy for queries not to be false positives comes from free variables ("overhead") in the solution structure, which are populated pseudorandomly. Construction is slightly faster for not tracking result values, and never fails. Instead, FP rate can jump up whenever and whereever entries are packed too tightly. For small structures, we can choose overhead to make this FP rate jump unlikely, as seen in updated unit test CompactnessAndBacktrackAndFpRate.
Unlike standard Ribbon, Homogeneous Ribbon seems to scale to arbitrary number of keys when accepting an FP rate penalty for small pockets of high FP rate in the structure. For example, 64-bit ribbon with 8 solution columns and 10% allocated space overhead for slots seems to achieve about 10.5% space overhead vs. information-theoretic minimum based on its observed FP rate with expected pockets of degradation. (FP rate is close to 1/256.) If targeting a higher FP rate with fewer solution columns, Homogeneous Ribbon can be even more space efficient, because the penalty from degradation is relatively smaller. If targeting a lower FP rate, Homogeneous Ribbon is less space efficient, as more allocated overhead is needed to keep the FP rate impact of degradation relatively under control. The new OptimizeHomogAtScale tool in ribbon_test helps to find these optimal allocation overheads for different numbers of solution columns. And Ribbon widths, with 128-bit Ribbon apparently cutting space overheads in half vs. 64-bit.
Other misc item specifics:
* Ribbon APIs in util/ribbon_config.h now provide configuration data for not just 5% construction failure rate (95% success), but also 50% and 0.1%.
* Note that the Ribbon structure does not exhibit "threshold" behavior as standard Xor filter does, so there is a roughly fixed space penalty to cut construction failure rate in half. Thus, there isn't really an "almost sure" setting.
* Although we can extrapolate settings for large filters, we don't have a good formula for configuring smaller filters (< 2^17 slots or so), and efforts to summarize with a formula have failed. Thus, small data is hard-coded from updated FindOccupancy tool.
* Enhances ApproximateNumEntries for public API Ribbon using more precise data (new API GetNumToAdd), thus a more accurate but not perfect reversal of CalculateSpace. (bloom_test updated to expect the greater precision)
* Move EndianSwapValue from coding.h to coding_lean.h to keep Ribbon code easily transferable from RocksDB
* Add some missing 'const' to member functions
* Small optimization to 128-bit BitParity
* Small refactoring of BandingStorage in ribbon_alg.h to support Homogeneous Ribbon
* CompactnessAndBacktrackAndFpRate now has an "expand" test: on construction failure, a possible alternative to re-seeding hash functions is simply to increase the number of slots (allocated space overhead) and try again with essentially the same hash values. (Start locations will be different roundings of the same scaled hash values--because fastrange not mod.) This seems to be as effective or more effective than re-seeding, as long as we increase the number of slots (m) by roughly m += m/w where w is the Ribbon width. This way, there is effectively an expansion by one slot for each ribbon-width window in the banding. (This approach assumes that getting "bad data" from your hash function is as unlikely as it naturally should be, e.g. no adversary.)
* 32-bit and 16-bit Ribbon configurations are added to ribbon_test for understanding their behavior, e.g. with FindOccupancy. They are not considered useful at this time and not tested with CompactnessAndBacktrackAndFpRate.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/7879
Test Plan: unit test updates included
Reviewed By: jay-zhuang
Differential Revision: D26371245
Pulled By: pdillinger
fbshipit-source-id: da6600d90a3785b99ad17a88b2a3027710b4ea3a
4 years ago
|
|
|
"util/ribbon_config.cc",
|
|
|
|
|
"util/slice.cc",
|
|
|
|
|
"util/status.cc",
|
|
|
|
|
"util/stderr_logger.cc",
|
|
|
|
|
"util/string_util.cc",
|
|
|
|
|
"util/thread_local.cc",
|
|
|
|
|
"util/threadpool_imp.cc",
|
|
|
|
|
"util/xxhash.cc",
|
|
|
|
|
"utilities/agg_merge/agg_merge.cc",
|
|
|
|
|
"utilities/backup/backup_engine.cc",
|
|
|
|
|
"utilities/blob_db/blob_compaction_filter.cc",
|
|
|
|
|
"utilities/blob_db/blob_db.cc",
|
|
|
|
|
"utilities/blob_db/blob_db_impl.cc",
|
|
|
|
|
"utilities/blob_db/blob_db_impl_filesnapshot.cc",
|
|
|
|
|
"utilities/blob_db/blob_dump_tool.cc",
|
|
|
|
|
"utilities/blob_db/blob_file.cc",
|
|
|
|
|
"utilities/cache_dump_load.cc",
|
|
|
|
|
"utilities/cache_dump_load_impl.cc",
|
|
|
|
|
"utilities/cassandra/cassandra_compaction_filter.cc",
|
|
|
|
|
"utilities/cassandra/format.cc",
|
|
|
|
|
"utilities/cassandra/merge_operator.cc",
|
|
|
|
|
"utilities/checkpoint/checkpoint_impl.cc",
|
|
|
|
|
"utilities/compaction_filters.cc",
|
|
|
|
|
"utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc",
|
|
|
|
|
"utilities/convenience/info_log_finder.cc",
|
|
|
|
|
"utilities/counted_fs.cc",
|
|
|
|
|
"utilities/debug.cc",
|
|
|
|
|
"utilities/env_mirror.cc",
|
|
|
|
|
"utilities/env_timed.cc",
|
|
|
|
|
"utilities/fault_injection_env.cc",
|
|
|
|
|
"utilities/fault_injection_fs.cc",
|
|
|
|
|
"utilities/fault_injection_secondary_cache.cc",
|
|
|
|
|
"utilities/leveldb_options/leveldb_options.cc",
|
|
|
|
|
"utilities/memory/memory_util.cc",
|
|
|
|
|
"utilities/merge_operators.cc",
|
|
|
|
|
"utilities/merge_operators/bytesxor.cc",
|
|
|
|
|
"utilities/merge_operators/max.cc",
|
|
|
|
|
"utilities/merge_operators/put.cc",
|
New API to get all merge operands for a Key (#5604)
Summary:
This is a new API added to db.h to allow for fetching all merge operands associated with a Key. The main motivation for this API is to support use cases where doing a full online merge is not necessary as it is performance sensitive. Example use-cases:
1. Update subset of columns and read subset of columns -
Imagine a SQL Table, a row is encoded as a K/V pair (as it is done in MyRocks). If there are many columns and users only updated one of them, we can use merge operator to reduce write amplification. While users only read one or two columns in the read query, this feature can avoid a full merging of the whole row, and save some CPU.
2. Updating very few attributes in a value which is a JSON-like document -
Updating one attribute can be done efficiently using merge operator, while reading back one attribute can be done more efficiently if we don't need to do a full merge.
----------------------------------------------------------------------------------------------------
API :
Status GetMergeOperands(
const ReadOptions& options, ColumnFamilyHandle* column_family,
const Slice& key, PinnableSlice* merge_operands,
GetMergeOperandsOptions* get_merge_operands_options,
int* number_of_operands)
Example usage :
int size = 100;
int number_of_operands = 0;
std::vector<PinnableSlice> values(size);
GetMergeOperandsOptions merge_operands_info;
db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k1", values.data(), merge_operands_info, &number_of_operands);
Description :
Returns all the merge operands corresponding to the key. If the number of merge operands in DB is greater than merge_operands_options.expected_max_number_of_operands no merge operands are returned and status is Incomplete. Merge operands returned are in the order of insertion.
merge_operands-> Points to an array of at-least merge_operands_options.expected_max_number_of_operands and the caller is responsible for allocating it. If the status returned is Incomplete then number_of_operands will contain the total number of merge operands found in DB for key.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5604
Test Plan:
Added unit test and perf test in db_bench that can be run using the command:
./db_bench -benchmarks=getmergeoperands --merge_operator=sortlist
Differential Revision: D16657366
Pulled By: vjnadimpalli
fbshipit-source-id: 0faadd752351745224ee12d4ae9ef3cb529951bf
5 years ago
|
|
|
"utilities/merge_operators/sortlist.cc",
|
|
|
|
|
"utilities/merge_operators/string_append/stringappend.cc",
|
|
|
|
|
"utilities/merge_operators/string_append/stringappend2.cc",
|
|
|
|
|
"utilities/merge_operators/uint64add.cc",
|
|
|
|
|
"utilities/object_registry.cc",
|
|
|
|
|
"utilities/option_change_migration/option_change_migration.cc",
|
|
|
|
|
"utilities/options/options_util.cc",
|
|
|
|
|
"utilities/persistent_cache/block_cache_tier.cc",
|
|
|
|
|
"utilities/persistent_cache/block_cache_tier_file.cc",
|
|
|
|
|
"utilities/persistent_cache/block_cache_tier_metadata.cc",
|
|
|
|
|
"utilities/persistent_cache/persistent_cache_tier.cc",
|
|
|
|
|
"utilities/persistent_cache/volatile_tier_impl.cc",
|
|
|
|
|
"utilities/simulator_cache/cache_simulator.cc",
|
|
|
|
|
"utilities/simulator_cache/sim_cache.cc",
|
|
|
|
|
"utilities/table_properties_collectors/compact_on_deletion_collector.cc",
|
|
|
|
|
"utilities/trace/file_trace_reader_writer.cc",
|
|
|
|
|
"utilities/trace/replayer_impl.cc",
|
|
|
|
|
"utilities/transactions/lock/lock_manager.cc",
|
|
|
|
|
"utilities/transactions/lock/point/point_lock_manager.cc",
|
|
|
|
|
"utilities/transactions/lock/point/point_lock_tracker.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/concurrent_tree.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/keyrange.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/lock_request.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/locktree.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/manager.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/range_buffer.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/treenode.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/txnid_set.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/wfg.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/standalone_port.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/util/dbt.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/util/memarena.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/range_tree_lock_manager.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/range_tree_lock_tracker.cc",
|
|
|
|
|
"utilities/transactions/optimistic_transaction.cc",
|
|
|
|
|
"utilities/transactions/optimistic_transaction_db_impl.cc",
|
|
|
|
|
"utilities/transactions/pessimistic_transaction.cc",
|
|
|
|
|
"utilities/transactions/pessimistic_transaction_db.cc",
|
|
|
|
|
"utilities/transactions/snapshot_checker.cc",
|
|
|
|
|
"utilities/transactions/transaction_base.cc",
|
|
|
|
|
"utilities/transactions/transaction_db_mutex_impl.cc",
|
|
|
|
|
"utilities/transactions/transaction_util.cc",
|
|
|
|
|
"utilities/transactions/write_prepared_txn.cc",
|
|
|
|
|
"utilities/transactions/write_prepared_txn_db.cc",
|
|
|
|
|
"utilities/transactions/write_unprepared_txn.cc",
|
|
|
|
|
"utilities/transactions/write_unprepared_txn_db.cc",
|
|
|
|
|
"utilities/ttl/db_ttl_impl.cc",
|
|
|
|
|
"utilities/wal_filter.cc",
|
|
|
|
|
"utilities/write_batch_with_index/write_batch_with_index.cc",
|
|
|
|
|
"utilities/write_batch_with_index/write_batch_with_index_internal.cc",
|
Multi file concurrency in MultiGet using coroutines and async IO (#9968)
Summary:
This PR implements a coroutine version of batched MultiGet in order to concurrently read from multiple SST files in a level using async IO, thus reducing the latency of the MultiGet. The API from the user perspective is still synchronous and single threaded, with the RocksDB part of the processing happening in the context of the caller's thread. In Version::MultiGet, the decision is made whether to call synchronous or coroutine code.
A good way to review this PR is to review the first 4 commits in order - de773b3, 70c2f70, 10b50e1, and 377a597 - before reviewing the rest.
TODO:
1. Figure out how to build it in CircleCI (requires some dependencies to be installed)
2. Do some stress testing with coroutines enabled
No regression in synchronous MultiGet between this branch and main -
```
./db_bench -use_existing_db=true --db=/data/mysql/rocksdb/prefix_scan -benchmarks="readseq,multireadrandom" -key_size=32 -value_size=512 -num=5000000 -batch_size=64 -multiread_batched=true -use_direct_reads=false -duration=60 -ops_between_duration_checks=1 -readonly=true -adaptive_readahead=true -threads=16 -cache_size=10485760000 -async_io=false -multiread_stride=40000 -statistics
```
Branch - ```multireadrandom : 4.025 micros/op 3975111 ops/sec 60.001 seconds 238509056 operations; 2062.3 MB/s (14767808 of 14767808 found)```
Main - ```multireadrandom : 3.987 micros/op 4013216 ops/sec 60.001 seconds 240795392 operations; 2082.1 MB/s (15231040 of 15231040 found)```
More benchmarks in various scenarios are given below. The measurements were taken with ```async_io=false``` (no coroutines) and ```async_io=true``` (use coroutines). For an IO bound workload (with every key requiring an IO), the coroutines version shows a clear benefit, being ~2.6X faster. For CPU bound workloads, the coroutines version has ~6-15% higher CPU utilization, depending on how many keys overlap an SST file.
1. Single thread IO bound workload on remote storage with sparse MultiGet batch keys (~1 key overlap/file) -
No coroutines - ```multireadrandom : 831.774 micros/op 1202 ops/sec 60.001 seconds 72136 operations; 0.6 MB/s (72136 of 72136 found)```
Using coroutines - ```multireadrandom : 318.742 micros/op 3137 ops/sec 60.003 seconds 188248 operations; 1.6 MB/s (188248 of 188248 found)```
2. Single thread CPU bound workload (all data cached) with ~1 key overlap/file -
No coroutines - ```multireadrandom : 4.127 micros/op 242322 ops/sec 60.000 seconds 14539384 operations; 125.7 MB/s (14539384 of 14539384 found)```
Using coroutines - ```multireadrandom : 4.741 micros/op 210935 ops/sec 60.000 seconds 12656176 operations; 109.4 MB/s (12656176 of 12656176 found)```
3. Single thread CPU bound workload with ~2 key overlap/file -
No coroutines - ```multireadrandom : 3.717 micros/op 269000 ops/sec 60.000 seconds 16140024 operations; 139.6 MB/s (16140024 of 16140024 found)```
Using coroutines - ```multireadrandom : 4.146 micros/op 241204 ops/sec 60.000 seconds 14472296 operations; 125.1 MB/s (14472296 of 14472296 found)```
4. CPU bound multi-threaded (16 threads) with ~4 key overlap/file -
No coroutines - ```multireadrandom : 4.534 micros/op 3528792 ops/sec 60.000 seconds 211728728 operations; 1830.7 MB/s (12737024 of 12737024 found) ```
Using coroutines - ```multireadrandom : 4.872 micros/op 3283812 ops/sec 60.000 seconds 197030096 operations; 1703.6 MB/s (12548032 of 12548032 found) ```
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9968
Reviewed By: akankshamahajan15
Differential Revision: D36348563
Pulled By: anand1976
fbshipit-source-id: c0ce85a505fd26ebfbb09786cbd7f25202038696
3 years ago
|
|
|
], deps=[
|
|
|
|
|
"//folly/container:f14_hash",
|
|
|
|
|
"//folly/experimental/coro:blocking_wait",
|
|
|
|
|
"//folly/experimental/coro:collect",
|
|
|
|
|
"//folly/experimental/coro:coroutine",
|
|
|
|
|
"//folly/experimental/coro:task",
|
|
|
|
|
"//folly/synchronization:distributed_mutex",
|
Multi file concurrency in MultiGet using coroutines and async IO (#9968)
Summary:
This PR implements a coroutine version of batched MultiGet in order to concurrently read from multiple SST files in a level using async IO, thus reducing the latency of the MultiGet. The API from the user perspective is still synchronous and single threaded, with the RocksDB part of the processing happening in the context of the caller's thread. In Version::MultiGet, the decision is made whether to call synchronous or coroutine code.
A good way to review this PR is to review the first 4 commits in order - de773b3, 70c2f70, 10b50e1, and 377a597 - before reviewing the rest.
TODO:
1. Figure out how to build it in CircleCI (requires some dependencies to be installed)
2. Do some stress testing with coroutines enabled
No regression in synchronous MultiGet between this branch and main -
```
./db_bench -use_existing_db=true --db=/data/mysql/rocksdb/prefix_scan -benchmarks="readseq,multireadrandom" -key_size=32 -value_size=512 -num=5000000 -batch_size=64 -multiread_batched=true -use_direct_reads=false -duration=60 -ops_between_duration_checks=1 -readonly=true -adaptive_readahead=true -threads=16 -cache_size=10485760000 -async_io=false -multiread_stride=40000 -statistics
```
Branch - ```multireadrandom : 4.025 micros/op 3975111 ops/sec 60.001 seconds 238509056 operations; 2062.3 MB/s (14767808 of 14767808 found)```
Main - ```multireadrandom : 3.987 micros/op 4013216 ops/sec 60.001 seconds 240795392 operations; 2082.1 MB/s (15231040 of 15231040 found)```
More benchmarks in various scenarios are given below. The measurements were taken with ```async_io=false``` (no coroutines) and ```async_io=true``` (use coroutines). For an IO bound workload (with every key requiring an IO), the coroutines version shows a clear benefit, being ~2.6X faster. For CPU bound workloads, the coroutines version has ~6-15% higher CPU utilization, depending on how many keys overlap an SST file.
1. Single thread IO bound workload on remote storage with sparse MultiGet batch keys (~1 key overlap/file) -
No coroutines - ```multireadrandom : 831.774 micros/op 1202 ops/sec 60.001 seconds 72136 operations; 0.6 MB/s (72136 of 72136 found)```
Using coroutines - ```multireadrandom : 318.742 micros/op 3137 ops/sec 60.003 seconds 188248 operations; 1.6 MB/s (188248 of 188248 found)```
2. Single thread CPU bound workload (all data cached) with ~1 key overlap/file -
No coroutines - ```multireadrandom : 4.127 micros/op 242322 ops/sec 60.000 seconds 14539384 operations; 125.7 MB/s (14539384 of 14539384 found)```
Using coroutines - ```multireadrandom : 4.741 micros/op 210935 ops/sec 60.000 seconds 12656176 operations; 109.4 MB/s (12656176 of 12656176 found)```
3. Single thread CPU bound workload with ~2 key overlap/file -
No coroutines - ```multireadrandom : 3.717 micros/op 269000 ops/sec 60.000 seconds 16140024 operations; 139.6 MB/s (16140024 of 16140024 found)```
Using coroutines - ```multireadrandom : 4.146 micros/op 241204 ops/sec 60.000 seconds 14472296 operations; 125.1 MB/s (14472296 of 14472296 found)```
4. CPU bound multi-threaded (16 threads) with ~4 key overlap/file -
No coroutines - ```multireadrandom : 4.534 micros/op 3528792 ops/sec 60.000 seconds 211728728 operations; 1830.7 MB/s (12737024 of 12737024 found) ```
Using coroutines - ```multireadrandom : 4.872 micros/op 3283812 ops/sec 60.000 seconds 197030096 operations; 1703.6 MB/s (12548032 of 12548032 found) ```
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9968
Reviewed By: akankshamahajan15
Differential Revision: D36348563
Pulled By: anand1976
fbshipit-source-id: c0ce85a505fd26ebfbb09786cbd7f25202038696
3 years ago
|
|
|
], headers=None, link_whole=False, extra_test_libs=False)
|
|
|
|
|
|
|
|
|
|
cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[
|
|
|
|
|
"cache/cache.cc",
|
Use deleters to label cache entries and collect stats (#8297)
Summary:
This change gathers and publishes statistics about the
kinds of items in block cache. This is especially important for
profiling relative usage of cache by index vs. filter vs. data blocks.
It works by iterating over the cache during periodic stats dump
(InternalStats, stats_dump_period_sec) or on demand when
DB::Get(Map)Property(kBlockCacheEntryStats), except that for
efficiency and sharing among column families, saved data from
the last scan is used when the data is not considered too old.
The new information can be seen in info LOG, for example:
Block cache LRUCache@0x7fca62229330 capacity: 95.37 MB collections: 8 last_copies: 0 last_secs: 0.00178 secs_since: 0
Block cache entry stats(count,size,portion): DataBlock(7092,28.24 MB,29.6136%) FilterBlock(215,867.90 KB,0.888728%) FilterMetaBlock(2,5.31 KB,0.00544%) IndexBlock(217,180.11 KB,0.184432%) WriteBuffer(1,256.00 KB,0.262144%) Misc(1,0.00 KB,0%)
And also through DB::GetProperty and GetMapProperty (here using
ldb just for demonstration):
$ ./ldb --db=/dev/shm/dbbench/ get_property rocksdb.block-cache-entry-stats
rocksdb.block-cache-entry-stats.bytes.data-block: 0
rocksdb.block-cache-entry-stats.bytes.deprecated-filter-block: 0
rocksdb.block-cache-entry-stats.bytes.filter-block: 0
rocksdb.block-cache-entry-stats.bytes.filter-meta-block: 0
rocksdb.block-cache-entry-stats.bytes.index-block: 178992
rocksdb.block-cache-entry-stats.bytes.misc: 0
rocksdb.block-cache-entry-stats.bytes.other-block: 0
rocksdb.block-cache-entry-stats.bytes.write-buffer: 0
rocksdb.block-cache-entry-stats.capacity: 8388608
rocksdb.block-cache-entry-stats.count.data-block: 0
rocksdb.block-cache-entry-stats.count.deprecated-filter-block: 0
rocksdb.block-cache-entry-stats.count.filter-block: 0
rocksdb.block-cache-entry-stats.count.filter-meta-block: 0
rocksdb.block-cache-entry-stats.count.index-block: 215
rocksdb.block-cache-entry-stats.count.misc: 1
rocksdb.block-cache-entry-stats.count.other-block: 0
rocksdb.block-cache-entry-stats.count.write-buffer: 0
rocksdb.block-cache-entry-stats.id: LRUCache@0x7f3636661290
rocksdb.block-cache-entry-stats.percent.data-block: 0.000000
rocksdb.block-cache-entry-stats.percent.deprecated-filter-block: 0.000000
rocksdb.block-cache-entry-stats.percent.filter-block: 0.000000
rocksdb.block-cache-entry-stats.percent.filter-meta-block: 0.000000
rocksdb.block-cache-entry-stats.percent.index-block: 2.133751
rocksdb.block-cache-entry-stats.percent.misc: 0.000000
rocksdb.block-cache-entry-stats.percent.other-block: 0.000000
rocksdb.block-cache-entry-stats.percent.write-buffer: 0.000000
rocksdb.block-cache-entry-stats.secs_for_last_collection: 0.000052
rocksdb.block-cache-entry-stats.secs_since_last_collection: 0
Solution detail - We need some way to flag what kind of blocks each
entry belongs to, preferably without changing the Cache API.
One of the complications is that Cache is a general interface that could
have other users that don't adhere to whichever convention we decide
on for keys and values. Or we would pay for an extra field in the Handle
that would only be used for this purpose.
This change uses a back-door approach, the deleter, to indicate the
"role" of a Cache entry (in addition to the value type, implicitly).
This has the added benefit of ensuring proper code origin whenever we
recognize a particular role for a cache entry; if the entry came from
some other part of the code, it will use an unrecognized deleter, which
we simply attribute to the "Misc" role.
An internal API makes for simple instantiation and automatic
registration of Cache deleters for a given value type and "role".
Another internal API, CacheEntryStatsCollector, solves the problem of
caching the results of a scan and sharing them, to ensure scans are
neither excessive nor redundant so as not to harm Cache performance.
Because code is added to BlocklikeTraits, it is pulled out of
block_based_table_reader.cc into its own file.
This is a reformulation of https://github.com/facebook/rocksdb/issues/8276, without the type checking option
(could still be added), and with actual stat gathering.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8297
Test Plan: manual testing with db_bench, and a couple of basic unit tests
Reviewed By: ltamasi
Differential Revision: D28488721
Pulled By: pdillinger
fbshipit-source-id: 472f524a9691b5afb107934be2d41d84f2b129fb
4 years ago
|
|
|
"cache/cache_entry_roles.cc",
|
New stable, fixed-length cache keys (#9126)
Summary:
This change standardizes on a new 16-byte cache key format for
block cache (incl compressed and secondary) and persistent cache (but
not table cache and row cache).
The goal is a really fast cache key with practically ideal stability and
uniqueness properties without external dependencies (e.g. from FileSystem).
A fixed key size of 16 bytes should enable future optimizations to the
concurrent hash table for block cache, which is a heavy CPU user /
bottleneck, but there appears to be measurable performance improvement
even with no changes to LRUCache.
This change replaces a lot of disjointed and ugly code handling cache
keys with calls to a simple, clean new internal API (cache_key.h).
(Preserving the old cache key logic under an option would be very ugly
and likely negate the performance gain of the new approach. Complete
replacement carries some inherent risk, but I think that's acceptable
with sufficient analysis and testing.)
The scheme for encoding new cache keys is complicated but explained
in cache_key.cc.
Also: EndianSwapValue is moved to math.h to be next to other bit
operations. (Explains some new include "math.h".) ReverseBits operation
added and unit tests added to hash_test for both.
Fixes https://github.com/facebook/rocksdb/issues/7405 (presuming a root cause)
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9126
Test Plan:
### Basic correctness
Several tests needed updates to work with the new functionality, mostly
because we are no longer relying on filesystem for stable cache keys
so table builders & readers need more context info to agree on cache
keys. This functionality is so core, a huge number of existing tests
exercise the cache key functionality.
### Performance
Create db with
`TEST_TMPDIR=/dev/shm ./db_bench -bloom_bits=10 -benchmarks=fillrandom -num=3000000 -partition_index_and_filters`
And test performance with
`TEST_TMPDIR=/dev/shm ./db_bench -readonly -use_existing_db -bloom_bits=10 -benchmarks=readrandom -num=3000000 -duration=30 -cache_index_and_filter_blocks -cache_size=250000 -threads=4`
using DEBUG_LEVEL=0 and simultaneous before & after runs.
Before ops/sec, avg over 100 runs: 121924
After ops/sec, avg over 100 runs: 125385 (+2.8%)
### Collision probability
I have built a tool, ./cache_bench -stress_cache_key to broadly simulate host-wide cache activity
over many months, by making some pessimistic simplifying assumptions:
* Every generated file has a cache entry for every byte offset in the file (contiguous range of cache keys)
* All of every file is cached for its entire lifetime
We use a simple table with skewed address assignment and replacement on address collision
to simulate files coming & going, with quite a variance (super-Poisson) in ages. Some output
with `./cache_bench -stress_cache_key -sck_keep_bits=40`:
```
Total cache or DBs size: 32TiB Writing 925.926 MiB/s or 76.2939TiB/day
Multiply by 9.22337e+18 to correct for simulation losses (but still assume whole file cached)
```
These come from default settings of 2.5M files per day of 32 MB each, and
`-sck_keep_bits=40` means that to represent a single file, we are only keeping 40 bits of
the 128-bit cache key. With file size of 2\*\*25 contiguous keys (pessimistic), our simulation
is about 2\*\*(128-40-25) or about 9 billion billion times more prone to collision than reality.
More default assumptions, relatively pessimistic:
* 100 DBs in same process (doesn't matter much)
* Re-open DB in same process (new session ID related to old session ID) on average
every 100 files generated
* Restart process (all new session IDs unrelated to old) 24 times per day
After enough data, we get a result at the end:
```
(keep 40 bits) 17 collisions after 2 x 90 days, est 10.5882 days between (9.76592e+19 corrected)
```
If we believe the (pessimistic) simulation and the mathematical generalization, we would need to run a billion machines all for 97 billion days to expect a cache key collision. To help verify that our generalization ("corrected") is robust, we can make our simulation more precise with `-sck_keep_bits=41` and `42`, which takes more running time to get enough data:
```
(keep 41 bits) 16 collisions after 4 x 90 days, est 22.5 days between (1.03763e+20 corrected)
(keep 42 bits) 19 collisions after 10 x 90 days, est 47.3684 days between (1.09224e+20 corrected)
```
The generalized prediction still holds. With the `-sck_randomize` option, we can see that we are beating "random" cache keys (except offsets still non-randomized) by a modest amount (roughly 20x less collision prone than random), which should make us reasonably comfortable even in "degenerate" cases:
```
197 collisions after 1 x 90 days, est 0.456853 days between (4.21372e+18 corrected)
```
I've run other tests to validate other conditions behave as expected, never behaving "worse than random" unless we start chopping off structured data.
Reviewed By: zhichao-cao
Differential Revision: D33171746
Pulled By: pdillinger
fbshipit-source-id: f16a57e369ed37be5e7e33525ace848d0537c88f
3 years ago
|
|
|
"cache/cache_key.cc",
|
|
|
|
|
"cache/cache_reservation_manager.cc",
|
|
|
|
|
"cache/charged_cache.cc",
|
|
|
|
|
"cache/clock_cache.cc",
|
|
|
|
|
"cache/compressed_secondary_cache.cc",
|
|
|
|
|
"cache/fast_lru_cache.cc",
|
|
|
|
|
"cache/lru_cache.cc",
|
|
|
|
|
"cache/sharded_cache.cc",
|
|
|
|
|
"db/arena_wrapped_db_iter.cc",
|
|
|
|
|
"db/blob/blob_contents.cc",
|
|
|
|
|
"db/blob/blob_fetcher.cc",
|
|
|
|
|
"db/blob/blob_file_addition.cc",
|
|
|
|
|
"db/blob/blob_file_builder.cc",
|
|
|
|
|
"db/blob/blob_file_cache.cc",
|
|
|
|
|
"db/blob/blob_file_garbage.cc",
|
|
|
|
|
"db/blob/blob_file_meta.cc",
|
Introduce a blob file reader class (#7461)
Summary:
The patch adds a class called `BlobFileReader` that can be used to retrieve blobs
using the information available in blob references (e.g. blob file number, offset, and
size). This will come in handy when implementing blob support for `Get`, `MultiGet`,
and iterators, and also for compaction/garbage collection.
When a `BlobFileReader` object is created (using the factory method `Create`),
it first checks whether the specified file is potentially valid by comparing the file
size against the combined size of the blob file header and footer (files smaller than
the threshold are considered malformed). Then, it opens the file, and reads and verifies
the header and footer. The verification involves magic number/CRC checks
as well as checking for unexpected header/footer fields, e.g. incorrect column family ID
or TTL blob files.
Blobs can be retrieved using `GetBlob`. `GetBlob` validates the offset and compression
type passed by the caller (because of the presence of the header and footer, the
specified offset cannot be too close to the start/end of the file; also, the compression type
has to match the one in the blob file header), and retrieves and potentially verifies and
uncompresses the blob. In particular, when `ReadOptions::verify_checksums` is set,
`BlobFileReader` reads the blob record header as well (as opposed to just the blob itself)
and verifies the key/value size, the key itself, as well as the CRC of the blob record header
and the key/value pair.
In addition, the patch exposes the compression type from `BlobIndex` (both using an
accessor and via `DebugString`), and adds a blob file read latency histogram to
`InternalStats` that can be used with `BlobFileReader`.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/7461
Test Plan: `make check`
Reviewed By: riversand963
Differential Revision: D23999219
Pulled By: ltamasi
fbshipit-source-id: deb6b1160d251258b308d5156e2ec063c3e12e5e
4 years ago
|
|
|
"db/blob/blob_file_reader.cc",
|
|
|
|
|
"db/blob/blob_garbage_meter.cc",
|
|
|
|
|
"db/blob/blob_log_format.cc",
|
|
|
|
|
"db/blob/blob_log_sequential_reader.cc",
|
|
|
|
|
"db/blob/blob_log_writer.cc",
|
|
|
|
|
"db/blob/blob_source.cc",
|
|
|
|
|
"db/blob/prefetch_buffer_collection.cc",
|
|
|
|
|
"db/builder.cc",
|
|
|
|
|
"db/c.cc",
|
|
|
|
|
"db/column_family.cc",
|
|
|
|
|
"db/compaction/compaction.cc",
|
|
|
|
|
"db/compaction/compaction_iterator.cc",
|
|
|
|
|
"db/compaction/compaction_job.cc",
|
|
|
|
|
"db/compaction/compaction_outputs.cc",
|
|
|
|
|
"db/compaction/compaction_picker.cc",
|
|
|
|
|
"db/compaction/compaction_picker_fifo.cc",
|
|
|
|
|
"db/compaction/compaction_picker_level.cc",
|
|
|
|
|
"db/compaction/compaction_picker_universal.cc",
|
|
|
|
|
"db/compaction/compaction_service_job.cc",
|
|
|
|
|
"db/compaction/compaction_state.cc",
|
|
|
|
|
"db/compaction/sst_partitioner.cc",
|
|
|
|
|
"db/compaction/subcompaction_state.cc",
|
|
|
|
|
"db/convenience.cc",
|
|
|
|
|
"db/db_filesnapshot.cc",
|
|
|
|
|
"db/db_impl/compacted_db_impl.cc",
|
|
|
|
|
"db/db_impl/db_impl.cc",
|
|
|
|
|
"db/db_impl/db_impl_compaction_flush.cc",
|
|
|
|
|
"db/db_impl/db_impl_debug.cc",
|
|
|
|
|
"db/db_impl/db_impl_experimental.cc",
|
|
|
|
|
"db/db_impl/db_impl_files.cc",
|
|
|
|
|
"db/db_impl/db_impl_open.cc",
|
|
|
|
|
"db/db_impl/db_impl_readonly.cc",
|
|
|
|
|
"db/db_impl/db_impl_secondary.cc",
|
|
|
|
|
"db/db_impl/db_impl_write.cc",
|
|
|
|
|
"db/db_info_dumper.cc",
|
|
|
|
|
"db/db_iter.cc",
|
|
|
|
|
"db/dbformat.cc",
|
|
|
|
|
"db/error_handler.cc",
|
|
|
|
|
"db/event_helpers.cc",
|
|
|
|
|
"db/experimental.cc",
|
|
|
|
|
"db/external_sst_file_ingestion_job.cc",
|
|
|
|
|
"db/file_indexer.cc",
|
|
|
|
|
"db/flush_job.cc",
|
|
|
|
|
"db/flush_scheduler.cc",
|
|
|
|
|
"db/forward_iterator.cc",
|
|
|
|
|
"db/import_column_family_job.cc",
|
|
|
|
|
"db/internal_stats.cc",
|
|
|
|
|
"db/log_reader.cc",
|
|
|
|
|
"db/log_writer.cc",
|
|
|
|
|
"db/logs_with_prep_tracker.cc",
|
|
|
|
|
"db/malloc_stats.cc",
|
|
|
|
|
"db/memtable.cc",
|
|
|
|
|
"db/memtable_list.cc",
|
|
|
|
|
"db/merge_helper.cc",
|
|
|
|
|
"db/merge_operator.cc",
|
|
|
|
|
"db/output_validator.cc",
|
|
|
|
|
"db/periodic_task_scheduler.cc",
|
|
|
|
|
"db/range_del_aggregator.cc",
|
|
|
|
|
"db/range_tombstone_fragmenter.cc",
|
|
|
|
|
"db/repair.cc",
|
|
|
|
|
"db/seqno_to_time_mapping.cc",
|
|
|
|
|
"db/snapshot_impl.cc",
|
|
|
|
|
"db/table_cache.cc",
|
|
|
|
|
"db/table_properties_collector.cc",
|
|
|
|
|
"db/transaction_log_impl.cc",
|
|
|
|
|
"db/trim_history_scheduler.cc",
|
|
|
|
|
"db/version_builder.cc",
|
|
|
|
|
"db/version_edit.cc",
|
|
|
|
|
"db/version_edit_handler.cc",
|
|
|
|
|
"db/version_set.cc",
|
|
|
|
|
"db/wal_edit.cc",
|
|
|
|
|
"db/wal_manager.cc",
|
|
|
|
|
"db/wide/wide_column_serialization.cc",
|
Add support for wide-column point lookups (#10540)
Summary:
The patch adds a new API `GetEntity` that can be used to perform
wide-column point lookups. It also extends the `Get` code path and
the `MemTable` / `MemTableList` and `Version` / `GetContext` logic
accordingly so that wide-column entities can be served from both
memtables and SSTs. If the result of a lookup is a wide-column entity
(`kTypeWideColumnEntity`), it is passed to the application in deserialized
form; if it is a plain old key-value (`kTypeValue`), it is presented as a
wide-column entity with a single default (anonymous) column.
(In contrast, regular `Get` returns plain old key-values as-is, and
returns the value of the default column for wide-column entities, see
https://github.com/facebook/rocksdb/issues/10483 .)
The result of `GetEntity` is a self-contained `PinnableWideColumns` object.
`PinnableWideColumns` contains a `PinnableSlice`, which either stores the
underlying data in its own buffer or holds on to a cache handle. It also contains
a `WideColumns` instance, which indexes the contents of the `PinnableSlice`,
so applications can access the values of columns efficiently.
There are several pieces of functionality which are currently not supported
for wide-column entities: there is currently no `MultiGetEntity` or wide-column
iterator; also, `Merge` and `GetMergeOperands` are not supported, and there
is no `GetEntity` implementation for read-only and secondary instances.
We plan to implement these in future PRs.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/10540
Test Plan: `make check`
Reviewed By: akankshamahajan15
Differential Revision: D38847474
Pulled By: ltamasi
fbshipit-source-id: 42311a34ccdfe88b3775e847a5e2a5296e002b5b
2 years ago
|
|
|
"db/wide/wide_columns.cc",
|
|
|
|
|
"db/write_batch.cc",
|
|
|
|
|
"db/write_batch_base.cc",
|
|
|
|
|
"db/write_controller.cc",
|
|
|
|
|
"db/write_thread.cc",
|
|
|
|
|
"env/composite_env.cc",
|
|
|
|
|
"env/env.cc",
|
|
|
|
|
"env/env_chroot.cc",
|
|
|
|
|
"env/env_encryption.cc",
|
|
|
|
|
"env/env_posix.cc",
|
|
|
|
|
"env/file_system.cc",
|
|
|
|
|
"env/file_system_tracer.cc",
|
|
|
|
|
"env/fs_posix.cc",
|
Make backups openable as read-only DBs (#8142)
Summary:
A current limitation of backups is that you don't know the
exact database state of when the backup was taken. With this new
feature, you can at least inspect the backup's DB state without
restoring it by opening it as a read-only DB.
Rather than add something like OpenAsReadOnlyDB to the BackupEngine API,
which would inhibit opening stackable DB implementations read-only
(if/when their APIs support it), we instead provide a DB name and Env
that can be used to open as a read-only DB.
Possible follow-up work:
* Add a version of GetBackupInfo for a single backup.
* Let CreateNewBackup return the BackupID of the newly-created backup.
Implementation details:
Refactored ChrootFileSystem to split off new base class RemapFileSystem,
which allows more general remapping of files. We use this base class to
implement BackupEngineImpl::RemapSharedFileSystem.
To minimize API impact, I decided to just add these fields `name_for_open`
and `env_for_open` to those set by GetBackupInfo when
include_file_details=true. Creating the RemapSharedFileSystem adds a bit
to the memory consumption, perhaps unnecessarily in some cases, but this
has been mitigated by (a) only initialize the RemapSharedFileSystem
lazily when GetBackupInfo with include_file_details=true is called, and
(b) using the existing `shared_ptr<FileInfo>` objects to hold most of the
mapping data.
To enhance API safety, RemapSharedFileSystem is wrapped by new
ReadOnlyFileSystem which rejects any attempts to write. This uncovered a
couple of places in which DB::OpenForReadOnly would write to the
filesystem, so I fixed these. Added a release note because this affects
logging.
Additional minor refactoring in backupable_db.cc to support the new
functionality.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8142
Test Plan:
new test (run with ASAN and UBSAN), added to stress test and
ran it for a while with amplified backup_one_in
Reviewed By: ajkr
Differential Revision: D27535408
Pulled By: pdillinger
fbshipit-source-id: 04666d310aa0261ef6b2385c43ca793ce1dfd148
4 years ago
|
|
|
"env/fs_remap.cc",
|
|
|
|
|
"env/io_posix.cc",
|
|
|
|
|
"env/mock_env.cc",
|
Experimental support for SST unique IDs (#8990)
Summary:
* New public header unique_id.h and function GetUniqueIdFromTableProperties
which computes a universally unique identifier based on table properties
of table files from recent RocksDB versions.
* Generation of DB session IDs is refactored so that they are
guaranteed unique in the lifetime of a process running RocksDB.
(SemiStructuredUniqueIdGen, new test included.) Along with file numbers,
this enables SST unique IDs to be guaranteed unique among SSTs generated
in a single process, and "better than random" between processes.
See https://github.com/pdillinger/unique_id
* In addition to public API producing 'external' unique IDs, there is a function
for producing 'internal' unique IDs, with functions for converting between the
two. In short, the external ID is "safe" for things people might do with it, and
the internal ID enables more "power user" features for the future. Specifically,
the external ID goes through a hashing layer so that any subset of bits in the
external ID can be used as a hash of the full ID, while also preserving
uniqueness guarantees in the first 128 bits (bijective both on first 128 bits
and on full 192 bits).
Intended follow-up:
* Use the internal unique IDs in cache keys. (Avoid conflicts with https://github.com/facebook/rocksdb/issues/8912) (The file offset can be XORed into
the third 64-bit value of the unique ID.)
* Publish the external unique IDs in FileStorageInfo (https://github.com/facebook/rocksdb/issues/8968)
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8990
Test Plan:
Unit tests added, and checking of unique ids in stress test.
NOTE in stress test we do not generate nearly enough files to thoroughly
stress uniqueness, but the test trims off pieces of the ID to check for
uniqueness so that we can infer (with some assumptions) stronger
properties in the aggregate.
Reviewed By: zhichao-cao, mrambacher
Differential Revision: D31582865
Pulled By: pdillinger
fbshipit-source-id: 1f620c4c86af9abe2a8d177b9ccf2ad2b9f48243
3 years ago
|
|
|
"env/unique_id_gen.cc",
|
|
|
|
|
"file/delete_scheduler.cc",
|
|
|
|
|
"file/file_prefetch_buffer.cc",
|
|
|
|
|
"file/file_util.cc",
|
|
|
|
|
"file/filename.cc",
|
|
|
|
|
"file/line_file_reader.cc",
|
|
|
|
|
"file/random_access_file_reader.cc",
|
|
|
|
|
"file/read_write_util.cc",
|
|
|
|
|
"file/readahead_raf.cc",
|
|
|
|
|
"file/sequence_file_reader.cc",
|
|
|
|
|
"file/sst_file_manager_impl.cc",
|
|
|
|
|
"file/writable_file_writer.cc",
|
|
|
|
|
"logging/auto_roll_logger.cc",
|
|
|
|
|
"logging/event_logger.cc",
|
|
|
|
|
"logging/log_buffer.cc",
|
|
|
|
|
"memory/arena.cc",
|
|
|
|
|
"memory/concurrent_arena.cc",
|
|
|
|
|
"memory/jemalloc_nodump_allocator.cc",
|
|
|
|
|
"memory/memkind_kmem_allocator.cc",
|
|
|
|
|
"memory/memory_allocator.cc",
|
|
|
|
|
"memtable/alloc_tracker.cc",
|
|
|
|
|
"memtable/hash_linklist_rep.cc",
|
|
|
|
|
"memtable/hash_skiplist_rep.cc",
|
|
|
|
|
"memtable/skiplistrep.cc",
|
|
|
|
|
"memtable/vectorrep.cc",
|
|
|
|
|
"memtable/write_buffer_manager.cc",
|
|
|
|
|
"monitoring/histogram.cc",
|
|
|
|
|
"monitoring/histogram_windowing.cc",
|
|
|
|
|
"monitoring/in_memory_stats_history.cc",
|
|
|
|
|
"monitoring/instrumented_mutex.cc",
|
|
|
|
|
"monitoring/iostats_context.cc",
|
|
|
|
|
"monitoring/perf_context.cc",
|
|
|
|
|
"monitoring/perf_level.cc",
|
|
|
|
|
"monitoring/persistent_stats_history.cc",
|
|
|
|
|
"monitoring/statistics.cc",
|
|
|
|
|
"monitoring/thread_status_impl.cc",
|
|
|
|
|
"monitoring/thread_status_updater.cc",
|
|
|
|
|
"monitoring/thread_status_updater_debug.cc",
|
|
|
|
|
"monitoring/thread_status_util.cc",
|
|
|
|
|
"monitoring/thread_status_util_debug.cc",
|
|
|
|
|
"options/cf_options.cc",
|
|
|
|
|
"options/configurable.cc",
|
|
|
|
|
"options/customizable.cc",
|
|
|
|
|
"options/db_options.cc",
|
|
|
|
|
"options/options.cc",
|
|
|
|
|
"options/options_helper.cc",
|
|
|
|
|
"options/options_parser.cc",
|
|
|
|
|
"port/port_posix.cc",
|
|
|
|
|
"port/stack_trace.cc",
|
|
|
|
|
"port/win/env_default.cc",
|
|
|
|
|
"port/win/env_win.cc",
|
|
|
|
|
"port/win/io_win.cc",
|
|
|
|
|
"port/win/port_win.cc",
|
|
|
|
|
"port/win/win_logger.cc",
|
|
|
|
|
"port/win/win_thread.cc",
|
|
|
|
|
"table/adaptive/adaptive_table_factory.cc",
|
|
|
|
|
"table/block_based/binary_search_index_reader.cc",
|
|
|
|
|
"table/block_based/block.cc",
|
|
|
|
|
"table/block_based/block_based_table_builder.cc",
|
|
|
|
|
"table/block_based/block_based_table_factory.cc",
|
|
|
|
|
"table/block_based/block_based_table_iterator.cc",
|
|
|
|
|
"table/block_based/block_based_table_reader.cc",
|
|
|
|
|
"table/block_based/block_builder.cc",
|
|
|
|
|
"table/block_based/block_prefetcher.cc",
|
|
|
|
|
"table/block_based/block_prefix_index.cc",
|
|
|
|
|
"table/block_based/data_block_footer.cc",
|
|
|
|
|
"table/block_based/data_block_hash_index.cc",
|
|
|
|
|
"table/block_based/filter_block_reader_common.cc",
|
|
|
|
|
"table/block_based/filter_policy.cc",
|
|
|
|
|
"table/block_based/flush_block_policy.cc",
|
|
|
|
|
"table/block_based/full_filter_block.cc",
|
|
|
|
|
"table/block_based/hash_index_reader.cc",
|
|
|
|
|
"table/block_based/index_builder.cc",
|
|
|
|
|
"table/block_based/index_reader_common.cc",
|
|
|
|
|
"table/block_based/parsed_full_filter_block.cc",
|
|
|
|
|
"table/block_based/partitioned_filter_block.cc",
|
|
|
|
|
"table/block_based/partitioned_index_iterator.cc",
|
|
|
|
|
"table/block_based/partitioned_index_reader.cc",
|
|
|
|
|
"table/block_based/reader_common.cc",
|
|
|
|
|
"table/block_based/uncompression_dict_reader.cc",
|
|
|
|
|
"table/block_fetcher.cc",
|
|
|
|
|
"table/cuckoo/cuckoo_table_builder.cc",
|
|
|
|
|
"table/cuckoo/cuckoo_table_factory.cc",
|
|
|
|
|
"table/cuckoo/cuckoo_table_reader.cc",
|
|
|
|
|
"table/format.cc",
|
|
|
|
|
"table/get_context.cc",
|
|
|
|
|
"table/iterator.cc",
|
|
|
|
|
"table/merging_iterator.cc",
|
|
|
|
|
"table/meta_blocks.cc",
|
|
|
|
|
"table/persistent_cache_helper.cc",
|
|
|
|
|
"table/plain/plain_table_bloom.cc",
|
|
|
|
|
"table/plain/plain_table_builder.cc",
|
|
|
|
|
"table/plain/plain_table_factory.cc",
|
|
|
|
|
"table/plain/plain_table_index.cc",
|
|
|
|
|
"table/plain/plain_table_key_coding.cc",
|
|
|
|
|
"table/plain/plain_table_reader.cc",
|
|
|
|
|
"table/sst_file_dumper.cc",
|
|
|
|
|
"table/sst_file_reader.cc",
|
|
|
|
|
"table/sst_file_writer.cc",
|
|
|
|
|
"table/table_factory.cc",
|
|
|
|
|
"table/table_properties.cc",
|
|
|
|
|
"table/two_level_iterator.cc",
|
Experimental support for SST unique IDs (#8990)
Summary:
* New public header unique_id.h and function GetUniqueIdFromTableProperties
which computes a universally unique identifier based on table properties
of table files from recent RocksDB versions.
* Generation of DB session IDs is refactored so that they are
guaranteed unique in the lifetime of a process running RocksDB.
(SemiStructuredUniqueIdGen, new test included.) Along with file numbers,
this enables SST unique IDs to be guaranteed unique among SSTs generated
in a single process, and "better than random" between processes.
See https://github.com/pdillinger/unique_id
* In addition to public API producing 'external' unique IDs, there is a function
for producing 'internal' unique IDs, with functions for converting between the
two. In short, the external ID is "safe" for things people might do with it, and
the internal ID enables more "power user" features for the future. Specifically,
the external ID goes through a hashing layer so that any subset of bits in the
external ID can be used as a hash of the full ID, while also preserving
uniqueness guarantees in the first 128 bits (bijective both on first 128 bits
and on full 192 bits).
Intended follow-up:
* Use the internal unique IDs in cache keys. (Avoid conflicts with https://github.com/facebook/rocksdb/issues/8912) (The file offset can be XORed into
the third 64-bit value of the unique ID.)
* Publish the external unique IDs in FileStorageInfo (https://github.com/facebook/rocksdb/issues/8968)
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8990
Test Plan:
Unit tests added, and checking of unique ids in stress test.
NOTE in stress test we do not generate nearly enough files to thoroughly
stress uniqueness, but the test trims off pieces of the ID to check for
uniqueness so that we can infer (with some assumptions) stronger
properties in the aggregate.
Reviewed By: zhichao-cao, mrambacher
Differential Revision: D31582865
Pulled By: pdillinger
fbshipit-source-id: 1f620c4c86af9abe2a8d177b9ccf2ad2b9f48243
3 years ago
|
|
|
"table/unique_id.cc",
|
|
|
|
|
"test_util/sync_point.cc",
|
|
|
|
|
"test_util/sync_point_impl.cc",
|
|
|
|
|
"test_util/transaction_test_util.cc",
|
|
|
|
|
"tools/dump/db_dump_tool.cc",
|
|
|
|
|
"tools/io_tracer_parser_tool.cc",
|
|
|
|
|
"tools/ldb_cmd.cc",
|
|
|
|
|
"tools/ldb_tool.cc",
|
|
|
|
|
"tools/sst_dump_tool.cc",
|
|
|
|
|
"trace_replay/block_cache_tracer.cc",
|
|
|
|
|
"trace_replay/io_tracer.cc",
|
|
|
|
|
"trace_replay/trace_record.cc",
|
|
|
|
|
"trace_replay/trace_record_handler.cc",
|
|
|
|
|
"trace_replay/trace_record_result.cc",
|
|
|
|
|
"trace_replay/trace_replay.cc",
|
Multi file concurrency in MultiGet using coroutines and async IO (#9968)
Summary:
This PR implements a coroutine version of batched MultiGet in order to concurrently read from multiple SST files in a level using async IO, thus reducing the latency of the MultiGet. The API from the user perspective is still synchronous and single threaded, with the RocksDB part of the processing happening in the context of the caller's thread. In Version::MultiGet, the decision is made whether to call synchronous or coroutine code.
A good way to review this PR is to review the first 4 commits in order - de773b3, 70c2f70, 10b50e1, and 377a597 - before reviewing the rest.
TODO:
1. Figure out how to build it in CircleCI (requires some dependencies to be installed)
2. Do some stress testing with coroutines enabled
No regression in synchronous MultiGet between this branch and main -
```
./db_bench -use_existing_db=true --db=/data/mysql/rocksdb/prefix_scan -benchmarks="readseq,multireadrandom" -key_size=32 -value_size=512 -num=5000000 -batch_size=64 -multiread_batched=true -use_direct_reads=false -duration=60 -ops_between_duration_checks=1 -readonly=true -adaptive_readahead=true -threads=16 -cache_size=10485760000 -async_io=false -multiread_stride=40000 -statistics
```
Branch - ```multireadrandom : 4.025 micros/op 3975111 ops/sec 60.001 seconds 238509056 operations; 2062.3 MB/s (14767808 of 14767808 found)```
Main - ```multireadrandom : 3.987 micros/op 4013216 ops/sec 60.001 seconds 240795392 operations; 2082.1 MB/s (15231040 of 15231040 found)```
More benchmarks in various scenarios are given below. The measurements were taken with ```async_io=false``` (no coroutines) and ```async_io=true``` (use coroutines). For an IO bound workload (with every key requiring an IO), the coroutines version shows a clear benefit, being ~2.6X faster. For CPU bound workloads, the coroutines version has ~6-15% higher CPU utilization, depending on how many keys overlap an SST file.
1. Single thread IO bound workload on remote storage with sparse MultiGet batch keys (~1 key overlap/file) -
No coroutines - ```multireadrandom : 831.774 micros/op 1202 ops/sec 60.001 seconds 72136 operations; 0.6 MB/s (72136 of 72136 found)```
Using coroutines - ```multireadrandom : 318.742 micros/op 3137 ops/sec 60.003 seconds 188248 operations; 1.6 MB/s (188248 of 188248 found)```
2. Single thread CPU bound workload (all data cached) with ~1 key overlap/file -
No coroutines - ```multireadrandom : 4.127 micros/op 242322 ops/sec 60.000 seconds 14539384 operations; 125.7 MB/s (14539384 of 14539384 found)```
Using coroutines - ```multireadrandom : 4.741 micros/op 210935 ops/sec 60.000 seconds 12656176 operations; 109.4 MB/s (12656176 of 12656176 found)```
3. Single thread CPU bound workload with ~2 key overlap/file -
No coroutines - ```multireadrandom : 3.717 micros/op 269000 ops/sec 60.000 seconds 16140024 operations; 139.6 MB/s (16140024 of 16140024 found)```
Using coroutines - ```multireadrandom : 4.146 micros/op 241204 ops/sec 60.000 seconds 14472296 operations; 125.1 MB/s (14472296 of 14472296 found)```
4. CPU bound multi-threaded (16 threads) with ~4 key overlap/file -
No coroutines - ```multireadrandom : 4.534 micros/op 3528792 ops/sec 60.000 seconds 211728728 operations; 1830.7 MB/s (12737024 of 12737024 found) ```
Using coroutines - ```multireadrandom : 4.872 micros/op 3283812 ops/sec 60.000 seconds 197030096 operations; 1703.6 MB/s (12548032 of 12548032 found) ```
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9968
Reviewed By: akankshamahajan15
Differential Revision: D36348563
Pulled By: anand1976
fbshipit-source-id: c0ce85a505fd26ebfbb09786cbd7f25202038696
3 years ago
|
|
|
"util/async_file_reader.cc",
|
|
|
|
|
"util/build_version.cc",
|
Eliminate unnecessary (slow) block cache Ref()ing in MultiGet (#9899)
Summary:
When MultiGet() determines that multiple query keys can be
served by examining the same data block in block cache (one Lookup()),
each PinnableSlice referring to data in that data block needs to hold
on to the block in cache so that they can be released at arbitrary
times by the API user. Historically this is accomplished with extra
calls to Ref() on the Handle from Lookup(), with each PinnableSlice
cleanup calling Release() on the Handle, but this creates extra
contention on the block cache for the extra Ref()s and Release()es,
especially because they hit the same cache shard repeatedly.
In the case of merge operands (possibly more cases?), the problem was
compounded by doing an extra Ref()+eventual Release() for each merge
operand for a key reusing a block (which could be the same key!), rather
than one Ref() per key. (Note: the non-shared case with `biter` was
already one per key.)
This change optimizes MultiGet not to rely on these extra, contentious
Ref()+Release() calls by instead, in the shared block case, wrapping
the cache Release() cleanup in a refcounted object referenced by the
PinnableSlices, such that after the last wrapped reference is released,
the cache entry is Release()ed. Relaxed atomic refcounts should be
much faster than mutex-guarded Ref() and Release(), and much less prone
to a performance cliff when MultiGet() does a lot of block sharing.
Note that I did not use std::shared_ptr, because that would require an
extra indirection object (shared_ptr itself new/delete) in order to
associate a ref increment/decrement with a Cleanable cleanup entry. (If
I assumed it was the size of two pointers, I could do some hackery to
make it work without the extra indirection, but that's too fragile.)
Some details:
* Fixed (removed) extra block cache tracing entries in cases of cache
entry reuse in MultiGet, but it's likely that in some other cases traces
are missing (XXX comment inserted)
* Moved existing implementations for cleanable.h from iterator.cc to
new cleanable.cc
* Improved API comments on Cleanable
* Added a public SharedCleanablePtr class to cleanable.h in case others
could benefit from the same pattern (potentially many Cleanables and/or
smart pointers referencing a shared Cleanable)
* Add a typedef for MultiGetContext::Mask
* Some variable renaming for clarity
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9899
Test Plan:
Added unit tests for SharedCleanablePtr.
Greatly enhanced ability of existing tests to detect cache use-after-free.
* Release PinnableSlices from MultiGet as they are read rather than in
bulk (in db_test_util wrapper).
* In ASAN build, default to using a trivially small LRUCache for block_cache
so that entries are immediately erased when unreferenced. (Updated two
tests that depend on caching.) New ASAN testsuite running time seems
OK to me.
If I introduce a bug into my implementation where we skip the shared
cleanups on block reuse, ASAN detects the bug in
`db_basic_test *MultiGet*`. If I remove either of the above testing
enhancements, the bug is not detected.
Consider for follow-up work: manipulate or randomize ordering of
PinnableSlice use and release from MultiGet db_test_util wrapper. But in
typical cases, natural ordering gives pretty good functional coverage.
Performance test:
In the extreme (but possible) case of MultiGetting the same or adjacent keys
in a batch, throughput can improve by an order of magnitude.
`./db_bench -benchmarks=multireadrandom -db=/dev/shm/testdb -readonly -num=5 -duration=10 -threads=20 -multiread_batched -batch_size=200`
Before ops/sec, num=5: 1,384,394
Before ops/sec, num=500: 6,423,720
After ops/sec, num=500: 10,658,794
After ops/sec, num=5: 16,027,257
Also note that previously, with high parallelism, having query keys
concentrated in a single block was worse than spreading them out a bit. Now
concentrated in a single block is faster than spread out, which is hopefully
consistent with natural expectation.
Random query performance: with num=1000000, over 999 x 10s runs running before & after simultaneously (each -threads=12):
Before: multireadrandom [AVG 999 runs] : 1088699 (± 7344) ops/sec; 120.4 (± 0.8 ) MB/sec
After: multireadrandom [AVG 999 runs] : 1090402 (± 7230) ops/sec; 120.6 (± 0.8 ) MB/sec
Possibly better, possibly in the noise.
Reviewed By: anand1976
Differential Revision: D35907003
Pulled By: pdillinger
fbshipit-source-id: bbd244d703649a8ca12d476f2d03853ed9d1a17e
3 years ago
|
|
|
"util/cleanable.cc",
|
|
|
|
|
"util/coding.cc",
|
|
|
|
|
"util/compaction_job_stats_impl.cc",
|
|
|
|
|
"util/comparator.cc",
|
|
|
|
|
"util/compression.cc",
|
|
|
|
|
"util/compression_context_cache.cc",
|
|
|
|
|
"util/concurrent_task_limiter_impl.cc",
|
|
|
|
|
"util/crc32c.cc",
|
|
|
|
|
"util/crc32c_arm64.cc",
|
|
|
|
|
"util/dynamic_bloom.cc",
|
|
|
|
|
"util/file_checksum_helper.cc",
|
|
|
|
|
"util/hash.cc",
|
|
|
|
|
"util/murmurhash.cc",
|
|
|
|
|
"util/random.cc",
|
|
|
|
|
"util/rate_limiter.cc",
|
Refine Ribbon configuration, improve testing, add Homogeneous (#7879)
Summary:
This change only affects non-schema-critical aspects of the production candidate Ribbon filter. Specifically, it refines choice of internal configuration parameters based on inputs. The changes are minor enough that the schema tests in bloom_test, some of which depend on this, are unaffected. There are also some minor optimizations and refactorings.
This would be a schema change for "smash" Ribbon, to fix some known issues with small filters, but "smash" Ribbon is not accessible in public APIs. Unit test CompactnessAndBacktrackAndFpRate updated to test small and medium-large filters. Run with --thoroughness=100 or so for much better detection power (not appropriate for continuous regression testing).
Homogenous Ribbon:
This change adds internally a Ribbon filter variant we call Homogeneous Ribbon, in collaboration with Stefan Walzer. The expected "result" value for every key is zero, instead of computed from a hash. Entropy for queries not to be false positives comes from free variables ("overhead") in the solution structure, which are populated pseudorandomly. Construction is slightly faster for not tracking result values, and never fails. Instead, FP rate can jump up whenever and whereever entries are packed too tightly. For small structures, we can choose overhead to make this FP rate jump unlikely, as seen in updated unit test CompactnessAndBacktrackAndFpRate.
Unlike standard Ribbon, Homogeneous Ribbon seems to scale to arbitrary number of keys when accepting an FP rate penalty for small pockets of high FP rate in the structure. For example, 64-bit ribbon with 8 solution columns and 10% allocated space overhead for slots seems to achieve about 10.5% space overhead vs. information-theoretic minimum based on its observed FP rate with expected pockets of degradation. (FP rate is close to 1/256.) If targeting a higher FP rate with fewer solution columns, Homogeneous Ribbon can be even more space efficient, because the penalty from degradation is relatively smaller. If targeting a lower FP rate, Homogeneous Ribbon is less space efficient, as more allocated overhead is needed to keep the FP rate impact of degradation relatively under control. The new OptimizeHomogAtScale tool in ribbon_test helps to find these optimal allocation overheads for different numbers of solution columns. And Ribbon widths, with 128-bit Ribbon apparently cutting space overheads in half vs. 64-bit.
Other misc item specifics:
* Ribbon APIs in util/ribbon_config.h now provide configuration data for not just 5% construction failure rate (95% success), but also 50% and 0.1%.
* Note that the Ribbon structure does not exhibit "threshold" behavior as standard Xor filter does, so there is a roughly fixed space penalty to cut construction failure rate in half. Thus, there isn't really an "almost sure" setting.
* Although we can extrapolate settings for large filters, we don't have a good formula for configuring smaller filters (< 2^17 slots or so), and efforts to summarize with a formula have failed. Thus, small data is hard-coded from updated FindOccupancy tool.
* Enhances ApproximateNumEntries for public API Ribbon using more precise data (new API GetNumToAdd), thus a more accurate but not perfect reversal of CalculateSpace. (bloom_test updated to expect the greater precision)
* Move EndianSwapValue from coding.h to coding_lean.h to keep Ribbon code easily transferable from RocksDB
* Add some missing 'const' to member functions
* Small optimization to 128-bit BitParity
* Small refactoring of BandingStorage in ribbon_alg.h to support Homogeneous Ribbon
* CompactnessAndBacktrackAndFpRate now has an "expand" test: on construction failure, a possible alternative to re-seeding hash functions is simply to increase the number of slots (allocated space overhead) and try again with essentially the same hash values. (Start locations will be different roundings of the same scaled hash values--because fastrange not mod.) This seems to be as effective or more effective than re-seeding, as long as we increase the number of slots (m) by roughly m += m/w where w is the Ribbon width. This way, there is effectively an expansion by one slot for each ribbon-width window in the banding. (This approach assumes that getting "bad data" from your hash function is as unlikely as it naturally should be, e.g. no adversary.)
* 32-bit and 16-bit Ribbon configurations are added to ribbon_test for understanding their behavior, e.g. with FindOccupancy. They are not considered useful at this time and not tested with CompactnessAndBacktrackAndFpRate.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/7879
Test Plan: unit test updates included
Reviewed By: jay-zhuang
Differential Revision: D26371245
Pulled By: pdillinger
fbshipit-source-id: da6600d90a3785b99ad17a88b2a3027710b4ea3a
4 years ago
|
|
|
"util/ribbon_config.cc",
|
|
|
|
|
"util/slice.cc",
|
|
|
|
|
"util/status.cc",
|
|
|
|
|
"util/stderr_logger.cc",
|
|
|
|
|
"util/string_util.cc",
|
|
|
|
|
"util/thread_local.cc",
|
|
|
|
|
"util/threadpool_imp.cc",
|
|
|
|
|
"util/xxhash.cc",
|
|
|
|
|
"utilities/agg_merge/agg_merge.cc",
|
|
|
|
|
"utilities/backup/backup_engine.cc",
|
|
|
|
|
"utilities/blob_db/blob_compaction_filter.cc",
|
|
|
|
|
"utilities/blob_db/blob_db.cc",
|
|
|
|
|
"utilities/blob_db/blob_db_impl.cc",
|
|
|
|
|
"utilities/blob_db/blob_db_impl_filesnapshot.cc",
|
|
|
|
|
"utilities/blob_db/blob_dump_tool.cc",
|
|
|
|
|
"utilities/blob_db/blob_file.cc",
|
|
|
|
|
"utilities/cache_dump_load.cc",
|
|
|
|
|
"utilities/cache_dump_load_impl.cc",
|
|
|
|
|
"utilities/cassandra/cassandra_compaction_filter.cc",
|
|
|
|
|
"utilities/cassandra/format.cc",
|
|
|
|
|
"utilities/cassandra/merge_operator.cc",
|
|
|
|
|
"utilities/checkpoint/checkpoint_impl.cc",
|
|
|
|
|
"utilities/compaction_filters.cc",
|
|
|
|
|
"utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc",
|
|
|
|
|
"utilities/convenience/info_log_finder.cc",
|
|
|
|
|
"utilities/counted_fs.cc",
|
|
|
|
|
"utilities/debug.cc",
|
|
|
|
|
"utilities/env_mirror.cc",
|
|
|
|
|
"utilities/env_timed.cc",
|
|
|
|
|
"utilities/fault_injection_env.cc",
|
|
|
|
|
"utilities/fault_injection_fs.cc",
|
|
|
|
|
"utilities/fault_injection_secondary_cache.cc",
|
|
|
|
|
"utilities/leveldb_options/leveldb_options.cc",
|
|
|
|
|
"utilities/memory/memory_util.cc",
|
|
|
|
|
"utilities/merge_operators.cc",
|
|
|
|
|
"utilities/merge_operators/bytesxor.cc",
|
|
|
|
|
"utilities/merge_operators/max.cc",
|
|
|
|
|
"utilities/merge_operators/put.cc",
|
|
|
|
|
"utilities/merge_operators/sortlist.cc",
|
|
|
|
|
"utilities/merge_operators/string_append/stringappend.cc",
|
|
|
|
|
"utilities/merge_operators/string_append/stringappend2.cc",
|
|
|
|
|
"utilities/merge_operators/uint64add.cc",
|
|
|
|
|
"utilities/object_registry.cc",
|
|
|
|
|
"utilities/option_change_migration/option_change_migration.cc",
|
|
|
|
|
"utilities/options/options_util.cc",
|
|
|
|
|
"utilities/persistent_cache/block_cache_tier.cc",
|
|
|
|
|
"utilities/persistent_cache/block_cache_tier_file.cc",
|
|
|
|
|
"utilities/persistent_cache/block_cache_tier_metadata.cc",
|
|
|
|
|
"utilities/persistent_cache/persistent_cache_tier.cc",
|
|
|
|
|
"utilities/persistent_cache/volatile_tier_impl.cc",
|
|
|
|
|
"utilities/simulator_cache/cache_simulator.cc",
|
|
|
|
|
"utilities/simulator_cache/sim_cache.cc",
|
|
|
|
|
"utilities/table_properties_collectors/compact_on_deletion_collector.cc",
|
|
|
|
|
"utilities/trace/file_trace_reader_writer.cc",
|
|
|
|
|
"utilities/trace/replayer_impl.cc",
|
|
|
|
|
"utilities/transactions/lock/lock_manager.cc",
|
|
|
|
|
"utilities/transactions/lock/point/point_lock_manager.cc",
|
|
|
|
|
"utilities/transactions/lock/point/point_lock_tracker.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/concurrent_tree.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/keyrange.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/lock_request.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/locktree.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/manager.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/range_buffer.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/treenode.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/txnid_set.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/locktree/wfg.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/standalone_port.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/util/dbt.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/lib/util/memarena.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/range_tree_lock_manager.cc",
|
|
|
|
|
"utilities/transactions/lock/range/range_tree/range_tree_lock_tracker.cc",
|
|
|
|
|
"utilities/transactions/optimistic_transaction.cc",
|
|
|
|
|
"utilities/transactions/optimistic_transaction_db_impl.cc",
|
|
|
|
|
"utilities/transactions/pessimistic_transaction.cc",
|
|
|
|
|
"utilities/transactions/pessimistic_transaction_db.cc",
|
|
|
|
|
"utilities/transactions/snapshot_checker.cc",
|
|
|
|
|
"utilities/transactions/transaction_base.cc",
|
|
|
|
|
"utilities/transactions/transaction_db_mutex_impl.cc",
|
|
|
|
|
"utilities/transactions/transaction_util.cc",
|
|
|
|
|
"utilities/transactions/write_prepared_txn.cc",
|
|
|
|
|
"utilities/transactions/write_prepared_txn_db.cc",
|
|
|
|
|
"utilities/transactions/write_unprepared_txn.cc",
|
|
|
|
|
"utilities/transactions/write_unprepared_txn_db.cc",
|
|
|
|
|
"utilities/ttl/db_ttl_impl.cc",
|
|
|
|
|
"utilities/wal_filter.cc",
|
|
|
|
|
"utilities/write_batch_with_index/write_batch_with_index.cc",
|
|
|
|
|
"utilities/write_batch_with_index/write_batch_with_index_internal.cc",
|
Multi file concurrency in MultiGet using coroutines and async IO (#9968)
Summary:
This PR implements a coroutine version of batched MultiGet in order to concurrently read from multiple SST files in a level using async IO, thus reducing the latency of the MultiGet. The API from the user perspective is still synchronous and single threaded, with the RocksDB part of the processing happening in the context of the caller's thread. In Version::MultiGet, the decision is made whether to call synchronous or coroutine code.
A good way to review this PR is to review the first 4 commits in order - de773b3, 70c2f70, 10b50e1, and 377a597 - before reviewing the rest.
TODO:
1. Figure out how to build it in CircleCI (requires some dependencies to be installed)
2. Do some stress testing with coroutines enabled
No regression in synchronous MultiGet between this branch and main -
```
./db_bench -use_existing_db=true --db=/data/mysql/rocksdb/prefix_scan -benchmarks="readseq,multireadrandom" -key_size=32 -value_size=512 -num=5000000 -batch_size=64 -multiread_batched=true -use_direct_reads=false -duration=60 -ops_between_duration_checks=1 -readonly=true -adaptive_readahead=true -threads=16 -cache_size=10485760000 -async_io=false -multiread_stride=40000 -statistics
```
Branch - ```multireadrandom : 4.025 micros/op 3975111 ops/sec 60.001 seconds 238509056 operations; 2062.3 MB/s (14767808 of 14767808 found)```
Main - ```multireadrandom : 3.987 micros/op 4013216 ops/sec 60.001 seconds 240795392 operations; 2082.1 MB/s (15231040 of 15231040 found)```
More benchmarks in various scenarios are given below. The measurements were taken with ```async_io=false``` (no coroutines) and ```async_io=true``` (use coroutines). For an IO bound workload (with every key requiring an IO), the coroutines version shows a clear benefit, being ~2.6X faster. For CPU bound workloads, the coroutines version has ~6-15% higher CPU utilization, depending on how many keys overlap an SST file.
1. Single thread IO bound workload on remote storage with sparse MultiGet batch keys (~1 key overlap/file) -
No coroutines - ```multireadrandom : 831.774 micros/op 1202 ops/sec 60.001 seconds 72136 operations; 0.6 MB/s (72136 of 72136 found)```
Using coroutines - ```multireadrandom : 318.742 micros/op 3137 ops/sec 60.003 seconds 188248 operations; 1.6 MB/s (188248 of 188248 found)```
2. Single thread CPU bound workload (all data cached) with ~1 key overlap/file -
No coroutines - ```multireadrandom : 4.127 micros/op 242322 ops/sec 60.000 seconds 14539384 operations; 125.7 MB/s (14539384 of 14539384 found)```
Using coroutines - ```multireadrandom : 4.741 micros/op 210935 ops/sec 60.000 seconds 12656176 operations; 109.4 MB/s (12656176 of 12656176 found)```
3. Single thread CPU bound workload with ~2 key overlap/file -
No coroutines - ```multireadrandom : 3.717 micros/op 269000 ops/sec 60.000 seconds 16140024 operations; 139.6 MB/s (16140024 of 16140024 found)```
Using coroutines - ```multireadrandom : 4.146 micros/op 241204 ops/sec 60.000 seconds 14472296 operations; 125.1 MB/s (14472296 of 14472296 found)```
4. CPU bound multi-threaded (16 threads) with ~4 key overlap/file -
No coroutines - ```multireadrandom : 4.534 micros/op 3528792 ops/sec 60.000 seconds 211728728 operations; 1830.7 MB/s (12737024 of 12737024 found) ```
Using coroutines - ```multireadrandom : 4.872 micros/op 3283812 ops/sec 60.000 seconds 197030096 operations; 1703.6 MB/s (12548032 of 12548032 found) ```
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9968
Reviewed By: akankshamahajan15
Differential Revision: D36348563
Pulled By: anand1976
fbshipit-source-id: c0ce85a505fd26ebfbb09786cbd7f25202038696
3 years ago
|
|
|
], deps=[
|
|
|
|
|
"//folly/container:f14_hash",
|
|
|
|
|
"//folly/experimental/coro:blocking_wait",
|
|
|
|
|
"//folly/experimental/coro:collect",
|
|
|
|
|
"//folly/experimental/coro:coroutine",
|
|
|
|
|
"//folly/experimental/coro:task",
|
|
|
|
|
"//folly/synchronization:distributed_mutex",
|
Multi file concurrency in MultiGet using coroutines and async IO (#9968)
Summary:
This PR implements a coroutine version of batched MultiGet in order to concurrently read from multiple SST files in a level using async IO, thus reducing the latency of the MultiGet. The API from the user perspective is still synchronous and single threaded, with the RocksDB part of the processing happening in the context of the caller's thread. In Version::MultiGet, the decision is made whether to call synchronous or coroutine code.
A good way to review this PR is to review the first 4 commits in order - de773b3, 70c2f70, 10b50e1, and 377a597 - before reviewing the rest.
TODO:
1. Figure out how to build it in CircleCI (requires some dependencies to be installed)
2. Do some stress testing with coroutines enabled
No regression in synchronous MultiGet between this branch and main -
```
./db_bench -use_existing_db=true --db=/data/mysql/rocksdb/prefix_scan -benchmarks="readseq,multireadrandom" -key_size=32 -value_size=512 -num=5000000 -batch_size=64 -multiread_batched=true -use_direct_reads=false -duration=60 -ops_between_duration_checks=1 -readonly=true -adaptive_readahead=true -threads=16 -cache_size=10485760000 -async_io=false -multiread_stride=40000 -statistics
```
Branch - ```multireadrandom : 4.025 micros/op 3975111 ops/sec 60.001 seconds 238509056 operations; 2062.3 MB/s (14767808 of 14767808 found)```
Main - ```multireadrandom : 3.987 micros/op 4013216 ops/sec 60.001 seconds 240795392 operations; 2082.1 MB/s (15231040 of 15231040 found)```
More benchmarks in various scenarios are given below. The measurements were taken with ```async_io=false``` (no coroutines) and ```async_io=true``` (use coroutines). For an IO bound workload (with every key requiring an IO), the coroutines version shows a clear benefit, being ~2.6X faster. For CPU bound workloads, the coroutines version has ~6-15% higher CPU utilization, depending on how many keys overlap an SST file.
1. Single thread IO bound workload on remote storage with sparse MultiGet batch keys (~1 key overlap/file) -
No coroutines - ```multireadrandom : 831.774 micros/op 1202 ops/sec 60.001 seconds 72136 operations; 0.6 MB/s (72136 of 72136 found)```
Using coroutines - ```multireadrandom : 318.742 micros/op 3137 ops/sec 60.003 seconds 188248 operations; 1.6 MB/s (188248 of 188248 found)```
2. Single thread CPU bound workload (all data cached) with ~1 key overlap/file -
No coroutines - ```multireadrandom : 4.127 micros/op 242322 ops/sec 60.000 seconds 14539384 operations; 125.7 MB/s (14539384 of 14539384 found)```
Using coroutines - ```multireadrandom : 4.741 micros/op 210935 ops/sec 60.000 seconds 12656176 operations; 109.4 MB/s (12656176 of 12656176 found)```
3. Single thread CPU bound workload with ~2 key overlap/file -
No coroutines - ```multireadrandom : 3.717 micros/op 269000 ops/sec 60.000 seconds 16140024 operations; 139.6 MB/s (16140024 of 16140024 found)```
Using coroutines - ```multireadrandom : 4.146 micros/op 241204 ops/sec 60.000 seconds 14472296 operations; 125.1 MB/s (14472296 of 14472296 found)```
4. CPU bound multi-threaded (16 threads) with ~4 key overlap/file -
No coroutines - ```multireadrandom : 4.534 micros/op 3528792 ops/sec 60.000 seconds 211728728 operations; 1830.7 MB/s (12737024 of 12737024 found) ```
Using coroutines - ```multireadrandom : 4.872 micros/op 3283812 ops/sec 60.000 seconds 197030096 operations; 1703.6 MB/s (12548032 of 12548032 found) ```
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9968
Reviewed By: akankshamahajan15
Differential Revision: D36348563
Pulled By: anand1976
fbshipit-source-id: c0ce85a505fd26ebfbb09786cbd7f25202038696
3 years ago
|
|
|
], headers=None, link_whole=True, extra_test_libs=False)
|
|
|
|
|
|
|
|
|
|
cpp_library_wrapper(name="rocksdb_test_lib", srcs=[
|
|
|
|
|
"db/db_test_util.cc",
|
|
|
|
|
"db/db_with_timestamp_test_util.cc",
|
|
|
|
|
"table/mock_table.cc",
|
|
|
|
|
"test_util/mock_time_env.cc",
|
|
|
|
|
"test_util/testharness.cc",
|
|
|
|
|
"test_util/testutil.cc",
|
Block cache simulator: Add pysim to simulate caches using reinforcement learning. (#5610)
Summary:
This PR implements cache eviction using reinforcement learning. It includes two implementations:
1. An implementation of Thompson Sampling for the Bernoulli Bandit [1].
2. An implementation of LinUCB with disjoint linear models [2].
The idea is that a cache uses multiple eviction policies, e.g., MRU, LRU, and LFU. The cache learns which eviction policy is the best and uses it upon a cache miss.
Thompson Sampling is contextless and does not include any features.
LinUCB includes features such as level, block type, caller, column family id to decide which eviction policy to use.
[1] Daniel J. Russo, Benjamin Van Roy, Abbas Kazerouni, Ian Osband, and Zheng Wen. 2018. A Tutorial on Thompson Sampling. Found. Trends Mach. Learn. 11, 1 (July 2018), 1-96. DOI: https://doi.org/10.1561/2200000070
[2] Lihong Li, Wei Chu, John Langford, and Robert E. Schapire. 2010. A contextual-bandit approach to personalized news article recommendation. In Proceedings of the 19th international conference on World wide web (WWW '10). ACM, New York, NY, USA, 661-670. DOI=http://dx.doi.org/10.1145/1772690.1772758
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5610
Differential Revision: D16435067
Pulled By: HaoyuHuang
fbshipit-source-id: 6549239ae14115c01cb1e70548af9e46d8dc21bb
5 years ago
|
|
|
"tools/block_cache_analyzer/block_cache_trace_analyzer.cc",
|
|
|
|
|
"tools/trace_analyzer_tool.cc",
|
|
|
|
|
"utilities/agg_merge/test_agg_merge.cc",
|
|
|
|
|
"utilities/cassandra/test_utils.cc",
|
|
|
|
|
], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=True)
|
|
|
|
|
|
|
|
|
|
cpp_library_wrapper(name="rocksdb_tools_lib", srcs=[
|
|
|
|
|
"test_util/testutil.cc",
|
Block cache simulator: Add pysim to simulate caches using reinforcement learning. (#5610)
Summary:
This PR implements cache eviction using reinforcement learning. It includes two implementations:
1. An implementation of Thompson Sampling for the Bernoulli Bandit [1].
2. An implementation of LinUCB with disjoint linear models [2].
The idea is that a cache uses multiple eviction policies, e.g., MRU, LRU, and LFU. The cache learns which eviction policy is the best and uses it upon a cache miss.
Thompson Sampling is contextless and does not include any features.
LinUCB includes features such as level, block type, caller, column family id to decide which eviction policy to use.
[1] Daniel J. Russo, Benjamin Van Roy, Abbas Kazerouni, Ian Osband, and Zheng Wen. 2018. A Tutorial on Thompson Sampling. Found. Trends Mach. Learn. 11, 1 (July 2018), 1-96. DOI: https://doi.org/10.1561/2200000070
[2] Lihong Li, Wei Chu, John Langford, and Robert E. Schapire. 2010. A contextual-bandit approach to personalized news article recommendation. In Proceedings of the 19th international conference on World wide web (WWW '10). ACM, New York, NY, USA, 661-670. DOI=http://dx.doi.org/10.1145/1772690.1772758
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5610
Differential Revision: D16435067
Pulled By: HaoyuHuang
fbshipit-source-id: 6549239ae14115c01cb1e70548af9e46d8dc21bb
5 years ago
|
|
|
"tools/block_cache_analyzer/block_cache_trace_analyzer.cc",
|
|
|
|
|
"tools/db_bench_tool.cc",
|
|
|
|
|
"tools/simulated_hybrid_file_system.cc",
|
|
|
|
|
"tools/trace_analyzer_tool.cc",
|
|
|
|
|
], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=False)
|
|
|
|
|
|
|
|
|
|
cpp_library_wrapper(name="rocksdb_cache_bench_tools_lib", srcs=["cache/cache_bench_tool.cc"], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=False)
|
|
|
|
|
|
|
|
|
|
rocks_cpp_library_wrapper(name="rocksdb_stress_lib", srcs=[
|
|
|
|
|
"db_stress_tool/batched_ops_stress.cc",
|
|
|
|
|
"db_stress_tool/cf_consistency_stress.cc",
|
|
|
|
|
"db_stress_tool/db_stress_common.cc",
|
|
|
|
|
"db_stress_tool/db_stress_driver.cc",
|
|
|
|
|
"db_stress_tool/db_stress_gflags.cc",
|
Experimental support for SST unique IDs (#8990)
Summary:
* New public header unique_id.h and function GetUniqueIdFromTableProperties
which computes a universally unique identifier based on table properties
of table files from recent RocksDB versions.
* Generation of DB session IDs is refactored so that they are
guaranteed unique in the lifetime of a process running RocksDB.
(SemiStructuredUniqueIdGen, new test included.) Along with file numbers,
this enables SST unique IDs to be guaranteed unique among SSTs generated
in a single process, and "better than random" between processes.
See https://github.com/pdillinger/unique_id
* In addition to public API producing 'external' unique IDs, there is a function
for producing 'internal' unique IDs, with functions for converting between the
two. In short, the external ID is "safe" for things people might do with it, and
the internal ID enables more "power user" features for the future. Specifically,
the external ID goes through a hashing layer so that any subset of bits in the
external ID can be used as a hash of the full ID, while also preserving
uniqueness guarantees in the first 128 bits (bijective both on first 128 bits
and on full 192 bits).
Intended follow-up:
* Use the internal unique IDs in cache keys. (Avoid conflicts with https://github.com/facebook/rocksdb/issues/8912) (The file offset can be XORed into
the third 64-bit value of the unique ID.)
* Publish the external unique IDs in FileStorageInfo (https://github.com/facebook/rocksdb/issues/8968)
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8990
Test Plan:
Unit tests added, and checking of unique ids in stress test.
NOTE in stress test we do not generate nearly enough files to thoroughly
stress uniqueness, but the test trims off pieces of the ID to check for
uniqueness so that we can infer (with some assumptions) stronger
properties in the aggregate.
Reviewed By: zhichao-cao, mrambacher
Differential Revision: D31582865
Pulled By: pdillinger
fbshipit-source-id: 1f620c4c86af9abe2a8d177b9ccf2ad2b9f48243
3 years ago
|
|
|
"db_stress_tool/db_stress_listener.cc",
|
|
|
|
|
"db_stress_tool/db_stress_shared_state.cc",
|
|
|
|
|
"db_stress_tool/db_stress_stat.cc",
|
|
|
|
|
"db_stress_tool/db_stress_test_base.cc",
|
|
|
|
|
"db_stress_tool/db_stress_tool.cc",
|
|
|
|
|
"db_stress_tool/expected_state.cc",
|
|
|
|
|
"db_stress_tool/multi_ops_txns_stress.cc",
|
|
|
|
|
"db_stress_tool/no_batched_ops_stress.cc",
|
|
|
|
|
"test_util/testutil.cc",
|
|
|
|
|
"tools/block_cache_analyzer/block_cache_trace_analyzer.cc",
|
|
|
|
|
"tools/trace_analyzer_tool.cc",
|
|
|
|
|
], headers=None)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_binary_wrapper(name="db_stress", srcs=["db_stress_tool/db_stress.cc"], deps=[":rocksdb_stress_lib"], extra_preprocessor_flags=[], extra_bench_libs=False)
|
|
|
|
|
|
|
|
|
|
cpp_binary_wrapper(name="ribbon_bench", srcs=["microbench/ribbon_bench.cc"], deps=[], extra_preprocessor_flags=[], extra_bench_libs=True)
|
|
|
|
|
|
|
|
|
|
cpp_binary_wrapper(name="db_basic_bench", srcs=["microbench/db_basic_bench.cc"], deps=[], extra_preprocessor_flags=[], extra_bench_libs=True)
|
|
|
|
|
|
|
|
|
|
add_c_test_wrapper()
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_0", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2438, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_1", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_2", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2446, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_3", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DataBlockSeek/iterations:1000000': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'seek_ns',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_4", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'RandomAccessFileReaderRead/enable_statistics:1/iterations:1000000': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_5", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_6", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_7", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'RandomAccessFileReaderRead/enable_statistics:0/iterations:1000000': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct']}}, slow=False, expected_runtime=2438, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_8", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:2/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_9", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_10", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_11", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2446, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_12", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_13", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:1/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_14", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:0/wal:0/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBPut/comp_style:0/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:1/iterations:51200/threads:8': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=False, expected_runtime=2437, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_0_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88891, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_1_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88804, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_2_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88803, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_3_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88891, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_4_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88809, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_5_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88803, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_6_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88813, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_7_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88813, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_8_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88709, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_9_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88711, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_10_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88819, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_11_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88711, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_12_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88709, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_13_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88709, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fancy_bench_wrapper(suite_name="rocksdb_microbench_suite_14_slow", binary_to_bench_to_metric_list_map={'db_basic_bench': {'DBGet/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:1/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'neg_qu_pct',
|
|
|
|
|
'threads'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBGet/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['db_size',
|
|
|
|
|
'get_mean',
|
|
|
|
|
'threads',
|
|
|
|
|
'real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'neg_qu_pct'],
|
|
|
|
|
'DBPut/comp_style:1/max_data:107374182400/per_key_size:256/enable_statistics:1/wal:0/iterations:409600/threads:1': ['real_time',
|
|
|
|
|
'put_mean',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:1/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorPrev/comp_style:2/max_data:536870912/per_key_size:256/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:0/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:0/negative_query:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:134217728/per_key_size:256/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/negative_query:0/enable_filter:0/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:1/negative_query:1/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'IteratorSeek/comp_style:2/max_data:536870912/per_key_size:256/enable_statistics:1/negative_query:0/enable_filter:1/iterations:10240/threads:1': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:134217728/per_key_size:256/enable_statistics:0/enable_filter:0/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:0/max_data:536870912/per_key_size:256/enable_statistics:1/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:1024/enable_statistics:1/enable_filter:0/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:1/max_data:536870912/per_key_size:256/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:134217728/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:1280/threads:8': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads'],
|
|
|
|
|
'PrefixSeek/comp_style:2/max_data:536870912/per_key_size:1024/enable_statistics:0/enable_filter:1/iterations:10240': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'db_size',
|
|
|
|
|
'threads']},
|
|
|
|
|
'ribbon_bench': {'FilterBuild/filter_impl:0/bits_per_key:20/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterBuild/filter_impl:3/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'size'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:10/key_len_avg:10/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:2/bits_per_key:20/key_len_avg:100/entry_num:1024': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryNegative/filter_impl:3/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads',
|
|
|
|
|
'fp_pct'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:10/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:0/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads'],
|
|
|
|
|
'FilterQueryPositive/filter_impl:3/bits_per_key:10/key_len_avg:100/entry_num:1048576': ['real_time',
|
|
|
|
|
'cpu_time',
|
|
|
|
|
'threads']}}, slow=True, expected_runtime=88711, sl_iterations=3, regression_threshold=10)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Generate a test rule for each entry in ROCKS_TESTS
|
|
|
|
|
# Do not build the tests in opt mode, since SyncPoint and other test code
|
|
|
|
|
# will not be included.
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="agg_merge_test",
|
|
|
|
|
srcs=["utilities/agg_merge/agg_merge_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="arena_test",
|
|
|
|
|
srcs=["memory/arena_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="auto_roll_logger_test",
|
|
|
|
|
srcs=["logging/auto_roll_logger_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="autovector_test",
|
|
|
|
|
srcs=["util/autovector_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="backup_engine_test",
|
|
|
|
|
srcs=["utilities/backup/backup_engine_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="blob_counting_iterator_test",
|
|
|
|
|
srcs=["db/blob/blob_counting_iterator_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="blob_db_test",
|
|
|
|
|
srcs=["utilities/blob_db/blob_db_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="blob_file_addition_test",
|
|
|
|
|
srcs=["db/blob/blob_file_addition_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="blob_file_builder_test",
|
|
|
|
|
srcs=["db/blob/blob_file_builder_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="blob_file_cache_test",
|
|
|
|
|
srcs=["db/blob/blob_file_cache_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="blob_file_garbage_test",
|
|
|
|
|
srcs=["db/blob/blob_file_garbage_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="blob_file_reader_test",
|
|
|
|
|
srcs=["db/blob/blob_file_reader_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="blob_garbage_meter_test",
|
|
|
|
|
srcs=["db/blob/blob_garbage_meter_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="blob_source_test",
|
|
|
|
|
srcs=["db/blob/blob_source_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="block_based_table_reader_test",
|
|
|
|
|
srcs=["table/block_based/block_based_table_reader_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="block_cache_trace_analyzer_test",
|
|
|
|
|
srcs=["tools/block_cache_analyzer/block_cache_trace_analyzer_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="block_cache_tracer_test",
|
|
|
|
|
srcs=["trace_replay/block_cache_tracer_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="block_fetcher_test",
|
|
|
|
|
srcs=["table/block_fetcher_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="block_test",
|
|
|
|
|
srcs=["table/block_based/block_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="bloom_test",
|
|
|
|
|
srcs=["util/bloom_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="cache_reservation_manager_test",
|
|
|
|
|
srcs=["cache/cache_reservation_manager_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="cache_simulator_test",
|
|
|
|
|
srcs=["utilities/simulator_cache/cache_simulator_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="cache_test",
|
|
|
|
|
srcs=["cache/cache_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="cassandra_format_test",
|
|
|
|
|
srcs=["utilities/cassandra/cassandra_format_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="cassandra_functional_test",
|
|
|
|
|
srcs=["utilities/cassandra/cassandra_functional_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="cassandra_row_merge_test",
|
|
|
|
|
srcs=["utilities/cassandra/cassandra_row_merge_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="cassandra_serialize_test",
|
|
|
|
|
srcs=["utilities/cassandra/cassandra_serialize_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="checkpoint_test",
|
|
|
|
|
srcs=["utilities/checkpoint/checkpoint_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="cleanable_test",
|
|
|
|
|
srcs=["table/cleanable_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="clipping_iterator_test",
|
|
|
|
|
srcs=["db/compaction/clipping_iterator_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="coding_test",
|
|
|
|
|
srcs=["util/coding_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="column_family_test",
|
|
|
|
|
srcs=["db/column_family_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="compact_files_test",
|
|
|
|
|
srcs=["db/compact_files_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="compact_on_deletion_collector_test",
|
|
|
|
|
srcs=["utilities/table_properties_collectors/compact_on_deletion_collector_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="compaction_iterator_test",
|
|
|
|
|
srcs=["db/compaction/compaction_iterator_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="compaction_job_stats_test",
|
|
|
|
|
srcs=["db/compaction/compaction_job_stats_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="compaction_job_test",
|
|
|
|
|
srcs=["db/compaction/compaction_job_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="compaction_picker_test",
|
|
|
|
|
srcs=["db/compaction/compaction_picker_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="compaction_service_test",
|
|
|
|
|
srcs=["db/compaction/compaction_service_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="comparator_db_test",
|
|
|
|
|
srcs=["db/comparator_db_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="compressed_secondary_cache_test",
|
|
|
|
|
srcs=["cache/compressed_secondary_cache_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="configurable_test",
|
|
|
|
|
srcs=["options/configurable_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="corruption_test",
|
|
|
|
|
srcs=["db/corruption_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="crc32c_test",
|
|
|
|
|
srcs=["util/crc32c_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="cuckoo_table_builder_test",
|
|
|
|
|
srcs=["table/cuckoo/cuckoo_table_builder_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="cuckoo_table_db_test",
|
|
|
|
|
srcs=["db/cuckoo_table_db_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="cuckoo_table_reader_test",
|
|
|
|
|
srcs=["table/cuckoo/cuckoo_table_reader_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="customizable_test",
|
|
|
|
|
srcs=["options/customizable_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="data_block_hash_index_test",
|
|
|
|
|
srcs=["table/block_based/data_block_hash_index_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_basic_test",
|
|
|
|
|
srcs=["db/db_basic_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_blob_basic_test",
|
|
|
|
|
srcs=["db/blob/db_blob_basic_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_blob_compaction_test",
|
|
|
|
|
srcs=["db/blob/db_blob_compaction_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_blob_corruption_test",
|
|
|
|
|
srcs=["db/blob/db_blob_corruption_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_blob_index_test",
|
|
|
|
|
srcs=["db/blob/db_blob_index_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_block_cache_test",
|
|
|
|
|
srcs=["db/db_block_cache_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_bloom_filter_test",
|
|
|
|
|
srcs=["db/db_bloom_filter_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_compaction_filter_test",
|
|
|
|
|
srcs=["db/db_compaction_filter_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_compaction_test",
|
|
|
|
|
srcs=["db/db_compaction_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_dynamic_level_test",
|
|
|
|
|
srcs=["db/db_dynamic_level_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_encryption_test",
|
|
|
|
|
srcs=["db/db_encryption_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_flush_test",
|
|
|
|
|
srcs=["db/db_flush_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_inplace_update_test",
|
|
|
|
|
srcs=["db/db_inplace_update_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_io_failure_test",
|
|
|
|
|
srcs=["db/db_io_failure_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_iter_stress_test",
|
|
|
|
|
srcs=["db/db_iter_stress_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_iter_test",
|
|
|
|
|
srcs=["db/db_iter_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_iterator_test",
|
|
|
|
|
srcs=["db/db_iterator_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_kv_checksum_test",
|
|
|
|
|
srcs=["db/db_kv_checksum_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_log_iter_test",
|
|
|
|
|
srcs=["db/db_log_iter_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_logical_block_size_cache_test",
|
|
|
|
|
srcs=["db/db_logical_block_size_cache_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_memtable_test",
|
|
|
|
|
srcs=["db/db_memtable_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_merge_operand_test",
|
|
|
|
|
srcs=["db/db_merge_operand_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_merge_operator_test",
|
|
|
|
|
srcs=["db/db_merge_operator_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_options_test",
|
|
|
|
|
srcs=["db/db_options_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_properties_test",
|
|
|
|
|
srcs=["db/db_properties_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_range_del_test",
|
|
|
|
|
srcs=["db/db_range_del_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_rate_limiter_test",
|
|
|
|
|
srcs=["db/db_rate_limiter_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_readonly_with_timestamp_test",
|
|
|
|
|
srcs=["db/db_readonly_with_timestamp_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_secondary_test",
|
|
|
|
|
srcs=["db/db_secondary_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_sst_test",
|
|
|
|
|
srcs=["db/db_sst_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_statistics_test",
|
|
|
|
|
srcs=["db/db_statistics_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_table_properties_test",
|
|
|
|
|
srcs=["db/db_table_properties_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_tailing_iter_test",
|
|
|
|
|
srcs=["db/db_tailing_iter_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_test",
|
|
|
|
|
srcs=["db/db_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_test2",
|
|
|
|
|
srcs=["db/db_test2.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_universal_compaction_test",
|
|
|
|
|
srcs=["db/db_universal_compaction_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_wal_test",
|
|
|
|
|
srcs=["db/db_wal_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_wide_basic_test",
|
|
|
|
|
srcs=["db/wide/db_wide_basic_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_with_timestamp_basic_test",
|
|
|
|
|
srcs=["db/db_with_timestamp_basic_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_with_timestamp_compaction_test",
|
|
|
|
|
srcs=["db/db_with_timestamp_compaction_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_write_buffer_manager_test",
|
|
|
|
|
srcs=["db/db_write_buffer_manager_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="db_write_test",
|
|
|
|
|
srcs=["db/db_write_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="dbformat_test",
|
|
|
|
|
srcs=["db/dbformat_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="defer_test",
|
|
|
|
|
srcs=["util/defer_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="delete_scheduler_test",
|
|
|
|
|
srcs=["file/delete_scheduler_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="deletefile_test",
|
|
|
|
|
srcs=["db/deletefile_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="dynamic_bloom_test",
|
|
|
|
|
srcs=["util/dynamic_bloom_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_library_wrapper(name="env_basic_test_lib", srcs=["env/env_basic_test.cc"], deps=[":rocksdb_test_lib"], headers=None, link_whole=False, extra_test_libs=True)
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="env_basic_test",
|
|
|
|
|
srcs=["env/env_basic_test.cc"],
|
|
|
|
|
deps=[":env_basic_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="env_logger_test",
|
|
|
|
|
srcs=["logging/env_logger_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="env_test",
|
|
|
|
|
srcs=["env/env_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="env_timed_test",
|
|
|
|
|
srcs=["utilities/env_timed_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="error_handler_fs_test",
|
|
|
|
|
srcs=["db/error_handler_fs_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="event_logger_test",
|
|
|
|
|
srcs=["logging/event_logger_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="external_sst_file_basic_test",
|
|
|
|
|
srcs=["db/external_sst_file_basic_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="external_sst_file_test",
|
|
|
|
|
srcs=["db/external_sst_file_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="fault_injection_test",
|
|
|
|
|
srcs=["db/fault_injection_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="file_indexer_test",
|
|
|
|
|
srcs=["db/file_indexer_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="file_reader_writer_test",
|
|
|
|
|
srcs=["util/file_reader_writer_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="filelock_test",
|
|
|
|
|
srcs=["util/filelock_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="filename_test",
|
|
|
|
|
srcs=["db/filename_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="flush_job_test",
|
|
|
|
|
srcs=["db/flush_job_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="full_filter_block_test",
|
|
|
|
|
srcs=["table/block_based/full_filter_block_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="hash_table_test",
|
|
|
|
|
srcs=["utilities/persistent_cache/hash_table_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="hash_test",
|
|
|
|
|
srcs=["util/hash_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="heap_test",
|
|
|
|
|
srcs=["util/heap_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="histogram_test",
|
|
|
|
|
srcs=["monitoring/histogram_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="import_column_family_test",
|
|
|
|
|
srcs=["db/import_column_family_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="inlineskiplist_test",
|
|
|
|
|
srcs=["memtable/inlineskiplist_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="io_posix_test",
|
|
|
|
|
srcs=["env/io_posix_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="io_tracer_parser_test",
|
|
|
|
|
srcs=["tools/io_tracer_parser_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="io_tracer_test",
|
|
|
|
|
srcs=["trace_replay/io_tracer_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="iostats_context_test",
|
|
|
|
|
srcs=["monitoring/iostats_context_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="ldb_cmd_test",
|
|
|
|
|
srcs=["tools/ldb_cmd_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="listener_test",
|
|
|
|
|
srcs=["db/listener_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="log_test",
|
|
|
|
|
srcs=["db/log_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="lru_cache_test",
|
|
|
|
|
srcs=["cache/lru_cache_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="manual_compaction_test",
|
|
|
|
|
srcs=["db/manual_compaction_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="memory_allocator_test",
|
|
|
|
|
srcs=["memory/memory_allocator_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="memory_test",
|
|
|
|
|
srcs=["utilities/memory/memory_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="memtable_list_test",
|
|
|
|
|
srcs=["db/memtable_list_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="merge_helper_test",
|
|
|
|
|
srcs=["db/merge_helper_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="merge_test",
|
|
|
|
|
srcs=["db/merge_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="merger_test",
|
|
|
|
|
srcs=["table/merger_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="mock_env_test",
|
|
|
|
|
srcs=["env/mock_env_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="object_registry_test",
|
|
|
|
|
srcs=["utilities/object_registry_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="obsolete_files_test",
|
|
|
|
|
srcs=["db/obsolete_files_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="optimistic_transaction_test",
|
|
|
|
|
srcs=["utilities/transactions/optimistic_transaction_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="option_change_migration_test",
|
|
|
|
|
srcs=["utilities/option_change_migration/option_change_migration_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="options_file_test",
|
|
|
|
|
srcs=["db/options_file_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="options_settable_test",
|
|
|
|
|
srcs=["options/options_settable_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="options_test",
|
|
|
|
|
srcs=["options/options_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="options_util_test",
|
|
|
|
|
srcs=["utilities/options/options_util_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="partitioned_filter_block_test",
|
|
|
|
|
srcs=["table/block_based/partitioned_filter_block_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="perf_context_test",
|
|
|
|
|
srcs=["db/perf_context_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="periodic_task_scheduler_test",
|
|
|
|
|
srcs=["db/periodic_task_scheduler_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="persistent_cache_test",
|
|
|
|
|
srcs=["utilities/persistent_cache/persistent_cache_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="plain_table_db_test",
|
|
|
|
|
srcs=["db/plain_table_db_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="point_lock_manager_test",
|
|
|
|
|
srcs=["utilities/transactions/lock/point/point_lock_manager_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="prefetch_test",
|
|
|
|
|
srcs=["file/prefetch_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="prefix_test",
|
|
|
|
|
srcs=["db/prefix_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="random_access_file_reader_test",
|
|
|
|
|
srcs=["file/random_access_file_reader_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="random_test",
|
|
|
|
|
srcs=["util/random_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="range_del_aggregator_test",
|
|
|
|
|
srcs=["db/range_del_aggregator_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="range_locking_test",
|
|
|
|
|
srcs=["utilities/transactions/lock/range/range_locking_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="range_tombstone_fragmenter_test",
|
|
|
|
|
srcs=["db/range_tombstone_fragmenter_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="rate_limiter_test",
|
|
|
|
|
srcs=["util/rate_limiter_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="reduce_levels_test",
|
|
|
|
|
srcs=["tools/reduce_levels_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="repair_test",
|
|
|
|
|
srcs=["db/repair_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="repeatable_thread_test",
|
|
|
|
|
srcs=["util/repeatable_thread_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="ribbon_test",
|
|
|
|
|
srcs=["util/ribbon_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="seqno_time_test",
|
|
|
|
|
srcs=["db/seqno_time_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="sim_cache_test",
|
|
|
|
|
srcs=["utilities/simulator_cache/sim_cache_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="skiplist_test",
|
|
|
|
|
srcs=["memtable/skiplist_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="slice_test",
|
|
|
|
|
srcs=["util/slice_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="slice_transform_test",
|
|
|
|
|
srcs=["util/slice_transform_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="sst_dump_test",
|
|
|
|
|
srcs=["tools/sst_dump_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="sst_file_reader_test",
|
|
|
|
|
srcs=["table/sst_file_reader_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="statistics_test",
|
|
|
|
|
srcs=["monitoring/statistics_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="stats_history_test",
|
|
|
|
|
srcs=["monitoring/stats_history_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="stringappend_test",
|
|
|
|
|
srcs=["utilities/merge_operators/string_append/stringappend_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="table_properties_collector_test",
|
|
|
|
|
srcs=["db/table_properties_collector_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="table_test",
|
|
|
|
|
srcs=["table/table_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="testutil_test",
|
|
|
|
|
srcs=["test_util/testutil_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="thread_list_test",
|
|
|
|
|
srcs=["util/thread_list_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="thread_local_test",
|
|
|
|
|
srcs=["util/thread_local_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="tiered_compaction_test",
|
|
|
|
|
srcs=["db/compaction/tiered_compaction_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="timer_queue_test",
|
|
|
|
|
srcs=["util/timer_queue_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="timer_test",
|
|
|
|
|
srcs=["util/timer_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
Snapshots with user-specified timestamps (#9879)
Summary:
In RocksDB, keys are associated with (internal) sequence numbers which denote when the keys are written
to the database. Sequence numbers in different RocksDB instances are unrelated, thus not comparable.
It is nice if we can associate sequence numbers with their corresponding actual timestamps. One thing we can
do is to support user-defined timestamp, which allows the applications to specify the format of custom timestamps
and encode a timestamp with each key. More details can be found at https://github.com/facebook/rocksdb/wiki/User-defined-Timestamp-%28Experimental%29.
This PR provides a different but complementary approach. We can associate rocksdb snapshots (defined in
https://github.com/facebook/rocksdb/blob/7.2.fb/include/rocksdb/snapshot.h#L20) with **user-specified** timestamps.
Since a snapshot is essentially an object representing a sequence number, this PR establishes a bi-directional mapping between sequence numbers and timestamps.
In the past, snapshots are usually taken by readers. The current super-version is grabbed, and a `rocksdb::Snapshot`
object is created with the last published sequence number of the super-version. You can see that the reader actually
has no good idea of what timestamp to assign to this snapshot, because by the time the `GetSnapshot()` is called,
an arbitrarily long period of time may have already elapsed since the last write, which is when the last published
sequence number is written.
This observation motivates the creation of "timestamped" snapshots on the write path. Currently, this functionality is
exposed only to the layer of `TransactionDB`. Application can tell RocksDB to create a snapshot when a transaction
commits, effectively associating the last sequence number with a timestamp. It is also assumed that application will
ensure any two snapshots with timestamps should satisfy the following:
```
snapshot1.seq < snapshot2.seq iff. snapshot1.ts < snapshot2.ts
```
If the application can guarantee that when a reader takes a timestamped snapshot, there is no active writes going on
in the database, then we also allow the user to use a new API `TransactionDB::CreateTimestampedSnapshot()` to create
a snapshot with associated timestamp.
Code example
```cpp
// Create a timestamped snapshot when committing transaction.
txn->SetCommitTimestamp(100);
txn->SetSnapshotOnNextOperation();
txn->Commit();
// A wrapper API for convenience
Status Transaction::CommitAndTryCreateSnapshot(
std::shared_ptr<TransactionNotifier> notifier,
TxnTimestamp ts,
std::shared_ptr<const Snapshot>* ret);
// Create a timestamped snapshot if caller guarantees no concurrent writes
std::pair<Status, std::shared_ptr<const Snapshot>> snapshot = txn_db->CreateTimestampedSnapshot(100);
```
The snapshots created in this way will be managed by RocksDB with ref-counting and potentially shared with
other readers. We provide the following APIs for readers to retrieve a snapshot given a timestamp.
```cpp
// Return the timestamped snapshot correponding to given timestamp. If ts is
// kMaxTxnTimestamp, then we return the latest timestamped snapshot if present.
// Othersise, we return the snapshot whose timestamp is equal to `ts`. If no
// such snapshot exists, then we return null.
std::shared_ptr<const Snapshot> TransactionDB::GetTimestampedSnapshot(TxnTimestamp ts) const;
// Return the latest timestamped snapshot if present.
std::shared_ptr<const Snapshot> TransactionDB::GetLatestTimestampedSnapshot() const;
```
We also provide two additional APIs for stats collection and reporting purposes.
```cpp
Status TransactionDB::GetAllTimestampedSnapshots(
std::vector<std::shared_ptr<const Snapshot>>& snapshots) const;
// Return timestamped snapshots whose timestamps fall in [ts_lb, ts_ub) and store them in `snapshots`.
Status TransactionDB::GetTimestampedSnapshots(
TxnTimestamp ts_lb,
TxnTimestamp ts_ub,
std::vector<std::shared_ptr<const Snapshot>>& snapshots) const;
```
To prevent the number of timestamped snapshots from growing infinitely, we provide the following API to release
timestamped snapshots whose timestamps are older than or equal to a given threshold.
```cpp
void TransactionDB::ReleaseTimestampedSnapshotsOlderThan(TxnTimestamp ts);
```
Before shutdown, RocksDB will release all timestamped snapshots.
Comparison with user-defined timestamp and how they can be combined:
User-defined timestamp persists every key with a timestamp, while timestamped snapshots maintain a volatile
mapping between snapshots (sequence numbers) and timestamps.
Different internal keys with the same user key but different timestamps will be treated as different by compaction,
thus a newer version will not hide older versions (with smaller timestamps) unless they are eligible for garbage collection.
In contrast, taking a timestamped snapshot at a certain sequence number and timestamp prevents all the keys visible in
this snapshot from been dropped by compaction. Here, visible means (seq < snapshot and most recent).
The timestamped snapshot supports the semantics of reading at an exact point in time.
Timestamped snapshots can also be used with user-defined timestamp.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9879
Test Plan:
```
make check
TEST_TMPDIR=/dev/shm make crash_test_with_txn
```
Reviewed By: siying
Differential Revision: D35783919
Pulled By: riversand963
fbshipit-source-id: 586ad905e169189e19d3bfc0cb0177a7239d1bd4
3 years ago
|
|
|
cpp_unittest_wrapper(name="timestamped_snapshot_test",
|
|
|
|
|
srcs=["utilities/transactions/timestamped_snapshot_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="trace_analyzer_test",
|
|
|
|
|
srcs=["tools/trace_analyzer_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="transaction_test",
|
|
|
|
|
srcs=["utilities/transactions/transaction_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="ttl_test",
|
|
|
|
|
srcs=["utilities/ttl/ttl_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="util_merge_operators_test",
|
|
|
|
|
srcs=["utilities/util_merge_operators_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="version_builder_test",
|
|
|
|
|
srcs=["db/version_builder_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="version_edit_test",
|
|
|
|
|
srcs=["db/version_edit_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="version_set_test",
|
|
|
|
|
srcs=["db/version_set_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="wal_manager_test",
|
|
|
|
|
srcs=["db/wal_manager_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="wide_column_serialization_test",
|
|
|
|
|
srcs=["db/wide/wide_column_serialization_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="work_queue_test",
|
|
|
|
|
srcs=["util/work_queue_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="write_batch_test",
|
|
|
|
|
srcs=["db/write_batch_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="write_batch_with_index_test",
|
|
|
|
|
srcs=["utilities/write_batch_with_index/write_batch_with_index_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="write_buffer_manager_test",
|
|
|
|
|
srcs=["memtable/write_buffer_manager_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="write_callback_test",
|
|
|
|
|
srcs=["db/write_callback_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
Support user-defined timestamps in write-committed txns (#9629)
Summary:
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9629
Pessimistic transactions use pessimistic concurrency control, i.e. locking. Keys are
locked upon first operation that writes the key or has the intention of writing. For example,
`PessimisticTransaction::Put()`, `PessimisticTransaction::Delete()`,
`PessimisticTransaction::SingleDelete()` will write to or delete a key, while
`PessimisticTransaction::GetForUpdate()` is used by application to indicate
to RocksDB that the transaction has the intention of performing write operation later
in the same transaction.
Pessimistic transactions support two-phase commit (2PC). A transaction can be
`Prepared()`'ed and then `Commit()`. The prepare phase is similar to a promise: once
`Prepare()` succeeds, the transaction has acquired the necessary resources to commit.
The resources include locks, persistence of WAL, etc.
Write-committed transaction is the default pessimistic transaction implementation. In
RocksDB write-committed transaction, `Prepare()` will write data to the WAL as a prepare
section. `Commit()` will write a commit marker to the WAL and then write data to the
memtables. While writing to the memtables, different keys in the transaction's write batch
will be assigned different sequence numbers in ascending order.
Until commit/rollback, the transaction holds locks on the keys so that no other transaction
can write to the same keys. Furthermore, the keys' sequence numbers represent the order
in which they are committed and should be made visible. This is convenient for us to
implement support for user-defined timestamps.
Since column families with and without timestamps can co-exist in the same database,
a transaction may or may not involve timestamps. Based on this observation, we add two
optional members to each `PessimisticTransaction`, `read_timestamp_` and
`commit_timestamp_`. If no key in the transaction's write batch has timestamp, then
setting these two variables do not have any effect. For the rest of this commit, we discuss
only the cases when these two variables are meaningful.
read_timestamp_ is used mainly for validation, and should be set before first call to
`GetForUpdate()`. Otherwise, the latter will return non-ok status. `GetForUpdate()` calls
`TryLock()` that can verify if another transaction has written the same key since
`read_timestamp_` till this call to `GetForUpdate()`. If another transaction has indeed
written the same key, then validation fails, and RocksDB allows this transaction to
refine `read_timestamp_` by increasing it. Note that a transaction can still use `Get()`
with a different timestamp to read, but the result of the read should not be used to
determine data that will be written later.
commit_timestamp_ must be set after finishing writing and before transaction commit.
This applies to both 2PC and non-2PC cases. In the case of 2PC, it's usually set after
prepare phase succeeds.
We currently require that the commit timestamp be chosen after all keys are locked. This
means we disallow the `TransactionDB`-level APIs if user-defined timestamp is used
by the transaction. Specifically, calling `PessimisticTransactionDB::Put()`,
`PessimisticTransactionDB::Delete()`, `PessimisticTransactionDB::SingleDelete()`,
etc. will return non-ok status because they specify timestamps before locking the keys.
Users are also prompted to use the `Transaction` APIs when they receive the non-ok status.
Reviewed By: ltamasi
Differential Revision: D31822445
fbshipit-source-id: b82abf8e230216dc89cc519564a588224a88fd43
3 years ago
|
|
|
cpp_unittest_wrapper(name="write_committed_transaction_ts_test",
|
|
|
|
|
srcs=["utilities/transactions/write_committed_transaction_ts_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="write_controller_test",
|
|
|
|
|
srcs=["db/write_controller_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="write_prepared_transaction_test",
|
|
|
|
|
srcs=["utilities/transactions/write_prepared_transaction_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cpp_unittest_wrapper(name="write_unprepared_transaction_test",
|
|
|
|
|
srcs=["utilities/transactions/write_unprepared_transaction_test.cc"],
|
|
|
|
|
deps=[":rocksdb_test_lib"],
|
|
|
|
|
extra_compiler_flags=[])
|
|
|
|
|
|
