|
|
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
|
|
// (found in the LICENSE.Apache file in the root directory).
|
|
|
|
//
|
|
|
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
|
|
//
|
|
|
|
// Encoding independent of machine byte order:
|
|
|
|
// * Fixed-length numbers are encoded with least-significant byte first
|
|
|
|
// (little endian, native order on Intel and others)
|
|
|
|
// * In addition we support variable length "varint" encoding
|
|
|
|
// * Strings are encoded prefixed by their length in varint format
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
#include <algorithm>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <string>
|
|
|
|
|
|
|
|
#include "rocksdb/write_batch.h"
|
|
|
|
#include "port/port.h"
|
|
|
|
|
|
|
|
// Some processors does not allow unaligned access to memory
|
|
|
|
#if defined(__sparc)
|
|
|
|
#define PLATFORM_UNALIGNED_ACCESS_NOT_ALLOWED
|
|
|
|
#endif
|
|
|
|
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
|
|
|
Fixed compile warnings in posix_logger.h and coding.h
Summary:
Fixed the following compile warnings:
/Users/yhchiang/rocksdb/util/posix_logger.h:32:11: error: unused variable 'kDebugLogChunkSize' [-Werror,-Wunused-const-variable]
const int kDebugLogChunkSize = 128 * 1024;
^
/Users/yhchiang/rocksdb/util/coding.h:24:20: error: unused variable 'kMaxVarint32Length' [-Werror,-Wunused-const-variable]
const unsigned int kMaxVarint32Length = 5;
^
2 errors generated.
Test Plan: make clean rocksdb
Reviewers: igor, sdong, anthony, IslamAbdelRahman, rven, kradhakrishnan, adamretter
Reviewed By: adamretter
Subscribers: andrewkr, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D56223
9 years ago
|
|
|
// The maximum length of a varint in bytes for 64-bit.
|
|
|
|
const unsigned int kMaxVarint64Length = 10;
|
|
|
|
|
|
|
|
// Standard Put... routines append to a string
|
|
|
|
extern void PutFixed16(std::string* dst, uint16_t value);
|
|
|
|
extern void PutFixed32(std::string* dst, uint32_t value);
|
|
|
|
extern void PutFixed64(std::string* dst, uint64_t value);
|
|
|
|
extern void PutVarint32(std::string* dst, uint32_t value);
|
|
|
|
extern void PutVarint32Varint32(std::string* dst, uint32_t value1,
|
|
|
|
uint32_t value2);
|
|
|
|
extern void PutVarint32Varint32Varint32(std::string* dst, uint32_t value1,
|
|
|
|
uint32_t value2, uint32_t value3);
|
|
|
|
extern void PutVarint64(std::string* dst, uint64_t value);
|
|
|
|
extern void PutVarint64Varint64(std::string* dst, uint64_t value1,
|
|
|
|
uint64_t value2);
|
|
|
|
extern void PutVarint32Varint64(std::string* dst, uint32_t value1,
|
|
|
|
uint64_t value2);
|
|
|
|
extern void PutVarint32Varint32Varint64(std::string* dst, uint32_t value1,
|
|
|
|
uint32_t value2, uint64_t value3);
|
|
|
|
extern void PutLengthPrefixedSlice(std::string* dst, const Slice& value);
|
|
|
|
extern void PutLengthPrefixedSliceParts(std::string* dst,
|
|
|
|
const SliceParts& slice_parts);
|
|
|
|
extern void PutLengthPrefixedSlicePartsWithPadding(
|
|
|
|
std::string* dst, const SliceParts& slice_parts, size_t pad_sz);
|
|
|
|
|
|
|
|
// Standard Get... routines parse a value from the beginning of a Slice
|
|
|
|
// and advance the slice past the parsed value.
|
|
|
|
extern bool GetFixed64(Slice* input, uint64_t* value);
|
|
|
|
extern bool GetFixed32(Slice* input, uint32_t* value);
|
|
|
|
extern bool GetFixed16(Slice* input, uint16_t* value);
|
|
|
|
extern bool GetVarint32(Slice* input, uint32_t* value);
|
|
|
|
extern bool GetVarint64(Slice* input, uint64_t* value);
|
Add an option to put first key of each sst block in the index (#5289)
Summary:
The first key is used to defer reading the data block until this file gets to the top of merging iterator's heap. For short range scans, most files never make it to the top of the heap, so this change can reduce read amplification by a lot sometimes.
Consider the following workload. There are a few data streams (we'll be calling them "logs"), each stream consisting of a sequence of blobs (we'll be calling them "records"). Each record is identified by log ID and a sequence number within the log. RocksDB key is concatenation of log ID and sequence number (big endian). Reads are mostly relatively short range scans, each within a single log. Writes are mostly sequential for each log, but writes to different logs are randomly interleaved. Compactions are disabled; instead, when we accumulate a few tens of sst files, we create a new column family and start writing to it.
So, a typical sst file consists of a few ranges of blocks, each range corresponding to one log ID (we use FlushBlockPolicy to cut blocks at log boundaries). A typical read would go like this. First, iterator Seek() reads one block from each sst file. Then a series of Next()s move through one sst file (since writes to each log are mostly sequential) until the subiterator reaches the end of this log in this sst file; then Next() switches to the next sst file and reads sequentially from that, and so on. Often a range scan will only return records from a small number of blocks in small number of sst files; in this case, the cost of initial Seek() reading one block from each file may be bigger than the cost of reading the actually useful blocks.
Neither iterate_upper_bound nor bloom filters can prevent reading one block from each file in Seek(). But this PR can: if the index contains first key from each block, we don't have to read the block until this block actually makes it to the top of merging iterator's heap, so for short range scans we won't read any blocks from most of the sst files.
This PR does the deferred block loading inside value() call. This is not ideal: there's no good way to report an IO error from inside value(). As discussed with siying offline, it would probably be better to change InternalIterator's interface to explicitly fetch deferred value and get status. I'll do it in a separate PR.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5289
Differential Revision: D15256423
Pulled By: al13n321
fbshipit-source-id: 750e4c39ce88e8d41662f701cf6275d9388ba46a
6 years ago
|
|
|
extern bool GetVarsignedint64(Slice* input, int64_t* value);
|
|
|
|
extern bool GetLengthPrefixedSlice(Slice* input, Slice* result);
|
|
|
|
// This function assumes data is well-formed.
|
|
|
|
extern Slice GetLengthPrefixedSlice(const char* data);
|
|
|
|
|
[RocksDB] BackupableDB
Summary:
In this diff I present you BackupableDB v1. You can easily use it to backup your DB and it will do incremental snapshots for you.
Let's first describe how you would use BackupableDB. It's inheriting StackableDB interface so you can easily construct it with your DB object -- it will add a method RollTheSnapshot() to the DB object. When you call RollTheSnapshot(), current snapshot of the DB will be stored in the backup dir. To restore, you can just call RestoreDBFromBackup() on a BackupableDB (which is a static method) and it will restore all files from the backup dir. In the next version, it will even support automatic backuping every X minutes.
There are multiple things you can configure:
1. backup_env and db_env can be different, which is awesome because then you can easily backup to HDFS or wherever you feel like.
2. sync - if true, it *guarantees* backup consistency on machine reboot
3. number of snapshots to keep - this will keep last N snapshots around if you want, for some reason, be able to restore from an earlier snapshot. All the backuping is done in incremental fashion - if we already have 00010.sst, we will not copy it again. *IMPORTANT* -- This is based on assumption that 00010.sst never changes - two files named 00010.sst from the same DB will always be exactly the same. Is this true? I always copy manifest, current and log files.
4. You can decide if you want to flush the memtables before you backup, or you're fine with backing up the log files -- either way, you get a complete and consistent view of the database at a time of backup.
5. More things you can find in BackupableDBOptions
Here is the directory structure I use:
backup_dir/CURRENT_SNAPSHOT - just 4 bytes holding the latest snapshot
0, 1, 2, ... - files containing serialized version of each snapshot - containing a list of files
files/*.sst - sst files shared between snapshots - if one snapshot references 00010.sst and another one needs to backup it from the DB, it will just reference the same file
files/ 0/, 1/, 2/, ... - snapshot directories containing private snapshot files - current, manifest and log files
All the files are ref counted and deleted immediatelly when they get out of scope.
Some other stuff in this diff:
1. Added GetEnv() method to the DB. Discussed with @haobo and we agreed that it seems right thing to do.
2. Fixed StackableDB interface. The way it was set up before, I was not able to implement BackupableDB.
Test Plan:
I have a unittest, but please don't look at this yet. I just hacked it up to help me with debugging. I will write a lot of good tests and update the diff.
Also, `make asan_check`
Reviewers: dhruba, haobo, emayanke
Reviewed By: dhruba
CC: leveldb, haobo
Differential Revision: https://reviews.facebook.net/D14295
11 years ago
|
|
|
extern Slice GetSliceUntil(Slice* slice, char delimiter);
|
|
|
|
|
|
|
|
// Borrowed from
|
|
|
|
// https://github.com/facebook/fbthrift/blob/449a5f77f9f9bae72c9eb5e78093247eef185c04/thrift/lib/cpp/util/VarintUtils-inl.h#L202-L208
|
|
|
|
constexpr inline uint64_t i64ToZigzag(const int64_t l) {
|
|
|
|
return (static_cast<uint64_t>(l) << 1) ^ static_cast<uint64_t>(l >> 63);
|
|
|
|
}
|
|
|
|
inline int64_t zigzagToI64(uint64_t n) {
|
|
|
|
return (n >> 1) ^ -static_cast<int64_t>(n & 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Pointer-based variants of GetVarint... These either store a value
|
|
|
|
// in *v and return a pointer just past the parsed value, or return
|
|
|
|
// nullptr on error. These routines only look at bytes in the range
|
|
|
|
// [p..limit-1]
|
|
|
|
extern const char* GetVarint32Ptr(const char* p,const char* limit, uint32_t* v);
|
|
|
|
extern const char* GetVarint64Ptr(const char* p,const char* limit, uint64_t* v);
|
|
|
|
inline const char* GetVarsignedint64Ptr(const char* p, const char* limit,
|
|
|
|
int64_t* value) {
|
|
|
|
uint64_t u = 0;
|
|
|
|
const char* ret = GetVarint64Ptr(p, limit, &u);
|
|
|
|
*value = zigzagToI64(u);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns the length of the varint32 or varint64 encoding of "v"
|
|
|
|
extern int VarintLength(uint64_t v);
|
|
|
|
|
|
|
|
// Lower-level versions of Put... that write directly into a character buffer
|
|
|
|
// REQUIRES: dst has enough space for the value being written
|
|
|
|
extern void EncodeFixed16(char* dst, uint16_t value);
|
|
|
|
extern void EncodeFixed32(char* dst, uint32_t value);
|
|
|
|
extern void EncodeFixed64(char* dst, uint64_t value);
|
|
|
|
|
|
|
|
// Lower-level versions of Put... that write directly into a character buffer
|
|
|
|
// and return a pointer just past the last byte written.
|
|
|
|
// REQUIRES: dst has enough space for the value being written
|
|
|
|
extern char* EncodeVarint32(char* dst, uint32_t value);
|
|
|
|
extern char* EncodeVarint64(char* dst, uint64_t value);
|
|
|
|
|
|
|
|
// Lower-level versions of Get... that read directly from a character buffer
|
|
|
|
// without any bounds checking.
|
|
|
|
|
|
|
|
inline uint16_t DecodeFixed16(const char* ptr) {
|
|
|
|
if (port::kLittleEndian) {
|
|
|
|
// Load the raw bytes
|
|
|
|
uint16_t result;
|
|
|
|
memcpy(&result, ptr, sizeof(result)); // gcc optimizes this to a plain load
|
|
|
|
return result;
|
|
|
|
} else {
|
|
|
|
return ((static_cast<uint16_t>(static_cast<unsigned char>(ptr[0]))) |
|
|
|
|
(static_cast<uint16_t>(static_cast<unsigned char>(ptr[1])) << 8));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline uint32_t DecodeFixed32(const char* ptr) {
|
|
|
|
if (port::kLittleEndian) {
|
|
|
|
// Load the raw bytes
|
|
|
|
uint32_t result;
|
|
|
|
memcpy(&result, ptr, sizeof(result)); // gcc optimizes this to a plain load
|
|
|
|
return result;
|
|
|
|
} else {
|
|
|
|
return ((static_cast<uint32_t>(static_cast<unsigned char>(ptr[0])))
|
|
|
|
| (static_cast<uint32_t>(static_cast<unsigned char>(ptr[1])) << 8)
|
|
|
|
| (static_cast<uint32_t>(static_cast<unsigned char>(ptr[2])) << 16)
|
|
|
|
| (static_cast<uint32_t>(static_cast<unsigned char>(ptr[3])) << 24));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline uint64_t DecodeFixed64(const char* ptr) {
|
|
|
|
if (port::kLittleEndian) {
|
|
|
|
// Load the raw bytes
|
|
|
|
uint64_t result;
|
|
|
|
memcpy(&result, ptr, sizeof(result)); // gcc optimizes this to a plain load
|
|
|
|
return result;
|
|
|
|
} else {
|
|
|
|
uint64_t lo = DecodeFixed32(ptr);
|
|
|
|
uint64_t hi = DecodeFixed32(ptr + 4);
|
|
|
|
return (hi << 32) | lo;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Internal routine for use by fallback path of GetVarint32Ptr
|
|
|
|
extern const char* GetVarint32PtrFallback(const char* p,
|
|
|
|
const char* limit,
|
|
|
|
uint32_t* value);
|
|
|
|
inline const char* GetVarint32Ptr(const char* p,
|
|
|
|
const char* limit,
|
|
|
|
uint32_t* value) {
|
|
|
|
if (p < limit) {
|
|
|
|
uint32_t result = *(reinterpret_cast<const unsigned char*>(p));
|
|
|
|
if ((result & 128) == 0) {
|
|
|
|
*value = result;
|
|
|
|
return p + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return GetVarint32PtrFallback(p, limit, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
// -- Implementation of the functions declared above
|
|
|
|
inline void EncodeFixed16(char* buf, uint16_t value) {
|
|
|
|
if (port::kLittleEndian) {
|
|
|
|
memcpy(buf, &value, sizeof(value));
|
|
|
|
} else {
|
|
|
|
buf[0] = value & 0xff;
|
|
|
|
buf[1] = (value >> 8) & 0xff;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void EncodeFixed32(char* buf, uint32_t value) {
|
|
|
|
if (port::kLittleEndian) {
|
|
|
|
memcpy(buf, &value, sizeof(value));
|
|
|
|
} else {
|
|
|
|
buf[0] = value & 0xff;
|
|
|
|
buf[1] = (value >> 8) & 0xff;
|
|
|
|
buf[2] = (value >> 16) & 0xff;
|
|
|
|
buf[3] = (value >> 24) & 0xff;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void EncodeFixed64(char* buf, uint64_t value) {
|
|
|
|
if (port::kLittleEndian) {
|
|
|
|
memcpy(buf, &value, sizeof(value));
|
|
|
|
} else {
|
|
|
|
buf[0] = value & 0xff;
|
|
|
|
buf[1] = (value >> 8) & 0xff;
|
|
|
|
buf[2] = (value >> 16) & 0xff;
|
|
|
|
buf[3] = (value >> 24) & 0xff;
|
|
|
|
buf[4] = (value >> 32) & 0xff;
|
|
|
|
buf[5] = (value >> 40) & 0xff;
|
|
|
|
buf[6] = (value >> 48) & 0xff;
|
|
|
|
buf[7] = (value >> 56) & 0xff;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Pull the last 8 bits and cast it to a character
|
|
|
|
inline void PutFixed16(std::string* dst, uint16_t value) {
|
|
|
|
if (port::kLittleEndian) {
|
|
|
|
dst->append(const_cast<const char*>(reinterpret_cast<char*>(&value)),
|
|
|
|
sizeof(value));
|
|
|
|
} else {
|
|
|
|
char buf[sizeof(value)];
|
|
|
|
EncodeFixed16(buf, value);
|
|
|
|
dst->append(buf, sizeof(buf));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutFixed32(std::string* dst, uint32_t value) {
|
|
|
|
if (port::kLittleEndian) {
|
|
|
|
dst->append(const_cast<const char*>(reinterpret_cast<char*>(&value)),
|
|
|
|
sizeof(value));
|
|
|
|
} else {
|
|
|
|
char buf[sizeof(value)];
|
|
|
|
EncodeFixed32(buf, value);
|
|
|
|
dst->append(buf, sizeof(buf));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutFixed64(std::string* dst, uint64_t value) {
|
|
|
|
if (port::kLittleEndian) {
|
|
|
|
dst->append(const_cast<const char*>(reinterpret_cast<char*>(&value)),
|
|
|
|
sizeof(value));
|
|
|
|
} else {
|
|
|
|
char buf[sizeof(value)];
|
|
|
|
EncodeFixed64(buf, value);
|
|
|
|
dst->append(buf, sizeof(buf));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutVarint32(std::string* dst, uint32_t v) {
|
|
|
|
char buf[5];
|
|
|
|
char* ptr = EncodeVarint32(buf, v);
|
|
|
|
dst->append(buf, static_cast<size_t>(ptr - buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutVarint32Varint32(std::string* dst, uint32_t v1, uint32_t v2) {
|
|
|
|
char buf[10];
|
|
|
|
char* ptr = EncodeVarint32(buf, v1);
|
|
|
|
ptr = EncodeVarint32(ptr, v2);
|
|
|
|
dst->append(buf, static_cast<size_t>(ptr - buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutVarint32Varint32Varint32(std::string* dst, uint32_t v1,
|
|
|
|
uint32_t v2, uint32_t v3) {
|
|
|
|
char buf[15];
|
|
|
|
char* ptr = EncodeVarint32(buf, v1);
|
|
|
|
ptr = EncodeVarint32(ptr, v2);
|
|
|
|
ptr = EncodeVarint32(ptr, v3);
|
|
|
|
dst->append(buf, static_cast<size_t>(ptr - buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline char* EncodeVarint64(char* dst, uint64_t v) {
|
|
|
|
static const unsigned int B = 128;
|
|
|
|
unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);
|
|
|
|
while (v >= B) {
|
|
|
|
*(ptr++) = (v & (B - 1)) | B;
|
|
|
|
v >>= 7;
|
|
|
|
}
|
|
|
|
*(ptr++) = static_cast<unsigned char>(v);
|
|
|
|
return reinterpret_cast<char*>(ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutVarint64(std::string* dst, uint64_t v) {
|
|
|
|
char buf[kMaxVarint64Length];
|
|
|
|
char* ptr = EncodeVarint64(buf, v);
|
|
|
|
dst->append(buf, static_cast<size_t>(ptr - buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutVarsignedint64(std::string* dst, int64_t v) {
|
|
|
|
char buf[kMaxVarint64Length];
|
|
|
|
// Using Zigzag format to convert signed to unsigned
|
|
|
|
char* ptr = EncodeVarint64(buf, i64ToZigzag(v));
|
|
|
|
dst->append(buf, static_cast<size_t>(ptr - buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutVarint64Varint64(std::string* dst, uint64_t v1, uint64_t v2) {
|
|
|
|
char buf[20];
|
|
|
|
char* ptr = EncodeVarint64(buf, v1);
|
|
|
|
ptr = EncodeVarint64(ptr, v2);
|
|
|
|
dst->append(buf, static_cast<size_t>(ptr - buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutVarint32Varint64(std::string* dst, uint32_t v1, uint64_t v2) {
|
|
|
|
char buf[15];
|
|
|
|
char* ptr = EncodeVarint32(buf, v1);
|
|
|
|
ptr = EncodeVarint64(ptr, v2);
|
|
|
|
dst->append(buf, static_cast<size_t>(ptr - buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutVarint32Varint32Varint64(std::string* dst, uint32_t v1,
|
|
|
|
uint32_t v2, uint64_t v3) {
|
|
|
|
char buf[20];
|
|
|
|
char* ptr = EncodeVarint32(buf, v1);
|
|
|
|
ptr = EncodeVarint32(ptr, v2);
|
|
|
|
ptr = EncodeVarint64(ptr, v3);
|
|
|
|
dst->append(buf, static_cast<size_t>(ptr - buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutLengthPrefixedSlice(std::string* dst, const Slice& value) {
|
|
|
|
PutVarint32(dst, static_cast<uint32_t>(value.size()));
|
|
|
|
dst->append(value.data(), value.size());
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutLengthPrefixedSliceParts(std::string* dst, size_t total_bytes,
|
|
|
|
const SliceParts& slice_parts) {
|
|
|
|
for (int i = 0; i < slice_parts.num_parts; ++i) {
|
|
|
|
total_bytes += slice_parts.parts[i].size();
|
|
|
|
}
|
|
|
|
PutVarint32(dst, static_cast<uint32_t>(total_bytes));
|
|
|
|
for (int i = 0; i < slice_parts.num_parts; ++i) {
|
|
|
|
dst->append(slice_parts.parts[i].data(), slice_parts.parts[i].size());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutLengthPrefixedSliceParts(std::string* dst,
|
|
|
|
const SliceParts& slice_parts) {
|
|
|
|
PutLengthPrefixedSliceParts(dst, /*total_bytes=*/0, slice_parts);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PutLengthPrefixedSlicePartsWithPadding(
|
|
|
|
std::string* dst, const SliceParts& slice_parts, size_t pad_sz) {
|
|
|
|
PutLengthPrefixedSliceParts(dst, /*total_bytes=*/pad_sz, slice_parts);
|
|
|
|
dst->append(pad_sz, '\0');
|
|
|
|
}
|
|
|
|
|
|
|
|
inline int VarintLength(uint64_t v) {
|
|
|
|
int len = 1;
|
|
|
|
while (v >= 128) {
|
|
|
|
v >>= 7;
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool GetFixed64(Slice* input, uint64_t* value) {
|
|
|
|
if (input->size() < sizeof(uint64_t)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
*value = DecodeFixed64(input->data());
|
|
|
|
input->remove_prefix(sizeof(uint64_t));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool GetFixed32(Slice* input, uint32_t* value) {
|
|
|
|
if (input->size() < sizeof(uint32_t)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
*value = DecodeFixed32(input->data());
|
|
|
|
input->remove_prefix(sizeof(uint32_t));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool GetFixed16(Slice* input, uint16_t* value) {
|
|
|
|
if (input->size() < sizeof(uint16_t)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
*value = DecodeFixed16(input->data());
|
|
|
|
input->remove_prefix(sizeof(uint16_t));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool GetVarint32(Slice* input, uint32_t* value) {
|
|
|
|
const char* p = input->data();
|
|
|
|
const char* limit = p + input->size();
|
|
|
|
const char* q = GetVarint32Ptr(p, limit, value);
|
|
|
|
if (q == nullptr) {
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
*input = Slice(q, static_cast<size_t>(limit - q));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool GetVarint64(Slice* input, uint64_t* value) {
|
|
|
|
const char* p = input->data();
|
|
|
|
const char* limit = p + input->size();
|
|
|
|
const char* q = GetVarint64Ptr(p, limit, value);
|
|
|
|
if (q == nullptr) {
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
*input = Slice(q, static_cast<size_t>(limit - q));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Add an option to put first key of each sst block in the index (#5289)
Summary:
The first key is used to defer reading the data block until this file gets to the top of merging iterator's heap. For short range scans, most files never make it to the top of the heap, so this change can reduce read amplification by a lot sometimes.
Consider the following workload. There are a few data streams (we'll be calling them "logs"), each stream consisting of a sequence of blobs (we'll be calling them "records"). Each record is identified by log ID and a sequence number within the log. RocksDB key is concatenation of log ID and sequence number (big endian). Reads are mostly relatively short range scans, each within a single log. Writes are mostly sequential for each log, but writes to different logs are randomly interleaved. Compactions are disabled; instead, when we accumulate a few tens of sst files, we create a new column family and start writing to it.
So, a typical sst file consists of a few ranges of blocks, each range corresponding to one log ID (we use FlushBlockPolicy to cut blocks at log boundaries). A typical read would go like this. First, iterator Seek() reads one block from each sst file. Then a series of Next()s move through one sst file (since writes to each log are mostly sequential) until the subiterator reaches the end of this log in this sst file; then Next() switches to the next sst file and reads sequentially from that, and so on. Often a range scan will only return records from a small number of blocks in small number of sst files; in this case, the cost of initial Seek() reading one block from each file may be bigger than the cost of reading the actually useful blocks.
Neither iterate_upper_bound nor bloom filters can prevent reading one block from each file in Seek(). But this PR can: if the index contains first key from each block, we don't have to read the block until this block actually makes it to the top of merging iterator's heap, so for short range scans we won't read any blocks from most of the sst files.
This PR does the deferred block loading inside value() call. This is not ideal: there's no good way to report an IO error from inside value(). As discussed with siying offline, it would probably be better to change InternalIterator's interface to explicitly fetch deferred value and get status. I'll do it in a separate PR.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5289
Differential Revision: D15256423
Pulled By: al13n321
fbshipit-source-id: 750e4c39ce88e8d41662f701cf6275d9388ba46a
6 years ago
|
|
|
inline bool GetVarsignedint64(Slice* input, int64_t* value) {
|
|
|
|
const char* p = input->data();
|
|
|
|
const char* limit = p + input->size();
|
|
|
|
const char* q = GetVarsignedint64Ptr(p, limit, value);
|
|
|
|
if (q == nullptr) {
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
*input = Slice(q, static_cast<size_t>(limit - q));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Swaps between big and little endian. Can be used to in combination
|
|
|
|
// with the little-endian encoding/decoding functions to encode/decode
|
|
|
|
// big endian.
|
|
|
|
template <typename T>
|
|
|
|
inline T EndianSwapValue(T v) {
|
|
|
|
static_assert(std::is_integral<T>::value, "non-integral type");
|
|
|
|
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
if (sizeof(T) == 2) {
|
|
|
|
return static_cast<T>(_byteswap_ushort(static_cast<uint16_t>(v)));
|
|
|
|
} else if (sizeof(T) == 4) {
|
|
|
|
return static_cast<T>(_byteswap_ulong(static_cast<uint32_t>(v)));
|
|
|
|
} else if (sizeof(T) == 8) {
|
|
|
|
return static_cast<T>(_byteswap_uint64(static_cast<uint64_t>(v)));
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (sizeof(T) == 2) {
|
|
|
|
return static_cast<T>(__builtin_bswap16(static_cast<uint16_t>(v)));
|
|
|
|
} else if (sizeof(T) == 4) {
|
|
|
|
return static_cast<T>(__builtin_bswap32(static_cast<uint32_t>(v)));
|
|
|
|
} else if (sizeof(T) == 8) {
|
|
|
|
return static_cast<T>(__builtin_bswap64(static_cast<uint64_t>(v)));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
// Recognized by clang as bswap, but not by gcc :(
|
|
|
|
T ret_val = 0;
|
|
|
|
for (size_t i = 0; i < sizeof(T); ++i) {
|
|
|
|
ret_val |= ((v >> (8 * i)) & 0xff) << (8 * (sizeof(T) - 1 - i));
|
|
|
|
}
|
|
|
|
return ret_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool GetLengthPrefixedSlice(Slice* input, Slice* result) {
|
|
|
|
uint32_t len = 0;
|
|
|
|
if (GetVarint32(input, &len) && input->size() >= len) {
|
|
|
|
*result = Slice(input->data(), len);
|
|
|
|
input->remove_prefix(len);
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Slice GetLengthPrefixedSlice(const char* data) {
|
|
|
|
uint32_t len = 0;
|
|
|
|
// +5: we assume "data" is not corrupted
|
|
|
|
// unsigned char is 7 bits, uint32_t is 32 bits, need 5 unsigned char
|
|
|
|
auto p = GetVarint32Ptr(data, data + 5 /* limit */, &len);
|
|
|
|
return Slice(p, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Slice GetSliceUntil(Slice* slice, char delimiter) {
|
|
|
|
uint32_t len = 0;
|
|
|
|
for (len = 0; len < slice->size() && slice->data()[len] != delimiter; ++len) {
|
|
|
|
// nothing
|
|
|
|
}
|
|
|
|
|
|
|
|
Slice ret(slice->data(), len);
|
|
|
|
slice->remove_prefix(len + ((len < slice->size()) ? 1 : 0));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<class T>
|
|
|
|
#ifdef ROCKSDB_UBSAN_RUN
|
|
|
|
#if defined(__clang__)
|
|
|
|
__attribute__((__no_sanitize__("alignment")))
|
|
|
|
#elif defined(__GNUC__)
|
|
|
|
__attribute__((__no_sanitize_undefined__))
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
inline void PutUnaligned(T *memory, const T &value) {
|
|
|
|
#if defined(PLATFORM_UNALIGNED_ACCESS_NOT_ALLOWED)
|
|
|
|
char *nonAlignedMemory = reinterpret_cast<char*>(memory);
|
|
|
|
memcpy(nonAlignedMemory, reinterpret_cast<const char*>(&value), sizeof(T));
|
|
|
|
#else
|
|
|
|
*memory = value;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
template<class T>
|
|
|
|
#ifdef ROCKSDB_UBSAN_RUN
|
|
|
|
#if defined(__clang__)
|
|
|
|
__attribute__((__no_sanitize__("alignment")))
|
|
|
|
#elif defined(__GNUC__)
|
|
|
|
__attribute__((__no_sanitize_undefined__))
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
inline void GetUnaligned(const T *memory, T *value) {
|
|
|
|
#if defined(PLATFORM_UNALIGNED_ACCESS_NOT_ALLOWED)
|
|
|
|
char *nonAlignedMemory = reinterpret_cast<char*>(value);
|
|
|
|
memcpy(nonAlignedMemory, reinterpret_cast<const char*>(memory), sizeof(T));
|
|
|
|
#else
|
|
|
|
*value = *memory;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace ROCKSDB_NAMESPACE
|