36a5f8ed7f
- Replace raw slice comparison with a call to user comparator.
Added test for custom comparators.
- Fix end of namespace comments.
- Fixed bug in picking inputs for a level-0 compaction.
When finding overlapping files, the covered range may expand
as files are added to the input set. We now correctly expand
the range when this happens instead of continuing to use the
old range. For example, suppose L0 contains files with the
following ranges:
F1: a .. d
F2: c .. g
F3: f .. j
and the initial compaction target is F3. We used to search
for range f..j which yielded {F2,F3}. However we now expand
the range as soon as another file is added. In this case,
when F2 is added, we expand the range to c..j and restart the
search. That picks up file F1 as well.
This change fixes a bug related to deleted keys showing up
incorrectly after a compaction as described in Issue 44.
(Sync with upstream @25072954)
69 lines
1.8 KiB
C++
69 lines
1.8 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.
|
|
|
|
#ifndef STORAGE_LEVELDB_UTIL_ARENA_H_
|
|
#define STORAGE_LEVELDB_UTIL_ARENA_H_
|
|
|
|
#include <cstddef>
|
|
#include <vector>
|
|
#include <assert.h>
|
|
#include <stdint.h>
|
|
|
|
namespace leveldb {
|
|
|
|
class Arena {
|
|
public:
|
|
Arena();
|
|
~Arena();
|
|
|
|
// Return a pointer to a newly allocated memory block of "bytes" bytes.
|
|
char* Allocate(size_t bytes);
|
|
|
|
// Allocate memory with the normal alignment guarantees provided by malloc
|
|
char* AllocateAligned(size_t bytes);
|
|
|
|
// Returns an estimate of the total memory usage of data allocated
|
|
// by the arena (including space allocated but not yet used for user
|
|
// allocations).
|
|
size_t MemoryUsage() const {
|
|
return blocks_memory_ + blocks_.capacity() * sizeof(char*);
|
|
}
|
|
|
|
private:
|
|
char* AllocateFallback(size_t bytes);
|
|
char* AllocateNewBlock(size_t block_bytes);
|
|
|
|
// Allocation state
|
|
char* alloc_ptr_;
|
|
size_t alloc_bytes_remaining_;
|
|
|
|
// Array of new[] allocated memory blocks
|
|
std::vector<char*> blocks_;
|
|
|
|
// Bytes of memory in blocks allocated so far
|
|
size_t blocks_memory_;
|
|
|
|
// No copying allowed
|
|
Arena(const Arena&);
|
|
void operator=(const Arena&);
|
|
};
|
|
|
|
inline char* Arena::Allocate(size_t bytes) {
|
|
// The semantics of what to return are a bit messy if we allow
|
|
// 0-byte allocations, so we disallow them here (we don't need
|
|
// them for our internal use).
|
|
assert(bytes > 0);
|
|
if (bytes <= alloc_bytes_remaining_) {
|
|
char* result = alloc_ptr_;
|
|
alloc_ptr_ += bytes;
|
|
alloc_bytes_remaining_ -= bytes;
|
|
return result;
|
|
}
|
|
return AllocateFallback(bytes);
|
|
}
|
|
|
|
} // namespace leveldb
|
|
|
|
#endif // STORAGE_LEVELDB_UTIL_ARENA_H_
|