duk_alloc_hybrid.c File Reference

#include "duktape.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

Go to the source code of this file.

Data Structures
struct	pool_size_spec
struct	pool_free_entry
struct	pool_header
struct	pool_state

Macros
#define	NUM_POOLS   (sizeof(pool_sizes) / sizeof(pool_size_spec))
#define	ADDR_IN_STATE_ALLOC(st, p)    ((char *) (p) >= (st)->alloc_start && (char *) (p) < (st)->alloc_end)
#define	ADDR_IN_HEADER_ALLOC(hdr, p)    ((char *) (p) >= (hdr)->alloc_start && (char *) (p) < (hdr)->alloc_end)

Typedefs
typedef struct pool_free_entry	pool_free_entry

Functions
static void	dump_pool_state (pool_state *st)
void *	duk_alloc_hybrid_init (void)
void *	duk_alloc_hybrid (void *udata, duk_size_t size)
void *	duk_realloc_hybrid (void *udata, void *ptr, duk_size_t size)
void	duk_free_hybrid (void *udata, void *ptr)

Variables
static pool_size_spec	pool_sizes []

Macro Definition Documentation

ADDR_IN_HEADER_ALLOC

#define ADDR_IN_HEADER_ALLOC	(		hdr,
			p )    ((char *) (p) >= (hdr)->alloc_start && (char *) (p) < (hdr)->alloc_end)

Definition at line 60 of file duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c.

#define ADDR_IN_HEADER_ALLOC(hdr,p) \
    ((char *) (p) >= (hdr)->alloc_start && (char *) (p) < (hdr)->alloc_end)

Referenced by duk_free_hybrid(), and duk_realloc_hybrid().

ADDR_IN_STATE_ALLOC

#define ADDR_IN_STATE_ALLOC	(		st,
			p )    ((char *) (p) >= (st)->alloc_start && (char *) (p) < (st)->alloc_end)

Definition at line 58 of file duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c.

#define ADDR_IN_STATE_ALLOC(st,p) \
    ((char *) (p) >= (st)->alloc_start && (char *) (p) < (st)->alloc_end)

Referenced by duk_free_hybrid(), and duk_realloc_hybrid().

NUM_POOLS

#define NUM_POOLS   (sizeof(pool_sizes) / sizeof(pool_size_spec))

Definition at line 34 of file duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c.

Referenced by duk_alloc_hybrid(), duk_alloc_hybrid_init(), duk_free_hybrid(), and duk_realloc_hybrid().

Typedef Documentation

pool_free_entry

typedef struct pool_free_entry pool_free_entry

Definition at line 38 of file duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c.

Function Documentation

duk_alloc_hybrid()

void * duk_alloc_hybrid	(	void *	udata,
		duk_size_t	size )

Definition at line 151 of file duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c.

                                                     {
    pool_state *st = (pool_state *) udata;
    int i;
    void *new_ptr;
 
#if 0
    dump_pool_state(st);
#endif
 
    if (size == 0) {
        return NULL;
    }
    if (size > st->pool_max_size) {
#ifdef DUK_ALLOC_HYBRID_DEBUG
        printf("alloc fallback: %ld\n", (long) size);
#endif
        return malloc(size);
    }
 
    for (i = 0; i < (int) NUM_POOLS; i++) {
        pool_header *hdr = st->headers + i;
        if (hdr->size < size) {
            continue;
        }
 
        if (hdr->free) {
#if 0
            printf("alloc from pool: %ld -> pool size %ld\n", (long) size, (long) hdr->size);
#endif
            new_ptr = (void *) hdr->free;
            hdr->free = hdr->free->next;
            return new_ptr;
        } else {
#ifdef DUK_ALLOC_HYBRID_DEBUG
            printf("alloc out of pool entries: %ld -> pool size %ld\n", (long) size, (long) hdr->size);
#endif
            break;
        }
    }
 
#ifdef DUK_ALLOC_HYBRID_DEBUG
    printf("alloc fallback (out of pool): %ld\n", (long) size);
#endif
    return malloc(size);
}

References dump_pool_state(), pool_header::free, pool_state::headers, malloc, pool_free_entry::next, NULL, NUM_POOLS, pool_state::pool_max_size, printf, and pool_header::size.

Referenced by create_duktape_heap(), create_duktape_heap(), and duk_realloc_hybrid().

duk_alloc_hybrid_init()

void * duk_alloc_hybrid_init

(

void

)

Definition at line 89 of file duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c.

                                  {
    pool_state *st;
    size_t total_size, max_size;
    int i, j;
    char *p;
 
    st = (pool_state *) malloc(sizeof(pool_state));
    if (!st) {
        return NULL;
    }
    memset((void *) st, 0, sizeof(pool_state));
    st->alloc_start = NULL;
    st->alloc_end = NULL;
 
    for (i = 0, total_size = 0, max_size = 0; i < (int) NUM_POOLS; i++) {
#ifdef DUK_ALLOC_HYBRID_DEBUG
        printf("Pool %d: size %ld, count %ld\n", i, (long) pool_sizes[i].size, (long) pool_sizes[i].count);
#endif
        total_size += pool_sizes[i].size * pool_sizes[i].count;
        if (pool_sizes[i].size > max_size) {
            max_size = pool_sizes[i].size;
        }
    }
#ifdef DUK_ALLOC_HYBRID_DEBUG
    printf("Total size %ld, max pool size %ld\n", (long) total_size, (long) max_size);
#endif
 
    st->alloc_start = (char *) malloc(total_size);
    if (!st->alloc_start) {
        free(st);
        return NULL;
    }
    st->alloc_end = st->alloc_start + total_size;
    st->pool_max_size = max_size;
    memset((void *) st->alloc_start, 0, total_size);
 
    for (i = 0, p = st->alloc_start; i < (int) NUM_POOLS; i++) {
        pool_header *hdr = st->headers + i;
 
        hdr->alloc_start = p;
        hdr->alloc_end = p + pool_sizes[i].size * pool_sizes[i].count;
        hdr->free = (pool_free_entry *) (void *) p;
        hdr->size = pool_sizes[i].size;
        hdr->count = pool_sizes[i].count;
 
        for (j = 0; j < pool_sizes[i].count; j++) {
            pool_free_entry *ent = (pool_free_entry *) (void *) p;
            if (j == pool_sizes[i].count - 1) {
                ent->next = (pool_free_entry *) NULL;
            } else {
                ent->next = (pool_free_entry *) (void *) (p + pool_sizes[i].size);
            }
            p += pool_sizes[i].size;
        }
    }
 
    dump_pool_state(st);
 
    /* Use 'st' as udata. */
    return (void *) st;
}

References pool_header::alloc_end, pool_state::alloc_end, pool_header::alloc_start, pool_state::alloc_start, pool_size_spec::count, pool_header::count, dump_pool_state(), free, pool_header::free, pool_state::headers, malloc, pool_free_entry::next, NULL, NUM_POOLS, pool_state::pool_max_size, pool_sizes, printf, pool_size_spec::size, and pool_header::size.

Referenced by create_duktape_heap(), and create_duktape_heap().

duk_free_hybrid()

void duk_free_hybrid	(	void *	udata,
		void *	ptr )

Definition at line 259 of file duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c.

                                             {
    pool_state *st = (pool_state *) udata;
    int i;
 
#if 0
    dump_pool_state(st);
#endif
 
    if (!ADDR_IN_STATE_ALLOC(st, ptr)) {
        if (ptr == NULL) {
            return;
        }
#if 0
        printf("free out of pool: %p\n", (void *) ptr);
#endif
        free(ptr);
        return;
    }
 
    for (i = 0; i < (int) NUM_POOLS; i++) {
        pool_header *hdr = st->headers + i;
        if (ADDR_IN_HEADER_ALLOC(hdr, ptr)) {
            ((pool_free_entry *) ptr)->next = hdr->free;
            hdr->free = (pool_free_entry *) ptr;
#if 0
            printf("free from pool: %p\n", ptr);
#endif
            return;
        }
    }
 
#ifdef DUK_ALLOC_HYBRID_DEBUG
    printf("NEVER HERE\n");
#endif
}

References ADDR_IN_HEADER_ALLOC, ADDR_IN_STATE_ALLOC, dump_pool_state(), free, pool_header::free, pool_state::headers, NULL, NUM_POOLS, and printf.

Referenced by create_duktape_heap(), and create_duktape_heap().

duk_realloc_hybrid()

void * duk_realloc_hybrid	(	void *	udata,
		void *	ptr,
		duk_size_t	size )

Definition at line 197 of file duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c.

                                                                  {
    pool_state *st = (pool_state *) udata;
    void *new_ptr;
    int i;
 
#if 0
    dump_pool_state(st);
#endif
 
    if (ADDR_IN_STATE_ALLOC(st, ptr)) {
        /* 'ptr' cannot be NULL. */
        for (i = 0; i < (int) NUM_POOLS; i++) {
            pool_header *hdr = st->headers + i;
            if (ADDR_IN_HEADER_ALLOC(hdr, ptr)) {
                if (size <= hdr->size) {
                    /* Still fits, no shrink support. */
#if 0
                    printf("realloc original from pool: still fits, size %ld, pool size %ld\n",
                           (long) size, (long) hdr->size);
#endif
                    return ptr;
                }
 
                new_ptr = duk_alloc_hybrid(udata, size);
                if (!new_ptr) {
#ifdef DUK_ALLOC_HYBRID_DEBUG
                    printf("realloc original from pool: needed larger size, failed to alloc\n");
#endif
                    return NULL;
                }
                memcpy(new_ptr, ptr, hdr->size);
 
                ((pool_free_entry *) ptr)->next = hdr->free;
                hdr->free = (pool_free_entry *) ptr;
#if 0
                printf("realloc original from pool: size %ld, pool size %ld\n", (long) size, (long) hdr->size);
#endif
                return new_ptr;
            }
        }
#ifdef DUK_ALLOC_HYBRID_DEBUG
        printf("NEVER HERE\n");
#endif
        return NULL;
    } else if (ptr != NULL) {
        if (size == 0) {
            free(ptr);
            return NULL;
        } else {
#ifdef DUK_ALLOC_HYBRID_DEBUG
            printf("realloc fallback: size %ld\n", (long) size);
#endif
            return realloc(ptr, size);
        }
    } else {
#if 0
        printf("realloc NULL ptr, call alloc: %ld\n", (long) size);
#endif
        return duk_alloc_hybrid(udata, size);
    }
}

References ADDR_IN_HEADER_ALLOC, ADDR_IN_STATE_ALLOC, duk_alloc_hybrid(), dump_pool_state(), free, pool_header::free, pool_state::headers, NULL, NUM_POOLS, printf, realloc, and pool_header::size.

Referenced by create_duktape_heap(), and create_duktape_heap().

dump_pool_state()

static void dump_pool_state ( pool_state * st )

static

Definition at line 84 of file duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c.

                                            {
    (void) st;
}

Referenced by duk_alloc_hybrid(), duk_alloc_hybrid_init(), duk_free_hybrid(), and duk_realloc_hybrid().

Variable Documentation

pool_sizes

pool_size_spec pool_sizes[]

static

Initial value:

= {
    { 32, 1024 },
    { 48, 2048 },
    { 64, 2048 },
    { 128, 2048 },
    { 256, 512 },
    { 1024, 64 },
    { 2048, 32 }
}

Definition at line 24 of file duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c.

                                     {
    { 32, 1024 },
    { 48, 2048 },
    { 64, 2048 },
    { 128, 2048 },
    { 256, 512 },
    { 1024, 64 },
    { 2048, 32 }
};

Referenced by duk_alloc_hybrid_init().