mirror of
https://github.com/facebook/rocksdb.git
synced 2024-11-26 07:30:54 +00:00
299ccedfec
- Added DB::CompactRange() method. Changed manual compaction code so it breaks up compactions of big ranges into smaller compactions. Changed the code that pushes the output of memtable compactions to higher levels to obey the grandparent constraint: i.e., we must never have a single file in level L that overlaps too much data in level L+1 (to avoid very expensive L-1 compactions). Added code to pretty-print internal keys. - Fixed bug where we would not detect overlap with files in level-0 because we were incorrectly using binary search on an array of files with overlapping ranges. Added "leveldb.sstables" property that can be used to dump all of the sstables and ranges that make up the db state. - Removing post_write_snapshot support. Email to leveldb mailing list brought up no users, just confusion from one person about what it meant. - Fixing static_cast char to unsigned on BIG_ENDIAN platforms. Fixes Issue 35 and Issue 36. - Comment clarification to address leveldb Issue 37. - Change license in posix_logger.h to match other files. - A build problem where uint32 was used instead of uint32_t. Sync with upstream @24408625
105 lines
3.9 KiB
C++
105 lines
3.9 KiB
C++
// 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.
|
|
//
|
|
// Endian-neutral encoding:
|
|
// * Fixed-length numbers are encoded with least-significant byte first
|
|
// * In addition we support variable length "varint" encoding
|
|
// * Strings are encoded prefixed by their length in varint format
|
|
|
|
#ifndef STORAGE_LEVELDB_UTIL_CODING_H_
|
|
#define STORAGE_LEVELDB_UTIL_CODING_H_
|
|
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <string>
|
|
#include "leveldb/slice.h"
|
|
#include "port/port.h"
|
|
|
|
namespace leveldb {
|
|
|
|
// Standard Put... routines append to a string
|
|
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 PutVarint64(std::string* dst, uint64_t value);
|
|
extern void PutLengthPrefixedSlice(std::string* dst, const Slice& value);
|
|
|
|
// Standard Get... routines parse a value from the beginning of a Slice
|
|
// and advance the slice past the parsed value.
|
|
extern bool GetVarint32(Slice* input, uint32_t* value);
|
|
extern bool GetVarint64(Slice* input, uint64_t* value);
|
|
extern bool GetLengthPrefixedSlice(Slice* input, Slice* result);
|
|
|
|
// Pointer-based variants of GetVarint... These either store a value
|
|
// in *v and return a pointer just past the parsed value, or return
|
|
// NULL 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);
|
|
|
|
// 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 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 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);
|
|
}
|
|
|
|
}
|
|
|
|
#endif // STORAGE_LEVELDB_UTIL_CODING_H_
|