diff --git a/polymer/eduke32/build/include/nedmalloc.h b/polymer/eduke32/build/include/nedmalloc.h deleted file mode 100644 index a438d2df0..000000000 --- a/polymer/eduke32/build/include/nedmalloc.h +++ /dev/null @@ -1,1639 +0,0 @@ -/* nedalloc, an alternative malloc implementation for multiple threads without -lock contention based on dlmalloc v2.8.4. (C) 2005-2010 Niall Douglas - -Boost Software License - Version 1.0 - August 17th, 2003 - -Permission is hereby granted, free of charge, to any person or organization -obtaining a copy of the software and accompanying documentation covered by -this license (the "Software") to use, reproduce, display, distribute, -execute, and transmit the Software, and to prepare derivative works of the -Software, and to permit third-parties to whom the Software is furnished to -do so, all subject to the following: - -The copyright notices in the Software and this entire statement, including -the above license grant, this restriction and the following disclaimer, -must be included in all copies of the Software, in whole or in part, and -all derivative works of the Software, unless such copies or derivative -works are solely in the form of machine-executable object code generated by -a source language processor. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT -SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE -FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, -ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. -*/ - -#ifndef NEDMALLOC_H -#define NEDMALLOC_H - -#ifndef UNREFERENCED_PARAMETER - #define UNREFERENCED_PARAMETER(x) x=x -#endif - -#if defined __GNUC__ || defined __clang__ -# define ATTRIBUTE(attrlist) __attribute__(attrlist) -#else -# define ATTRIBUTE(attrlist) -#endif - -/*! \file nedmalloc.h -\brief Defines the functionality provided by nedalloc. -*/ - -/*! \mainpage - -Please see the Readme.html -*/ - -/*! \def NEDMALLOC_DEBUG -\brief Defines the assertion checking performed by nedalloc - -NEDMALLOC_DEBUG can be defined to cause DEBUG to be set differently for nedmalloc -than for the rest of the build. Remember to set NDEBUG to disable all assertion -checking too. -*/ - -/*! \def ENABLE_LARGE_PAGES -\brief Defines whether nedalloc uses large pages (>=2Mb) - -ENABLE_LARGE_PAGES enables support for requesting memory from the system in large -(typically >=2Mb) pages if the host OS supports this. These occupy just a single -TLB entry and can significantly improve performance in large working set applications. -*/ - -/*! \def ENABLE_FAST_HEAP_DETECTION -\brief Defines whether nedalloc takes platform specific shortcuts when detecting foreign blocks. - -ENABLE_FAST_HEAP_DETECTION enables special logic to detect blocks allocated -by the system heap. This avoids 1.5%-2% overhead when checking for non-nedmalloc -blocks, but it assumes that the NT and glibc heaps function in a very specific -fashion which may not hold true across OS upgrades. -*/ - -/*! \def HAVE_CPP0XRVALUEREFS -\ingroup C++ -\brief Enables rvalue references - -Define to enable the usage of rvalue references which enables move semantics and -other things. Automatically defined if __cplusplus indicates a C++0x compiler, -otherwise you'll need to set it yourself. -*/ - -/*! \def HAVE_CPP0XVARIADICTEMPLATES -\ingroup C++ -\brief Enables variadic templates - -Define to enable the usage of variadic templates which enables the use of arbitrary -numbers of policies and other useful things. Automatically defined if __cplusplus -indicates a C++0x compiler, otherwise you'll need to set it yourself. -*/ - -/*! \def HAVE_CPP0XSTATICASSERT -\ingroup C++ -\brief Enables static assertions - -Define to enable the usage of static assertions. Automatically defined if __cplusplus -indicates a C++0x compiler, otherwise you'll need to set it yourself. -*/ - -/*! \def HAVE_CPP0XTYPETRAITS -\ingroup C++ -\brief Enables type traits - -Define to enable the usage of <type_traits>. Automatically defined if __cplusplus -indicates a C++0x compiler, otherwise you'll need to set it yourself. -*/ - -#if __cplusplus > 199711L || defined(HAVE_CPP0X) /* Do we have C++0x? */ -#undef HAVE_CPP0XRVALUEREFS -#define HAVE_CPP0XRVALUEREFS 1 -#undef HAVE_CPP0XVARIADICTEMPLATES -#define HAVE_CPP0XVARIADICTEMPLATES 1 -#undef HAVE_CPP0XSTATICASSERT -#define HAVE_CPP0XSTATICASSERT 1 -#undef HAVE_CPP0XTYPETRAITS -#define HAVE_CPP0XTYPETRAITS 1 -#endif - -#include /* for size_t */ - -/*! \def NEDMALLOCEXTSPEC -\brief Defines how nedalloc's API is to be made visible. - -NEDMALLOCEXTSPEC can be defined to be __declspec(dllexport) or -__attribute__ ((visibility("default"))) or whatever you like. It defaults -to extern unless NEDMALLOC_DLL_EXPORTS is set as it would be when building -nedmalloc.dll. - */ -#ifndef NEDMALLOCEXTSPEC - #ifdef NEDMALLOC_DLL_EXPORTS - #ifdef _WIN32 - #define NEDMALLOCEXTSPEC extern __declspec(dllexport) - #elif defined(__GNUC__) - #define NEDMALLOCEXTSPEC extern __attribute__ ((visibility("default"))) - #endif - #ifndef ENABLE_TOLERANT_NEDMALLOC - #define ENABLE_TOLERANT_NEDMALLOC 1 - #endif - #else - #define NEDMALLOCEXTSPEC extern - #endif -#endif - -/*! \def NEDMALLOCDEPRECATED -\brief Defined to mark an API as deprecated */ -#ifndef NEDMALLOCDEPRECATED -#if defined(_MSC_VER) && !defined(__GCCXML__) - #define NEDMALLOCDEPRECATED __declspec(deprecated) -#elif defined(__GNUC__) && !defined(__GCCXML__) - #define NEDMALLOCDEPRECATED __attribute ((deprecated)) -#else -//! Marks a function as being deprecated - #define NEDMALLOCDEPRECATED -#endif -#endif - -/*! \def RESTRICT -\brief Defined to the restrict keyword or equivalent if available */ -#ifndef RESTRICT -#if __STDC_VERSION__ >= 199901L /* C99 or better */ - #define RESTRICT restrict -#else - #if defined(_MSC_VER) && _MSC_VER>=1400 - #define RESTRICT __restrict - #endif - #ifdef __GNUC__ - #define RESTRICT __restrict - #endif -#endif -#ifndef RESTRICT - #define RESTRICT -#endif -#endif - -#if defined(_MSC_VER) && _MSC_VER>=1400 - #define NEDMALLOCPTRATTR __declspec(restrict) - #define NEDMALLOCNOALIASATTR __declspec(noalias) -#endif -#ifdef __GNUC__ - #define NEDMALLOCPTRATTR __attribute__ ((malloc)) -#endif -/*! \def NEDMALLOCPTRATTR -\brief Defined to the specifier for a pointer which points to a memory block. Like NEDMALLOCNOALIASATTR, but sadly not identical. */ -#ifndef NEDMALLOCPTRATTR - #define NEDMALLOCPTRATTR -#endif -/*! \def NEDMALLOCNOALIASATTR -\brief Defined to the specifier for a pointer which does not alias any other variable. */ -#ifndef NEDMALLOCNOALIASATTR - #define NEDMALLOCNOALIASATTR -#endif - -/*! \def USE_MAGIC_HEADERS -\brief Defines whether nedalloc should use magic headers in foreign heap block detection - -USE_MAGIC_HEADERS causes nedalloc to allocate an extra three sizeof(size_t) -to each block. nedpfree() and nedprealloc() can then automagically know when -to free a system allocated block. Enabling this typically adds 20-50% to -application memory usage, and is mandatory if USE_ALLOCATOR is not 1. -*/ -#ifndef USE_MAGIC_HEADERS - #define USE_MAGIC_HEADERS 0 -#endif - -/*! \def USE_ALLOCATOR -\brief Defines the underlying allocator to use - -USE_ALLOCATOR can be one of these settings (it defaults to 1): - 0: System allocator (nedmalloc now simply acts as a threadcache) which is - very useful for testing with valgrind and Glowcode. - WARNING: Intended for DEBUG USE ONLY - not all functions work correctly. - 1: dlmalloc -*/ -#ifndef USE_ALLOCATOR - #define USE_ALLOCATOR 1 /* dlmalloc */ -#endif - -#if !USE_ALLOCATOR && !USE_MAGIC_HEADERS -#error If you are using the system allocator then you MUST use magic headers -#endif - -/*! \def REPLACE_SYSTEM_ALLOCATOR -\brief Defines whether to replace the system allocator (malloc(), free() et al) with nedalloc's implementation. - -REPLACE_SYSTEM_ALLOCATOR on POSIX causes nedalloc's functions to be called -malloc, free etc. instead of nedmalloc, nedfree etc. You may or may not want -this. On Windows it causes nedmalloc to patch all loaded DLLs and binaries -to replace usage of the system allocator. - -Always turns on ENABLE_TOLERANT_NEDMALLOC. -*/ -#ifdef REPLACE_SYSTEM_ALLOCATOR - #if USE_ALLOCATOR==0 - #error Cannot combine using the system allocator with replacing the system allocator - #endif - #ifndef ENABLE_TOLERANT_NEDMALLOC - #define ENABLE_TOLERANT_NEDMALLOC 1 - #endif - #ifndef _WIN32 /* We have a dedicated patcher for Windows */ - #define nedmalloc malloc - #define nedmalloc2 malloc2 - #define nedcalloc calloc - #define nedrealloc realloc - #define nedrealloc2 realloc2 - #define nedfree free - #define nedfree2 free2 - #define nedmemalign memalign - #define nedmallinfo mallinfo - #define nedmallopt mallopt - #define nedmalloc_trim malloc_trim - #define nedmalloc_stats malloc_stats - #define nedmalloc_footprint malloc_footprint - #define nedindependent_calloc independent_calloc - #define nedindependent_comalloc independent_comalloc - #ifdef __GNUC__ - #define nedmemsize malloc_usable_size - #endif - #endif -#endif - -/*! \def ENABLE_TOLERANT_NEDMALLOC -\brief Defines whether nedalloc should check for blocks from the system allocator. - -ENABLE_TOLERANT_NEDMALLOC is automatically turned on if REPLACE_SYSTEM_ALLOCATOR -is set or the Windows DLL is being built. This causes nedmalloc to detect when a -system allocator block is passed to it and to handle it appropriately. Note that -without USE_MAGIC_HEADERS there is a very tiny chance that nedmalloc will segfault -on non-Windows builds (it uses Win32 SEH to trap segfaults on Windows and there -is no comparable system on POSIX). -*/ - -#if defined(__cplusplus) -extern "C" { -#endif -/*! \brief Returns information about a memory pool */ -struct nedmallinfo { - size_t arena; /*!< non-mmapped space allocated from system */ - size_t ordblks; /*!< number of free chunks */ - size_t smblks; /*!< always 0 */ - size_t hblks; /*!< always 0 */ - size_t hblkhd; /*!< space in mmapped regions */ - size_t usmblks; /*!< maximum total allocated space */ - size_t fsmblks; /*!< always 0 */ - size_t uordblks; /*!< total allocated space */ - size_t fordblks; /*!< total free space */ - size_t keepcost; /*!< releasable (via malloc_trim) space */ -}; -#if defined(__cplusplus) -} -#endif - -/*! \def NO_NED_NAMESPACE -\brief Defines the use of the nedalloc namespace for the C functions. - -NO_NED_NAMESPACE prevents the functions from being defined in the nedalloc -namespace when in C++ (uses the global C namespace instead). -*/ -/*! \def THROWSPEC -\brief Defined to throw() or noexcept(true) (as in, throws nothing) under C++, otherwise nothing. -*/ -#if defined(__cplusplus) - #if !defined(NO_NED_NAMESPACE) -namespace nedalloc { - #else -extern "C" { - #endif - #if __cplusplus > 199711L - #define THROWSPEC noexcept(true) - #else - #define THROWSPEC throw() - #endif -#else - #define THROWSPEC -#endif - -/* These are the global functions */ - -/*! \defgroup v2malloc The v2 malloc API - -\warning This API is being completely retired in v1.10 beta 2 and replaced with the API -being developed for inclusion into the C1X programming language standard - -For the v1.10 release which was generously sponsored by -Applied Research Associates (USA), -a new general purpose allocator API was designed which is intended to remedy many -of the long standing problems and inefficiencies introduced by the ISO C allocator -API. Internally nedalloc's implementations of nedmalloc(), nedcalloc(), nedmemalign() -and nedrealloc() call into this API: - - - -If nedmalloc.h is being included by C++ code, the alignment and flags parameters -default to zero which makes the new API identical to the old API (roll on the introduction -of default parameters to C!). The ability for realloc2() to take an alignment is -particularly useful for extending aligned vector arrays such as SSE/AVX -vector arrays. Hitherto SSE/AVX vector code had to jump through all sorts of unpleasant -hoops to maintain alignment :(. - -Note that using any of these flags other than M2_ZERO_MEMORY or any alignment -other than zero inhibits the threadcache. - -Currently MREMAP support is limited to Linux and Windows. Patches implementing -support for other platforms are welcome. - -On Linux the non portable mremap() kernel function is currently used, so in fact -the M2_RESERVE_* options are currently ignored. - -On Windows, there are two different MREMAP implementations which are chosen according -to whether a 32 bit or a 64 bit build is being performed. The 32 bit implementation -is based on Win32 file mappings where it reserves the address space within the Windows -VM system, so you can safely specify silly reservation quantities like 2Gb per block -and not exhaust local process address space. Note however that on x86 this costs -2Kb (1Kb if PAE is off) of kernel memory per Mb reserved, and as kernel memory has -a hard limit of 447Mb on x86 you will find the total address space reservable in -the system is limited. On x64, or if you define WIN32_DIRECT_USE_FILE_MAPPINGS=0 -on x86, a much faster implementation of using VirtualAlloc(MEM_RESERVE) to directly -reserve the address space is used. - -When using M2_RESERVE_* with realloc2(), the setting only takes effect when the -mmapped chunk has exceeded its reservation space and a new reservation space needs -to be created. -*/ - -#ifndef M2_FLAGS_DEFINED -#define M2_FLAGS_DEFINED - -/*! \def M2_ZERO_MEMORY -\ingroup v2malloc -\brief Sets the contents of the allocated block (or any increase in the allocated -block) to zero. - -Note that this zeroes only the increase from what dlmalloc thinks -the chunk's size is, so if you realloc2() a block which wasn't allocated using -malloc2() using this flag then you may have garbage just before the newly extended -space. - -\li Rationale: Memory returned by the system is guaranteed to -be zero on most platforms, and hence dlmalloc knows when it can skip zeroing -memory. This improves performance. -*/ -#define M2_ZERO_MEMORY (1<<0) - -/*! \def M2_PREVENT_MOVE -\ingroup v2malloc -\brief Cause realloc2() to attempt to extend a block in place, but to never move -it. - -\li Rationale: C++ makes almost no use of realloc(), even for -contiguous arrays such as std::vector<> because most C++ objects cannot be relocated -in memory without a copy or rvalue construction (though some clever STL implementations -specialise for Plain Old Data (POD) types, and use realloc() then and only then). -This flag allows C++ containers to speculatively try to extend in place, thus -improving performance especially for large allocations which will use -mmap(). -*/ -#define M2_PREVENT_MOVE (1<<1) - -/*! \def M2_ALWAYS_MMAP -\ingroup v2malloc -\brief Always allocate as though mmap_threshold were being exceeded. - -In the case of realloc2(), note that setting this bit will not necessarily mmap a chunk -which isn't already mmapped, but it will force a mmapped chunk if new memory -needs allocating. - -\li Rationale: If you know that an array you are allocating -is going to be repeatedly extended up into the hundred of kilobytes range, then -you can avoid the constant memory copying into larger blocks by specifying this -flag at the beginning along with one of the M2_RESERVE_* flags below. This can -greatly improve performance for large arrays. -*/ -#define M2_ALWAYS_MMAP (1<<2) -#define M2_RESERVED1 (1<<3) -#define M2_RESERVED2 (1<<4) -#define M2_RESERVED3 (1<<5) -#define M2_RESERVED4 (1<<6) -#define M2_RESERVED5 (1<<7) -#define M2_RESERVE_ISMULTIPLIER (1<<15) -/* 7 bits is given to the address reservation specifier. -This lets you set a multiplier (bit 15 set) or a 1<< shift value. -*/ -#define M2_RESERVE_MASK 0x00007f00 - -/*! \def M2_RESERVE_MULT(n) -\ingroup v2malloc -\brief Reserve n times as much address space such that mmapped realloc2(size <= -n * original size) avoids memory copying and hence is much faster. -*/ -#define M2_RESERVE_MULT(n) (M2_RESERVE_ISMULTIPLIER|(((n)<<8)&M2_RESERVE_MASK)) - -/*! \def M2_RESERVE_SHIFT(n) -\ingroup v2malloc -\brief Reserve (1<0.01%) but real chance of segfault on non-Windows -systems when passing non-nedmalloc blocks if you don't use USE_MAGIC_HEADERS. -*/ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR size_t nedblksize(int *RESTRICT isforeign, void *RESTRICT mem, unsigned flags=0) THROWSPEC; -#else -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR size_t nedblksize(int *RESTRICT isforeign, void *RESTRICT mem, unsigned flags) THROWSPEC; -#endif -/*! \brief Identical to nedblksize() except without the isforeign */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR size_t nedmemsize(void *RESTRICT mem) THROWSPEC; - -/*! \brief Equivalent to nedpsetvalue((nedpool *) 0, v) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void nedsetvalue(void *v) THROWSPEC; - -/*! \brief Equivalent to nedpmalloc2((nedpool *) 0, size, 0, 0) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedmalloc(size_t size) THROWSPEC; -/*! \brief Equivalent to nedpmalloc2((nedpool *) 0, no*size, 0, M2_ZERO_MEMORY) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedcalloc(size_t no, size_t size) THROWSPEC; -/*! \brief Equivalent to nedprealloc2((nedpool *) 0, size, mem, size, 0, M2_RESERVE_MULT(8)) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedrealloc(void *mem, size_t size) THROWSPEC; -/*! \brief Equivalent to nedpfree2((nedpool *) 0, mem, 0) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void nedfree(void *mem) THROWSPEC; -/*! \brief Equivalent to nedpmalloc2((nedpool *) 0, size, alignment, 0) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedmemalign(size_t alignment, size_t bytes) THROWSPEC; - -#if defined(__cplusplus) -/*! \ingroup v2malloc -\brief Equivalent to nedpmalloc2((nedpool *) 0, size, alignment, flags) */ -NEDMALLOCDEPRECATED NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedmalloc2(size_t size, size_t alignment=0, unsigned flags=0) THROWSPEC; -/*! \ingroup v2malloc -\brief Equivalent to nedprealloc2((nedpool *) 0, mem, size, alignment, flags) */ -NEDMALLOCDEPRECATED NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedrealloc2(void *mem, size_t size, size_t alignment=0, unsigned flags=0) THROWSPEC; -/*! \ingroup v2malloc -\brief Equivalent to nedpfree2((nedpool *) 0, mem, flags) */ -NEDMALLOCDEPRECATED NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void nedfree2(void *mem, unsigned flags=0) THROWSPEC; -#else -NEDMALLOCDEPRECATED NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedmalloc2(size_t size, size_t alignment, unsigned flags) THROWSPEC; -NEDMALLOCDEPRECATED NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedrealloc2(void *mem, size_t size, size_t alignment, unsigned flags) THROWSPEC; -NEDMALLOCDEPRECATED NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void nedfree2(void *mem, unsigned flags) THROWSPEC; -#endif - -/*! \brief Equivalent to nedpmallinfo((nedpool *) 0) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR struct nedmallinfo nedmallinfo(void) THROWSPEC; -/*! \brief Equivalent to nedpmallopt((nedpool *) 0, parno, value) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR int nedmallopt(int parno, int value) THROWSPEC; -/*! \brief Returns the internal allocation granularity and the magic header XOR used for internal consistency checks. */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void* nedmalloc_internals(size_t *granularity, size_t *magic) THROWSPEC; -/*! \brief Equivalent to nedpmalloc_trim((nedpool *) 0, pad) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR int nedmalloc_trim(size_t pad) THROWSPEC; -/*! \brief Equivalent to nedpmalloc_stats((nedpool *) 0) */ -NEDMALLOCEXTSPEC void nedmalloc_stats(void) THROWSPEC; -/*! \brief Equivalent to nedpmalloc_footprint((nedpool *) 0) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR size_t nedmalloc_footprint(void) THROWSPEC; -/*! \brief Equivalent to nedpindependent_calloc((nedpool *) 0, elemsno, elemsize, chunks) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedindependent_calloc(size_t elemsno, size_t elemsize, void **chunks) THROWSPEC; -/*! \brief Equivalent to nedpindependent_comalloc((nedpool *) 0, elems, sizes, chunks) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedindependent_comalloc(size_t elems, size_t *sizes, void **chunks) THROWSPEC; - -/*! \brief Destroys the system memory pool used by the functions above. - -Useful for when you have nedmalloc in a DLL you're about to unload. -If you call ANY nedmalloc functions after calling this you will -get a fatal exception! -*/ -NEDMALLOCEXTSPEC void neddestroysyspool() THROWSPEC; - -/*! \brief A nedpool type */ -struct nedpool_t; -/*! \brief A nedpool type */ -typedef struct nedpool_t nedpool; - -/*! \brief Creates a memory pool for use with the nedp* functions below. - -Capacity is how much to allocate immediately (if you know you'll be allocating a lot -of memory very soon) which you can leave at zero. Threads specifies how many threads -will *normally* be accessing the pool concurrently. Setting this to zero means it -extends on demand, but be careful of this as it can rapidly consume system resources -where bursts of concurrent threads use a pool at once. -*/ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR nedpool *nedcreatepool(size_t capacity, int threads) THROWSPEC; - -/*! \brief Destroys a memory pool previously created by nedcreatepool(). -*/ -NEDMALLOCEXTSPEC void neddestroypool(nedpool *p) THROWSPEC; - -/*! \brief Returns a zero terminated snapshot of threadpools existing at the time of call. - -Call nedfree() on the returned list when you are done. Returns zero if there is only the -system pool in existence. -*/ -NEDMALLOCEXTSPEC nedpool **nedpoollist() THROWSPEC; - -/*! \brief Sets a value to be associated with a pool. - -You can retrieve this value by passing any memory block allocated from that pool. -*/ -NEDMALLOCEXTSPEC void nedpsetvalue(nedpool *p, void *v) THROWSPEC; - -/*! \brief Gets a previously set value using nedpsetvalue() or zero if memory is unknown. - -Optionally can also retrieve pool. You can detect an unknown block by the return -being zero and *p being unmodifed. -*/ -NEDMALLOCEXTSPEC void *nedgetvalue(nedpool **p, void *mem) THROWSPEC; - -/*! \brief Trims the thread cache for the calling thread, returning any existing cache -data to the central pool. - -Remember to ALWAYS call with zero if you used the system pool. Setting disable to -non-zero replicates neddisablethreadcache(). -*/ -NEDMALLOCEXTSPEC void nedtrimthreadcache(nedpool *p, int disable) THROWSPEC; - -/*! \brief Disables the thread cache for the calling thread, returning any existing cache -data to the central pool. - -Remember to ALWAYS call with zero if you used the system pool. -*/ -NEDMALLOCEXTSPEC void neddisablethreadcache(nedpool *p) THROWSPEC; - -/*! \brief Releases all memory in all threadcaches in the pool, and writes all -accumulated memory operations to the log if enabled. - -You can pass zero for filepath to use the compiled default, or else a char[MAX_PATH] -containing the path you wish to use for the log file. The log file is always -appended to if it already exists. After writing the logs, the logging ability -is disabled for that pool. - -\warning Do NOT call this if the pool is in use - this call is NOT threadsafe. -*/ -NEDMALLOCEXTSPEC size_t nedflushlogs(nedpool *p, char *filepath) THROWSPEC; - - -/*! \brief Equivalent to nedpmalloc2(p, size, 0, 0) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedpmalloc(nedpool *p, size_t size) THROWSPEC; -/*! \brief Equivalent to nedpmalloc2(p, no*size, 0, M2_ZERO_MEMORY) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedpcalloc(nedpool *p, size_t no, size_t size) THROWSPEC; -/*! \brief Equivalent to nedprealloc2(p, mem, size, 0, M2_RESERVE_MULT(8)) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedprealloc(nedpool *p, void *mem, size_t size) THROWSPEC; -/*! \brief Equivalent to nedpfree2(p, mem, 0) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void nedpfree(nedpool *p, void *mem) THROWSPEC; -/*! \brief Equivalent to nedpmalloc2(p, bytes, alignment, 0) */ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedpmemalign(nedpool *p, size_t alignment, size_t bytes) THROWSPEC; -#if defined(__cplusplus) -/*! \ingroup v2malloc -\brief Allocates a block of memory sized \em size from pool \em p, aligned to \em alignment and according to the flags \em flags. -*/ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedpmalloc2(nedpool *p, size_t size, size_t alignment=0, unsigned flags=0) THROWSPEC; -/*! \ingroup v2malloc -\brief Resizes the block of memory at \em mem in pool \em p to size \em size, aligned to \em alignment and according to the flags \em flags. -*/ -NEDMALLOCDEPRECATED NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedprealloc2(nedpool *p, void *mem, size_t size, size_t alignment=0, unsigned flags=0) THROWSPEC; -/*! \brief Frees the block \em mem from the pool \em p according to flags \em flags. */ -NEDMALLOCDEPRECATED NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void nedpfree2(nedpool *p, void *mem, unsigned flags=0) THROWSPEC; -#else -NEDMALLOCDEPRECATED NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedpmalloc2(nedpool *p, size_t size, size_t alignment, unsigned flags) THROWSPEC; -NEDMALLOCDEPRECATED NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedprealloc2(nedpool *p, void *mem, size_t size, size_t alignment, unsigned flags) THROWSPEC; -NEDMALLOCDEPRECATED NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void nedpfree2(nedpool *p, void *mem, unsigned flags) THROWSPEC; -#endif -/*! \brief Returns information about the memory pool */ -NEDMALLOCEXTSPEC struct nedmallinfo nedpmallinfo(nedpool *p) THROWSPEC; -/*! \brief Changes the operational parameters of the memory pool */ -NEDMALLOCEXTSPEC int nedpmallopt(nedpool *p, int parno, int value) THROWSPEC; -/*! \brief Tries to release as much free memory back to the system as possible, leaving \em pad remaining per threadpool. */ -NEDMALLOCEXTSPEC int nedpmalloc_trim(nedpool *p, size_t pad) THROWSPEC; -/*! \brief Prints some operational statistics to stdout. */ -NEDMALLOCEXTSPEC void nedpmalloc_stats(nedpool *p) THROWSPEC; -/*! \brief Returns how much memory is currently in use by the memory pool */ -NEDMALLOCEXTSPEC size_t nedpmalloc_footprint(nedpool *p) THROWSPEC; -/*! \brief Returns a series of guaranteed consecutive cleared memory allocations. - - independent_calloc is similar to calloc, but instead of returning a - single cleared space, it returns an array of pointers to n_elements - independent elements that can hold contents of size elem_size, each - of which starts out cleared, and can be independently freed, - realloc'ed etc. The elements are guaranteed to be adjacently - allocated (this is not guaranteed to occur with multiple callocs or - mallocs), which may also improve cache locality in some - applications. - - The "chunks" argument is optional (i.e., may be null, which is - probably the most typical usage). If it is null, the returned array - is itself dynamically allocated and should also be freed when it is - no longer needed. Otherwise, the chunks array must be of at least - n_elements in length. It is filled in with the pointers to the - chunks. - - In either case, independent_calloc returns this pointer array, or - null if the allocation failed. If n_elements is zero and "chunks" - is null, it returns a chunk representing an array with zero elements - (which should be freed if not wanted). - - Each element must be individually freed when it is no longer - needed. If you'd like to instead be able to free all at once, you - should instead use regular calloc and assign pointers into this - space to represent elements. (In this case though, you cannot - independently free elements.) - - independent_calloc simplifies and speeds up implementations of many - kinds of pools. It may also be useful when constructing large data - structures that initially have a fixed number of fixed-sized nodes, - but the number is not known at compile time, and some of the nodes - may later need to be freed. For example: - - struct Node { int item; struct Node* next; }; - - struct Node* build_list() { - struct Node** pool; - int n = read_number_of_nodes_needed(); - if (n <= 0) return 0; - pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0); - if (pool == 0) die(); - // organize into a linked list... - struct Node* first = pool[0]; - for (i = 0; i < n-1; ++i) - pool[i]->next = pool[i+1]; - free(pool); // Can now free the array (or not, if it is needed later) - return first; - } -*/ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedpindependent_calloc(nedpool *p, size_t elemsno, size_t elemsize, void **chunks) THROWSPEC; -/*! \brief Returns a series of guaranteed consecutive allocations. - - independent_comalloc allocates, all at once, a set of n_elements - chunks with sizes indicated in the "sizes" array. It returns - an array of pointers to these elements, each of which can be - independently freed, realloc'ed etc. The elements are guaranteed to - be adjacently allocated (this is not guaranteed to occur with - multiple callocs or mallocs), which may also improve cache locality - in some applications. - - The "chunks" argument is optional (i.e., may be null). If it is null - the returned array is itself dynamically allocated and should also - be freed when it is no longer needed. Otherwise, the chunks array - must be of at least n_elements in length. It is filled in with the - pointers to the chunks. - - In either case, independent_comalloc returns this pointer array, or - null if the allocation failed. If n_elements is zero and chunks is - null, it returns a chunk representing an array with zero elements - (which should be freed if not wanted). - - Each element must be individually freed when it is no longer - needed. If you'd like to instead be able to free all at once, you - should instead use a single regular malloc, and assign pointers at - particular offsets in the aggregate space. (In this case though, you - cannot independently free elements.) - - independent_comallac differs from independent_calloc in that each - element may have a different size, and also that it does not - automatically clear elements. - - independent_comalloc can be used to speed up allocation in cases - where several structs or objects must always be allocated at the - same time. For example: - - struct Head { ... } - struct Foot { ... } - - void send_message(char* msg) { - int msglen = strlen(msg); - size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) }; - void* chunks[3]; - if (independent_comalloc(3, sizes, chunks) == 0) - die(); - struct Head* head = (struct Head*)(chunks[0]); - char* body = (char*)(chunks[1]); - struct Foot* foot = (struct Foot*)(chunks[2]); - // ... - } - - In general though, independent_comalloc is worth using only for - larger values of n_elements. For small values, you probably won't - detect enough difference from series of malloc calls to bother. - - Overuse of independent_comalloc can increase overall memory usage, - since it cannot reuse existing noncontiguous small chunks that - might be available for some of the elements. -*/ -NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedpindependent_comalloc(nedpool *p, size_t elems, size_t *sizes, void **chunks) THROWSPEC; - -#if defined(__cplusplus) -} /* namespace or extern "C" */ -#include -#include -#ifdef HAVE_CPP0XTYPETRAITS -#include -#endif - -// Touch into existence for future platforms -namespace std { namespace tr1 { } } - -/*! \defgroup C++ C++ language support - -Thanks to the generous support of Applied Research Associates (USA), nedalloc has extensive -C++ language support which uses C++ metaprogramming techniques to provide a policy driven -STL container reimplementor. The metaprogramming silently overrides or replaces the STL implementation -on your system (MSVC and GCC are the two currently supported) to \b substantially improve -the performance of STL containers by making use of nedalloc's additional features. - -Sounds difficult to use? Not really. Simply do this: -\code -using namespace nedalloc; -typedef nedallocatorise::policy, - nedpolicy::mmap<>::policy, - nedpolicy::reserveN<26>::policy // 1<<26 = 64Mb. 10,000,000 * sizeof(unsigned int) = 38Mb. ->::value myvectortype; -myvectortype a; -for(int n=0; n<10000000; n++) - a.push_back(n); -\endcode - -The metaprogramming requires a new C++ compiler (> year 2008), and it will readily make use -of a C++0x compiler where it will use rvalue referencing, variadic templates, type traits and more. -Visual Studio 2008 or later is sufficent, as is GCC v4.4 or later. - -nedalloc's metaprogramming is designed to be extensible, so the rest of this page is intended for those -wishing to customise the metaprogramming. If you simply wish to know how to use the -nedalloc::nedallocator STL allocator or the nedalloc::nedallocatorise STL reimplementor, please refer -to test.cpp which gives several examples of usage. - -

Extending the metaprogramming:

-A nedallocator policy looks as follows: -\code -namespace nedpolicy { - template struct sizedalign - { - template class policy : public Base - { - template friend class nedallocatorI::baseimplementation; - protected: - size_t policy_alignment(size_t bytes) const - { - return (bytes < size) ? alignment : 0; - } - }; - }; -} -\endcode -The policy above implements a size based alignment, so if the block being allocated is -less than \em size then it causes \em alignment to be used, otherwise it does not align. -The sizedalign struct is merely a template parameter encapsulator used to capture -additional parameters, so the real policy is in fact the class policy held within in. -If you did not need to specify any additional parameters e.g. if you were defining -policy_nedpool(), then you would directly define a policy returning your nedpool and pass -it directly to nedallocator<>. - -The primary policy functions which are intended to be overridden are listed in -nedalloc::nedallocatorI::baseimplementation in nedmalloc.h and are prefixed by "policy_". -However, there is absolutely no reason why the meatier functions such as -nedalloc::nedallocatorI::baseimplementation::allocate() cannot be overriden, and indeed -some of the policies defined in nedmalloc.h do just that. - -Policy composition is handled by a dedicated recursive variadic template called -nedalloc::nedallocatorI::policycompositor. If you have \em really specialised needs, you -can partially specialise this class to make it do all sorts of interesting things - hence -its separation into its own class. -*/ - -/*! \brief The nedalloc namespace */ -namespace nedalloc { - -/*! \def NEDSTATIC_ASSERT(expr, msg) -\brief Generates a static assertion if (expr)==0 at compile time. - -Make SURE your message contains no spaces or anything else which would make it an invalid -variable name. -*/ -#ifndef HAVE_CPP0XSTATICASSERT -template struct StaticAssert; -template<> struct StaticAssert -{ - StaticAssert() { } -}; -#define NEDSTATIC_ASSERT(expr, msg) \ - nedalloc::StaticAssert<(expr)!=0> ERROR_##msg -#else -#define NEDSTATIC_ASSERT(expr, msg) static_assert((expr)!=0, #msg ) -#endif - -/*! \brief The policy namespace in which all nedallocator policies live. */ -namespace nedpolicy { - /*! \class empty - \ingroup C++ - \brief An empty policy which does nothing. - */ - template class empty : public Base - { - }; -} - -/*! \brief The implementation namespace where the internals live. */ -namespace nedallocatorI -{ - using namespace std; - using namespace tr1; - - /* Roll on variadic templates is all I can say! */ -#ifdef HAVE_CPP0XVARIADICTEMPLATES - template class... policies> class policycompositor - { - public: - typedef policies value; - }; -#else - template class A=nedpolicy::empty, - template class B=nedpolicy::empty, - template class C=nedpolicy::empty, - template class D=nedpolicy::empty, - template class E=nedpolicy::empty, - template class F=nedpolicy::empty, - template class G=nedpolicy::empty, - template class H=nedpolicy::empty, - template class I=nedpolicy::empty, - template class J=nedpolicy::empty, - template class K=nedpolicy::empty, - template class L=nedpolicy::empty, - template class M=nedpolicy::empty, - template class N=nedpolicy::empty, - template class O=nedpolicy::empty - > class policycompositor - { - typedef policycompositor temp; - public: - typedef A value; - }; -#endif - template class policycompositor - { - public: - typedef Impl value; - }; -} - -template class... policies -#else - template class policy1=nedpolicy::empty, - template class policy2=nedpolicy::empty, - template class policy3=nedpolicy::empty, - template class policy4=nedpolicy::empty, - template class policy5=nedpolicy::empty, - template class policy6=nedpolicy::empty, - template class policy7=nedpolicy::empty, - template class policy8=nedpolicy::empty, - template class policy9=nedpolicy::empty, - template class policy10=nedpolicy::empty, - template class policy11=nedpolicy::empty, - template class policy12=nedpolicy::empty, - template class policy13=nedpolicy::empty, - template class policy14=nedpolicy::empty, - template class policy15=nedpolicy::empty -#endif -> class nedallocator; - -namespace nedallocatorI -{ - /*! \brief The base implementation class */ - template class baseimplementation - { - //NEDSTATIC_ASSERT(false, Bad_policies_specified); - }; - /*! \brief The base implementation class */ - template class... policies -#else - template class policy1, - template class policy2, - template class policy3, - template class policy4, - template class policy5, - template class policy6, - template class policy7, - template class policy8, - template class policy9, - template class policy10, - template class policy11, - template class policy12, - template class policy13, - template class policy14, - template class policy15 -#endif - > class baseimplementation > - { - protected: - //! \brief The most derived nedallocator implementation type - typedef nedallocator implementationType; - //! \brief Returns a this for the most derived nedallocator implementation type - implementationType *_this() { return static_cast(this); } - //! \brief Returns a this for the most derived nedallocator implementation type - const implementationType *_this() const { return static_cast(this); } - //! \brief Specifies the nedpool to use. Defaults to zero (the system pool). - nedpool *policy_nedpool(size_t bytes) const - { - UNREFERENCED_PARAMETER(bytes); - return 0; - } - //! \brief Specifies the granularity to use. Defaults to \em bytes (no granularity). - size_t policy_granularity(size_t bytes) const - { - return bytes; - } - //! \brief Specifies the alignment to use. Defaults to zero (no alignment). - size_t policy_alignment(size_t bytes) const - { - UNREFERENCED_PARAMETER(bytes); - return 0; - } - //! \brief Specifies the flags to use. Defaults to zero (no flags). - unsigned policy_flags(size_t bytes) const - { - UNREFERENCED_PARAMETER(bytes); - return 0; - } - //! \brief Specifies what to do when the allocation fails. Defaults to throwing std::bad_alloc. - void policy_throwbadalloc(size_t bytes) const - { - UNREFERENCED_PARAMETER(bytes); -#if defined __EXCEPTIONS && !defined DISABLE_EXCEPTIONS - throw std::bad_alloc(); -#endif - } - //! \brief Specifies if the type is POD. Is std::is_pod::value on C++0x compilers, otherwise false. - static const bool policy_typeIsPOD= -#ifdef HAVE_CPP0XTYPETRAITS - is_pod::value; -#else - false; -#endif - public: - typedef T *pointer; - typedef const T *const_pointer; - typedef T &reference; - typedef const T &const_reference; - typedef T value_type; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - T *address(T &r) const { return &r; } - const T *address(const T &s) const { return &s; } - size_t max_size() const { return (static_cast(0) - static_cast(1)) / sizeof(T); } - bool operator!=(const baseimplementation &other) const { return !(*this == other); } - bool operator==(const baseimplementation &other) const { UNREFERENCED_PARAMETER(other); return true; } - - void construct(T *const p, const T &t) const { - void *const _p = static_cast(p); - new (_p) T(t); - } - void destroy(T *const p) const { - p->~T(); - } - baseimplementation() { } - baseimplementation(const baseimplementation &) { } -#ifdef HAVE_CPP0XRVALUEREFS - baseimplementation(baseimplementation &&) { } -#endif - template struct rebind { - typedef nedallocator other; - }; - template baseimplementation(const nedallocator &) { } - - T *allocate(const size_t n) const { - // Leave these spelled out to aid debugging - const size_t t_size = sizeof(T); - size_t size = _this()->policy_granularity(n*t_size); - nedpool *pool = _this()->policy_nedpool(size); - size_t alignment = _this()->policy_alignment(size); - unsigned flags = _this()->policy_flags(size); - void *ptr = nedpmalloc2(pool, size, alignment, flags); - if(!ptr) - _this()->policy_throwbadalloc(size); - return static_cast(ptr); - } - void deallocate(T *p, const size_t n) const { - UNREFERENCED_PARAMETER(n); - nedpfree(0/*not needed*/, p); - } - template T *allocate(const size_t n, const U * /* hint */) const { - return allocate(n); - } - private: - baseimplementation &operator=(const baseimplementation &); - }; - -} - -namespace nedpolicy -{ - /*! \class granulate - \ingroup C++ - \brief A policy setting the granularity of the allocated memory. - - Memory is sized according to (size+granularity-1) & ~(granularity-1). - In other words, granularity \b must be a power of two. - */ - template struct granulate - { - template class policy : public Base - { - template friend class nedallocatorI::baseimplementation; - protected: - size_t policy_granularity(size_t bytes) const - { - return (bytes+granularity-1) & ~(granularity-1); - } - }; - }; - /*! \class align - \ingroup C++ - \brief A policy setting the alignment of the allocated memory. - */ - template struct align - { - template class policy : public Base - { - template friend class nedallocatorI::baseimplementation; - protected: - size_t policy_alignment(size_t bytes) const - { - UNREFERENCED_PARAMETER(bytes); - return alignment; - } - }; - }; - /*! \class zero - \ingroup C++ - \brief A policy causing the zeroing of the allocated memory. - */ - template struct zero - { - template class policy : public Base - { - template friend class nedallocatorI::baseimplementation; - protected: - unsigned policy_flags(size_t bytes) const - { - return dozero ? Base::policy_flags(bytes)|M2_ZERO_MEMORY : Base::policy_flags(bytes); - } - }; - }; - /*! \class preventmove - \ingroup C++ - \brief A policy preventing the moving of the allocated memory. - */ - template struct preventmove - { - template class policy : public Base - { - template friend class nedallocatorI::baseimplementation; - protected: - unsigned policy_flags(size_t bytes) const - { - return doprevent ? Base::policy_flags(bytes)|M2_PREVENT_MOVE : Base::policy_flags(bytes); - } - }; - }; - /*! \class mmap - \ingroup C++ - \brief A policy causing the mmapping of the allocated memory. - */ - template struct mmap - { - template class policy : public Base - { - template friend class nedallocatorI::baseimplementation; - protected: - unsigned policy_flags(size_t bytes) const - { - return dommap ? Base::policy_flags(bytes)|M2_ALWAYS_MMAP : Base::policy_flags(bytes); - } - }; - }; - /*! \class reserveX - \ingroup C++ - \brief A policy causing the address reservation of X times the allocated memory. - */ - template struct reserveX - { - template class policy : public Base - { - template friend class nedallocatorI::baseimplementation; - protected: - unsigned policy_flags(size_t bytes) const - { - return Base::policy_flags(bytes)|M2_RESERVE_MULT(X); - } - }; - }; - /*! \class reserveN - \ingroup C++ - \brief A policy causing the address reservation of (1< struct reserveN - { - template class policy : public Base - { - template friend class nedallocatorI::baseimplementation; - protected: - unsigned policy_flags(size_t bytes) const - { - return Base::policy_flags(bytes)|M2_RESERVE_SHIFT(N); - } - }; - }; - /*! \class badalloc - \ingroup C++ - \brief A policy specifying what to throw when an allocation failure occurs. - - A type specialisation exists for badalloc which is equivalent to new(nothrow) - i.e. return zero and don't throw anything. - */ - template struct badalloc - { - template class policy : public Base - { - template friend class nedallocatorI::baseimplementation; - protected: - void policy_throwbadalloc(size_t bytes) const - { - UNREFERENCED_PARAMETER(bytes); -#if defined __EXCEPTIONS && !defined DISABLE_EXCEPTIONS - throw T(); -#endif - } - }; - }; - template<> struct badalloc - { - template class policy : public Base - { - template friend class nedallocatorI::baseimplementation; - protected: - void policy_throwbadalloc(size_t bytes) const - { - UNREFERENCED_PARAMETER(bytes); - } - }; - }; - /*! \class typeIsPOD - \ingroup C++ - \brief A policy forcing the treatment of the type as Plain Old Data (POD) - - On C++0x compilers, the <type_traits> is_pod::value is used by default. - However, for earlier compilers and for types where is_pod<>::value returns false - even though the type actually is POD (for example, if you declare a - constructor you lose PODness even if the data contents are still POD), you can - force PODness one way or another. When treated as POD, memcpy() is used instead - of copy construction and realloc() is permitted to move the memory contents when - resizing. - */ - template struct typeIsPOD - { - template class policy : public Base - { - template friend class nedallocatorI::baseimplementation; - protected: - static const bool policy_typeIsPOD=ispod; - }; - }; -} - -/*! \class nedallocator -\ingroup C++ -\brief A policy driven STL allocator which uses nedmalloc - -One of the lesser known features of STL container classes is their ability to take -an allocator implementation class, so where you had std::vector you can now -have std::vector > such that -std::vector<> will now use nedalloc as the policy specifies. - -You almost certainly don't want to use this directly except in the naive -case. See nedalloc::nedallocatorise to see what I mean. -*/ -template class... policies -#else - template class policy1, - template class policy2, - template class policy3, - template class policy4, - template class policy5, - template class policy6, - template class policy7, - template class policy8, - template class policy9, - template class policy10, - template class policy11, - template class policy12, - template class policy13, - template class policy14, - template class policy15 -#endif -> class nedallocator : public nedallocatorI::policycompositor< -#ifdef HAVE_CPP0XVARIADICTEMPLATES - nedallocatorI::baseimplementation >, - policies... -#else - nedallocatorI::baseimplementation >, - policy1, policy2, policy3, policy4, policy5, - policy6, policy7, policy8, policy9, policy10, - policy11, policy12, policy13, policy14, policy15 -#endif ->::value -{ - typedef typename nedallocatorI::policycompositor< -#ifdef HAVE_CPP0XVARIADICTEMPLATES - nedallocatorI::baseimplementation >, - policies... -#else - nedallocatorI::baseimplementation >, - policy1, policy2, policy3, policy4, policy5, - policy6, policy7, policy8, policy9, policy10, - policy11, policy12, policy13, policy14, policy15 -#endif - >::value Base; -public: - nedallocator() { } - nedallocator(const nedallocator &o) : Base(o) { } -#ifdef HAVE_CPP0XRVALUEREFS - nedallocator(nedallocator &&o) : Base(std::move(o)) { } -#endif - /* This templated constructor and rebind() are used by MSVC's secure iterator checker. - I think it's best to not copy state even though it may break policies which store data. */ - template nedallocator(const nedallocator &o) { UNREFERENCED_PARAMETER(o); } -#ifdef HAVE_CPP0XRVALUEREFS - template nedallocator(nedallocator &&o) { } -#endif - - template struct rebind { - typedef nedallocator other; - }; -}; - -namespace nedallocatorI { - // Holds a static allocator instance shared by anything allocating from allocator - template struct StaticAllocator - { - static allocator &get() - { - static allocator a; - return a; - } - }; - // RAII holder for a Newed object - template struct PtrHolder - { - T *mem; - PtrHolder(T *_mem) : mem(_mem) { } - ~PtrHolder() - { - if(mem) - { - allocator &a=nedallocatorI::StaticAllocator::get(); - a.deallocate(mem, sizeof(T)); - mem=0; - } - } - T *release() { T *ret=mem; mem=0; return ret; } - T *operator *() { return mem; } - const T *operator *() const { return mem; } - }; -} -/*! \brief Allocates the memory for an instance of object \em T and constructs it. - -If an exception is thrown during construction, the memory is freed before -rethrowing the exception. - -Usage is very simple: -\code - SSEVectorType *foo1=New(4, 5, 6, 7); -\endcode -*/ -#ifdef HAVE_CPP0XVARIADICTEMPLATES -template, typename... Parameters> inline T *New(const Parameters&... parameters) -#else -template inline T *New() -#endif -{ - allocator &a=nedallocatorI::StaticAllocator::get(); - nedallocatorI::PtrHolder ret(a.allocate(sizeof(T))); - if(*ret) - { -#ifdef HAVE_CPP0XVARIADICTEMPLATES - new((void *) *ret) T(parameters...); -#else - new((void *) *ret) T; -#endif - } - return ret.release(); -} -#ifndef HAVE_CPP0XVARIADICTEMPLATES -// Extremely annoying not to have default template arguments for functions pre-C++0x -template inline T *New() -{ - return New >(); -} -// Also, it's painful to replicate function overloads :( -#define NEDMALLOC_NEWIMPL \ -template inline T *New(NEDMALLOC_NEWIMPLPARSDEFS) \ -{ \ - allocator &a=nedallocatorI::StaticAllocator::get(); \ - nedallocatorI::PtrHolder ret(a.allocate(sizeof(T))); \ - if(*ret) \ - { \ - new((void *) *ret) T(NEDMALLOC_NEWIMPLPARS); \ - } \ - return ret.release(); \ -} \ -template inline T *New(NEDMALLOC_NEWIMPLPARSDEFS)\ -{ \ - return New >(NEDMALLOC_NEWIMPLPARS); \ -} -#define NEDMALLOC_NEWIMPLTYPES typename P1 -#define NEDMALLOC_NEWIMPLPARSDEFS const P1 &p1 -#define NEDMALLOC_NEWIMPLPARS p1 -NEDMALLOC_NEWIMPL -#undef NEDMALLOC_NEWIMPLTYPES -#undef NEDMALLOC_NEWIMPLPARSDEFS -#undef NEDMALLOC_NEWIMPLPARS - -#define NEDMALLOC_NEWIMPLTYPES typename P1, typename P2 -#define NEDMALLOC_NEWIMPLPARSDEFS const P1 &p1, const P2 &p2 -#define NEDMALLOC_NEWIMPLPARS p1, p2 -NEDMALLOC_NEWIMPL -#undef NEDMALLOC_NEWIMPLTYPES -#undef NEDMALLOC_NEWIMPLPARSDEFS -#undef NEDMALLOC_NEWIMPLPARS - -#define NEDMALLOC_NEWIMPLTYPES typename P1, typename P2, typename P3 -#define NEDMALLOC_NEWIMPLPARSDEFS const P1 &p1, const P2 &p2, const P3 &p3 -#define NEDMALLOC_NEWIMPLPARS p1, p2, p3 -NEDMALLOC_NEWIMPL -#undef NEDMALLOC_NEWIMPLTYPES -#undef NEDMALLOC_NEWIMPLPARSDEFS -#undef NEDMALLOC_NEWIMPLPARS - -#define NEDMALLOC_NEWIMPLTYPES typename P1, typename P2, typename P3, typename P4 -#define NEDMALLOC_NEWIMPLPARSDEFS const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4 -#define NEDMALLOC_NEWIMPLPARS p1, p2, p3, p4 -NEDMALLOC_NEWIMPL -#undef NEDMALLOC_NEWIMPLTYPES -#undef NEDMALLOC_NEWIMPLPARSDEFS -#undef NEDMALLOC_NEWIMPLPARS - -#define NEDMALLOC_NEWIMPLTYPES typename P1, typename P2, typename P3, typename P4, typename P5 -#define NEDMALLOC_NEWIMPLPARSDEFS const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5 -#define NEDMALLOC_NEWIMPLPARS p1, p2, p3, p4, p5 -NEDMALLOC_NEWIMPL -#undef NEDMALLOC_NEWIMPLTYPES -#undef NEDMALLOC_NEWIMPLPARSDEFS -#undef NEDMALLOC_NEWIMPLPARS - -#undef NEDMALLOC_NEWIMPL -#endif - -/*! \brief Destructs an instance of object T, and releases the memory used to store it. -*/ -template inline void Delete(const T *_obj) -{ - T *obj=const_cast(_obj); - allocator &a=nedallocatorI::StaticAllocator::get(); - obj->~T(); - a.deallocate(obj, sizeof(T)); -} -template inline void Delete(const T *obj) { Delete >(obj); } - -/*! \class nedallocatorise -\ingroup C++ -\brief Reimplements a given STL container to make full and efficient usage of nedalloc -\param stlcontainer The STL container you wish to reimplement -\param T The type to be contained -\param policies... Any policies you want applied to the allocator - - -This is a clever bit of C++ metaprogramming if I do say so myself! What it does -is to specialise a STL container implementation to make full use of nedalloc's -advanced facilities, so for example if you do: -\code -using namespace nedalloc; -typedef nedallocatorise::policy, - nedpolicy::mmap<>::policy, - nedpolicy::reserveN<26>::policy // 1<<26 = 64Mb. 10,000,000 * sizeof(unsigned int) = 38Mb. ->::value myvectortype; -myvectortype a; -for(int n=0; n<10000000; n++) - a.push_back(n); -\endcode -What happens here is that nedallocatorise reimplements the parts of -std::vector which extend and shrink the actual memory allocation. -Because the typeIsPOD policy is specified, it means that realloc() -rather than realloc(M2_PREVENT_MOVE) can be used. Also, because the -mmap and the reserveN policies are specified, std::vector immediately -reserves 64Mb of address space and forces the immediate use of mmap(). -This allows you to push_back() a lot of data very, very quickly indeed. -You will also find that pop_back() actually reduces the allocation now -(most implementations don't bother ever releasing memory except when -reaching empty or when resize() is called). When mmapped, reserve() -is automatically held at a minimum of <page size>/sizeof(type) though -larger values are respected. - -test.cpp has a benchmark of the speed differences you may realise, plus -an example of usage. -*/ -template class stlcontainer, - typename T, -#ifdef HAVE_CPP0XVARIADICTEMPLATES - template class... policies -#else - template class policy1=nedpolicy::empty, - template class policy2=nedpolicy::empty, - template class policy3=nedpolicy::empty, - template class policy4=nedpolicy::empty, - template class policy5=nedpolicy::empty, - template class policy6=nedpolicy::empty, - template class policy7=nedpolicy::empty, - template class policy8=nedpolicy::empty, - template class policy9=nedpolicy::empty, - template class policy10=nedpolicy::empty, - template class policy11=nedpolicy::empty, - template class policy12=nedpolicy::empty, - template class policy13=nedpolicy::empty, - template class policy14=nedpolicy::empty, - template class policy15=nedpolicy::empty -#endif -> class nedallocatorise -{ -public: - //! The reimplemented STL container type - typedef stlcontainer > value; -}; - -} /* namespace */ -#endif - -/* Some miscellaneous dlmalloc option documentation */ - -#ifdef DOXYGEN_IS_PARSING_ME -/* Just some false defines to keep doxygen happy */ - -#define NEDMALLOC_DEBUG DEBUG -#define ENABLE_LARGE_PAGES undef -#define ENABLE_FAST_HEAP_DETECTION undef -#define REPLACE_SYSTEM_ALLOCATOR undef -#define ENABLE_TOLERANT_NEDMALLOC undef -#define NO_NED_NAMESPACE undef - -/*! \def MALLOC_ALIGNMENT -\brief Defines what alignment normally returned blocks should use. Is 16 bytes on Mac OS X, otherwise 8 bytes. */ -#define MALLOC_ALIGNMENT 8 - -/*! \def USE_LOCKS -\brief Defines the threadsafety of nedalloc - -USE_LOCKS can be 2 if you want to define your own MLOCK_T, INITIAL_LOCK, -ACQUIRE_LOCK, RELEASE_LOCK, TRY_LOCK, IS_LOCKED and NULL_LOCK_INITIALIZER. -*/ -#define USE_LOCKS 1 - -/*! \def DEFAULT_GRANULARITY -\brief Defines the granularity in which to request or free system memory. -*/ -#define DEFAULT_GRANULARITY (2*1024*1024) - -/*! \def DEFAULT_TRIM_THRESHOLD -\brief Defines how much memory must be free before returning it to the system. -*/ -#define DEFAULT_TRIM_THRESHOLD (2*1024*1024) - -/*! \def DEFAULT_MMAP_THRESHOLD -\brief Defines the threshold above which mmap() is used to perform direct allocation. -*/ -#define DEFAULT_MMAP_THRESHOLD (256*1024) - -/*! \def MAX_RELEASE_CHECK_RATE -\brief Defines how many free() ops should occur before checking how much free memory there is. -*/ -#define MAX_RELEASE_CHECK_RATE 4095 - -/*! \def NEDMALLOC_FORCERESERVE -\brief Lets you force address space reservation in the \b standard malloc API - -Note that by default realloc() sets M2_RESERVE_MULT(8) when thunking to realloc2(), -so you probably don't need to override this -*/ -#define NEDMALLOC_FORCERESERVE(p, mem, size) 0 - -/*! \def NEDMALLOC_TESTLOGENTRY -\brief Used to determine whether a given memory operation should be logged. -*/ -#define NEDMALLOC_TESTLOGENTRY(tc, np, type, mspace, size, mem, alignment, flags, returned) ((type)&ENABLE_LOGGING) - -/*! \def NEDMALLOC_STACKBACKTRACEDEPTH -\brief Turns on stack backtracing in the logger. - -You almost certainly want to constrain what gets logged using NEDMALLOC_TESTLOGENTRY -if you turn this on as the sheer volume of data output can make execution very slow. -*/ -#define NEDMALLOC_STACKBACKTRACEDEPTH 0 - -#endif - -#endif diff --git a/polymer/eduke32/build/src/winbits.c b/polymer/eduke32/build/src/winbits.c index b155dc2e0..fdcfa927b 100644 --- a/polymer/eduke32/build/src/winbits.c +++ b/polymer/eduke32/build/src/winbits.c @@ -9,17 +9,10 @@ #include "cache1d.h" #include "winbits.h" -#ifndef DEBUGGINGAIDS -# define DISABLE_EXCEPTIONS -# include "nedmalloc.h" -#endif - #if defined(_M_X64) || defined(__amd64__) || defined(__x86_64__) # define EBACKTRACEDLL "ebacktrace1-64.dll" -# define NEDMALLOCDLL "nedmalloc-64.dll" #else # define EBACKTRACEDLL "ebacktrace1.dll" -# define NEDMALLOCDLL "nedmalloc.dll" #endif int32_t backgroundidle = 1; @@ -34,8 +27,6 @@ static HANDLE instanceflag = NULL; static OSVERSIONINFOEX osv; -static HMODULE nedhandle = NULL; - static int32_t togglecomp = 1; // @@ -188,19 +179,7 @@ static void ToggleDesktopComposition(BOOL compEnable) // void win_open(void) { -#ifndef DEBUGGINGAIDS - if ((nedhandle = LoadLibrary(NEDMALLOCDLL))) - { -#ifdef __cplusplus - nedalloc::nedpool_t *(WINAPI *nedcreatepool)(size_t, int); - if ((nedcreatepool = (nedalloc::nedpool_t *(WINAPI *)(size_t, int))GetProcAddress(nedhandle, "nedcreatepool"))) -#else - nedpool *(WINAPI *nedcreatepool)(size_t, int); - if ((nedcreatepool = (void *)GetProcAddress(nedhandle, "nedcreatepool"))) -#endif - nedcreatepool(SYSTEM_POOL_SIZE, -1); - } -#else +#ifdef DEBUGGINGAIDS LoadLibraryA(EBACKTRACEDLL); /* wm_msgbox("boo","didn't load backtrace DLL (code %d)\n", (int)GetLastError()); @@ -230,9 +209,6 @@ void win_init(void) } win_printversion(); - - if (nedhandle) - initprintf("Initialized nedmalloc\n"); } void win_setvideomode(int32_t c) diff --git a/polymer/eduke32/eduke32.vcxproj b/polymer/eduke32/eduke32.vcxproj index 84e089f95..0acb1d972 100644 --- a/polymer/eduke32/eduke32.vcxproj +++ b/polymer/eduke32/eduke32.vcxproj @@ -89,11 +89,9 @@ - - diff --git a/polymer/eduke32/eduke32.vcxproj.filters b/polymer/eduke32/eduke32.vcxproj.filters index 155458524..7cc71ccda 100644 --- a/polymer/eduke32/eduke32.vcxproj.filters +++ b/polymer/eduke32/eduke32.vcxproj.filters @@ -102,9 +102,6 @@ build\headers - - build\headers - build\headers @@ -378,9 +375,6 @@ eduke32\headers - - build\headers - eduke32\headers diff --git a/polymer/eduke32/package/nedmalloc.dll b/polymer/eduke32/package/nedmalloc.dll deleted file mode 100644 index e52c86a66..000000000 Binary files a/polymer/eduke32/package/nedmalloc.dll and /dev/null differ diff --git a/polymer/eduke32/source/game.c b/polymer/eduke32/source/game.c index 658379b68..154014e38 100644 --- a/polymer/eduke32/source/game.c +++ b/polymer/eduke32/source/game.c @@ -11051,11 +11051,7 @@ int32_t app_main(int32_t argc, const char **argv) int32_t i = 0, j; char cwd[BMAX_PATH]; // extern char datetimestring[]; -#ifdef NEDMALLOC - ENetCallbacks callbacks = { Bmalloc, Bfree, NULL }; -#else ENetCallbacks callbacks = { NULL, NULL, NULL }; -#endif G_ExtPreInit(); diff --git a/polymer/eduke32/source/sdlmusic.c b/polymer/eduke32/source/sdlmusic.c index 43c5b4d53..0a7e88d90 100644 --- a/polymer/eduke32/source/sdlmusic.c +++ b/polymer/eduke32/source/sdlmusic.c @@ -180,7 +180,7 @@ int32_t MUSIC_Init(int32_t SoundCard, int32_t Address) sz = (numargs+2)*sizeof(char *) + (c-command+1); sz = ((sz+pagesize-1)/pagesize)*pagesize; -#if defined(NEDMALLOC) || defined(__APPLE__) || defined(__ANDROID__) +#if defined(__APPLE__) || defined(__ANDROID__) external_midi_argv = Bcalloc(1,sz+pagesize); if (!external_midi_argv) goto fallback;