status-im
/
op-geth
mirror of https://github.com/status-im/op-geth.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
op-geth/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.h

232 lines
8.4 KiB
C
Executable File
Raw Blame History

#if !defined(DUK_ALLOC_POOL_H_INCLUDED)
#define DUK_ALLOC_POOL_H_INCLUDED
#include "duktape.h"
#if defined(__cplusplus)
extern "C" {
#endif
/* 32-bit (big endian) marker used at the end of pool entries so that wasted
* space can be detected. Waste tracking must be enabled explicitly.
*/
#if defined(DUK_ALLOC_POOL_TRACK_WASTE)
#define DUK_ALLOC_POOL_WASTE_MARKER 0xedcb2345UL
#endif
/* Pointer compression with ROM strings/objects:
*
* For now, use DUK_USE_ROM_OBJECTS to signal the need for compressed ROM
* pointers. DUK_USE_ROM_PTRCOMP_FIRST is provided for the ROM pointer
* compression range minimum to avoid duplication in user code.
*/
#if defined(DUK_USE_ROM_OBJECTS) && defined(DUK_USE_HEAPPTR16)
#define DUK_ALLOC_POOL_ROMPTR_COMPRESSION
#define DUK_ALLOC_POOL_ROMPTR_FIRST DUK_USE_ROM_PTRCOMP_FIRST
/* This extern declaration is provided by duktape.h, array provided by duktape.c.
* Because duk_config.h may include this file (to get the inline functions) we
* need to forward declare this also here.
*/
extern const void * const duk_rom_compressed_pointers[];
#endif
/* Pool configuration for a certain block size. */
typedef struct {
unsigned int size; /* must be divisible by 4 and >= sizeof(void *) */
unsigned int a; /* bytes (not count) to allocate: a*t + b, t is an arbitrary scale parameter */
unsigned int b;
} duk_pool_config;
/* Freelist entry, must fit into the smallest block size. */
struct duk_pool_free;
typedef struct duk_pool_free duk_pool_free;
struct duk_pool_free {
duk_pool_free *next;
};
/* Pool state for a certain block size. */
typedef struct {
duk_pool_free *first;
char *alloc_end;
unsigned int size;
unsigned int count;
#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER)
unsigned int hwm_used_count;
#endif
} duk_pool_state;
/* Statistics for a certain pool. */
typedef struct {
size_t used_count;
size_t used_bytes;
size_t free_count;
size_t free_bytes;
size_t waste_bytes;
size_t hwm_used_count;
} duk_pool_stats;
/* Top level state for all pools. Pointer to this struct is used as the allocator
* userdata pointer.
*/
typedef struct {
int num_pools;
duk_pool_state *states;
#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER)
size_t hwm_used_bytes;
size_t hwm_waste_bytes;
#endif
} duk_pool_global;
/* Statistics for the entire set of pools. */
typedef struct {
size_t used_bytes;
size_t free_bytes;
size_t waste_bytes;
size_t hwm_used_bytes;
size_t hwm_waste_bytes;
} duk_pool_global_stats;
/* Initialize a pool allocator, arguments:
* - buffer and size: continuous region to use for pool, must align to 4
* - config: configuration for pools in ascending block size
* - state: state for pools, matches config order
* - num_pools: number of entries in 'config' and 'state'
* - global: global state structure
*
* The 'config', 'state', and 'global' pointers must be valid beyond the init
* call, as long as the pool is used.
*
* Returns a void pointer to be used as userdata for the allocator functions.
* Concretely the return value will be "(void *) global", i.e. the global
* state struct. If pool init fails, the return value will be NULL.
*/
void *duk_alloc_pool_init(char *buffer,
size_t size,
const duk_pool_config *configs,
duk_pool_state *states,
int num_pools,
duk_pool_global *global);
/* Duktape allocation providers. Typing matches Duktape requirements. */
void *duk_alloc_pool(void *udata, duk_size_t size);
void *duk_realloc_pool(void *udata, void *ptr, duk_size_t size);
void duk_free_pool(void *udata, void *ptr);
/* Stats. */
void duk_alloc_pool_get_pool_stats(duk_pool_state *s, duk_pool_stats *res);
void duk_alloc_pool_get_global_stats(duk_pool_global *g, duk_pool_global_stats *res);
/* Duktape pointer compression global state (assumes single pool). */
#if defined(DUK_USE_ROM_OBJECTS) && defined(DUK_USE_HEAPPTR16)
extern const void *duk_alloc_pool_romptr_low;
extern const void *duk_alloc_pool_romptr_high;
duk_uint16_t duk_alloc_pool_enc16_rom(void *ptr);
#endif
#if defined(DUK_USE_HEAPPTR16)
extern void *duk_alloc_pool_ptrcomp_base;
#endif
#if 0
duk_uint16_t duk_alloc_pool_enc16(void *ptr);
void *duk_alloc_pool_dec16(duk_uint16_t val);
#endif
/* Inlined pointer compression functions. Gcc and clang -Os won't in
* practice inline these without an "always inline" attribute because it's
* more size efficient (by a few kB) to use explicit calls instead. Having
* these defined inline here allows performance optimized builds to inline
* pointer compression operations.
*
* Pointer compression assumes there's a single globally registered memory
* pool which makes pointer compression more efficient. This would be easy
* to fix by adding a userdata pointer to the compression functions and
* plumbing the heap userdata from the compression/decompression macros.
*/
/* DUK_ALWAYS_INLINE is not a public API symbol so it may go away in even a
* minor update. But it's pragmatic for this extra because it handles many
* compilers via duk_config.h detection. Check that the macro exists so that
* if it's gone, we can still compile.
*/
#if defined(DUK_ALWAYS_INLINE)
#define DUK__ALLOC_POOL_ALWAYS_INLINE DUK_ALWAYS_INLINE
#else
#define DUK__ALLOC_POOL_ALWAYS_INLINE /* nop */
#endif
#if defined(DUK_USE_HEAPPTR16)
static DUK__ALLOC_POOL_ALWAYS_INLINE duk_uint16_t duk_alloc_pool_enc16(void *ptr) {
if (ptr == NULL) {
/* With 'return 0' gcc and clang -Os generate inefficient code.
* For example, gcc -Os generates:
*
* 0804911d <duk_alloc_pool_enc16>:
* 804911d: 55 push %ebp
* 804911e: 85 c0 test %eax,%eax
* 8049120: 89 e5 mov %esp,%ebp
* 8049122: 74 0b je 804912f <duk_alloc_pool_enc16+0x12>
* 8049124: 2b 05 e4 90 07 08 sub 0x80790e4,%eax
* 804912a: c1 e8 02 shr $0x2,%eax
* 804912d: eb 02 jmp 8049131 <duk_alloc_pool_enc16+0x14>
* 804912f: 31 c0 xor %eax,%eax
* 8049131: 5d pop %ebp
* 8049132: c3 ret
*
* The NULL path checks %eax for zero; if it is zero, a zero
* is unnecessarily loaded into %eax again. The non-zero path
* has an unnecessary jump as a side effect of this.
*
* Using 'return (duk_uint16_t) (intptr_t) ptr;' generates similarly
* inefficient code; not sure how to make the result better.
*/
return 0;
}
#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION)
if (ptr >= duk_alloc_pool_romptr_low && ptr <= duk_alloc_pool_romptr_high) {
/* This is complex enough now to need a separate function. */
return duk_alloc_pool_enc16_rom(ptr);
}
#endif
return (duk_uint16_t) (((size_t) ((char *) ptr - (char *) duk_alloc_pool_ptrcomp_base)) >> 2);
}
static DUK__ALLOC_POOL_ALWAYS_INLINE void *duk_alloc_pool_dec16(duk_uint16_t val) {
if (val == 0) {
/* As with enc16 the gcc and clang -Os output is inefficient,
* e.g. gcc -Os:
*
* 08049133 <duk_alloc_pool_dec16>:
* 8049133: 55 push %ebp
* 8049134: 66 85 c0 test %ax,%ax
* 8049137: 89 e5 mov %esp,%ebp
* 8049139: 74 0e je 8049149 <duk_alloc_pool_dec16+0x16>
* 804913b: 8b 15 e4 90 07 08 mov 0x80790e4,%edx
* 8049141: 0f b7 c0 movzwl %ax,%eax
* 8049144: 8d 04 82 lea (%edx,%eax,4),%eax
* 8049147: eb 02 jmp 804914b <duk_alloc_pool_dec16+0x18>
* 8049149: 31 c0 xor %eax,%eax
* 804914b: 5d pop %ebp
* 804914c: c3 ret
*/
return NULL;
}
#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION)
if (val >= DUK_ALLOC_POOL_ROMPTR_FIRST) {
/* This is a blind lookup, could check index validity.
* Duktape should never decompress a pointer which would
* be out-of-bounds here.
*/
return (void *) (intptr_t) (duk_rom_compressed_pointers[val - DUK_ALLOC_POOL_ROMPTR_FIRST]);
}
#endif
return (void *) ((char *) duk_alloc_pool_ptrcomp_base + (((size_t) val) << 2));
}
#endif
#if defined(__cplusplus)
}
#endif /* end 'extern "C"' wrapper */
#endif /* DUK_ALLOC_POOL_H_INCLUDED */
Reference in New Issue View Git Blame Copy Permalink