Igor Canadi
11 years ago
commit
6de1b5b83e
@ -1,3 +1,3 @@ |
|||||||
* Detailed instructions on how to compile using fbcode and jemalloc |
* Detailed instructions on how to compile using fbcode and jemalloc |
||||||
|
|
||||||
* Latest release is 2.5.fb |
* Latest release is 2.7.fb |
||||||
|
|||||||
@ -0,0 +1,329 @@ |
|||||||
|
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
||||||
|
// This source code is licensed under the BSD-style license found in the
|
||||||
|
// LICENSE file in the root directory of this source tree. An additional grant
|
||||||
|
// of patent rights can be found in the PATENTS file in the same directory.
|
||||||
|
#pragma once |
||||||
|
|
||||||
|
#include <algorithm> |
||||||
|
#include <cassert> |
||||||
|
#include <stdexcept> |
||||||
|
#include <iterator> |
||||||
|
#include <vector> |
||||||
|
|
||||||
|
namespace rocksdb { |
||||||
|
|
||||||
|
// A vector that leverages pre-allocated stack-based array to achieve better
|
||||||
|
// performance for array with small amount of items.
|
||||||
|
//
|
||||||
|
// The interface resembles that of vector, but with less features since we aim
|
||||||
|
// to solve the problem that we have in hand, rather than implementing a
|
||||||
|
// full-fledged generic container.
|
||||||
|
//
|
||||||
|
// Currently we don't support:
|
||||||
|
// * reserve()/shrink_to_fit()/resize()
|
||||||
|
// If used correctly, in most cases, people should not touch the
|
||||||
|
// underlying vector at all.
|
||||||
|
// * random insert()/erase(), please only use push_back()/pop_back().
|
||||||
|
// * No move/swap operations. Each autovector instance has a
|
||||||
|
// stack-allocated array and if we want support move/swap operations, we
|
||||||
|
// need to copy the arrays other than just swapping the pointers. In this
|
||||||
|
// case we'll just explicitly forbid these operations since they may
|
||||||
|
// lead users to make false assumption by thinking they are inexpensive
|
||||||
|
// operations.
|
||||||
|
//
|
||||||
|
// Naming style of public methods almost follows that of the STL's.
|
||||||
|
template <class T, size_t kSize = 8> |
||||||
|
class autovector { |
||||||
|
public: |
||||||
|
// General STL-style container member types.
|
||||||
|
typedef T value_type; |
||||||
|
typedef typename std::vector<T>::difference_type difference_type; |
||||||
|
typedef typename std::vector<T>::size_type size_type; |
||||||
|
typedef value_type& reference; |
||||||
|
typedef const value_type& const_reference; |
||||||
|
typedef value_type* pointer; |
||||||
|
typedef const value_type* const_pointer; |
||||||
|
|
||||||
|
// This class is the base for regular/const iterator
|
||||||
|
template <class TAutoVector, class TValueType> |
||||||
|
class iterator_impl { |
||||||
|
public: |
||||||
|
// -- iterator traits
|
||||||
|
typedef iterator_impl<TAutoVector, TValueType> self_type; |
||||||
|
typedef TValueType value_type; |
||||||
|
typedef TValueType& reference; |
||||||
|
typedef TValueType* pointer; |
||||||
|
typedef typename TAutoVector::difference_type difference_type; |
||||||
|
typedef std::random_access_iterator_tag iterator_category; |
||||||
|
|
||||||
|
iterator_impl(TAutoVector* vect, size_t index) |
||||||
|
: vect_(vect) |
||||||
|
, index_(index) { |
||||||
|
}; |
||||||
|
iterator_impl(const iterator_impl&) = default; |
||||||
|
~iterator_impl() { } |
||||||
|
iterator_impl& operator=(const iterator_impl&) = default; |
||||||
|
|
||||||
|
// -- Advancement
|
||||||
|
// iterator++
|
||||||
|
self_type& operator++() { |
||||||
|
++index_; |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
// ++iterator
|
||||||
|
self_type operator++(int) { |
||||||
|
auto old = *this; |
||||||
|
++index_; |
||||||
|
return old; |
||||||
|
} |
||||||
|
|
||||||
|
// iterator--
|
||||||
|
self_type& operator--() { |
||||||
|
--index_; |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
// --iterator
|
||||||
|
self_type operator--(int) { |
||||||
|
auto old = *this; |
||||||
|
--index_; |
||||||
|
return old; |
||||||
|
} |
||||||
|
|
||||||
|
self_type operator-(difference_type len) { |
||||||
|
return self_type(vect_, index_ - len); |
||||||
|
} |
||||||
|
|
||||||
|
difference_type operator-(const self_type& other) { |
||||||
|
assert(vect_ == other.vect_); |
||||||
|
return index_ - other.index_; |
||||||
|
} |
||||||
|
|
||||||
|
self_type operator+(difference_type len) { |
||||||
|
return self_type(vect_, index_ + len); |
||||||
|
} |
||||||
|
|
||||||
|
self_type& operator+=(difference_type len) { |
||||||
|
index_ += len; |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
self_type& operator-=(difference_type len) { |
||||||
|
index_ -= len; |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
// -- Reference
|
||||||
|
reference operator*() { |
||||||
|
assert(vect_->size() >= index_); |
||||||
|
return (*vect_)[index_]; |
||||||
|
} |
||||||
|
pointer operator->() { |
||||||
|
assert(vect_->size() >= index_); |
||||||
|
return &(*vect_)[index_]; |
||||||
|
} |
||||||
|
|
||||||
|
// -- Logical Operators
|
||||||
|
bool operator==(const self_type& other) const { |
||||||
|
assert(vect_ == other.vect_); |
||||||
|
return index_ == other.index_; |
||||||
|
} |
||||||
|
|
||||||
|
bool operator!=(const self_type& other) const { |
||||||
|
return !(*this == other); |
||||||
|
} |
||||||
|
|
||||||
|
bool operator>(const self_type& other) const { |
||||||
|
assert(vect_ == other.vect_); |
||||||
|
return index_ > other.index_; |
||||||
|
} |
||||||
|
|
||||||
|
bool operator<(const self_type& other) const { |
||||||
|
assert(vect_ == other.vect_); |
||||||
|
return index_ < other.index_; |
||||||
|
} |
||||||
|
|
||||||
|
bool operator>=(const self_type& other) const { |
||||||
|
assert(vect_ == other.vect_); |
||||||
|
return index_ >= other.index_; |
||||||
|
} |
||||||
|
|
||||||
|
bool operator<=(const self_type& other) const { |
||||||
|
assert(vect_ == other.vect_); |
||||||
|
return index_ <= other.index_; |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
TAutoVector* vect_ = nullptr; |
||||||
|
size_t index_ = 0; |
||||||
|
}; |
||||||
|
|
||||||
|
typedef iterator_impl<autovector, value_type> iterator; |
||||||
|
typedef iterator_impl<const autovector, const value_type> const_iterator; |
||||||
|
typedef std::reverse_iterator<iterator> reverse_iterator; |
||||||
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator; |
||||||
|
|
||||||
|
autovector() = default; |
||||||
|
~autovector() = default; |
||||||
|
|
||||||
|
// -- Immutable operations
|
||||||
|
// Indicate if all data resides in in-stack data structure.
|
||||||
|
bool only_in_stack() const { |
||||||
|
// If no element was inserted at all, the vector's capacity will be `0`.
|
||||||
|
return vect_.capacity() == 0; |
||||||
|
} |
||||||
|
|
||||||
|
size_type size() const { |
||||||
|
return num_stack_items_ + vect_.size(); |
||||||
|
} |
||||||
|
|
||||||
|
bool empty() const { |
||||||
|
return size() == 0; |
||||||
|
} |
||||||
|
|
||||||
|
// will not check boundry
|
||||||
|
const_reference operator[](size_type n) const { |
||||||
|
return n < kSize ? values_[n] : vect_[n - kSize]; |
||||||
|
} |
||||||
|
|
||||||
|
reference operator[](size_type n) { |
||||||
|
return n < kSize ? values_[n] : vect_[n - kSize]; |
||||||
|
} |
||||||
|
|
||||||
|
// will check boundry
|
||||||
|
const_reference at(size_type n) const { |
||||||
|
if (n >= size()) { |
||||||
|
throw std::out_of_range("autovector: index out of range"); |
||||||
|
} |
||||||
|
return (*this)[n]; |
||||||
|
} |
||||||
|
|
||||||
|
reference at(size_type n) { |
||||||
|
if (n >= size()) { |
||||||
|
throw std::out_of_range("autovector: index out of range"); |
||||||
|
} |
||||||
|
return (*this)[n]; |
||||||
|
} |
||||||
|
|
||||||
|
reference front() { |
||||||
|
assert(!empty()); |
||||||
|
return *begin(); |
||||||
|
} |
||||||
|
|
||||||
|
const_reference front() const { |
||||||
|
assert(!empty()); |
||||||
|
return *begin(); |
||||||
|
} |
||||||
|
|
||||||
|
reference back() { |
||||||
|
assert(!empty()); |
||||||
|
return *(end() - 1); |
||||||
|
} |
||||||
|
|
||||||
|
const_reference back() const { |
||||||
|
assert(!empty()); |
||||||
|
return *(end() - 1); |
||||||
|
} |
||||||
|
|
||||||
|
// -- Mutable Operations
|
||||||
|
void push_back(T&& item) { |
||||||
|
if (num_stack_items_ < kSize) { |
||||||
|
values_[num_stack_items_++] = std::move(item); |
||||||
|
} else { |
||||||
|
vect_.push_back(item); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void push_back(const T& item) { |
||||||
|
push_back(value_type(item)); |
||||||
|
} |
||||||
|
|
||||||
|
template<class... Args> |
||||||
|
void emplace_back(Args&&... args) { |
||||||
|
push_back(value_type(args...)); |
||||||
|
} |
||||||
|
|
||||||
|
void pop_back() { |
||||||
|
assert(!empty()); |
||||||
|
if (!vect_.empty()) { |
||||||
|
vect_.pop_back(); |
||||||
|
} else { |
||||||
|
--num_stack_items_; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void clear() { |
||||||
|
num_stack_items_ = 0; |
||||||
|
vect_.clear(); |
||||||
|
} |
||||||
|
|
||||||
|
// -- Copy and Assignment
|
||||||
|
autovector& assign(const autovector& other); |
||||||
|
|
||||||
|
autovector(const autovector& other) { |
||||||
|
assign(other); |
||||||
|
} |
||||||
|
|
||||||
|
autovector& operator=(const autovector& other) { |
||||||
|
return assign(other); |
||||||
|
} |
||||||
|
|
||||||
|
// move operation are disallowed since it is very hard to make sure both
|
||||||
|
// autovectors are allocated from the same function stack.
|
||||||
|
autovector& operator=(autovector&& other) = delete; |
||||||
|
autovector(autovector&& other) = delete; |
||||||
|
|
||||||
|
// -- Iterator Operations
|
||||||
|
iterator begin() { |
||||||
|
return iterator(this, 0); |
||||||
|
} |
||||||
|
|
||||||
|
const_iterator begin() const { |
||||||
|
return const_iterator(this, 0); |
||||||
|
} |
||||||
|
|
||||||
|
iterator end() { |
||||||
|
return iterator(this, this->size()); |
||||||
|
} |
||||||
|
|
||||||
|
const_iterator end() const { |
||||||
|
return const_iterator(this, this->size()); |
||||||
|
} |
||||||
|
|
||||||
|
reverse_iterator rbegin() { |
||||||
|
return reverse_iterator(end()); |
||||||
|
} |
||||||
|
|
||||||
|
const_reverse_iterator rbegin() const { |
||||||
|
return const_reverse_iterator(end()); |
||||||
|
} |
||||||
|
|
||||||
|
reverse_iterator rend() { |
||||||
|
return reverse_iterator(begin()); |
||||||
|
} |
||||||
|
|
||||||
|
const_reverse_iterator rend() const { |
||||||
|
return const_reverse_iterator(begin()); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
size_type num_stack_items_ = 0; // current number of items
|
||||||
|
value_type values_[kSize]; // the first `kSize` items
|
||||||
|
// used only if there are more than `kSize` items.
|
||||||
|
std::vector<T> vect_; |
||||||
|
}; |
||||||
|
|
||||||
|
template <class T, size_t kSize> |
||||||
|
autovector<T, kSize>& autovector<T, kSize>::assign(const autovector& other) { |
||||||
|
// copy the internal vector
|
||||||
|
vect_.assign(other.vect_.begin(), other.vect_.end()); |
||||||
|
|
||||||
|
// copy array
|
||||||
|
num_stack_items_ = other.num_stack_items_; |
||||||
|
std::copy(other.values_, other.values_ + num_stack_items_, values_); |
||||||
|
|
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
} // rocksdb
|
||||||
@ -0,0 +1,290 @@ |
|||||||
|
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
||||||
|
// This source code is licensed under the BSD-style license found in the
|
||||||
|
// LICENSE file in the root directory of this source tree. An additional grant
|
||||||
|
// of patent rights can be found in the PATENTS file in the same directory.
|
||||||
|
|
||||||
|
#include <atomic> |
||||||
|
#include <iostream> |
||||||
|
|
||||||
|
#include "rocksdb/env.h" |
||||||
|
#include "util/autovector.h" |
||||||
|
#include "util/testharness.h" |
||||||
|
#include "util/testutil.h" |
||||||
|
|
||||||
|
namespace rocksdb { |
||||||
|
|
||||||
|
using namespace std; |
||||||
|
|
||||||
|
class AutoVectorTest { }; |
||||||
|
|
||||||
|
const size_t kSize = 8; |
||||||
|
TEST(AutoVectorTest, PushBackAndPopBack) { |
||||||
|
autovector<size_t, kSize> vec; |
||||||
|
ASSERT_TRUE(vec.empty()); |
||||||
|
ASSERT_EQ(0ul, vec.size()); |
||||||
|
|
||||||
|
for (size_t i = 0; i < 1000 * kSize; ++i) { |
||||||
|
vec.push_back(i); |
||||||
|
ASSERT_TRUE(!vec.empty()); |
||||||
|
if (i < kSize) { |
||||||
|
ASSERT_TRUE(vec.only_in_stack()); |
||||||
|
} else { |
||||||
|
ASSERT_TRUE(!vec.only_in_stack()); |
||||||
|
} |
||||||
|
ASSERT_EQ(i + 1, vec.size()); |
||||||
|
ASSERT_EQ(i, vec[i]); |
||||||
|
ASSERT_EQ(i, vec.at(i)); |
||||||
|
} |
||||||
|
|
||||||
|
size_t size = vec.size(); |
||||||
|
while (size != 0) { |
||||||
|
vec.pop_back(); |
||||||
|
// will always be in heap
|
||||||
|
ASSERT_TRUE(!vec.only_in_stack()); |
||||||
|
ASSERT_EQ(--size, vec.size()); |
||||||
|
} |
||||||
|
|
||||||
|
ASSERT_TRUE(vec.empty()); |
||||||
|
} |
||||||
|
|
||||||
|
TEST(AutoVectorTest, EmplaceBack) { |
||||||
|
typedef std::pair<size_t, std::string> ValueType; |
||||||
|
autovector<ValueType, kSize> vec; |
||||||
|
|
||||||
|
for (size_t i = 0; i < 1000 * kSize; ++i) { |
||||||
|
vec.emplace_back(i, std::to_string(i + 123)); |
||||||
|
ASSERT_TRUE(!vec.empty()); |
||||||
|
if (i < kSize) { |
||||||
|
ASSERT_TRUE(vec.only_in_stack()); |
||||||
|
} else { |
||||||
|
ASSERT_TRUE(!vec.only_in_stack()); |
||||||
|
} |
||||||
|
|
||||||
|
ASSERT_EQ(i + 1, vec.size()); |
||||||
|
ASSERT_EQ(i, vec[i].first); |
||||||
|
ASSERT_EQ(std::to_string(i + 123), vec[i].second); |
||||||
|
} |
||||||
|
|
||||||
|
vec.clear(); |
||||||
|
ASSERT_TRUE(vec.empty()); |
||||||
|
ASSERT_TRUE(!vec.only_in_stack()); |
||||||
|
} |
||||||
|
|
||||||
|
void AssertEqual( |
||||||
|
const autovector<size_t, kSize>& a, const autovector<size_t, kSize>& b) { |
||||||
|
ASSERT_EQ(a.size(), b.size()); |
||||||
|
ASSERT_EQ(a.empty(), b.empty()); |
||||||
|
ASSERT_EQ(a.only_in_stack(), b.only_in_stack()); |
||||||
|
for (size_t i = 0; i < a.size(); ++i) { |
||||||
|
ASSERT_EQ(a[i], b[i]); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
TEST(AutoVectorTest, CopyAndAssignment) { |
||||||
|
// Test both heap-allocated and stack-allocated cases.
|
||||||
|
for (auto size : { kSize / 2, kSize * 1000 }) { |
||||||
|
autovector<size_t, kSize> vec; |
||||||
|
for (size_t i = 0; i < size; ++i) { |
||||||
|
vec.push_back(i); |
||||||
|
} |
||||||
|
|
||||||
|
{ |
||||||
|
autovector<size_t, kSize> other; |
||||||
|
other = vec; |
||||||
|
AssertEqual(other, vec); |
||||||
|
} |
||||||
|
|
||||||
|
{ |
||||||
|
autovector<size_t, kSize> other(vec); |
||||||
|
AssertEqual(other, vec); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
TEST(AutoVectorTest, Iterators) { |
||||||
|
autovector<std::string, kSize> vec; |
||||||
|
for (size_t i = 0; i < kSize * 1000; ++i) { |
||||||
|
vec.push_back(std::to_string(i)); |
||||||
|
} |
||||||
|
|
||||||
|
// basic operator test
|
||||||
|
ASSERT_EQ(vec.front(), *vec.begin()); |
||||||
|
ASSERT_EQ(vec.back(), *(vec.end() - 1)); |
||||||
|
ASSERT_TRUE(vec.begin() < vec.end()); |
||||||
|
|
||||||
|
// non-const iterator
|
||||||
|
size_t index = 0; |
||||||
|
for (const auto& item : vec) { |
||||||
|
ASSERT_EQ(vec[index++], item); |
||||||
|
} |
||||||
|
|
||||||
|
index = vec.size() - 1; |
||||||
|
for (auto pos = vec.rbegin(); pos != vec.rend(); ++pos) { |
||||||
|
ASSERT_EQ(vec[index--], *pos); |
||||||
|
} |
||||||
|
|
||||||
|
// const iterator
|
||||||
|
const auto& cvec = vec; |
||||||
|
index = 0; |
||||||
|
for (const auto& item : cvec) { |
||||||
|
ASSERT_EQ(cvec[index++], item); |
||||||
|
} |
||||||
|
|
||||||
|
index = vec.size() - 1; |
||||||
|
for (auto pos = cvec.rbegin(); pos != cvec.rend(); ++pos) { |
||||||
|
ASSERT_EQ(cvec[index--], *pos); |
||||||
|
} |
||||||
|
|
||||||
|
// forward and backward
|
||||||
|
auto pos = vec.begin(); |
||||||
|
while (pos != vec.end()) { |
||||||
|
auto old_val = *pos; |
||||||
|
auto old = pos++; |
||||||
|
// HACK: make sure -> works
|
||||||
|
ASSERT_TRUE(!old->empty()); |
||||||
|
ASSERT_EQ(old_val, *old); |
||||||
|
ASSERT_TRUE(pos == vec.end() || old_val != *pos); |
||||||
|
} |
||||||
|
|
||||||
|
pos = vec.begin(); |
||||||
|
for (size_t i = 0; i < vec.size(); i += 2) { |
||||||
|
// Cannot use ASSERT_EQ since that macro depends on iostream serialization
|
||||||
|
ASSERT_TRUE(pos + 2 - 2 == pos); |
||||||
|
pos += 2; |
||||||
|
ASSERT_TRUE(pos >= vec.begin()); |
||||||
|
ASSERT_TRUE(pos <= vec.end()); |
||||||
|
|
||||||
|
size_t diff = static_cast<size_t>(pos - vec.begin()); |
||||||
|
ASSERT_EQ(i + 2, diff); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
vector<string> GetTestKeys(size_t size) { |
||||||
|
vector<string> keys; |
||||||
|
keys.resize(size); |
||||||
|
|
||||||
|
int index = 0; |
||||||
|
for (auto& key : keys) { |
||||||
|
key = "item-" + to_string(index++); |
||||||
|
} |
||||||
|
return keys; |
||||||
|
} |
||||||
|
|
||||||
|
template<class TVector> |
||||||
|
void BenchmarkVectorCreationAndInsertion( |
||||||
|
string name, size_t ops, size_t item_size, |
||||||
|
const std::vector<typename TVector::value_type>& items) { |
||||||
|
auto env = Env::Default(); |
||||||
|
|
||||||
|
int index = 0; |
||||||
|
auto start_time = env->NowNanos(); |
||||||
|
auto ops_remaining = ops; |
||||||
|
while(ops_remaining--) { |
||||||
|
TVector v; |
||||||
|
for (size_t i = 0; i < item_size; ++i) { |
||||||
|
v.push_back(items[index++]); |
||||||
|
} |
||||||
|
} |
||||||
|
auto elapsed = env->NowNanos() - start_time; |
||||||
|
cout << "created " << ops << " " << name << " instances:\n\t" |
||||||
|
<< "each was inserted with " << item_size << " elements\n\t" |
||||||
|
<< "total time elapsed: " << elapsed << " (ns)" << endl; |
||||||
|
} |
||||||
|
|
||||||
|
template <class TVector> |
||||||
|
size_t BenchmarkSequenceAccess(string name, size_t ops, size_t elem_size) { |
||||||
|
TVector v; |
||||||
|
for (const auto& item : GetTestKeys(elem_size)) { |
||||||
|
v.push_back(item); |
||||||
|
} |
||||||
|
auto env = Env::Default(); |
||||||
|
|
||||||
|
auto ops_remaining = ops; |
||||||
|
auto start_time = env->NowNanos(); |
||||||
|
size_t total = 0; |
||||||
|
while (ops_remaining--) { |
||||||
|
auto end = v.end(); |
||||||
|
for (auto pos = v.begin(); pos != end; ++pos) { |
||||||
|
total += pos->size(); |
||||||
|
} |
||||||
|
} |
||||||
|
auto elapsed = env->NowNanos() - start_time; |
||||||
|
cout << "performed " << ops << " sequence access against " << name << "\n\t" |
||||||
|
<< "size: " << elem_size << "\n\t" |
||||||
|
<< "total time elapsed: " << elapsed << " (ns)" << endl; |
||||||
|
// HACK avoid compiler's optimization to ignore total
|
||||||
|
return total; |
||||||
|
} |
||||||
|
|
||||||
|
// This test case only reports the performance between std::vector<string>
|
||||||
|
// and autovector<string>. We chose string for comparison because in most
|
||||||
|
// o our use cases we used std::vector<string>.
|
||||||
|
TEST(AutoVectorTest, PerfBench) { |
||||||
|
// We run same operations for kOps times in order to get a more fair result.
|
||||||
|
size_t kOps = 100000; |
||||||
|
|
||||||
|
// Creation and insertion test
|
||||||
|
// Test the case when there is:
|
||||||
|
// * no element inserted: internal array of std::vector may not really get
|
||||||
|
// initialize.
|
||||||
|
// * one element inserted: internal array of std::vector must have
|
||||||
|
// initialized.
|
||||||
|
// * kSize elements inserted. This shows the most time we'll spend if we
|
||||||
|
// keep everything in stack.
|
||||||
|
// * 2 * kSize elements inserted. The internal vector of
|
||||||
|
// autovector must have been initialized.
|
||||||
|
cout << "=====================================================" << endl; |
||||||
|
cout << "Creation and Insertion Test (value type: std::string)" << endl; |
||||||
|
cout << "=====================================================" << endl; |
||||||
|
|
||||||
|
// pre-generated unique keys
|
||||||
|
auto string_keys = GetTestKeys(kOps * 2 * kSize); |
||||||
|
for (auto insertions : { 0ul, 1ul, kSize / 2, kSize, 2 * kSize }) { |
||||||
|
BenchmarkVectorCreationAndInsertion<vector<string>>( |
||||||
|
"vector<string>", kOps, insertions, string_keys |
||||||
|
); |
||||||
|
BenchmarkVectorCreationAndInsertion<autovector<string, kSize>>( |
||||||
|
"autovector<string>", kOps, insertions, string_keys |
||||||
|
); |
||||||
|
cout << "-----------------------------------" << endl; |
||||||
|
} |
||||||
|
|
||||||
|
cout << "=====================================================" << endl; |
||||||
|
cout << "Creation and Insertion Test (value type: uint64_t)" << endl; |
||||||
|
cout << "=====================================================" << endl; |
||||||
|
|
||||||
|
// pre-generated unique keys
|
||||||
|
vector<uint64_t> int_keys(kOps * 2 * kSize); |
||||||
|
for (size_t i = 0; i < kOps * 2 * kSize; ++i) { |
||||||
|
int_keys[i] = i; |
||||||
|
} |
||||||
|
for (auto insertions : { 0ul, 1ul, kSize / 2, kSize, 2 * kSize }) { |
||||||
|
BenchmarkVectorCreationAndInsertion<vector<uint64_t>>( |
||||||
|
"vector<uint64_t>", kOps, insertions, int_keys |
||||||
|
); |
||||||
|
BenchmarkVectorCreationAndInsertion<autovector<uint64_t, kSize>>( |
||||||
|
"autovector<uint64_t>", kOps, insertions, int_keys |
||||||
|
); |
||||||
|
cout << "-----------------------------------" << endl; |
||||||
|
} |
||||||
|
|
||||||
|
// Sequence Access Test
|
||||||
|
cout << "=====================================================" << endl; |
||||||
|
cout << "Sequence Access Test" << endl; |
||||||
|
cout << "=====================================================" << endl; |
||||||
|
for (auto elem_size : { kSize / 2, kSize, 2 * kSize }) { |
||||||
|
BenchmarkSequenceAccess<vector<string>>( |
||||||
|
"vector", kOps, elem_size |
||||||
|
); |
||||||
|
BenchmarkSequenceAccess<autovector<string, kSize>>( |
||||||
|
"autovector", kOps, elem_size |
||||||
|
); |
||||||
|
cout << "-----------------------------------" << endl; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace rocksdb
|
||||||
|
|
||||||
|
int main(int argc, char** argv) { |
||||||
|
return rocksdb::test::RunAllTests(); |
||||||
|
} |
||||||
Loading…
Reference in new issue