janwas
c0ed950657
this snowballed into a massive search+destroy of the hodgepodge of mostly equivalent types we had in use (int, uint, unsigned, unsigned int, i32, u32, ulong, uintN). it is more efficient to use 64-bit types in 64-bit mode, so the preferred default is size_t (for anything remotely resembling a size or index). tile coordinates are ssize_t to allow more efficient conversion to/from floating point. flags are int because we almost never need more than 15 distinct bits, bit test/set is not slower and int is fastest to type. finally, some data that is pretty much directly passed to OpenGL is now typed accordingly. after several hours, the code now requires fewer casts and less guesswork. other changes: - unit and player IDs now have an "invalid id" constant in the respective class to avoid casting and -1 - fix some endian/64-bit bugs in the map (un)packing. added a convenience function to write/read a size_t. - ia32: change CPUID interface to allow passing in ecx (required for cache topology detection, which I need at work). remove some unneeded functions from asm, replace with intrinsics where possible. This was SVN commit r5942.
99 lines
2.7 KiB
C
99 lines
2.7 KiB
C
/**
|
|
* =========================================================================
|
|
* File : bucket.h
|
|
* Project : 0 A.D.
|
|
* Description : bucket allocator
|
|
* =========================================================================
|
|
*/
|
|
|
|
// license: GPL; see lib/license.txt
|
|
|
|
#ifndef INCLUDED_BUCKET
|
|
#define INCLUDED_BUCKET
|
|
|
|
/**
|
|
* allocator design goals:
|
|
* - either fixed- or variable-sized blocks;
|
|
* - allow freeing individual blocks if they are all fixed-size;
|
|
* - never relocates;
|
|
* - no fixed limit.
|
|
*
|
|
* note: this type of allocator is called "region-based" in the literature
|
|
* and is also known as "obstack"; see "Reconsidering Custom Memory
|
|
* Allocation" (Berger, Zorn, McKinley).
|
|
* if individual variable-size elements must be freeable, consider "reaps":
|
|
* basically a combination of region and heap, where frees go to the heap and
|
|
* allocs exhaust that memory first and otherwise use the region.
|
|
*
|
|
* opaque! do not read/write any fields!
|
|
**/
|
|
struct LIB_API Bucket
|
|
{
|
|
/**
|
|
* currently open bucket.
|
|
**/
|
|
u8* bucket;
|
|
|
|
/**
|
|
* offset of free space at end of current bucket (i.e. # bytes in use).
|
|
**/
|
|
size_t pos;
|
|
|
|
void* freelist;
|
|
|
|
size_t el_size;
|
|
|
|
/**
|
|
* records # buckets allocated; verifies the list of buckets is correct.
|
|
**/
|
|
size_t num_buckets;
|
|
};
|
|
|
|
|
|
/**
|
|
* ready the Bucket object for use.
|
|
*
|
|
* @param Bucket*
|
|
* @param el_size 0 to allow variable-sized allocations (which cannot be
|
|
* freed individually); otherwise, it specifies the number of bytes that
|
|
* will be returned by bucket_alloc (whose size parameter is then ignored).
|
|
* @return LibError.
|
|
**/
|
|
LIB_API LibError bucket_create(Bucket* b, size_t el_size);
|
|
|
|
/**
|
|
* free all memory that ensued from <b>.
|
|
*
|
|
* future alloc and free calls on this Bucket will fail.
|
|
*
|
|
* @param Bucket*
|
|
**/
|
|
LIB_API void bucket_destroy(Bucket* b);
|
|
|
|
/**
|
|
* Dole out memory from the Bucket.
|
|
* exhausts the freelist before returning new entries to improve locality.
|
|
*
|
|
* @param Bucket*
|
|
* @param size bytes to allocate; ignored if bucket_create's el_size was not 0.
|
|
* @return allocated memory, or 0 if the Bucket would have to be expanded and
|
|
* there isn't enough memory to do so.
|
|
**/
|
|
LIB_API void* bucket_alloc(Bucket* b, size_t size);
|
|
|
|
LIB_API void* bucket_fast_alloc(Bucket* b);
|
|
|
|
/**
|
|
* make an entry available for reuse in the given Bucket.
|
|
*
|
|
* this is not allowed if created for variable-size elements.
|
|
* rationale: avoids having to pass el_size here and compare with size when
|
|
* allocating; also prevents fragmentation and leaking memory.
|
|
*
|
|
* @param Bucket*
|
|
* @param el entry allocated via bucket_alloc.
|
|
**/
|
|
LIB_API void bucket_free(Bucket* b, void* el);
|
|
|
|
#endif // #ifndef INCLUDED_BUCKET
|