blob: f217ec25b0bb3f1fbd4af7e4ff21482f674b7561 (
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
/*
* Copyright (C) 2012-2014 Alec Thomas <alec@swapoff.org>
* All rights reserved.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution.
*
* Author: Alec Thomas <alec@swapoff.org>
*/
#pragma once
#include <cstddef>
#include <cassert>
#include <vector>
namespace entityx {
/**
* Provides a resizable, semi-contiguous pool of memory for constructing
* objects in. Pointers into the pool will be invalided only when the pool is
* destroyed.
*
* The semi-contiguous nature aims to provide cache-friendly iteration.
*
* Lookups are O(1).
* Appends are amortized O(1).
*/
class BasePool {
public:
explicit BasePool(std::size_t element_size, std::size_t chunk_size = 8192)
: element_size_(element_size), chunk_size_(chunk_size), capacity_(0) {}
virtual ~BasePool();
std::size_t size() const { return size_; }
std::size_t capacity() const { return capacity_; }
std::size_t chunks() const { return blocks_.size(); }
/// Ensure at least n elements will fit in the pool.
inline void expand(std::size_t n) {
if (n >= size_) {
if (n >= capacity_) reserve(n);
size_ = n;
}
}
inline void reserve(std::size_t n) {
while (capacity_ < n) {
char *chunk = new char[element_size_ * chunk_size_];
blocks_.push_back(chunk);
capacity_ += chunk_size_;
}
}
inline void *get(std::size_t n) {
assert(n < size_);
return blocks_[n / chunk_size_] + (n % chunk_size_) * element_size_;
}
inline const void *get(std::size_t n) const {
assert(n < size_);
return blocks_[n / chunk_size_] + (n % chunk_size_) * element_size_;
}
virtual void destroy(std::size_t n) = 0;
protected:
std::vector<char *> blocks_;
std::size_t element_size_;
std::size_t chunk_size_;
std::size_t size_ = 0;
std::size_t capacity_;
};
/**
* Implementation of BasePool that provides type-"safe" deconstruction of
* elements in the pool.
*/
template <typename T, std::size_t ChunkSize = 8192>
class Pool : public BasePool {
public:
Pool() : BasePool(sizeof(T), ChunkSize) {}
virtual ~Pool() {
// Component destructors *must* be called by owner.
}
virtual void destroy(std::size_t n) override {
assert(n < size_);
T *ptr = static_cast<T*>(get(n));
ptr->~T();
}
};
} // namespace entityx
|
