pastk/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

[succinct] Fixed succinct library to work on iOS (just used classes)

Browse source
This commit is contained in:
Denis Koronchik 2014-08-27 12:38:48 +03:00 • committed by Alex Zolotarev
parent 9f8b7b7cb5
commit 4b9a91403d
5 changed files with 67 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
3party/succinct/bit_vector.hpp
View file

@ -236,7 +236,7 @@ namespace succinct {
other.m_bits.swap(m_bits);
}
inline size_t size() const {
inline uint64_t size() const {
return m_size;
}
@ -277,12 +277,14 @@ namespace succinct {
}
// unsafe and fast version of get_word, it retrieves at least 56 bits
/*
inline uint64_t get_word56(uint64_t pos) const
{
// XXX check endianness?
const char* ptr = reinterpret_cast<const char*>(m_bits.data());
return *(reinterpret_cast<uint64_t const*>(ptr + pos / 8)) >> (pos % 8);
}
*/
inline uint64_t predecessor0(uint64_t pos) const {
assert(pos < m_size);
@ -355,7 +357,7 @@ namespace succinct {
, m_pos(uint64_t(-1))
{}
enumerator(bit_vector const& bv, size_t pos)
enumerator(bit_vector const& bv, uint64_t pos)
: m_bv(&bv)
, m_pos(pos)
, m_buf(0)
@ -374,7 +376,7 @@ namespace succinct {
return b;
}
inline uint64_t take(size_t l)
inline uint64_t take(uint64_t l)
{
if (m_avail < l) fill_buf();
uint64_t val;
@ -422,9 +424,9 @@ namespace succinct {
}
bit_vector const* m_bv;
size_t m_pos;
uint64_t m_pos;
uint64_t m_buf;
size_t m_avail;
uint64_t m_avail;
};
struct unary_enumerator {
@ -504,7 +506,7 @@ namespace succinct {
};
protected:
size_t m_size;
uint64_t m_size;
mapper::mappable_vector<uint64_t> m_bits;
};

18
3party/succinct/darray.hpp
View file

@ -24,8 +24,8 @@ namespace succinct {
std::vector<uint16_t> subblock_inventory;
std::vector<uint64_t> overflow_positions;
for (size_t word_idx = 0; word_idx < data.size(); ++word_idx) {
size_t cur_pos = word_idx * 64;
for (uint64_t word_idx = 0; word_idx < data.size(); ++word_idx) {
uint64_t cur_pos = word_idx * 64;
uint64_t cur_word = WordGetter()(data, word_idx);
unsigned long l;
while (broadword::lsb(cur_word, l)) {
@ -81,20 +81,20 @@ namespace succinct {
return m_overflow_positions[overflow_pos + (idx % block_size)];
}
size_t subblock = idx / subblock_size;
size_t start_pos = uint64_t(block_pos) + m_subblock_inventory[subblock];
size_t reminder = idx % subblock_size;
uint64_t subblock = idx / subblock_size;
uint64_t start_pos = uint64_t(block_pos) + m_subblock_inventory[subblock];
uint64_t reminder = idx % subblock_size;
mapper::mappable_vector<uint64_t> const& data = bv.data();
if (!reminder) {
return start_pos;
} else {
size_t word_idx = start_pos / 64;
size_t word_shift = start_pos % 64;
uint64_t word_idx = start_pos / 64;
uint64_t word_shift = start_pos % 64;
uint64_t word = WordGetter()(data, word_idx) & (uint64_t(-1) << word_shift);
while (true) {
size_t popcnt = broadword::popcount(word);
uint64_t popcnt = broadword::popcount(word);
if (reminder < popcnt) break;
reminder -= popcnt;
word = WordGetter()(data, ++word_idx);
@ -136,7 +136,7 @@ namespace succinct {
static const size_t subblock_size = 32;
static const size_t max_in_block_distance = 1 << 16;
size_t m_positions;
uint64_t m_positions;
mapper::mappable_vector<int64_t> m_block_inventory;
mapper::mappable_vector<uint16_t> m_subblock_inventory;
mapper::mappable_vector<uint64_t> m_overflow_positions;

26
3party/succinct/darray64.hpp
View file

@ -12,7 +12,7 @@ namespace succinct {
: n_ones(0)
{}
void append1(size_t skip0 = 0)
void append1(uint64_t skip0 = 0)
{
bits.append_bits(0, skip0);
bits.push_back(1);
@ -27,7 +27,7 @@ namespace succinct {
n_ones += 1;
}
size_t n_ones;
uint64_t n_ones;
bit_vector_builder bits;
std::vector<uint64_t> block_inventory;
std::vector<uint16_t> subblock_inventory;
@ -63,7 +63,7 @@ namespace succinct {
;
}
size_t num_ones() const
uint64_t num_ones() const
{
return m_num_ones;
}
@ -73,25 +73,25 @@ namespace succinct {
return m_bits;
}
size_t select(size_t idx) const
uint64_t select(uint64_t idx) const
{
assert(idx < num_ones());
size_t block = idx / block_size;
size_t block_pos = m_block_inventory[block];
uint64_t block = idx / block_size;
uint64_t block_pos = m_block_inventory[block];
size_t subblock = idx / subblock_size;
size_t start_pos = block_pos + m_subblock_inventory[subblock];
size_t reminder = idx % subblock_size;
uint64_t subblock = idx / subblock_size;
uint64_t start_pos = block_pos + m_subblock_inventory[subblock];
uint64_t reminder = idx % subblock_size;
if (!reminder) {
return start_pos;
} else {
size_t word_idx = start_pos / 64;
size_t word_shift = start_pos % 64;
uint64_t word_idx = start_pos / 64;
uint64_t word_shift = start_pos % 64;
uint64_t word = m_bits.data()[word_idx] & (uint64_t(-1) << word_shift);
while (true) {
size_t popcnt = broadword::popcount(word);
uint64_t popcnt = broadword::popcount(word);
if (reminder < popcnt) break;
reminder -= popcnt;
word = m_bits.data()[++word_idx];
@ -106,7 +106,7 @@ namespace succinct {
static const size_t block_size = 1024; // 64 * block_size must fit in an uint16_t (64 is the max sparsity of bits)
static const size_t subblock_size = 64;
size_t m_num_ones;
uint64_t m_num_ones;
bit_vector m_bits;
mapper::mappable_vector<uint64_t> m_block_inventory;
mapper::mappable_vector<uint16_t> m_subblock_inventory;

14
3party/succinct/gamma_vector.hpp
View file

@ -38,14 +38,14 @@ namespace succinct {
bit_vector(&low_bits).swap(m_low_bits);
}
value_type operator[](size_t idx) const
value_type operator[](uint64_t idx) const
{
size_t pos = m_high_bits.select(idx);
size_t l; // ignored
uint64_t pos = m_high_bits.select(idx);
uint64_t l; // ignored
return retrieve_value(idx, pos, l);
}
size_t size() const
uint64_t size() const
{
return m_high_bits.num_ones() - 1;
}
@ -66,7 +66,7 @@ namespace succinct {
private:
value_type retrieve_value(size_t idx, size_t pos, size_t& l) const
value_type retrieve_value(uint64_t idx, uint64_t pos, uint64_t & l) const
{
assert(m_high_bits.bits()[pos] == 1);
l = broadword::lsb(m_high_bits.bits().get_word(pos + 1));
@ -110,8 +110,8 @@ namespace succinct {
private:
gamma_vector const* m_c;
size_t m_idx;
size_t m_pos;
uint64_t m_idx;
uint64_t m_pos;
bit_vector::unary_enumerator m_high_bits_enumerator;
bit_vector::enumerator m_low_bits_enumerator;

37
3party/succinct/mapper.hpp
View file

@ -11,8 +11,12 @@
#include "mappable_vector.hpp"
namespace succinct { namespace mapper {
#define NEED_TO_ALIGN4(v) (4 - ((v) % 4))
#define ALIGN4_PTR(v) { uint32_t x = (uint64_t)(v) % 4; if (x > 0) (v) += 4 - x; }
struct freeze_flags {
// enum {
// };
@ -34,7 +38,7 @@ namespace succinct { namespace mapper {
{}
std::string name;
size_t size;
uint64_t size;
std::vector<size_node_ptr> children;
void dump(std::ostream& os = std::cerr, size_t depth = 0) {
@ -72,6 +76,14 @@ namespace succinct { namespace mapper {
operator()(T& val, const char* /* friendly_name */) {
m_fout.write(reinterpret_cast<const char*>(&val), sizeof(T));
m_written += sizeof(T);
uint32_t padding = NEED_TO_ALIGN4(m_written);
static uint32_t const zero = 0;
if (padding > 0 && padding < 4)
{
m_fout.write(reinterpret_cast<const char*>(&zero), padding);
m_written += padding;
}
return *this;
}
@ -84,6 +96,14 @@ namespace succinct { namespace mapper {
m_fout.write(reinterpret_cast<const char*>(vec.m_data), long(n_bytes));
m_written += n_bytes;
uint32_t padding = NEED_TO_ALIGN4(m_written);
static uint32_t const zero = 0;
if (padding > 0 && padding < 4)
{
m_fout.write(reinterpret_cast<const char*>(&zero), padding);
m_written += padding;
}
return *this;
}
@ -120,6 +140,8 @@ namespace succinct { namespace mapper {
operator()(T& val, const char* /* friendly_name */) {
val = *reinterpret_cast<const T*>(m_cur);
m_cur += sizeof(T);
ALIGN4_PTR(m_cur);
return *this;
}
@ -141,6 +163,7 @@ namespace succinct { namespace mapper {
}
m_cur += bytes;
ALIGN4_PTR(m_cur);
return *this;
}
@ -168,7 +191,7 @@ namespace succinct { namespace mapper {
template <typename T>
typename boost::disable_if<boost::is_pod<T>, sizeof_visitor&>::type
operator()(T& val, const char* friendly_name) {
size_t checkpoint = m_size;
uint64_t checkpoint = m_size;
size_node_ptr parent_node;
if (m_cur_size_node) {
parent_node = m_cur_size_node;
@ -195,9 +218,9 @@ namespace succinct { namespace mapper {
template<typename T>
sizeof_visitor&
operator()(mappable_vector<T>& vec, const char* friendly_name) {
size_t checkpoint = m_size;
uint64_t checkpoint = m_size;
(*this)(vec.m_size, "size");
m_size += static_cast<size_t>(vec.m_size * sizeof(T));
m_size += static_cast<uint64_t>(vec.m_size * sizeof(T));
if (m_cur_size_node) {
make_node(friendly_name)->size = m_size - checkpoint;
@ -206,7 +229,7 @@ namespace succinct { namespace mapper {
return *this;
}
size_t size() const {
uint64_t size() const {
return m_size;
}
@ -225,7 +248,7 @@ namespace succinct { namespace mapper {
return node;
}
size_t m_size;
uint64_t m_size;
size_node_ptr m_cur_size_node;
};
@ -261,7 +284,7 @@ namespace succinct { namespace mapper {
}
template <typename T>
size_t size_of(T& val)
uint64_t size_of(T& val)
{
detail::sizeof_visitor sizer;
sizer(val, "");