summaryrefslogtreecommitdiff
path: root/src/misc/blob.hpp
blob: 7784b6af6bcf4ec89ffa006e734b2cd84a3fc203 (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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
/*
 * 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 blob.hpp Support for storing random binary data. */

#ifndef BLOB_HPP
#define BLOB_HPP

#include "../core/alloc_func.hpp"

/**
 * Base class for simple binary blobs.
 *  Item is byte.
 *  The word 'simple' means:
 *    - no configurable allocator type (always made from heap)
 *    - no smart deallocation - deallocation must be called from the same
 *        module (DLL) where the blob was allocated
 *    - no configurable allocation policy (how big blocks should be allocated)
 *    - no extra ownership policy (i.e. 'copy on write') when blob is copied
 *    - no thread synchronization at all
 *
 *  Internal member layout:
 *  1. The only class member is pointer to the first item (see union).
 *  2. Allocated block contains the blob header (see BlobHeader) followed by the raw byte data.
 *     Always, when it allocates memory the allocated size is:
 *                                                      sizeof(BlobHeader) + <data capacity>
 *  3. Two 'virtual' members (items and capacity) are stored in the BlobHeader at beginning
 *     of the allocated block.
 *  4. The pointer of the union pobsize_ts behind the header (to the first data byte).
 *     When memory block is allocated, the sizeof(BlobHeader) it added to it.
 *  5. Benefits of this layout:
 *     - items are accessed in the simplest possible way - just dereferencing the pointer,
 *       which is good for performance (assuming that data are accessed most often).
 *     - sizeof(blob) is the same as the size of any other pointer
 *  6. Drawbacks of this layout:
 *     - the fact that a pointer to the allocated block is adjusted by sizeof(BlobHeader) before
 *       it is stored can lead to several confusions:
 *         - it is not a common pattern so the implementation code is bit harder to read.
 *         - valgrind may generate a warning that the allocated block is lost (not accessible).
 */
class ByteBlob {
protected:
	/** header of the allocated memory block */
	struct BlobHeader {
		size_t items;     ///< actual blob size in bytes
		size_t capacity;  ///< maximum (allocated) size in bytes
	};

	/** type used as class member */
	union {
		byte       *data;    ///< ptr to the first byte of data
		BlobHeader *header;  ///< ptr just after the BlobHeader holding items and capacity
	};

private:
	/**
	 * Just to silence an unsilencable GCC 4.4+ warning
	 * Note: This cannot be 'const' as we do a lot of 'hdrEmpty[0]->items += 0;' and 'hdrEmpty[0]->capacity += 0;'
	 *       after const_casting.
	 */
	static BlobHeader hdrEmpty[];

public:
	static const size_t tail_reserve = 4; ///< four extra bytes will be always allocated and zeroed at the end
	static const size_t header_size = sizeof(BlobHeader);

	/** default constructor - initializes empty blob */
	inline ByteBlob()
	{
		InitEmpty();
	}

	/** copy constructor */
	inline ByteBlob(const ByteBlob &src)
	{
		InitEmpty();
		AppendRaw(src);
	}

	/** move constructor - take ownership of blob data */
	inline ByteBlob(BlobHeader * const & src)
	{
		assert(src != nullptr);
		header = src;
		*const_cast<BlobHeader**>(&src) = nullptr;
	}

	/** destructor */
	inline ~ByteBlob()
	{
		Free();
	}

protected:
	/** all allocation should happen here */
	static inline BlobHeader *RawAlloc(size_t num_bytes)
	{
		return (BlobHeader*)MallocT<byte>(num_bytes);
	}

	/**
	 * Return header pointer to the static BlobHeader with
	 * both items and capacity containing zero
	 */
	static inline BlobHeader *Zero()
	{
		return const_cast<BlobHeader *>(&ByteBlob::hdrEmpty[1]);
	}

	/** simple allocation policy - can be optimized later */
	static inline size_t AllocPolicy(size_t min_alloc)
	{
		if (min_alloc < (1 << 9)) {
			if (min_alloc < (1 << 5)) return (1 << 5);
			return (min_alloc < (1 << 7)) ? (1 << 7) : (1 << 9);
		}
		if (min_alloc < (1 << 15)) {
			if (min_alloc < (1 << 11)) return (1 << 11);
			return (min_alloc < (1 << 13)) ? (1 << 13) : (1 << 15);
		}
		if (min_alloc < (1 << 20)) {
			if (min_alloc < (1 << 17)) return (1 << 17);
			return (min_alloc < (1 << 19)) ? (1 << 19) : (1 << 20);
		}
		min_alloc = (min_alloc | ((1 << 20) - 1)) + 1;
		return min_alloc;
	}

	/** all deallocations should happen here */
	static inline void RawFree(BlobHeader *p)
	{
		/* Just to silence an unsilencable GCC 4.4+ warning. */
		assert(p != ByteBlob::hdrEmpty);

		/* In case GCC warns about the following, see GCC's PR38509 why it is bogus. */
		free(p);
	}

	/** initialize the empty blob */
	inline void InitEmpty()
	{
		header = Zero();
	}

	/** initialize blob by attaching it to the given header followed by data */
	inline void Init(BlobHeader *src)
	{
		header = &src[1];
	}

	/** blob header accessor - use it rather than using the pointer arithmetic directly - non-const version */
	inline BlobHeader& Hdr()
	{
		return *(header - 1);
	}

	/** blob header accessor - use it rather than using the pointer arithmetic directly - const version */
	inline const BlobHeader& Hdr() const
	{
		return *(header - 1);
	}

	/** return reference to the actual blob size - used when the size needs to be modified */
	inline size_t& LengthRef()
	{
		return Hdr().items;
	}

public:
	/** return true if blob doesn't contain valid data */
	inline bool IsEmpty() const
	{
		return Length() == 0;
	}

	/** return the number of valid data bytes in the blob */
	inline size_t Length() const
	{
		return Hdr().items;
	}

	/** return the current blob capacity in bytes */
	inline size_t Capacity() const
	{
		return Hdr().capacity;
	}

	/** return pointer to the first byte of data - non-const version */
	inline byte *Begin()
	{
		return data;
	}

	/** return pointer to the first byte of data - const version */
	inline const byte *Begin() const
	{
		return data;
	}

	/** invalidate blob's data - doesn't free buffer */
	inline void Clear()
	{
		LengthRef() = 0;
	}

	/** free the blob's memory */
	inline void Free()
	{
		if (Capacity() > 0) {
			RawFree(&Hdr());
			InitEmpty();
		}
	}

	/** append new bytes at the end of existing data bytes - reallocates if necessary */
	inline void AppendRaw(const void *p, size_t num_bytes)
	{
		assert(p != nullptr);
		if (num_bytes > 0) {
			memcpy(Append(num_bytes), p, num_bytes);
		}
	}

	/** append bytes from given source blob to the end of existing data bytes - reallocates if necessary */
	inline void AppendRaw(const ByteBlob& src)
	{
		if (!src.IsEmpty()) {
			memcpy(Append(src.Length()), src.Begin(), src.Length());
		}
	}

	/**
	 * Reallocate if there is no free space for num_bytes bytes.
	 *  @return pointer to the new data to be added
	 */
	inline byte *Prepare(size_t num_bytes)
	{
		size_t new_size = Length() + num_bytes;
		if (new_size > Capacity()) SmartAlloc(new_size);
		return data + Length();
	}

	/**
	 * Increase Length() by num_bytes.
	 *  @return pointer to the new data added
	 */
	inline byte *Append(size_t num_bytes)
	{
		byte *pNewData = Prepare(num_bytes);
		LengthRef() += num_bytes;
		return pNewData;
	}

	/** reallocate blob data if needed */
	void SmartAlloc(size_t new_size)
	{
		if (Capacity() >= new_size) return;
		/* calculate minimum block size we need to allocate
		 * and ask allocation policy for some reasonable block size */
		assert(new_size < SIZE_MAX - header_size - tail_reserve);
		new_size = AllocPolicy(header_size + new_size + tail_reserve);

		/* allocate new block and setup header */
		BlobHeader *tmp = RawAlloc(new_size);
		tmp->items = Length();
		tmp->capacity = new_size - (header_size + tail_reserve);

		/* copy existing data */
		if (tmp->items != 0) {
			memcpy(tmp + 1, data, tmp->items);
		}

		/* replace our block with new one */
		if (Capacity() > 0) {
			RawFree(&Hdr());
		}
		Init(tmp);
	}

	/** fixing the four bytes at the end of blob data - useful when blob is used to hold string */
	inline void FixTail() const
	{
		if (Capacity() > 0) {
			byte *p = &data[Length()];
			for (uint i = 0; i < tail_reserve; i++) {
				p[i] = 0;
			}
		}
	}
};

/**
 * Blob - simple dynamic T array. T (template argument) is a placeholder for any type.
 *  T can be any integral type, pointer, or structure. Using Blob instead of just plain C array
 *  simplifies the resource management in several ways:
 *  1. When adding new item(s) it automatically grows capacity if needed.
 *  2. When variable of type Blob comes out of scope it automatically frees the data buffer.
 *  3. Takes care about the actual data size (number of used items).
 *  4. Dynamically constructs only used items (as opposite of static array which constructs all items)
 */
template <typename T>
class CBlobT : public ByteBlob {
	/* make template arguments public: */
public:
	typedef ByteBlob base;

	static const size_t type_size = sizeof(T);

	struct OnTransfer {
		typename base::BlobHeader *header;

		OnTransfer(const OnTransfer& src) : header(src.header)
		{
			assert(src.header != nullptr);
			*const_cast<typename base::BlobHeader**>(&src.header) = nullptr;
		}

		OnTransfer(CBlobT& src) : header(src.header)
		{
			src.InitEmpty();
		}

		~OnTransfer()
		{
			assert(header == nullptr);
		}
	};

	/** Default constructor - makes new Blob ready to accept any data */
	inline CBlobT()
		: base()
	{}

	/** Take ownership constructor */
	inline CBlobT(const OnTransfer& ot)
		: base(ot.header)
	{}

	/** Destructor - ensures that allocated memory (if any) is freed */
	inline ~CBlobT()
	{
		Free();
	}

	/** Check the validity of item index (only in debug mode) */
	inline void CheckIdx(size_t index) const
	{
		assert(index < Size());
	}

	/** Return pointer to the first data item - non-const version */
	inline T *Data()
	{
		return (T*)base::Begin();
	}

	/** Return pointer to the first data item - const version */
	inline const T *Data() const
	{
		return (const T*)base::Begin();
	}

	/** Return pointer to the index-th data item - non-const version */
	inline T *Data(size_t index)
	{
		CheckIdx(index);
		return (Data() + index);
	}

	/** Return pointer to the index-th data item - const version */
	inline const T *Data(size_t index) const
	{
		CheckIdx(index);
		return (Data() + index);
	}

	/** Return number of items in the Blob */
	inline size_t Size() const
	{
		return (base::Length() / type_size);
	}

	/** Return total number of items that can fit in the Blob without buffer reallocation */
	inline size_t MaxSize() const
	{
		return (base::Capacity() / type_size);
	}

	/** Return number of additional items that can fit in the Blob without buffer reallocation */
	inline size_t GetReserve() const
	{
		return ((base::Capacity() - base::Length()) / type_size);
	}

	/** Grow number of data items in Blob by given number - doesn't construct items */
	inline T *GrowSizeNC(size_t num_items)
	{
		return (T*)base::Append(num_items * type_size);
	}

	/**
	 * Ensures that given number of items can be added to the end of Blob. Returns pointer to the
	 *  first free (unused) item
	 */
	inline T *MakeFreeSpace(size_t num_items)
	{
		return (T*)base::Prepare(num_items * type_size);
	}

	inline OnTransfer Transfer()
	{
		return OnTransfer(*this);
	}
};


#endif /* BLOB_HPP */