Skip to content

Commit a254630

Browse files
IvorforceIvorforce
committed
Add FixedVector template.
This is a high performance `Vector`-like object that can be used if the maximum number of objects is small and known, and the objects are needed only temporarily.
1 parent 9e6ee9c commit a254630

File tree

3 files changed

+240
-0
lines changed

3 files changed

+240
-0
lines changed

‎core/templates/fixed_vector.h

+155
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,155 @@
1+
/**************************************************************************/
2+
/* fixed_vector.h */
3+
/**************************************************************************/
4+
/* This file is part of: */
5+
/* GODOT ENGINE */
6+
/* https://godotengine.org */
7+
/**************************************************************************/
8+
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9+
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
10+
/* */
11+
/* Permission is hereby granted, free of charge, to any person obtaining */
12+
/* a copy of this software and associated documentation files (the */
13+
/* "Software"), to deal in the Software without restriction, including */
14+
/* without limitation the rights to use, copy, modify, merge, publish, */
15+
/* distribute, sublicense, and/or sell copies of the Software, and to */
16+
/* permit persons to whom the Software is furnished to do so, subject to */
17+
/* the following conditions: */
18+
/* */
19+
/* The above copyright notice and this permission notice shall be */
20+
/* included in all copies or substantial portions of the Software. */
21+
/* */
22+
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23+
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24+
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25+
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26+
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27+
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28+
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29+
/**************************************************************************/
30+
31+
#pragma once
32+
33+
/**
34+
* A high performance Vector of fixed capacity.
35+
* Especially useful if you need to create an array on the stack, to
36+
* prevent dynamic allocations (especially in bottleneck code).
37+
*
38+
* Choose CAPACITY such that it is enough for all elements that could be added through all branches.
39+
*
40+
*/
41+
template <class T, uint32_t CAPACITY>
42+
class FixedVector {
43+
// This declaration allows us to access other FixedVector's private members.
44+
template <class T_, uint32_t CAPACITY_>
45+
friend class FixedVector;
46+
47+
uint32_t _size = 0;
48+
alignas(T) uint8_t _data[CAPACITY * sizeof(T)];
49+
50+
constexpr static uint32_t DATA_PADDING = MAX(alignof(T), alignof(uint32_t)) - alignof(uint32_t);
51+
52+
public:
53+
_FORCE_INLINE_ constexpr FixedVector() = default;
54+
constexpr FixedVector(std::initializer_list<T> p_init) {
55+
ERR_FAIL_COND(p_init.size() > CAPACITY);
56+
for (const T &element : p_init) {
57+
memnew_placement(ptr() + _size++, T(element));
58+
}
59+
}
60+
61+
template <uint32_t p_capacity>
62+
constexpr FixedVector(const FixedVector<T, p_capacity> &p_from) {
63+
ERR_FAIL_COND(p_from.size() > CAPACITY);
64+
if constexpr (std::is_trivially_copyable_v<T>) {
65+
// Copy size and all provided elements at once.
66+
memcpy((void *)&_size, (void *)&p_from._size, sizeof(_size) + DATA_PADDING + p_from.size() * sizeof(T));
67+
} else {
68+
for (const T &element : p_from) {
69+
memnew_placement(ptr() + _size++, T(element));
70+
}
71+
}
72+
}
73+
74+
template <uint32_t p_capacity>
75+
constexpr FixedVector(FixedVector<T, p_capacity> &&p_from) {
76+
ERR_FAIL_COND(p_from.size() > CAPACITY);
77+
// Copy size and all provided elements at once.
78+
// Note: Assumes trivial relocatability.
79+
memcpy((void *)&_size, (void *)&p_from._size, sizeof(_size) + DATA_PADDING + p_from.size() * sizeof(T));
80+
p_from._size = 0;
81+
}
82+
83+
~FixedVector() {
84+
if constexpr (!std::is_trivially_destructible_v<T>) {
85+
for (uint32_t i = 0; i < _size; i++) {
86+
ptr()[i].~T();
87+
}
88+
}
89+
}
90+
91+
_FORCE_INLINE_ constexpr T *ptr() { return (T *)(_data); }
92+
_FORCE_INLINE_ constexpr const T *ptr() const { return (const T *)(_data); }
93+
94+
_FORCE_INLINE_ constexpr operator Span<T>() const { return Span<T>(ptr(), size()); }
95+
_FORCE_INLINE_ constexpr Span<T> span() const { return operator Span<T>(); }
96+
97+
_FORCE_INLINE_ constexpr uint32_t size() const { return _size; }
98+
_FORCE_INLINE_ constexpr bool is_empty() const { return !_size; }
99+
_FORCE_INLINE_ constexpr bool is_full() const { return _size == CAPACITY; }
100+
_FORCE_INLINE_ constexpr uint32_t capacity() const { return CAPACITY; }
101+
102+
_FORCE_INLINE_ constexpr void clear() { resize(0); }
103+
104+
/// p_ensure_zero can be used to initialize trivial types with all-zero bytes.
105+
/// p_force_trivial can be used to skip the constructor, for better performance.
106+
template <bool p_ensure_zero = false, bool p_force_trivial = false>
107+
constexpr Error resize(uint32_t p_size) {
108+
static_assert(!p_force_trivial || std::is_trivially_destructible_v<T>, "force_trivial may only be true if the type is trivially destructible.");
109+
110+
if (!p_force_trivial && p_size > _size) {
111+
ERR_FAIL_COND_V(p_size > CAPACITY, ERR_OUT_OF_MEMORY);
112+
memnew_arr_placement<p_ensure_zero>(ptr() + _size, p_size - _size);
113+
} else if (p_size < _size) {
114+
if constexpr (!std::is_trivially_destructible_v<T>) {
115+
for (uint32_t i = p_size; i < _size; i++) {
116+
ptr()[i].~T();
117+
}
118+
}
119+
}
120+
121+
_size = p_size;
122+
return OK;
123+
}
124+
125+
constexpr void push_back(const T &p_val) {
126+
ERR_FAIL_COND(_size >= CAPACITY);
127+
memnew_placement(ptr() + _size, T(p_val));
128+
_size++;
129+
}
130+
131+
constexpr void pop_back() {
132+
ERR_FAIL_COND(_size == 0);
133+
_size--;
134+
ptr()[_size].~T();
135+
}
136+
137+
// NOTE: Subscripts sanity check the bounds to avoid undefined behavior.
138+
// This is slower than direct buffer access and can prevent autovectorization.
139+
// If the bounds are known, use ptr() subscript instead.
140+
constexpr const T &operator[](uint32_t p_index) const {
141+
CRASH_COND(p_index >= _size);
142+
return ptr()[p_index];
143+
}
144+
145+
constexpr T &operator[](uint32_t p_index) {
146+
CRASH_COND(p_index >= _size);
147+
return ptr()[p_index];
148+
}
149+
150+
_FORCE_INLINE_ constexpr T *begin() { return ptr(); }
151+
_FORCE_INLINE_ constexpr T *end() { return ptr() + _size; }
152+
153+
_FORCE_INLINE_ constexpr const T *begin() const { return ptr(); }
154+
_FORCE_INLINE_ constexpr const T *end() const { return ptr() + _size; }
155+
};

‎tests/core/templates/test_fixed_vector.h

+84
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
/**************************************************************************/
2+
/* test_fixed_vector.h */
3+
/**************************************************************************/
4+
/* This file is part of: */
5+
/* GODOT ENGINE */
6+
/* https://godotengine.org */
7+
/**************************************************************************/
8+
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9+
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
10+
/* */
11+
/* Permission is hereby granted, free of charge, to any person obtaining */
12+
/* a copy of this software and associated documentation files (the */
13+
/* "Software"), to deal in the Software without restriction, including */
14+
/* without limitation the rights to use, copy, modify, merge, publish, */
15+
/* distribute, sublicense, and/or sell copies of the Software, and to */
16+
/* permit persons to whom the Software is furnished to do so, subject to */
17+
/* the following conditions: */
18+
/* */
19+
/* The above copyright notice and this permission notice shall be */
20+
/* included in all copies or substantial portions of the Software. */
21+
/* */
22+
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23+
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24+
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25+
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26+
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27+
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28+
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29+
/**************************************************************************/
30+
31+
#pragma once
32+
33+
#include "core/templates/fixed_vector.h"
34+
35+
#include "tests/test_macros.h"
36+
37+
namespace TestFixedVector {
38+
39+
TEST_CASE("[FixedVector] Basic Checks") {
40+
FixedVector<uint16_t, 1> vector;
41+
CHECK_EQ(vector.capacity(), 1);
42+
43+
CHECK_EQ(vector.size(), 0);
44+
CHECK(vector.is_empty());
45+
CHECK(!vector.is_full());
46+
47+
vector.push_back(5);
48+
CHECK_EQ(vector.size(), 1);
49+
CHECK_EQ(vector[0], 5);
50+
CHECK_EQ(vector.ptr()[0], 5);
51+
CHECK(!vector.is_empty());
52+
CHECK(vector.is_full());
53+
54+
vector.pop_back();
55+
CHECK_EQ(vector.size(), 0);
56+
CHECK(vector.is_empty());
57+
CHECK(!vector.is_full());
58+
59+
FixedVector<uint16_t, 2> vector1 = { 1, 2 };
60+
CHECK_EQ(vector1.capacity(), 2);
61+
CHECK_EQ(vector1.size(), 2);
62+
CHECK_EQ(vector1[0], 1);
63+
CHECK_EQ(vector1[1], 2);
64+
65+
FixedVector<uint16_t, 3> vector2(vector1);
66+
CHECK_EQ(vector2.capacity(), 3);
67+
CHECK_EQ(vector2.size(), 2);
68+
CHECK_EQ(vector2[0], 1);
69+
CHECK_EQ(vector2[1], 2);
70+
71+
FixedVector<Variant, 3> vector_variant;
72+
CHECK_EQ(vector_variant.size(), 0);
73+
CHECK_EQ(vector_variant.capacity(), 3);
74+
vector_variant.resize(3);
75+
vector_variant[0] = "Test";
76+
vector_variant[1] = 1;
77+
CHECK_EQ(vector_variant.capacity(), 3);
78+
CHECK_EQ(vector_variant.size(), 3);
79+
CHECK_EQ(vector_variant[0], "Test");
80+
CHECK_EQ(vector_variant[1], Variant(1));
81+
CHECK_EQ(vector_variant[2].get_type(), Variant::NIL);
82+
}
83+
84+
} //namespace TestFixedVector

‎tests/test_main.cpp

+1
Original file line numberDiff line numberDiff line change
@@ -94,6 +94,7 @@
9494
#include "tests/core/string/test_translation_server.h"
9595
#include "tests/core/templates/test_a_hash_map.h"
9696
#include "tests/core/templates/test_command_queue.h"
97+
#include "tests/core/templates/test_fixed_vector.h"
9798
#include "tests/core/templates/test_hash_map.h"
9899
#include "tests/core/templates/test_hash_set.h"
99100
#include "tests/core/templates/test_list.h"

0 commit comments

Comments
 (0)