From 07e8ca9c8c9539430a3a17b7c0953a1079fac2bb Mon Sep 17 00:00:00 2001 From: Lev Dragunov Date: Mon, 13 Jul 2015 12:35:41 +0300 Subject: Revert "[3party][succinct] Fixed uint64_t <-> size_t warnings." --- 3party/succinct/bit_vector.hpp | 28 ++++++++-------- 3party/succinct/darray.hpp | 12 ++++--- 3party/succinct/darray64.hpp | 18 +++++----- 3party/succinct/elias_fano_compressed_list.hpp | 2 +- 3party/succinct/gamma_vector.hpp | 4 +-- 3party/succinct/mappable_vector.hpp | 8 +++-- 3party/succinct/mapper.hpp | 6 ++-- 3party/succinct/rs_bit_vector.hpp | 46 ++++++++++++++------------ 3party/succinct/util.hpp | 8 +---- 9 files changed, 67 insertions(+), 65 deletions(-) (limited to '3party') diff --git a/3party/succinct/bit_vector.hpp b/3party/succinct/bit_vector.hpp index 8b6e157ec0..5ca0e7db96 100644 --- a/3party/succinct/bit_vector.hpp +++ b/3party/succinct/bit_vector.hpp @@ -13,7 +13,7 @@ namespace succinct { namespace detail { inline size_t words_for(uint64_t n) { - return util::to_size(util::ceil_div(n, 64)); + return util::ceil_div(n, 64); } } @@ -52,7 +52,7 @@ namespace succinct { } inline void set(uint64_t pos, bool b) { - size_t const word = util::to_size(pos / 64); + uint64_t word = pos / 64; uint64_t pos_in_word = pos % 64; m_bits[word] &= ~(uint64_t(1) << pos_in_word); @@ -66,7 +66,7 @@ namespace succinct { assert(len == 64 || (bits >> len) == 0); if (!len) return; uint64_t mask = (len == 64) ? uint64_t(-1) : ((uint64_t(1) << len) - 1); - size_t const word = util::to_size(pos / 64); + uint64_t word = pos / 64; uint64_t pos_in_word = pos % 64; m_bits[word] &= ~(mask << pos_in_word); @@ -79,7 +79,7 @@ namespace succinct { } } - inline void append_bits(uint64_t bits, uint8_t len) + inline void append_bits(uint64_t bits, size_t len) { // check there are no spurious bits assert(len == 64 || (bits >> len) == 0); @@ -99,7 +99,7 @@ namespace succinct { inline void zero_extend(uint64_t n) { m_size += n; - size_t const needed = detail::words_for(m_size) - m_bits.size(); + uint64_t needed = detail::words_for(m_size) - m_bits.size(); if (needed) { m_bits.insert(m_bits.end(), needed, 0); m_cur_word = &m_bits.back(); @@ -113,7 +113,7 @@ namespace succinct { n -= 64; } if (n) { - append_bits(uint64_t(-1) >> (64 - n), static_cast(n)); + append_bits(uint64_t(-1) >> (64 - n), n); } } @@ -242,7 +242,7 @@ namespace succinct { inline bool operator[](uint64_t pos) const { assert(pos < m_size); - size_t const block = util::to_size(pos / 64); + uint64_t block = pos / 64; assert(block < m_bits.size()); uint64_t shift = pos % 64; return (m_bits[block] >> shift) & 1; @@ -253,7 +253,7 @@ namespace succinct { if (!len) { return 0; } - size_t const block = util::to_size(pos / 64); + uint64_t block = pos / 64; uint64_t shift = pos % 64; uint64_t mask = -(len == 64) | ((1ULL << len) - 1); if (shift + len <= 64) { @@ -267,7 +267,7 @@ namespace succinct { inline uint64_t get_word(uint64_t pos) const { assert(pos < size()); - size_t const block = util::to_size(pos / 64); + uint64_t block = pos / 64; uint64_t shift = pos % 64; uint64_t word = m_bits[block] >> shift; if (shift && block + 1 < m_bits.size()) { @@ -288,7 +288,7 @@ namespace succinct { inline uint64_t predecessor0(uint64_t pos) const { assert(pos < m_size); - size_t block = util::to_size(pos / 64); + uint64_t block = pos / 64; uint64_t shift = 64 - pos % 64 - 1; uint64_t word = ~m_bits[block]; word = (word << shift) >> shift; @@ -303,7 +303,7 @@ namespace succinct { inline uint64_t successor0(uint64_t pos) const { assert(pos < m_size); - size_t block = util::to_size(pos / 64); + uint64_t block = pos / 64; uint64_t shift = pos % 64; uint64_t word = (~m_bits[block] >> shift) << shift; @@ -318,7 +318,7 @@ namespace succinct { inline uint64_t predecessor1(uint64_t pos) const { assert(pos < m_size); - size_t block = util::to_size(pos / 64); + uint64_t block = pos / 64; uint64_t shift = 64 - pos % 64 - 1; uint64_t word = m_bits[block]; word = (word << shift) >> shift; @@ -333,7 +333,7 @@ namespace succinct { inline uint64_t successor1(uint64_t pos) const { assert(pos < m_size); - size_t block = util::to_size(pos / 64); + uint64_t block = pos / 64; uint64_t shift = pos % 64; uint64_t word = (m_bits[block] >> shift) << shift; @@ -363,7 +363,7 @@ namespace succinct { , m_buf(0) , m_avail(0) { - m_bv->data().prefetch(util::to_size(m_pos / 64)); + m_bv->data().prefetch(m_pos / 64); } inline bool next() diff --git a/3party/succinct/darray.hpp b/3party/succinct/darray.hpp index c2ed3cc108..79920f2f8d 100644 --- a/3party/succinct/darray.hpp +++ b/3party/succinct/darray.hpp @@ -24,7 +24,7 @@ namespace succinct { std::vector subblock_inventory; std::vector overflow_positions; - for (size_t word_idx = 0; word_idx < data.size(); ++word_idx) { + 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; @@ -74,20 +74,22 @@ namespace succinct { inline uint64_t select(bit_vector const& bv, uint64_t idx) const { assert(idx < num_positions()); - int64_t block_pos = m_block_inventory[util::to_size(idx / block_size)]; + uint64_t block = idx / block_size; + int64_t block_pos = m_block_inventory[block]; if (block_pos < 0) { uint64_t overflow_pos = uint64_t(-block_pos - 1); - return m_overflow_positions[util::to_size(overflow_pos + (idx % block_size))]; + return m_overflow_positions[overflow_pos + (idx % block_size)]; } - uint64_t start_pos = uint64_t(block_pos) + m_subblock_inventory[util::to_size(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 const& data = bv.data(); if (!reminder) { return start_pos; } else { - size_t word_idx = util::to_size(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); diff --git a/3party/succinct/darray64.hpp b/3party/succinct/darray64.hpp index 522dc181c7..07fad2bd9d 100644 --- a/3party/succinct/darray64.hpp +++ b/3party/succinct/darray64.hpp @@ -12,7 +12,7 @@ namespace succinct { : n_ones(0) {} - void append1(uint8_t skip0 = 0) + void append1(uint64_t skip0 = 0) { bits.append_bits(0, skip0); bits.push_back(1); @@ -21,8 +21,7 @@ namespace succinct { block_inventory.push_back(bits.size() - 1); } if (n_ones % subblock_size == 0) { - size_t const block = util::to_size(n_ones / block_size); - subblock_inventory.push_back(uint16_t(bits.size() - 1 - block_inventory[block])); + subblock_inventory.push_back(uint16_t(bits.size() - 1 - block_inventory[n_ones / block_size])); } n_ones += 1; @@ -77,22 +76,25 @@ namespace succinct { uint64_t select(uint64_t idx) const { assert(idx < num_ones()); - uint64_t block_pos = m_block_inventory[util::to_size(idx / block_size)]; - uint64_t start_pos = block_pos + m_subblock_inventory[util::to_size(idx / subblock_size)]; + uint64_t block = idx / block_size; + uint64_t block_pos = m_block_inventory[block]; + + 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 = util::to_size(start_pos / 64); + uint64_t word_idx = start_pos / 64; uint64_t word_shift = start_pos % 64; - uint64_t word = m_bits[word_idx] & (uint64_t(-1) << word_shift); + uint64_t word = m_bits.data()[word_idx] & (uint64_t(-1) << word_shift); while (true) { uint64_t popcnt = broadword::popcount(word); if (reminder < popcnt) break; reminder -= popcnt; - word = m_bits[++word_idx]; + word = m_bits.data()[++word_idx]; } return 64 * word_idx + broadword::select_in_word(word, reminder); diff --git a/3party/succinct/elias_fano_compressed_list.hpp b/3party/succinct/elias_fano_compressed_list.hpp index c509c4a3dd..51d1848710 100644 --- a/3party/succinct/elias_fano_compressed_list.hpp +++ b/3party/succinct/elias_fano_compressed_list.hpp @@ -47,7 +47,7 @@ namespace succinct { return ((uint64_t(1) << l) | m_bits.get_bits(r.first, l)) - 1; } - uint64_t size() const + size_t size() const { return m_ef.num_ones() - 1; } diff --git a/3party/succinct/gamma_vector.hpp b/3party/succinct/gamma_vector.hpp index b3a77559cc..7b31a249d2 100644 --- a/3party/succinct/gamma_vector.hpp +++ b/3party/succinct/gamma_vector.hpp @@ -99,8 +99,8 @@ namespace succinct { value_type next() { assert(m_idx <= m_c->size()); - uint64_t next_pos = m_high_bits_enumerator.next(); - uint64_t l = next_pos - m_pos - 1; + size_t next_pos = m_high_bits_enumerator.next(); + size_t l = next_pos - m_pos - 1; m_pos = next_pos; uint64_t chunk = m_low_bits_enumerator.take(l); uint64_t val = (chunk | (uint64_t(1) << (l))) - 1; diff --git a/3party/succinct/mappable_vector.hpp b/3party/succinct/mappable_vector.hpp index 3a968a99a6..0c1c9a76ea 100644 --- a/3party/succinct/mappable_vector.hpp +++ b/3party/succinct/mappable_vector.hpp @@ -9,6 +9,8 @@ #include #include +#include + #include "intrinsics.hpp" namespace succinct { namespace mapper { @@ -84,7 +86,7 @@ namespace succinct { namespace mapper { mappable_vector(from).swap(*this); } - size_t size() const { + uint64_t size() const { return m_size; } @@ -96,7 +98,7 @@ namespace succinct { namespace mapper { return m_data + m_size; } - inline T const& operator[](size_t i) const { + inline T const& operator[](uint64_t i) const { assert(i < m_size); return m_data[i]; } @@ -115,7 +117,7 @@ namespace succinct { namespace mapper { protected: const T* m_data; - size_t m_size; + uint64_t m_size; deleter_t m_deleter; }; diff --git a/3party/succinct/mapper.hpp b/3party/succinct/mapper.hpp index c71196b110..a39873307d 100644 --- a/3party/succinct/mapper.hpp +++ b/3party/succinct/mapper.hpp @@ -107,7 +107,7 @@ namespace succinct { namespace mapper { return *this; } - uint64_t written() const { + size_t written() const { return m_written; } @@ -255,7 +255,7 @@ namespace succinct { namespace mapper { } template - uint64_t freeze(T& val, std::ofstream& fout, uint64_t flags = 0, const char* friendly_name = "") + size_t freeze(T& val, std::ofstream& fout, uint64_t flags = 0, const char* friendly_name = "") { detail::freeze_visitor freezer(fout, flags); freezer(val, friendly_name); @@ -263,7 +263,7 @@ namespace succinct { namespace mapper { } template - uint64_t freeze(T& val, const char* filename, uint64_t flags = 0, const char* friendly_name = "") + size_t freeze(T& val, const char* filename, uint64_t flags = 0, const char* friendly_name = "") { std::ofstream fout; fout.exceptions(std::ifstream::failbit); diff --git a/3party/succinct/rs_bit_vector.hpp b/3party/succinct/rs_bit_vector.hpp index 232bf5c24b..1197ffb100 100644 --- a/3party/succinct/rs_bit_vector.hpp +++ b/3party/succinct/rs_bit_vector.hpp @@ -58,7 +58,7 @@ namespace succinct { uint64_t r = sub_block_rank(sub_block); uint64_t sub_left = pos % 64; if (sub_left) { - r += broadword::popcount(m_bits[util::to_size(sub_block)] << (64 - sub_left)); + r += broadword::popcount(m_bits[sub_block] << (64 - sub_left)); } return r; } @@ -71,18 +71,19 @@ namespace succinct { using broadword::popcount; using broadword::select_in_word; assert(n < num_ones()); - size_t a = 0; - size_t b = num_blocks(); + uint64_t a = 0; + uint64_t b = num_blocks(); if (m_select_hints.size()) { - size_t const chunk = util::to_size(n / select_ones_per_hint); + uint64_t chunk = n / select_ones_per_hint; if (chunk != 0) { - a = util::to_size(m_select_hints[chunk - 1]); + a = m_select_hints[chunk - 1]; } - b = util::to_size(m_select_hints[chunk] + 1); + b = m_select_hints[chunk] + 1; } + uint64_t block = 0; while (b - a > 1) { - size_t const mid = a + (b - a) / 2; + uint64_t mid = a + (b - a) / 2; uint64_t x = block_rank(mid); if (x <= n) { a = mid; @@ -90,7 +91,7 @@ namespace succinct { b = mid; } } - size_t const block = a; + block = a; assert(block < num_blocks()); uint64_t block_offset = block * block_size; @@ -104,7 +105,7 @@ namespace succinct { cur_rank += sub_ranks >> (7 - sub_block_offset) * 9 & 0x1FF; assert(cur_rank <= n); - size_t const word_offset = util::to_size(block_offset + sub_block_offset); + uint64_t word_offset = block_offset + sub_block_offset; return word_offset * 64 + select_in_word(m_bits[word_offset], n - cur_rank); } @@ -113,18 +114,19 @@ namespace succinct { using broadword::popcount; using broadword::select_in_word; assert(n < num_zeros()); - size_t a = 0; - size_t b = num_blocks(); + uint64_t a = 0; + uint64_t b = num_blocks(); if (m_select0_hints.size()) { - size_t const chunk = util::to_size(n / select_zeros_per_hint); + uint64_t chunk = n / select_zeros_per_hint; if (chunk != 0) { - a = util::to_size(m_select0_hints[chunk - 1]); + a = m_select0_hints[chunk - 1]; } - b = util::to_size(m_select0_hints[chunk] + 1); + b = m_select0_hints[chunk] + 1; } + uint64_t block = 0; while (b - a > 1) { - size_t const mid = a + (b - a) / 2; + uint64_t mid = a + (b - a) / 2; uint64_t x = block_rank0(mid); if (x <= n) { a = mid; @@ -132,7 +134,7 @@ namespace succinct { b = mid; } } - size_t const block = a; + block = a; assert(block < num_blocks()); uint64_t block_offset = block * block_size; @@ -145,34 +147,34 @@ namespace succinct { cur_rank0 += sub_ranks >> (7 - sub_block_offset) * 9 & 0x1FF; assert(cur_rank0 <= n); - size_t const word_offset = util::to_size(block_offset + sub_block_offset); + uint64_t word_offset = block_offset + sub_block_offset; return word_offset * 64 + select_in_word(~m_bits[word_offset], n - cur_rank0); } protected: - inline size_t num_blocks() const { + inline uint64_t num_blocks() const { return m_block_rank_pairs.size() / 2 - 1; } - inline uint64_t block_rank(size_t block) const { + inline uint64_t block_rank(uint64_t block) const { return m_block_rank_pairs[block * 2]; } inline uint64_t sub_block_rank(uint64_t sub_block) const { uint64_t r = 0; - size_t const block = util::to_size(sub_block / block_size); + uint64_t block = sub_block / block_size; r += block_rank(block); uint64_t left = sub_block % block_size; r += sub_block_ranks(block) >> ((7 - left) * 9) & 0x1FF; return r; } - inline uint64_t sub_block_ranks(size_t block) const { + inline uint64_t sub_block_ranks(uint64_t block) const { return m_block_rank_pairs[block * 2 + 1]; } - inline uint64_t block_rank0(size_t block) const { + inline uint64_t block_rank0(uint64_t block) const { return block * block_size * 64 - m_block_rank_pairs[block * 2]; } diff --git a/3party/succinct/util.hpp b/3party/succinct/util.hpp index 5cdea07c9d..c8c079fcf4 100644 --- a/3party/succinct/util.hpp +++ b/3party/succinct/util.hpp @@ -10,13 +10,7 @@ #include #include -namespace succinct { namespace util -{ - inline size_t to_size(uint64_t n) - { - assert(n <= std::numeric_limits::max()); - return static_cast(n); - } +namespace succinct { namespace util { inline void trim_newline_chars(std::string& s) { -- cgit v1.2.3