miguel.horta/openttd-cmclient
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Codechange: Replace Array/FixedSizeArray with std::deque. (#12409)

Browse Source 
Array/FixedSizeArray is actually a resizeable container that allocates space in chunks and allows resizing without invalidating pointers.

This is also a behaviour of std::deque, so use that instead.
This commit is contained in:
Peter Nelson
2024-05-04 10:55:16 +01:00
committed by GitHub
parent cb26b0e92d
commit d074ab909c
7 changed files with 35 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/misc/CMakeLists.txt
View File

@@ -1,12 +1,10 @@
add_files(
array.hpp
binaryheap.hpp
countedobj.cpp
countedptr.hpp
dbg_helpers.cpp
dbg_helpers.h
endian_buffer.hpp
fixedsizearray.hpp
getoptdata.cpp
getoptdata.h
hashtable.hpp

116
src/misc/array.hpp
View File

@@ -1,116 +0,0 @@
/*
* This file is part of OpenTTD.
* OpenTTD 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, version 2.
* OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file array.hpp Array without an explicit maximum size. */
#ifndef ARRAY_HPP
#define ARRAY_HPP
#include "fixedsizearray.hpp"
#include "../string_func.h"
/**
* Flexible array with size limit. Implemented as fixed size
* array of fixed size arrays
*/
template <class T, uint B = 1024, uint N = B>
class SmallArray {
protected:
typedef FixedSizeArray<T, B> SubArray; ///< inner array
typedef FixedSizeArray<SubArray, N> SuperArray; ///< outer array
static const uint Tcapacity = B * N; ///< total max number of items
SuperArray data; ///< array of arrays of items
/** return first sub-array with free space for new item */
inline SubArray &FirstFreeSubArray()
{
uint super_size = data.Length();
if (super_size > 0) {
SubArray &s = data[super_size - 1];
if (!s.IsFull()) return s;
}
return *data.AppendC();
}
public:
/** implicit constructor */
inline SmallArray()
{
}
/** Clear (destroy) all items */
inline void Clear()
{
data.Clear();
}
/** Return actual number of items */
inline uint Length() const
{
uint super_size = data.Length();
if (super_size == 0) return 0;
uint sub_size = data[super_size - 1].Length();
return (super_size - 1) * B + sub_size;
}
/** return true if array is empty */
inline bool IsEmpty()
{
return data.IsEmpty();
}
/** return true if array is full */
inline bool IsFull()
{
return data.IsFull() && data[N - 1].IsFull();
}
/** allocate but not construct new item */
inline T *Append()
{
return FirstFreeSubArray().Append();
}
/** allocate and construct new item */
inline T *AppendC()
{
return FirstFreeSubArray().AppendC();
}
/** indexed access (non-const) */
inline T& operator[](uint index)
{
const SubArray &s = data[index / B];
T &item = s[index % B];
return item;
}
/** indexed access (const) */
inline const T& operator[](uint index) const
{
const SubArray &s = data[index / B];
const T &item = s[index % B];
return item;
}
/**
* Helper for creating a human readable output of this data.
* @param dmp The location to dump to.
*/
template <typename D> void Dump(D &dmp) const
{
dmp.WriteValue("capacity", Tcapacity);
uint num_items = Length();
dmp.WriteValue("num_items", num_items);
for (uint i = 0; i < num_items; i++) {
const T &item = (*this)[i];
dmp.WriteStructT(fmt::format("item[{}]", i), &item);
}
}
};
#endif /* ARRAY_HPP */

28
src/misc/dbg_helpers.h
View File

@@ -165,6 +165,34 @@ struct DumpTarget {
EndStruct();
}
}
/** Dump nested object (or only its name if this instance is already known). */
template <typename S> void WriteStructT(const std::string &name, const std::deque<S> *s)
{
static size_t type_id = ++LastTypeId();
if (s == nullptr) {
/* No need to dump nullptr struct. */
WriteValue(name, "<null>");
return;
}
std::string known_as;
if (FindKnownName(type_id, s, known_as)) {
/* We already know this one, no need to dump it. */
std::string known_as_str = std::string("known_as.") + name;
WriteValue(name, known_as_str);
} else {
/* Still unknown, dump it */
BeginStruct(type_id, name, s);
size_t num_items = s->size();
this->WriteValue("num_items", std::to_string(num_items));
for (size_t i = 0; i < num_items; i++) {
const auto &item = (*s)[i];
this->WriteStructT(fmt::format("item[{}]", i), &item);
}
EndStruct();
}
}
};
#endif /* DBG_HELPERS_H */

158
src/misc/fixedsizearray.hpp
View File

@@ -1,158 +0,0 @@
/*
* This file is part of OpenTTD.
* OpenTTD 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, version 2.
* OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file fixedsizearray.hpp A fixed size array that doesn't create items until needed. */
#ifndef FIXEDSIZEARRAY_HPP
#define FIXEDSIZEARRAY_HPP
#include "../core/alloc_func.hpp"
/**
* fixed size array
* Upon construction it preallocates fixed size block of memory
* for all items, but doesn't construct them. Item's construction
* is delayed.
*/
template <class T, uint C>
struct FixedSizeArray {
protected:
/** header for fixed size array */
struct ArrayHeader
{
uint items; ///< number of items in the array
uint reference_count; ///< block reference counter (used by copy constructor and by destructor)
};
/* make constants visible from outside */
static const uint Tsize = sizeof(T); ///< size of item
static const uint HeaderSize = sizeof(ArrayHeader); ///< size of header
/**
* the only member of fixed size array is pointer to the block
* of C array of items. Header can be found on the offset -sizeof(ArrayHeader).
*/
T *data;
/** return reference to the array header (non-const) */
inline ArrayHeader &Hdr()
{
return *(ArrayHeader*)(((uint8_t*)data) - HeaderSize);
}
/** return reference to the array header (const) */
inline const ArrayHeader &Hdr() const
{
return *(ArrayHeader*)(((uint8_t*)data) - HeaderSize);
}
/** return reference to the block reference counter */
inline uint &RefCnt()
{
return Hdr().reference_count;
}
/** return reference to number of used items */
inline uint &SizeRef()
{
return Hdr().items;
}
public:
/** Default constructor. Preallocate space for items and header, then initialize header. */
FixedSizeArray()
{
/* Ensure the size won't overflow. */
static_assert(C < (SIZE_MAX - HeaderSize) / Tsize);
/* allocate block for header + items (don't construct items) */
data = (T*)((MallocT<uint8_t>(HeaderSize + C * Tsize)) + HeaderSize);
SizeRef() = 0; // initial number of items
RefCnt() = 1; // initial reference counter
}
/** Copy constructor. Preallocate space for items and header, then initialize header. */
FixedSizeArray(const FixedSizeArray<T, C> &src)
{
/* share block (header + items) with the source array */
data = src.data;
RefCnt()++; // now we share block with the source
}
/** destroy remaining items and free the memory block */
~FixedSizeArray()
{
/* release one reference to the shared block */
if ((--RefCnt()) > 0) return; // and return if there is still some owner
Clear();
/* free the memory block occupied by items */
free(((uint8_t*)data) - HeaderSize);
data = nullptr;
}
/** Clear (destroy) all items */
inline void Clear()
{
/* Walk through all allocated items backward and destroy them
* Note: this->Length() can be zero. In that case data[this->Length() - 1] is evaluated unsigned
* on some compilers with some architectures. (e.g. gcc with x86) */
for (T *pItem = this->data + this->Length() - 1; pItem >= this->data; pItem--) {
pItem->~T();
}
/* number of items become zero */
SizeRef() = 0;
}
/** return number of used items */
inline uint Length() const
{
return Hdr().items;
}
/** return true if array is full */
inline bool IsFull() const
{
return Length() >= C;
}
/** return true if array is empty */
inline bool IsEmpty() const
{
return Length() <= 0;
}
/** add (allocate), but don't construct item */
inline T *Append()
{
assert(!IsFull());
return &data[SizeRef()++];
}
/** add and construct item using default constructor */
inline T *AppendC()
{
T *item = Append();
new(item)T;
return item;
}
/** return item by index (non-const version) */
inline T& operator[](uint index)
{
assert(index < Length());
return data[index];
}
/** return item by index (const version) */
inline const T& operator[](uint index) const
{
assert(index < Length());
return data[index];
}
};
#endif /* FIXEDSIZEARRAY_HPP */