--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+/*
+ * Bitmap based in-memory allocator.
+ * Author: Ramesh Chander, Ramesh.Chander@sandisk.com
+ *
+ */
+
+#include "BitAllocator.h"
+
+#include "BitMapAllocator.h"
+#include "bluestore_types.h"
+#include "common/debug.h"
+
+#define dout_context cct
+#define dout_subsys ceph_subsys_bluestore
+#undef dout_prefix
+#define dout_prefix *_dout << "bitmapalloc:"
+
+
+BitMapAllocator::BitMapAllocator(CephContext* cct, int64_t device_size,
+ int64_t block_size)
+ : cct(cct)
+{
+ if (!ISP2(block_size)) {
+ derr << __func__ << " block_size " << block_size
+ << " not power of 2 aligned!"
+ << dendl;
+ assert(ISP2(block_size));
+ return;
+ }
+
+ int64_t zone_size_blks = cct->_conf->bluestore_bitmapallocator_blocks_per_zone;
+ if (!ISP2(zone_size_blks)) {
+ derr << __func__ << " zone_size " << zone_size_blks
+ << " not power of 2 aligned!"
+ << dendl;
+ assert(ISP2(zone_size_blks));
+ return;
+ }
+
+ int64_t span_size = cct->_conf->bluestore_bitmapallocator_span_size;
+ if (!ISP2(span_size)) {
+ derr << __func__ << " span_size " << span_size
+ << " not power of 2 aligned!"
+ << dendl;
+ assert(ISP2(span_size));
+ return;
+ }
+
+ m_block_size = block_size;
+ m_total_size = P2ALIGN(device_size, block_size);
+ m_bit_alloc = new BitAllocator(cct, device_size / block_size,
+ zone_size_blks, CONCURRENT, true);
+ if (!m_bit_alloc) {
+ derr << __func__ << " Unable to intialize Bit Allocator" << dendl;
+ assert(m_bit_alloc);
+ }
+ dout(10) << __func__ << " instance " << (uint64_t) this
+ << " size 0x" << std::hex << device_size << std::dec
+ << dendl;
+}
+
+BitMapAllocator::~BitMapAllocator()
+{
+ delete m_bit_alloc;
+}
+
+void BitMapAllocator::insert_free(uint64_t off, uint64_t len)
+{
+ dout(20) << __func__ << " instance " << (uint64_t) this
+ << " off 0x" << std::hex << off
+ << " len 0x" << len << std::dec
+ << dendl;
+
+ assert(!(off % m_block_size));
+ assert(!(len % m_block_size));
+
+ m_bit_alloc->free_blocks(off / m_block_size,
+ len / m_block_size);
+}
+
+int BitMapAllocator::reserve(uint64_t need)
+{
+ int nblks = need / m_block_size; // apply floor
+ assert(!(need % m_block_size));
+ dout(10) << __func__ << " instance " << (uint64_t) this
+ << " num_used " << m_bit_alloc->get_used_blocks()
+ << " total " << m_bit_alloc->total_blocks()
+ << dendl;
+
+ if (!m_bit_alloc->reserve_blocks(nblks)) {
+ return -ENOSPC;
+ }
+ return 0;
+}
+
+void BitMapAllocator::unreserve(uint64_t unused)
+{
+ int nblks = unused / m_block_size;
+ assert(!(unused % m_block_size));
+
+ dout(10) << __func__ << " instance " << (uint64_t) this
+ << " unused " << nblks
+ << " num used " << m_bit_alloc->get_used_blocks()
+ << " total " << m_bit_alloc->total_blocks()
+ << dendl;
+
+ m_bit_alloc->unreserve_blocks(nblks);
+}
+
+int64_t BitMapAllocator::allocate(
+ uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
+ int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents)
+{
+
+ assert(!(alloc_unit % m_block_size));
+ assert(alloc_unit);
+
+ assert(!max_alloc_size || max_alloc_size >= alloc_unit);
+
+ dout(10) << __func__ <<" instance "<< (uint64_t) this
+ << " want_size " << want_size
+ << " alloc_unit " << alloc_unit
+ << " hint " << hint
+ << dendl;
+ hint = hint % m_total_size; // make hint error-tolerant
+ return allocate_dis(want_size, alloc_unit / m_block_size,
+ max_alloc_size, hint / m_block_size, extents);
+}
+
+int64_t BitMapAllocator::allocate_dis(
+ uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
+ int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents)
+{
+ ExtentList block_list = ExtentList(extents, m_block_size, max_alloc_size);
+ int64_t nblks = (want_size + m_block_size - 1) / m_block_size;
+ int64_t num = 0;
+
+ num = m_bit_alloc->alloc_blocks_dis_res(nblks, alloc_unit, hint, &block_list);
+ if (num == 0) {
+ return -ENOSPC;
+ }
+
+ return num * m_block_size;
+}
+
+void BitMapAllocator::release(
+ uint64_t offset, uint64_t length)
+{
+ dout(10) << __func__ << " 0x"
+ << std::hex << offset << "~" << length << std::dec
+ << dendl;
+ insert_free(offset, length);
+}
+
+uint64_t BitMapAllocator::get_free()
+{
+ assert(m_bit_alloc->total_blocks() >= m_bit_alloc->get_used_blocks());
+ return ((
+ m_bit_alloc->total_blocks() - m_bit_alloc->get_used_blocks()) *
+ m_block_size);
+}
+
+void BitMapAllocator::dump()
+{
+ dout(0) << __func__ << " instance " << this << dendl;
+ m_bit_alloc->dump();
+}
+
+void BitMapAllocator::init_add_free(uint64_t offset, uint64_t length)
+{
+ dout(10) << __func__ << " instance " << (uint64_t) this
+ << " offset 0x" << std::hex << offset
+ << " length 0x" << length << std::dec
+ << dendl;
+ uint64_t size = m_bit_alloc->size() * m_block_size;
+
+ uint64_t offset_adj = ROUND_UP_TO(offset, m_block_size);
+ uint64_t length_adj = ((length - (offset_adj - offset)) /
+ m_block_size) * m_block_size;
+
+ if ((offset_adj + length_adj) > size) {
+ assert(((offset_adj + length_adj) - m_block_size) < size);
+ length_adj = size - offset_adj;
+ }
+
+ insert_free(offset_adj, length_adj);
+}
+
+void BitMapAllocator::init_rm_free(uint64_t offset, uint64_t length)
+{
+ dout(10) << __func__ << " instance " << (uint64_t) this
+ << " offset 0x" << std::hex << offset
+ << " length 0x" << length << std::dec
+ << dendl;
+
+ // we use the same adjustment/alignment that init_add_free does
+ // above so that we can yank back some of the space.
+ uint64_t offset_adj = ROUND_UP_TO(offset, m_block_size);
+ uint64_t length_adj = ((length - (offset_adj - offset)) /
+ m_block_size) * m_block_size;
+
+ assert(!(offset_adj % m_block_size));
+ assert(!(length_adj % m_block_size));
+
+ int64_t first_blk = offset_adj / m_block_size;
+ int64_t count = length_adj / m_block_size;
+
+ if (count)
+ m_bit_alloc->set_blocks_used(first_blk, count);
+}
+
+
+void BitMapAllocator::shutdown()
+{
+ dout(10) << __func__ << " instance " << (uint64_t) this << dendl;
+ m_bit_alloc->shutdown();
+}
+
Code Review / stor4nfv.git / blobdiff