454 lines
16 KiB
C++
454 lines
16 KiB
C++
/*
|
|
Copyright (c) 2013 Microsoft Corporation. All rights reserved.
|
|
Released under Apache 2.0 license as described in the file LICENSE.
|
|
|
|
Author: Leonardo de Moura
|
|
*/
|
|
#pragma once
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include "util/rc.h"
|
|
|
|
#ifndef LEAN_PVECTOR_MIN_QUOTA
|
|
#define LEAN_PVECTOR_MIN_QUOTA 16
|
|
#endif
|
|
|
|
namespace lean {
|
|
/**
|
|
\brief Vector with O(1) copy operation.
|
|
We call it pvector because it can be used to simulate persistent vectors.
|
|
*/
|
|
template<typename T>
|
|
class pvector {
|
|
enum class cell_kind { PushBack, PopBack, Set, Root };
|
|
|
|
/**
|
|
\brief Base class for representing the data.
|
|
We have two kinds of data: delta and root (the actual vector).
|
|
The deltas store changes to shared vectors.
|
|
*/
|
|
struct cell {
|
|
cell_kind m_kind;
|
|
MK_LEAN_RC();
|
|
cell(cell_kind k):m_kind(k), m_rc(0) {}
|
|
cell(cell const & c):m_kind(c.m_kind), m_rc(0) {}
|
|
void dealloc();
|
|
unsigned size() const;
|
|
/**
|
|
\brief Return the quota for a cell. When the quota of cell reaches 0, then we perform a deep copy.
|
|
*/
|
|
unsigned quota() const;
|
|
cell_kind kind() const { return m_kind; }
|
|
};
|
|
|
|
/**
|
|
\brief Cell for wrapping std::vector
|
|
*/
|
|
struct root_cell : public cell {
|
|
std::vector<T> m_vector;
|
|
root_cell():cell(cell_kind::Root) {}
|
|
};
|
|
|
|
/**
|
|
\brief Base class for storing non-destructive updates: Push, Pop, Set.
|
|
\remark We can view delta_cell's as delayed operations.
|
|
*/
|
|
struct delta_cell : public cell {
|
|
unsigned m_size;
|
|
unsigned m_quota;
|
|
cell * m_prev;
|
|
delta_cell(cell_kind k, unsigned sz, cell * prev):cell(k), m_size(sz), m_quota(prev->quota() - 1), m_prev(prev) {
|
|
lean_assert(m_prev);
|
|
m_prev->inc_ref();
|
|
}
|
|
delta_cell(delta_cell const & c):cell(c), m_size(c.m_size), m_quota(c.m_quota), m_prev(c.m_prev) {
|
|
lean_assert(m_prev);
|
|
m_prev->inc_ref();
|
|
}
|
|
~delta_cell() { lean_assert(m_prev); m_prev->dec_ref(); }
|
|
};
|
|
|
|
/**
|
|
\brief Cell for representing the vector obtained by removing the last element from
|
|
the vector represented by \c prev.
|
|
*/
|
|
struct pop_cell : public delta_cell {
|
|
pop_cell(cell * prev):delta_cell(cell_kind::PopBack, prev->size() - 1, prev) {}
|
|
pop_cell(pop_cell const & c):delta_cell(c) {}
|
|
};
|
|
|
|
/**
|
|
\brief Cell for representing the vector obtained by adding \c v
|
|
to the vector represented by \c prev.
|
|
*/
|
|
struct push_cell : public delta_cell {
|
|
T m_val;
|
|
push_cell(T const & v, cell * prev):delta_cell(cell_kind::PushBack, prev->size() + 1, prev), m_val(v) {}
|
|
push_cell(push_cell const & c):delta_cell(c), m_val(c.m_val) {}
|
|
};
|
|
|
|
/**
|
|
\brief Cell for representing the vector obtained by updating position \c i with value \c v
|
|
in the the vector represented by \c prev.
|
|
*/
|
|
struct set_cell : public delta_cell {
|
|
unsigned m_idx;
|
|
T m_val;
|
|
set_cell(unsigned i, T const & v, cell * prev):delta_cell(cell_kind::Set, prev->size(), prev), m_idx(i), m_val(v) {}
|
|
set_cell(set_cell const & c):delta_cell(c), m_idx(c.m_idx), m_val(c.m_val) {}
|
|
};
|
|
|
|
static push_cell & to_push(cell * c) { lean_assert(c->kind() == cell_kind::PushBack); return *static_cast<push_cell*>(c); }
|
|
static push_cell const & to_push(cell const * c) { lean_assert(c->kind() == cell_kind::PushBack); return *static_cast<push_cell const *>(c); }
|
|
static pop_cell & to_pop(cell * c) { lean_assert(c->kind() == cell_kind::PopBack); return *static_cast<pop_cell*>(c); }
|
|
static pop_cell const & to_pop(cell const * c) { lean_assert(c->kind() == cell_kind::PopBack); return *static_cast<pop_cell const *>(c); }
|
|
static set_cell & to_set(cell * c) { lean_assert(c->kind() == cell_kind::Set); return *static_cast<set_cell*>(c); }
|
|
static set_cell const & to_set(cell const * c) { lean_assert(c->kind() == cell_kind::Set); return *static_cast<set_cell const *>(c); }
|
|
static root_cell & to_root(cell * c) { lean_assert(c->kind() == cell_kind::Root); return *static_cast<root_cell*>(c); }
|
|
static root_cell const & to_root(cell const * c) { lean_assert(c->kind() == cell_kind::Root); return *static_cast<root_cell const *>(c); }
|
|
|
|
cell * m_ptr;
|
|
pvector(cell * d):m_ptr(d) { lean_assert(m_ptr); m_ptr->inc_ref(); }
|
|
|
|
/** \brief Return true iff the cell associated with this vector is shared */
|
|
bool is_shared() const { return m_ptr->get_rc() > 1; }
|
|
|
|
/** \brief Update the cell (and reference counters) of this vector */
|
|
void update_cell(cell * new_cell) {
|
|
lean_assert(new_cell);
|
|
lean_assert(m_ptr);
|
|
new_cell->inc_ref();
|
|
m_ptr->dec_ref();
|
|
m_ptr = new_cell;
|
|
}
|
|
|
|
/**
|
|
\brief Auxiliary method for \c flat
|
|
Given an empty vector \c r, then <tt>flat_core(c, r)</tt> will
|
|
store in r the vector represented by cell \c c.
|
|
That is, the vector obtained after finding the root cell (aka wrapper for std::vector),
|
|
and applying all deltas.
|
|
*/
|
|
static void flat_core(cell * c, std::vector<T> & r) {
|
|
lean_assert(r.empty());
|
|
switch (c->kind()) {
|
|
case cell_kind::PushBack:
|
|
flat_core(to_push(c).m_prev, r);
|
|
r.push_back(to_push(c).m_val);
|
|
break;
|
|
case cell_kind::PopBack:
|
|
flat_core(to_pop(c).m_prev, r);
|
|
r.pop_back();
|
|
break;
|
|
case cell_kind::Set:
|
|
flat_core(to_set(c).m_prev, r);
|
|
r[to_set(c).m_idx] = to_set(c).m_val;
|
|
break;
|
|
case cell_kind::Root:
|
|
r = to_root(c).m_vector;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Change the representation to a root cell.
|
|
*/
|
|
void flat() {
|
|
lean_assert(m_ptr->kind() != cell_kind::Root);
|
|
std::vector<T> r;
|
|
flat_core(m_ptr, r);
|
|
update_cell(new root_cell());
|
|
to_root(m_ptr).m_vector.swap(r);
|
|
lean_assert(!is_shared());
|
|
}
|
|
|
|
/**
|
|
\brief If the quota associated with m_cell is zero, then
|
|
compute a flat representation. That is, represent the vector
|
|
using a single root_cell.
|
|
*/
|
|
void flat_if_needed() {
|
|
lean_assert(m_ptr->kind() != cell_kind::Root);
|
|
if (static_cast<delta_cell*>(m_ptr)->m_quota == 0) {
|
|
flat();
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Update quota based on the cost of a read
|
|
Return true if the quota was updated, and false
|
|
if the representation had to be updated.
|
|
*/
|
|
bool update_quota_on_read(unsigned cost) {
|
|
cost /= 2; // reads are cheaper than writes
|
|
if (cost > 0) {
|
|
if (cost >= m_ptr->quota()) {
|
|
flat();
|
|
return false;
|
|
} else {
|
|
if (is_shared()) {
|
|
switch (m_ptr->kind()) {
|
|
case cell_kind::PushBack: update_cell(new push_cell(to_push(m_ptr))); break;
|
|
case cell_kind::PopBack: update_cell(new pop_cell(to_pop(m_ptr))); break;
|
|
case cell_kind::Set: update_cell(new set_cell(to_set(m_ptr))); break;
|
|
case cell_kind::Root: lean_unreachable(); break;
|
|
}
|
|
}
|
|
lean_assert(!is_shared());
|
|
lean_assert(cost < static_cast<delta_cell*>(m_ptr)->m_quota);
|
|
static_cast<delta_cell*>(m_ptr)->m_quota -= cost;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void pop_back_core() { update_cell(new pop_cell(m_ptr)); }
|
|
|
|
void push_back_core(T const & v) { update_cell(new push_cell(v, m_ptr)); }
|
|
|
|
void set_core(unsigned i, T const & v) { update_cell(new set_cell(i, v, m_ptr)); }
|
|
|
|
bool is_root() const { return m_ptr->kind() == cell_kind::Root; }
|
|
|
|
public:
|
|
pvector():m_ptr(new root_cell()) { m_ptr->inc_ref(); }
|
|
pvector(pvector const & s):m_ptr(s.m_ptr) { m_ptr->inc_ref(); }
|
|
pvector(pvector && s):m_ptr(s.m_ptr) { s.m_ptr = nullptr; }
|
|
~pvector() { if (m_ptr) m_ptr->dec_ref(); }
|
|
|
|
pvector & operator=(pvector const & s) { LEAN_COPY_REF(pvector, s); }
|
|
pvector & operator=(pvector && s) { LEAN_MOVE_REF(pvector, s); }
|
|
|
|
/** \brief Return the number of elements */
|
|
unsigned size() const { return m_ptr->size(); }
|
|
|
|
/** \brief Check whether the container is empty */
|
|
bool empty() const { return size() == 0; }
|
|
|
|
/**
|
|
\brief Access specified element
|
|
\pre i < size()
|
|
*/
|
|
T const & get(unsigned i) const {
|
|
lean_assert(i < size());
|
|
cell const * it = m_ptr;
|
|
unsigned cost = 0;
|
|
while (true) {
|
|
switch (it->kind()) {
|
|
case cell_kind::PushBack:
|
|
if (i + 1 == to_push(it).m_size) {
|
|
if (const_cast<pvector*>(this)->update_quota_on_read(cost))
|
|
return to_push(it).m_val;
|
|
else
|
|
return get(i); // representation was changed, \c it may have been deleted
|
|
}
|
|
break;
|
|
case cell_kind::PopBack:
|
|
break;
|
|
case cell_kind::Set:
|
|
if (to_set(it).m_idx == i) {
|
|
if (const_cast<pvector*>(this)->update_quota_on_read(cost))
|
|
return to_set(it).m_val;
|
|
else
|
|
return get(i); // representation was changed, \c it may have been deleted
|
|
}
|
|
break;
|
|
case cell_kind::Root:
|
|
if (const_cast<pvector*>(this)->update_quota_on_read(cost))
|
|
return to_root(it).m_vector[i];
|
|
else
|
|
return get(i); // representation was changed, \c it may have been deleted
|
|
}
|
|
it = static_cast<delta_cell const *>(it)->m_prev;
|
|
cost++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Return the last element in the vector
|
|
\pre !empty()
|
|
*/
|
|
T const & back() const {
|
|
lean_assert(!empty());
|
|
return operator[](size() - 1);
|
|
}
|
|
|
|
/**
|
|
\brief Add an element to the end of the vector
|
|
*/
|
|
void push_back(T const & v) {
|
|
if (!is_root())
|
|
flat_if_needed();
|
|
switch (m_ptr->kind()) {
|
|
case cell_kind::PushBack: case cell_kind::Set: case cell_kind::PopBack:
|
|
push_back_core(v);
|
|
break;
|
|
case cell_kind::Root:
|
|
if (!is_shared())
|
|
to_root(m_ptr).m_vector.push_back(v);
|
|
else
|
|
push_back_core(v);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Remove the last element
|
|
\pre !empty()
|
|
*/
|
|
void pop_back() {
|
|
lean_assert(!empty());
|
|
if (!is_root())
|
|
flat_if_needed();
|
|
switch (m_ptr->kind()) {
|
|
case cell_kind::PushBack:
|
|
update_cell(to_push(m_ptr).m_prev);
|
|
break;
|
|
case cell_kind::Set: case cell_kind::PopBack:
|
|
pop_back_core();
|
|
break;
|
|
case cell_kind::Root:
|
|
if (!is_shared())
|
|
to_root(m_ptr).m_vector.pop_back();
|
|
else
|
|
pop_back_core();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Update position \c i with value \c v
|
|
\pre i < size()
|
|
*/
|
|
void set(unsigned i, T const & v) {
|
|
lean_assert(i < size());
|
|
if (!is_root())
|
|
flat_if_needed();
|
|
switch (m_ptr->kind()) {
|
|
case cell_kind::PushBack:
|
|
case cell_kind::PopBack:
|
|
set_core(i, v);
|
|
break;
|
|
case cell_kind::Set:
|
|
if (!is_shared() && i == to_set(m_ptr).m_idx)
|
|
to_set(m_ptr).m_val = v;
|
|
else
|
|
set_core(i, v);
|
|
break;
|
|
case cell_kind::Root:
|
|
if (!is_shared())
|
|
to_root(m_ptr).m_vector[i] = v;
|
|
else
|
|
set_core(i, v);
|
|
break;
|
|
}
|
|
}
|
|
|
|
class ref {
|
|
pvector & m_vector;
|
|
unsigned m_idx;
|
|
public:
|
|
ref(pvector & v, unsigned i):m_vector(v), m_idx(i) {}
|
|
ref & operator=(T const & a) { m_vector.set(m_idx, a); return *this; }
|
|
operator T const &() const { return m_vector.get(m_idx); }
|
|
};
|
|
|
|
T const & operator[](unsigned i) const { return get(i); }
|
|
|
|
ref operator[](unsigned i) { return ref(*this, i); }
|
|
|
|
class iterator {
|
|
friend class pvector;
|
|
pvector const & m_vector;
|
|
unsigned m_it;
|
|
iterator(pvector const & v, unsigned it):m_vector(v), m_it(it) {}
|
|
public:
|
|
iterator(iterator const & s):m_vector(s.m_vector), m_it(s.m_it) {}
|
|
iterator & operator++() { ++m_it; return *this; }
|
|
iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
|
|
bool operator==(iterator const & s) const { lean_assert(&m_vector == &(s.m_vector)); return m_it == s.m_it; }
|
|
bool operator!=(iterator const & s) const { return !operator==(s); }
|
|
T const & operator*() const { return m_vector[m_it]; }
|
|
T const * operator->() const { return &(m_vector[m_it]); }
|
|
};
|
|
|
|
/** \brief Return an iterator to the beginning */
|
|
iterator begin() const { return iterator(*this, 0); }
|
|
/** \brief Return an iterator to the end */
|
|
iterator end() const { return iterator(*this, size()); }
|
|
};
|
|
|
|
template<typename T>
|
|
void pvector<T>::cell::dealloc() {
|
|
switch (kind()) {
|
|
case cell_kind::PushBack: delete static_cast<push_cell*>(this); break;
|
|
case cell_kind::PopBack: delete static_cast<pop_cell*>(this); break;
|
|
case cell_kind::Set: delete static_cast<set_cell*>(this); break;
|
|
case cell_kind::Root: delete static_cast<root_cell*>(this); break;
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
unsigned pvector<T>::cell::size() const {
|
|
switch (kind()) {
|
|
case cell_kind::PushBack: case cell_kind::PopBack: case cell_kind::Set:
|
|
return static_cast<delta_cell const *>(this)->m_size;
|
|
case cell_kind::Root:
|
|
return static_cast<root_cell const *>(this)->m_vector.size();
|
|
}
|
|
lean_unreachable();
|
|
return 0;
|
|
}
|
|
|
|
template<typename T>
|
|
unsigned pvector<T>::cell::quota() const {
|
|
switch (kind()) {
|
|
case cell_kind::PushBack: case cell_kind::PopBack: case cell_kind::Set:
|
|
return static_cast<delta_cell const *>(this)->m_quota;
|
|
case cell_kind::Root: {
|
|
unsigned sz = size();
|
|
if (sz < LEAN_PVECTOR_MIN_QUOTA)
|
|
return LEAN_PVECTOR_MIN_QUOTA;
|
|
else
|
|
return sz;
|
|
}
|
|
}
|
|
lean_unreachable();
|
|
return 0;
|
|
}
|
|
|
|
/** \brief Non-destructive push_back. It is simulated using O(1) copy. */
|
|
template<typename T>
|
|
pvector<T> push_back(pvector<T> const & s, T const & v) { pvector<T> r(s); r.push_back(v); return r; }
|
|
/** \brief Non-destructive pop_back. It is simulated using O(1) copy. */
|
|
template<typename T>
|
|
pvector<T> pop_back(pvector<T> const & s) { pvector<T> r(s); r.pop_back(); return r; }
|
|
/** \brief Non-destructive set. It is simulated using O(1) copy. */
|
|
template<typename T>
|
|
pvector<T> set(pvector<T> const & s, unsigned i, T const & v) { pvector<T> r(s); r.set(i, v); return r; }
|
|
/** \brief Return the last element of \c s. */
|
|
template<typename T>
|
|
T const & back(pvector<T> const & s) { return s.back(); }
|
|
/** \brief Return true iff \c s is empty. */
|
|
template<typename T>
|
|
bool empty(pvector<T> const & s) { return s.empty(); }
|
|
/** \brief Return the size of \c s. */
|
|
template<typename T>
|
|
unsigned size(pvector<T> const & s) { return s.size(); }
|
|
|
|
template<typename T> inline std::ostream & operator<<(std::ostream & out, pvector<T> const & d) {
|
|
out << "[";
|
|
bool first = true;
|
|
auto it = d.begin();
|
|
auto end = d.end();
|
|
for (; it != end; ++it) {
|
|
if (first)
|
|
first = false;
|
|
else
|
|
out << ", ";
|
|
out << *it;
|
|
}
|
|
out << "]";
|
|
return out;
|
|
}
|
|
}
|