tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add SmallVector and tests

Browse Source 
Summary: SmallVector data structure introduction.  This is the first step. In this revision are SmallVector implementation and tests. The second step will be swapping std::vector with SmallVector in the current codebase.

Reviewers: teon.banek, buda, ipaljak, mtomic

Reviewed By: teon.banek, ipaljak

Subscribers: ipaljak, pullbot

Differential Revision: https://phabricator.memgraph.io/D1730
This commit is contained in:
Dino Santl 2018-11-14 14:11:20 +01:00
parent 7f44b895b4
commit d3634e9a39
3 changed files with 1264 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

953
src/utils/small_vector.hpp Normal file
View File

@ -0,0 +1,953 @@
//===- small_vector.hpp - 'Normally small' vectors --------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the SmallVector class.
//
//===----------------------------------------------------------------------===//
#pragma once
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <initializer_list>
#include <iterator>
#include <memory>
#include "utils/likely.hpp"
// TODO (dsantl) This is original definition of LLVM_NODISCARD:
/// LLVM_NODISCARD - Warn if a type or return value is discarded.
// #if __cplusplus > 201402L && __has_cpp_attribute(nodiscard)
// #define LLVM_NODISCARD [[nodiscard]]
// #elif !__cplusplus
// // Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
// // error when __has_cpp_attribute is given a scoped attribute in C mode.
// #define LLVM_NODISCARD
// #elif __has_cpp_attribute(clang::warn_unused_result)
// #define LLVM_NODISCARD [[clang::warn_unused_result]]
// #else
// #define LLVM_NODISCARD
// #endif
#define LLVM_NODISCARD
// LLVM External Functions
namespace utils {
namespace detail {
/// NextPowerOf2 - Returns the next power of two (in 64-bits)
/// that is strictly greater than a. Returns zero on overflow.
inline uint64_t NextPowerOf2(uint64_t a) {
a |= (a >> 1);
a |= (a >> 2);
a |= (a >> 4);
a |= (a >> 8);
a |= (a >> 16);
a |= (a >> 32);
return a + 1;
}
}
}
namespace utils {
/// This is all the non-templated stuff common to all SmallVectors.
class SmallVectorBase {
protected:
void *begin_x_, *end_x_, *capacity_x_;
protected:
SmallVectorBase(void *first_el, size_t size)
: begin_x_(first_el),
end_x_(first_el),
capacity_x_((char *)first_el + size) {}
/// This is an implementation of the Grow() method which only works
/// on POD-like data types and is out of line to reduce code duplication.
void GrowPod(void *first_el, size_t min_size_in_bytes, size_t t_size);
public:
/// This returns size()*sizeof(T).
size_t size_in_bytes() const {
return size_t((char *)end_x_ - (char *)begin_x_);
}
/// capacity_in_bytes - This returns capacity()*sizeof(T).
size_t capacity_in_bytes() const {
return size_t((char *)capacity_x_ - (char *)begin_x_);
}
LLVM_NODISCARD bool empty() const { return begin_x_ == end_x_; }
};
template <typename T, unsigned N>
struct SmallVectorStorage;
/// This is the part of SmallVectorTemplateBase which does not depend on whether
/// the type T is a POD. The extra dummy template argument is used by ArrayRef
/// to avoid unnecessarily requiring T to be complete.
template <typename T, typename = void>
class SmallVectorTemplateCommon : public SmallVectorBase {
private:
template <typename, unsigned>
friend struct SmallVectorStorage;
// Allocate raw space for n elements of type T. If T has a ctor or dtor, we
// don't want it to be automatically run, so we need to represent the space as
// something else. Use an array of char of sufficient alignment.
////////////typedef utils::AlignedCharArrayUnion<T> U;
typedef typename std::aligned_union<1, T>::type U;
U first_el_;
// Space after 'first_el' is clobbered, do not add any instance vars after it.
protected:
SmallVectorTemplateCommon(size_t size) : SmallVectorBase(&first_el_, size) {}
void GrowPod(size_t min_size_in_bytes, size_t t_size) {
SmallVectorBase::GrowPod(&first_el_, min_size_in_bytes, t_size);
}
/// Return true if this is a smallvector which has not had dynamic
/// memory allocated for it.
bool IsSmall() const {
return begin_x_ == static_cast<const void *>(&first_el_);
}
/// Put this vector in a state of being small.
void ResetToSmall() { begin_x_ = end_x_ = capacity_x_ = &first_el_; }
void SetEnd(T *P) { this->end_x_ = P; }
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T value_type;
typedef T *iterator;
typedef const T *const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef T &reference;
typedef const T &const_reference;
typedef T *pointer;
typedef const T *const_pointer;
// forward iterator creation methods.
inline iterator begin() { return (iterator)this->begin_x_; }
inline const_iterator begin() const { return (const_iterator)this->begin_x_; }
inline iterator end() { return (iterator)this->end_x_; }
inline const_iterator end() const { return (const_iterator)this->end_x_; }
protected:
iterator CapacityPtr() { return (iterator)this->capacity_x_; }
const_iterator CapacityPtr() const {
return (const_iterator)this->capacity_x_;
}
public:
// reverse iterator creation methods.
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());
}
inline size_type size() const { return end() - begin(); }
size_type max_size() const { return size_type(-1) / sizeof(T); }
/// Return the total number of elements in the currently allocated buffer.
size_t capacity() const { return CapacityPtr() - begin(); }
/// Return a pointer to the vector's buffer, even if empty().
pointer data() { return pointer(begin()); }
/// Return a pointer to the vector's buffer, even if empty().
const_pointer data() const { return const_pointer(begin()); }
inline reference operator[](size_type idx) {
assert(idx < size());
return begin()[idx];
}
inline const_reference operator[](size_type idx) const {
assert(idx < size());
return begin()[idx];
}
reference front() {
assert(!empty());
return begin()[0];
}
const_reference front() const {
assert(!empty());
return begin()[0];
}
reference back() {
assert(!empty());
return end()[-1];
}
const_reference back() const {
assert(!empty());
return end()[-1];
}
};
/// SmallVectorTemplateBase<TIsPodLike = false> - This is where we put method
/// implementations that are designed to work with non-POD-like T's.
template <typename T, bool TIsPodLike>
class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
protected:
SmallVectorTemplateBase(size_t size) : SmallVectorTemplateCommon<T>(size) {}
static void DestroyRange(T *s, T *e) {
while (s != e) {
--e;
e->~T();
}
}
/// Move the range [i, e) into the uninitialized memory starting with "dest",
/// constructing elements as needed.
template <typename TIt1, typename TIt2>
static void UninitializedMove(TIt1 i, TIt1 e, TIt2 dest) {
std::uninitialized_copy(std::make_move_iterator(i),
std::make_move_iterator(e), dest);
}
/// Copy the range [i, e) onto the uninitialized memory starting with "dest",
/// constructing elements as needed.
template <typename TIt1, typename TIt2>
static void UninitializedCopy(TIt1 i, TIt1 e, TIt2 dest) {
std::uninitialized_copy(i, e, dest);
}
/// Grow the allocated memory (without initializing new elements), doubling
/// the size of the allocated memory. Guarantees space for at least one more
/// element, or min_size more elements if specified.
void Grow(size_t min_size = 0);
public:
void push_back(const T &elt) {
if (UNLIKELY(this->end_x_ >= this->capacity_x_)) this->Grow();
::new ((void *)this->end()) T(elt);
this->SetEnd(this->end() + 1);
}
void push_back(T &&elt) {
if (UNLIKELY(this->end_x_ >= this->capacity_x_)) this->Grow();
::new ((void *)this->end()) T(::std::move(elt));
this->SetEnd(this->end() + 1);
}
void pop_back() {
this->SetEnd(this->end() - 1);
this->end()->~T();
}
};
// Define this out-of-line to dissuade the C++ compiler from inlining it.
template <typename T, bool TIsPodLike>
void SmallVectorTemplateBase<T, TIsPodLike>::Grow(size_t min_size) {
size_t cur_capacity = this->capacity();
size_t cur_size = this->size();
// Always Grow, even from zero.
size_t new_capacity = size_t(utils::detail::NextPowerOf2(cur_capacity + 2));
if (new_capacity < min_size) new_capacity = min_size;
T *new_elts = static_cast<T *>(malloc(new_capacity * sizeof(T)));
// Move the elements over.
this->UninitializedMove(this->begin(), this->end(), new_elts);
// Destroy the original elements.
DestroyRange(this->begin(), this->end());
// If this wasn't grown from the inline copy, deallocate the old space.
if (!this->IsSmall()) free(this->begin());
this->SetEnd(new_elts + cur_size);
this->begin_x_ = new_elts;
this->capacity_x_ = this->begin() + new_capacity;
}
/// SmallVectorTemplateBase<TIsPodLike = true> - This is where we put method
/// implementations that are designed to work with POD-like T's.
template <typename T>
class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
protected:
SmallVectorTemplateBase(size_t size) : SmallVectorTemplateCommon<T>(size) {}
// No need to do a destroy loop for POD's.
static void DestroyRange(T *, T *) {}
/// Move the range [i, e) onto the uninitialized memory
/// starting with "dest", constructing elements into it as needed.
template <typename TIt1, typename TIt2>
static void UninitializedMove(TIt1 i, TIt1 e, TIt2 dest) {
// Just do a copy.
UninitializedCopy(i, e, dest);
}
/// Copy the range [i, e) onto the uninitialized memory
/// starting with "dest", constructing elements into it as needed.
template <typename TIt1, typename TIt2>
static void UninitializedCopy(TIt1 i, TIt1 e, TIt2 dest) {
// Arbitrary iterator types; just use the basic implementation.
std::uninitialized_copy(i, e, dest);
}
/// Copy the range [i, e) onto the uninitialized memory
/// starting with "dest", constructing elements into it as needed.
template <typename T1, typename T2>
static void UninitializedCopy(
T1 *i, T1 *e, T2 *dest,
typename std::enable_if<std::is_same<typename std::remove_const<T1>::type,
T2>::value>::type * = nullptr) {
// Use memcpy for PODs iterated by pointers (which includes SmallVector
// iterators): std::uninitialized_copy optimizes to memmove, but we can
// use memcpy here. Note that i and e are iterators and thus might be
// invalid for memcpy if they are equal.
if (i != e) memcpy(dest, i, (e - i) * sizeof(T));
}
/// Double the size of the allocated memory, guaranteeing space for at
/// least one more element or min_size if specified.
void Grow(size_t min_size = 0) {
this->GrowPod(min_size * sizeof(T), sizeof(T));
}
public:
void push_back(const T &elt) {
if (UNLIKELY(this->end_x_ >= this->capacity_x_)) this->Grow();
memcpy(this->end(), &elt, sizeof(T));
this->SetEnd(this->end() + 1);
}
void pop_back() { this->SetEnd(this->end() - 1); }
};
/// This class consists of common code factored out of the SmallVector class to
/// reduce code duplication based on the SmallVector 'n' template parameter.
template <typename T>
class SmallVectorImpl
: public SmallVectorTemplateBase<T, std::is_pod<T>::value> {
typedef SmallVectorTemplateBase<T, std::is_pod<T>::value> SuperClass;
SmallVectorImpl(const SmallVectorImpl &) = delete;
public:
typedef typename SuperClass::iterator iterator;
typedef typename SuperClass::const_iterator const_iterator;
typedef typename SuperClass::size_type size_type;
protected:
// Default ctor - Initialize to empty.
explicit SmallVectorImpl(unsigned n)
: SmallVectorTemplateBase<T, std::is_pod<T>::value>(n * sizeof(T)) {}
public:
~SmallVectorImpl() {
// Destroy the constructed elements in the vector.
this->DestroyRange(this->begin(), this->end());
// If this wasn't grown from the inline copy, deallocate the old space.
if (!this->IsSmall()) free(this->begin());
}
void clear() {
this->DestroyRange(this->begin(), this->end());
this->end_x_ = this->begin_x_;
}
void resize(size_type n) {
if (n < this->size()) {
this->DestroyRange(this->begin() + n, this->end());
this->SetEnd(this->begin() + n);
} else if (n > this->size()) {
if (this->capacity() < n) this->Grow(n);
for (auto i = this->end(), e = this->begin() + n; i != e; ++i)
new (&*i) T();
this->SetEnd(this->begin() + n);
}
}
void resize(size_type n, const T &nv) {
if (n < this->size()) {
this->DestroyRange(this->begin() + n, this->end());
this->SetEnd(this->begin() + n);
} else if (n > this->size()) {
if (this->capacity() < n) this->Grow(n);
std::uninitialized_fill(this->end(), this->begin() + n, nv);
this->SetEnd(this->begin() + n);
}
}
void reserve(size_type n) {
if (this->capacity() < n) this->Grow(n);
}
LLVM_NODISCARD T pop_back_val() {
T result = ::std::move(this->back());
this->pop_back();
return result;
}
void swap(SmallVectorImpl &rhs);
/// Add the specified range to the end of the SmallVector.
template <typename TInIter>
void append(TInIter in_start, TInIter in_end) {
size_type num_inputs = std::distance(in_start, in_end);
// Grow allocated space if needed.
if (num_inputs > size_type(this->CapacityPtr() - this->end()))
this->Grow(this->size() + num_inputs);
// Copy the new elements over.
this->UninitializedCopy(in_start, in_end, this->end());
this->SetEnd(this->end() + num_inputs);
}
/// Add the specified range to the end of the SmallVector.
void append(size_type num_inputs, const T &elt) {
// Grow allocated space if needed.
if (num_inputs > size_type(this->CapacityPtr() - this->end()))
this->Grow(this->size() + num_inputs);
// Copy the new elements over.
std::uninitialized_fill_n(this->end(), num_inputs, elt);
this->SetEnd(this->end() + num_inputs);
}
void append(std::initializer_list<T> il) { append(il.begin(), il.end()); }
void assign(size_type num_elts, const T &elt) {
clear();
if (this->capacity() < num_elts) this->Grow(num_elts);
this->SetEnd(this->begin() + num_elts);
std::uninitialized_fill(this->begin(), this->end(), elt);
}
void assign(std::initializer_list<T> il) {
clear();
append(il);
}
iterator erase(const_iterator ci) {
// Just cast away constness because this is a non-const member function.
iterator i = const_cast<iterator>(ci);
assert(i >= this->begin() && "Iterator to erase is out of bounds.");
assert(i < this->end() && "Erasing at past-the-end iterator.");
iterator n = i;
// Shift all elts down one.
std::move(i + 1, this->end(), i);
// Drop the last elt.
this->pop_back();
return (n);
}
iterator erase(const_iterator cs, const_iterator ce) {
// Just cast away constness because this is a non-const member function.
iterator s = const_cast<iterator>(cs);
iterator e = const_cast<iterator>(ce);
assert(s >= this->begin() && "Range to erase is out of bounds.");
assert(s <= e && "Trying to erase invalid range.");
assert(e <= this->end() && "Trying to erase past the end.");
iterator n = s;
// Shift all elts down.
iterator i = std::move(e, this->end(), s);
// Drop the last elts.
this->DestroyRange(i, this->end());
this->SetEnd(i);
return (n);
}
iterator insert(iterator i, T &&elt) {
if (i == this->end()) { // Important special case for empty vector.
this->push_back(::std::move(elt));
return this->end() - 1;
}
assert(i >= this->begin() && "Insertion iterator is out of bounds.");
assert(i <= this->end() && "Inserting past the end of the vector.");
if (this->end_x_ >= this->capacity_x_) {
size_t elt_no = i - this->begin();
this->Grow();
i = this->begin() + elt_no;
}
::new ((void *)this->end()) T(::std::move(this->back()));
// Push everything else over.
std::move_backward(i, this->end() - 1, this->end());
this->SetEnd(this->end() + 1);
// If we just moved the element we're inserting, be sure to update
// the reference.
T *elt_ptr = &elt;
if (i <= elt_ptr && elt_ptr < this->end_x_) ++elt_ptr;
*i = ::std::move(*elt_ptr);
return i;
}
iterator insert(iterator i, const T &elt) {
if (i == this->end()) { // Important special case for empty vector.
this->push_back(elt);
return this->end() - 1;
}
assert(i >= this->begin() && "Insertion iterator is out of bounds.");
assert(i <= this->end() && "Inserting past the end of the vector.");
if (this->end_x_ >= this->capacity_x_) {
size_t elt_no = i - this->begin();
this->Grow();
i = this->begin() + elt_no;
}
::new ((void *)this->end()) T(std::move(this->back()));
// Push everything else over.
std::move_backward(i, this->end() - 1, this->end());
this->SetEnd(this->end() + 1);
// If we just moved the element we're inserting, be sure to update
// the reference.
const T *elt_ptr = &elt;
if (i <= elt_ptr && elt_ptr < this->end_x_) ++elt_ptr;
*i = *elt_ptr;
return i;
}
iterator insert(iterator i, size_type num_to_insert, const T &elt) {
// Convert iterator to elt# to avoid invalidating iterator when we reserve()
size_t insert_elt = i - this->begin();
if (i == this->end()) { // Important special case for empty vector.
append(num_to_insert, elt);
return this->begin() + insert_elt;
}
assert(i >= this->begin() && "Insertion iterator is out of bounds.");
assert(i <= this->end() && "Inserting past the end of the vector.");
// Ensure there is enough space.
reserve(this->size() + num_to_insert);
// Uninvalidate the iterator.
i = this->begin() + insert_elt;
// If there are more elements between the insertion point and the end of the
// range than there are being inserted, we can use a simple approach to
// insertion. Since we already reserved space, we know that this won't
// reallocate the vector.
if (size_t(this->end() - i) >= num_to_insert) {
T *old_end = this->end();
append(std::move_iterator<iterator>(this->end() - num_to_insert),
std::move_iterator<iterator>(this->end()));
// Copy the existing elements that get replaced.
std::move_backward(i, old_end - num_to_insert, old_end);
std::fill_n(i, num_to_insert, elt);
return i;
}
// Otherwise, we're inserting more elements than exist already, and we're
// not inserting at the end.
// Move over the elements that we're about to overwrite.
T *old_end = this->end();
this->SetEnd(this->end() + num_to_insert);
size_t num_overwritten = old_end - i;
this->UninitializedMove(i, old_end, this->end() - num_overwritten);
// Replace the overwritten part.
std::fill_n(i, num_overwritten, elt);
// Insert the non-overwritten middle part.
std::uninitialized_fill_n(old_end, num_to_insert - num_overwritten, elt);
return i;
}
template <typename TIt>
iterator insert(iterator i, TIt from, TIt to) {
// Convert iterator to elt# to avoid invalidating iterator when we reserve()
size_t insert_elt = i - this->begin();
if (i == this->end()) { // Important special case for empty vector.
append(from, to);
return this->begin() + insert_elt;
}
assert(i >= this->begin() && "Insertion iterator is out of bounds.");
assert(i <= this->end() && "Inserting past the end of the vector.");
size_t num_to_insert = std::distance(from, to);
// Ensure there is enough space.
reserve(this->size() + num_to_insert);
// Uninvalidate the iterator.
i = this->begin() + insert_elt;
// If there are more elements between the insertion point and the end of the
// range than there are being inserted, we can use a simple approach to
// insertion. Since we already reserved space, we know that this won't
// reallocate the vector.
if (size_t(this->end() - i) >= num_to_insert) {
T *old_end = this->end();
append(std::move_iterator<iterator>(this->end() - num_to_insert),
std::move_iterator<iterator>(this->end()));
// Copy the existing elements that get replaced.
std::move_backward(i, old_end - num_to_insert, old_end);
std::copy(from, to, i);
return i;
}
// Otherwise, we're inserting more elements than exist already, and we're
// not inserting at the end.
// Move over the elements that we're about to overwrite.
T *old_end = this->end();
this->SetEnd(this->end() + num_to_insert);
size_t num_overwritten = old_end - i;
this->UninitializedMove(i, old_end, this->end() - num_overwritten);
// Replace the overwritten part.
for (T *j = i; num_overwritten > 0; --num_overwritten) {
*j = *from;
++j;
++from;
}
// Insert the non-overwritten middle part.
this->UninitializedCopy(from, to, old_end);
return i;
}
void insert(iterator i, std::initializer_list<T> il) {
insert(i, il.begin(), il.end());
}
template <typename... TArgTypes>
void emplace_back(TArgTypes &&... args) {
if (UNLIKELY(this->end_x_ >= this->capacity_x_)) this->Grow();
::new ((void *)this->end()) T(std::forward<TArgTypes>(args)...);
this->SetEnd(this->end() + 1);
}
SmallVectorImpl &operator=(const SmallVectorImpl &rhs);
SmallVectorImpl &operator=(SmallVectorImpl &&rhs);
bool operator==(const SmallVectorImpl &rhs) const {
if (this->size() != rhs.size()) return false;
return std::equal(this->begin(), this->end(), rhs.begin());
}
bool operator!=(const SmallVectorImpl &rhs) const { return !(*this == rhs); }
bool operator<(const SmallVectorImpl &rhs) const {
return std::lexicographical_compare(this->begin(), this->end(), rhs.begin(),
rhs.end());
}
/// Set the array size to \p n, which the current array must have enough
/// capacity for.
///
/// This does not construct or destroy any elements in the vector.
///
/// Clients can use this in conjunction with capacity() to write past the end
/// of the buffer when they know that more elements are available, and only
/// update the size later. This avoids the cost of value initializing elements
/// which will only be overwritten.
void set_size(size_type n) {
assert(n <= this->capacity());
this->SetEnd(this->begin() + n);
}
};
template <typename T>
void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &rhs) {
if (this == &rhs) return;
// We can only avoid copying elements if neither vector is small.
if (!this->IsSmall() && !rhs.IsSmall()) {
std::swap(this->begin_x_, rhs.begin_x_);
std::swap(this->end_x_, rhs.end_x_);
std::swap(this->capacity_x_, rhs.capacity_x_);
return;
}
if (rhs.size() > this->capacity()) this->Grow(rhs.size());
if (this->size() > rhs.capacity()) rhs.Grow(this->size());
// Swap the shared elements.
size_t num_shared = this->size();
if (num_shared > rhs.size()) num_shared = rhs.size();
for (size_type i = 0; i != num_shared; ++i) std::swap((*this)[i], rhs[i]);
// Copy over the extra elts.
if (this->size() > rhs.size()) {
size_t elt_diff = this->size() - rhs.size();
this->UninitializedCopy(this->begin() + num_shared, this->end(), rhs.end());
rhs.SetEnd(rhs.end() + elt_diff);
this->DestroyRange(this->begin() + num_shared, this->end());
this->SetEnd(this->begin() + num_shared);
} else if (rhs.size() > this->size()) {
size_t elt_diff = rhs.size() - this->size();
this->UninitializedCopy(rhs.begin() + num_shared, rhs.end(), this->end());
this->SetEnd(this->end() + elt_diff);
this->DestroyRange(rhs.begin() + num_shared, rhs.end());
rhs.SetEnd(rhs.begin() + num_shared);
}
}
template <typename T>
SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(
const SmallVectorImpl<T> &rhs) {
// Avoid self-assignment.
if (this == &rhs) return *this;
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t rhh_size = rhs.size();
size_t cur_size = this->size();
if (cur_size >= rhh_size) {
// Assign common elements.
iterator new_end;
if (rhh_size)
new_end = std::copy(rhs.begin(), rhs.begin() + rhh_size, this->begin());
else
new_end = this->begin();
// Destroy excess elements.
this->DestroyRange(new_end, this->end());
// Trim.
this->SetEnd(new_end);
return *this;
}
// If we have to Grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the Grow.
// FIXME: don't do this if they're efficiently moveable.
if (this->capacity() < rhh_size) {
// Destroy current elements.
this->DestroyRange(this->begin(), this->end());
this->SetEnd(this->begin());
cur_size = 0;
this->Grow(rhh_size);
} else if (cur_size) {
// Otherwise, use assignment for the already-constructed elements.
std::copy(rhs.begin(), rhs.begin() + cur_size, this->begin());
}
// Copy construct the new elements in place.
this->UninitializedCopy(rhs.begin() + cur_size, rhs.end(),
this->begin() + cur_size);
// Set end.
this->SetEnd(this->begin() + rhh_size);
return *this;
}
template <typename T>
SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&rhs) {
// Avoid self-assignment.
if (this == &rhs) return *this;
// If the rhs isn't small, clear this vector and then steal its buffer.
if (!rhs.IsSmall()) {
this->DestroyRange(this->begin(), this->end());
if (!this->IsSmall()) free(this->begin());
this->begin_x_ = rhs.begin_x_;
this->end_x_ = rhs.end_x_;
this->capacity_x_ = rhs.capacity_x_;
rhs.ResetToSmall();
return *this;
}
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t rhh_size = rhs.size();
size_t cur_size = this->size();
if (cur_size >= rhh_size) {
// Assign common elements.
iterator new_end = this->begin();
if (rhh_size) new_end = std::move(rhs.begin(), rhs.end(), new_end);
// Destroy excess elements and trim the bounds.
this->DestroyRange(new_end, this->end());
this->SetEnd(new_end);
// Clear the rhs.
rhs.clear();
return *this;
}
// If we have to Grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the Grow.
// FIXME: this may not actually make any sense if we can efficiently move
// elements.
if (this->capacity() < rhh_size) {
// Destroy current elements.
this->DestroyRange(this->begin(), this->end());
this->SetEnd(this->begin());
cur_size = 0;
this->Grow(rhh_size);
} else if (cur_size) {
// Otherwise, use assignment for the already-constructed elements.
std::move(rhs.begin(), rhs.begin() + cur_size, this->begin());
}
// Move-construct the new elements in place.
this->UninitializedMove(rhs.begin() + cur_size, rhs.end(),
this->begin() + cur_size);
// Set end.
this->SetEnd(this->begin() + rhh_size);
rhs.clear();
return *this;
}
/// Storage for the SmallVector elements which aren't contained in
/// SmallVectorTemplateCommon. There are 'n-1' elements here. The remaining '1'
/// element is in the base class. This is specialized for the n=1 and n=0 cases
/// to avoid allocating unnecessary storage.
template <typename T, unsigned N>
struct SmallVectorStorage {
typename SmallVectorTemplateCommon<T>::U InlineElts[N - 1];
};
template <typename T>
struct SmallVectorStorage<T, 1> {};
template <typename T>
struct SmallVectorStorage<T, 0> {};
/// This is a 'vector' (really, a variable-sized array), optimized
/// for the case when the array is small. It contains some number of elements
/// in-place, which allows it to avoid heap allocation when the actual number of
/// elements is below that threshold. This allows normal "small" cases to be
/// fast without losing generality for large inputs.
///
/// Note that this does not attempt to be exception safe.
///
template <typename T, unsigned N>
class SmallVector : public SmallVectorImpl<T> {
/// Inline space for elements which aren't stored in the base class.
SmallVectorStorage<T, N> Storage;
public:
SmallVector() : SmallVectorImpl<T>(N) {}
explicit SmallVector(size_t size, const T &value = T())
: SmallVectorImpl<T>(N) {
this->assign(size, value);
}
template <typename TIt>
SmallVector(TIt s, TIt e) : SmallVectorImpl<T>(N) {
this->append(s, e);
}
SmallVector(std::initializer_list<T> il) : SmallVectorImpl<T>(N) {
this->assign(il);
}
SmallVector(const SmallVector &rhs) : SmallVectorImpl<T>(N) {
if (!rhs.empty()) SmallVectorImpl<T>::operator=(rhs);
}
const SmallVector &operator=(const SmallVector &rhs) {
SmallVectorImpl<T>::operator=(rhs);
return *this;
}
SmallVector(SmallVector &&rhs) : SmallVectorImpl<T>(N) {
if (!rhs.empty()) SmallVectorImpl<T>::operator=(::std::move(rhs));
}
const SmallVector &operator=(SmallVector &&rhs) {
SmallVectorImpl<T>::operator=(::std::move(rhs));
return *this;
}
SmallVector(SmallVectorImpl<T> &&rhs) : SmallVectorImpl<T>(N) {
if (!rhs.empty()) SmallVectorImpl<T>::operator=(::std::move(rhs));
}
const SmallVector &operator=(SmallVectorImpl<T> &&rhs) {
SmallVectorImpl<T>::operator=(::std::move(rhs));
return *this;
}
const SmallVector &operator=(std::initializer_list<T> il) {
this->assign(il);
return *this;
}
};
template <typename T, unsigned N>
static inline size_t capacity_in_bytes(const SmallVector<T, N> &x) {
return x.capacity_in_bytes();
}
} // End utils namespace
namespace std {
/// Implement std::swap in terms of SmallVector swap.
template <typename T>
inline void swap(utils::SmallVectorImpl<T> &lhs,
utils::SmallVectorImpl<T> &rhs) {
lhs.swap(rhs);
}
/// Implement std::swap in terms of SmallVector swap.
template <typename T, unsigned N>
inline void swap(utils::SmallVector<T, N> &lhs, utils::SmallVector<T, N> &rhs) {
lhs.swap(rhs);
}
}
namespace utils {
/// GrowPod - This is an implementation of the Grow() method which only works
/// on POD-like datatypes and is out of line to reduce code duplication.
inline void SmallVectorBase::GrowPod(void *first_el, size_t min_size_in_bytes,
size_t t_size) {
size_t cur_size_btyes = size_in_bytes();
size_t new_capacity_in_bytes =
2 * capacity_in_bytes() + t_size; // Always Grow.
if (new_capacity_in_bytes < min_size_in_bytes)
new_capacity_in_bytes = min_size_in_bytes;
void *new_elts;
if (begin_x_ == first_el) {
new_elts = malloc(new_capacity_in_bytes);
// Copy the elements over. No need to run dtors on PODs.
memcpy(new_elts, this->begin_x_, cur_size_btyes);
} else {
// If this wasn't grown from the inline copy, Grow the allocated space.
new_elts = realloc(this->begin_x_, new_capacity_in_bytes);
}
assert(new_elts && "Out of memory");
this->end_x_ = (char *)new_elts + cur_size_btyes;
this->begin_x_ = new_elts;
this->capacity_x_ = (char *)this->begin_x_ + new_capacity_in_bytes;
}
}

3
tests/unit/CMakeLists.txt
View File

@ -222,6 +222,9 @@ target_link_libraries(${test_prefix}slk_advanced mg-single-node kvstore_dummy_li
add_unit_test(slk_core.cpp)
target_link_libraries(${test_prefix}slk_core glog gflags)
add_unit_test(small_vector.cpp)
target_link_libraries(${test_prefix}small_vector mg-utils)
add_unit_test(state_delta.cpp)
target_link_libraries(${test_prefix}state_delta mg-single-node kvstore_dummy_lib)

308
tests/unit/small_vector.cpp Normal file
View File

@ -0,0 +1,308 @@
#include <atomic>
#include <chrono>
#include <experimental/optional>
#include <string>
#include <thread>
#include <utility>
#include <vector>
#include "gtest/gtest.h"
#include "utils/small_vector.hpp"
TEST(SmallVector, BasicTest) {
const int kMaxElements = 10;
utils::SmallVector<int, kMaxElements> small_vector;
for (int i = 0; i < kMaxElements; ++i) {
small_vector.push_back(i);
}
for (int i = 0; i < kMaxElements; ++i) {
EXPECT_EQ(small_vector[i], i);
}
}
TEST(SmallVector, Clear) {
const int kMaxElements = 10;
utils::SmallVector<int, kMaxElements> small_vector;
for (int i = 0; i < kMaxElements + 1; ++i) {
small_vector.push_back(i);
}
auto capacity = small_vector.capacity();
EXPECT_EQ(small_vector.size(), kMaxElements + 1);
small_vector.clear();
EXPECT_EQ(small_vector.size(), 0);
EXPECT_EQ(capacity, small_vector.capacity());
}
TEST(SmallVector, Resize) {
const int kSmallStorageSize = 5;
const int kTwiceTheSmallStorage = 2 * kSmallStorageSize;
const int kSomeRandomConst = 505;
utils::SmallVector<int, kSmallStorageSize> small_vector;
for (int i = 0; i < kTwiceTheSmallStorage; ++i) {
small_vector.push_back(i);
}
EXPECT_EQ(small_vector.size(), kTwiceTheSmallStorage);
small_vector.resize(kSmallStorageSize);
EXPECT_EQ(small_vector.size(), kSmallStorageSize);
small_vector.resize(kTwiceTheSmallStorage, kSomeRandomConst);
for (int i = kSmallStorageSize; i < kTwiceTheSmallStorage; ++i)
EXPECT_EQ(small_vector[i], kSomeRandomConst);
}
TEST(SmallVector, Reserve) {
const int kMaxElements = 1000;
const int kMaxElementsAfter = 1000;
utils::SmallVector<int, kMaxElements> small_vector;
EXPECT_EQ(small_vector.capacity(), kMaxElements);
small_vector.reserve(kMaxElementsAfter);
EXPECT_EQ(small_vector.capacity(), kMaxElementsAfter);
small_vector.reserve(1);
EXPECT_EQ(small_vector.capacity(), kMaxElementsAfter);
}
TEST(SmallVector, PopBackVal) {
const int kMaxElements = 10;
utils::SmallVector<std::string, kMaxElements> small_vector;
for (int i = 0; i < kMaxElements; ++i) {
small_vector.push_back(std::to_string(i));
}
for (int i = kMaxElements - 1; i >= 0; --i) {
EXPECT_EQ(small_vector.pop_back_val(), std::to_string(i));
}
EXPECT_EQ(small_vector.size(), 0);
}
TEST(SmallVector, Swap) {
const int kSize1 = 10;
const int kSize2 = 1000;
utils::SmallVector<int, kSize1> vector1;
utils::SmallVector<int, kSize2> vector2;
utils::SmallVector<int, kSize1> vector3;
utils::SmallVector<int, kSize2> vector4;
utils::SmallVector<int, kSize2> ref_vector1;
utils::SmallVector<int, kSize2> ref_vector2;
utils::SmallVector<int, kSize2> ref_vector3;
utils::SmallVector<int, kSize2> ref_vector4;
for (int i = 0; i < kSize1; ++i) {
int value = i % 3;
ref_vector1.push_back(value);
vector1.push_back(value);
ref_vector3.push_back(value + 1);
vector3.push_back(value + 1);
}
for (int i = 0; i < 2 * kSize2; ++i) {
ref_vector2.push_back(i);
vector2.push_back(i);
ref_vector4.push_back(i + 1);
vector4.push_back(i + 1);
}
EXPECT_EQ(ref_vector1, vector1);
EXPECT_EQ(ref_vector2, vector2);
EXPECT_EQ(ref_vector3, vector3);
EXPECT_EQ(ref_vector4, vector4);
EXPECT_NE(vector1, vector2);
EXPECT_NE(vector3, vector4);
vector1.swap(vector2);
vector4.swap(vector3);
EXPECT_EQ(ref_vector1, vector2);
EXPECT_EQ(ref_vector2, vector1);
EXPECT_EQ(ref_vector3, vector4);
EXPECT_EQ(ref_vector4, vector3);
}
TEST(SmallVector, Append1) {
const int kMaxElements = 100;
const int kSize = 10;
std::vector<int> test_vector;
for (int i = 0; i < kMaxElements; ++i) {
test_vector.push_back(i);
}
utils::SmallVector<int, kSize> small_vector = {20};
small_vector.append(test_vector.begin(), test_vector.end());
EXPECT_EQ(20, small_vector[0]);
for (int i = 0; i < kMaxElements; ++i) {
EXPECT_EQ(test_vector[i], small_vector[i + 1]);
}
}
TEST(SmallVector, Append2) {
const int kSize = 10;
const std::string kElement = "dolje na koljena, reci mi moja voljena";
utils::SmallVector<std::string, 0> test_vector(kSize, kElement);
utils::SmallVector<std::string, kSize> small_vector;
small_vector.append(kSize, kElement);
EXPECT_EQ(small_vector.size(), kSize);
EXPECT_EQ(test_vector, small_vector);
}
TEST(SmallVector, Append3) {
const int kSize = 3;
utils::SmallVector<int, kSize> test_vector = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5};
utils::SmallVector<int, kSize> small_vector = {1, 2, 3, 4, 5};
small_vector.append({1, 2, 3, 4, 5});
EXPECT_EQ(test_vector, small_vector);
}
TEST(SmallVector, Assign1) {
const int kSize = 3;
const int kElemNum = 100;
const std::string kElement = "brate samo loudam malo toga sejvam";
utils::SmallVector<std::string, kSize> test_vector;
utils::SmallVector<std::string, kSize> small_vector = {"a", "b", "c",
"d", "e", "f"};
for (int i = 0; i < kElemNum; ++i) {
test_vector.push_back(kElement);
}
small_vector.assign(100, kElement);
EXPECT_EQ(test_vector, small_vector);
}
TEST(SmallVector, Assign2) {
const int kSize = 3;
const std::string kElement = "preko tjedna gospoda";
utils::SmallVector<std::string, kSize> test_vector = {kElement};
utils::SmallVector<std::string, kSize> small_vector = {"a", "b", "c",
"d", "e", "f"};
small_vector.assign({kElement});
EXPECT_EQ(test_vector, small_vector);
}
TEST(SmallVector, Erase) {
const int kSize = 3;
utils::SmallVector<std::string, kSize> small_vector = {"a", "b", "c",
"d", "e", "f"};
small_vector.erase(small_vector.begin() + 1, small_vector.end());
EXPECT_EQ(1, small_vector.size());
EXPECT_EQ("a", small_vector[0]);
small_vector.erase(small_vector.begin());
EXPECT_EQ(0, small_vector.size());
}
TEST(SmallVector, Insert) {
const int kSize = 3;
const std::string kXXX = "xxx";
utils::SmallVector<std::string, kSize> test_vector = {"1", "2", "3", "4",
"5"};
utils::SmallVector<std::string, kSize> small_vector = {"a", "b", "c",
"d", "e", "f"};
small_vector.insert(small_vector.begin(), kXXX);
EXPECT_EQ(kXXX, small_vector[0]);
small_vector.insert(small_vector.begin() + 1, test_vector.begin(),
test_vector.end());
for (int i = 0; i < 5; ++i) {
EXPECT_EQ(test_vector[i], small_vector[i + 1]);
}
small_vector.insert(small_vector.end(), 10, kXXX);
for (int i = small_vector.size() - 1; i >= small_vector.size() - 10; --i) {
EXPECT_EQ(kXXX, small_vector[i]);
}
small_vector.insert(small_vector.begin(), {"www", "abc"});
EXPECT_EQ("www", small_vector[0]);
EXPECT_EQ("abc", small_vector[1]);
}
TEST(SmallVector, EmplaceBack) {
const int kSize = 3;
utils::SmallVector<std::string, kSize> small_vector = {"a", "b", "c",
"d", "e", "f"};
small_vector.emplace_back("g");
EXPECT_EQ("g", small_vector.back());
}
TEST(SmallVector, PushPopBack) {
const int kSize = 3;
const int kElemNum = 10000;
utils::SmallVector<int, kSize> small_vector;
EXPECT_EQ(0, small_vector.size());
for (int i = 0; i < kElemNum; ++i) {
small_vector.push_back(i);
}
EXPECT_EQ(kElemNum, small_vector.size());
for (int i = 0; i < kElemNum; ++i) {
small_vector.pop_back();
}
EXPECT_EQ(0, small_vector.size());
}
TEST(SmallVector, Capacity) {
const int kSize = 3;
const int kElemNum = 10000;
utils::SmallVector<int, kSize> small_vector;
EXPECT_EQ(0, small_vector.size());
EXPECT_EQ(3, small_vector.capacity());
for (int i = 0; i < kElemNum; ++i) {
small_vector.push_back(i);
}
EXPECT_EQ(kElemNum, small_vector.size());
EXPECT_LE(kElemNum, small_vector.capacity());
}
TEST(SmallVector, Data) {
const int kSize = 3;
const int kElemNum = 100;
utils::SmallVector<int, kSize> small_vector;
for (int i = 0; i < kElemNum; ++i) {
small_vector.push_back(i);
}
int *p = small_vector.data();
for (int i = 0; i < kElemNum; ++i) {
EXPECT_EQ(i, *(p + i));
}
}
TEST(SmallVector, Empty) {
const int kSize = 3;
const int kElemNum = 10000;
utils::SmallVector<int, kSize> small_vector;
EXPECT_TRUE(small_vector.empty());
for (int i = 0; i < kElemNum; ++i) {
small_vector.push_back(i);
}
EXPECT_FALSE(small_vector.empty());
for (int i = 0; i < kElemNum; ++i) {
small_vector.pop_back();
}
EXPECT_TRUE(small_vector.empty());
}
TEST(SmallVector, Operators) {
const int kSize = 3;
const int kElemNum = 10000;
utils::SmallVector<int, kSize> small_vector_1;
utils::SmallVector<int, kSize> small_vector_2;
for (int i = 0; i < kElemNum; ++i) {
small_vector_1.push_back(i);
small_vector_2.push_back(i + 1);
}
EXPECT_NE(small_vector_1, small_vector_2);
EXPECT_FALSE(small_vector_1 == small_vector_2);
EXPECT_TRUE(small_vector_1 < small_vector_2);
}