summaryrefslogtreecommitdiffstats
path: root/src/os/bluestore/StupidAllocator.h
blob: e1fc101e0879f7bf1e64f273489c01c00b5e2d09 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab

#ifndef CEPH_OS_BLUESTORE_STUPIDALLOCATOR_H
#define CEPH_OS_BLUESTORE_STUPIDALLOCATOR_H

#include <mutex>

#include "Allocator.h"
#include "include/btree_map.h"
#include "include/interval_set.h"
#include "os/bluestore/bluestore_types.h"
#include "include/mempool.h"
#include "common/ceph_mutex.h"

class StupidAllocator : public Allocator {
  CephContext* cct;
  ceph::mutex lock = ceph::make_mutex("StupidAllocator::lock");

  int64_t num_free;     ///< total bytes in freelist
  uint64_t bdev_block_size;

  template <typename K, typename V> using allocator_t =
    mempool::bluestore_alloc::pool_allocator<std::pair<const K, V>>;
  template <typename K, typename V> using btree_map_t =
    btree::btree_map<K, V, std::less<K>, allocator_t<K, V>>;
  using interval_set_t = interval_set<uint64_t, btree_map_t>;
  std::vector<interval_set_t> free;  ///< leading-edge copy

  uint64_t last_alloc = 0;

  unsigned _choose_bin(uint64_t len);
  void _insert_free(uint64_t offset, uint64_t len);

  uint64_t _aligned_len(
    interval_set_t::iterator p,
    uint64_t alloc_unit);

public:
  StupidAllocator(CephContext* cct,
                  const std::string& name,
                  int64_t size,
                  int64_t block_size);
  ~StupidAllocator() override;
  const char* get_type() const override
  {
    return "stupid";
  }

  int64_t allocate(
    uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
    int64_t hint, PExtentVector *extents) override;

  int64_t allocate_int(
    uint64_t want_size, uint64_t alloc_unit, int64_t hint,
    uint64_t *offset, uint32_t *length);

  void release(
    const interval_set<uint64_t>& release_set) override;

  uint64_t get_free() override;
  double get_fragmentation() override;

  void dump() override;
  void foreach(std::function<void(uint64_t offset, uint64_t length)> notify) override;

  void init_add_free(uint64_t offset, uint64_t length) override;
  void init_rm_free(uint64_t offset, uint64_t length) override;

  void shutdown() override;
};

#endif