thin-provisioning-tools/persistent-data/space-maps/core.cc

245 lines
5.9 KiB
C++
Raw Normal View History

// Copyright (C) 2020 Red Hat, Inc. All rights reserved.
//
// This file is part of the thin-provisioning-tools source.
//
// thin-provisioning-tools is free software: you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation, either version 3 of
// the License, or (at your option) any later version.
//
// thin-provisioning-tools is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with thin-provisioning-tools. If not, see
// <http://www.gnu.org/licenses/>.
#include "persistent-data/space-maps/core.h"
#include "base/math_utils.h"
#include <stdexcept>
using namespace persistent_data;
using namespace std;
//----------------------------------------------------------------
namespace {
constexpr block_address ENTRIES_PER_WORD = 4 * sizeof(uint64_t);
class core_map : public checked_space_map {
public:
typedef std::shared_ptr<core_map> ptr;
core_map(block_address nr_blocks);
block_address get_nr_blocks() const override;
block_address get_nr_free() const override;
ref_t get_count(block_address b) const override;
void set_count(block_address b, ref_t c) override;
void commit() override;
void inc(block_address b, ref_t count) override;
void dec(block_address b, ref_t count) override;
maybe_block find_free(span_iterator &it) override;
void extend(block_address extra_blocks) override;
void count_metadata(block_counter &bc) const override;
// FIXME: meaningless, but this class is only used for testing
size_t root_size() const override;
// FIXME: meaningless, but this class is only used for testing
virtual void copy_root(void *dest, size_t len) const override;
checked_space_map::ptr clone() const override;
private:
ref_t get_count_(block_address b) const;
void set_count_(block_address b, ref_t c);
void check_block_(block_address b) const;
ref_t lookup_bits_(block_address b) const;
void set_bits_(block_address b, ref_t c);
ref_t lookup_exception_(block_address b) const;
block_address nr_blocks_;
block_address nr_free_;
block_address search_start_;
std::vector<uint64_t> bits_;
std::map<block_address, ref_t> exceptions_;
};
core_map::core_map(block_address nr_blocks)
: nr_blocks_(nr_blocks),
nr_free_(nr_blocks),
search_start_(0),
bits_(base::div_up(nr_blocks, ENTRIES_PER_WORD)) {
}
block_address
core_map::get_nr_blocks() const {
return nr_blocks_;
}
block_address
core_map::get_nr_free() const {
return nr_free_;
}
ref_t
core_map::get_count(block_address b) const {
check_block_(b);
return get_count_(b);
}
void
core_map::set_count(block_address b, ref_t c) {
check_block_(b);
set_count_(b, c);
}
void
core_map::commit() {
}
void
core_map::inc(block_address b, ref_t count) {
check_block_(b);
auto old_c = get_count_(b);
set_count_(b, old_c + count);
}
void
core_map::dec(block_address b, ref_t count) {
check_block_(b);
auto old_c = get_count_(b);
set_count_(b, old_c - count);
}
core_map::maybe_block
core_map::find_free(span_iterator &it) {
for (maybe_span ms = it.first(); ms; ms = it.next()) {
for (block_address b = std::max(search_start_, ms->first); b < ms->second; b++) {
check_block_(b);
if (!get_count_(b))
return maybe_block(b);
}
}
return maybe_block();
}
void
core_map::extend(block_address extra_blocks) {
throw std::runtime_error("'extend' not implemented");
}
void
core_map::count_metadata(block_counter &bc) const {
}
// FIXME: meaningless, but this class is only used for testing
size_t
core_map::root_size() const {
return 0;
}
// FIXME: meaningless, but this class is only used for testing
void
core_map::copy_root(void *dest, size_t len) const {
throw std::runtime_error("'copy root' not implemented");
}
checked_space_map::ptr
core_map::clone() const {
return ptr(new core_map(*this));
}
void
core_map::check_block_(block_address b) const {
if (b >= nr_blocks_)
throw std::runtime_error("block out of bounds");
}
ref_t
core_map::get_count_(block_address b) const {
auto c = lookup_bits_(b);
if (c == 3)
c = lookup_exception_(b);
return c;
}
void
core_map::set_count_(block_address b, ref_t c) {
auto old_c = get_count_(b);
if (old_c > 2) {
if (c > 2)
exceptions_[b] = c;
else {
exceptions_.erase(b);
set_bits_(b, c);
}
} else {
if (c > 2) {
set_bits_(b, 3);
exceptions_.insert(make_pair(b, c));
} else
set_bits_(b, c);
}
if (old_c == 0 && c > 0) {
nr_free_--;
if (b == search_start_)
search_start_++;
} else if (old_c > 0 && c == 0) {
if (b < search_start_)
search_start_ = b;
nr_free_++;
}
}
ref_t
core_map::lookup_bits_(block_address b) const {
block_address word = b / ENTRIES_PER_WORD;
block_address shift = (b % ENTRIES_PER_WORD) * 2;
return (bits_[word] >> shift) & 0b11;
}
void
core_map::set_bits_(block_address b, ref_t c) {
if (c > 3)
throw runtime_error("bad count");
block_address word = b / ENTRIES_PER_WORD;
block_address shift = (b % ENTRIES_PER_WORD) * 2ull;
auto w = bits_[word] & ~(0b11ull << shift);
bits_[word] = w | (((uint64_t) c) << shift);
}
ref_t
core_map::lookup_exception_(block_address b) const {
auto it = exceptions_.find(b);
if (it == exceptions_.end())
throw runtime_error("core space map exception entry missing");
return it->second;
}
}
//----------------------------------------------------------------
checked_space_map::ptr
persistent_data::create_core_map(block_address nr_blocks)
{
return checked_space_map::ptr(new core_map(nr_blocks));
}
//----------------------------------------------------------------