alloc.c File Reference

#include <stdio.h>
#include <derive-c/alloc/std.h>
#include <derive-c/prelude.h>
#include <derive-c/alloc/hybridstatic/template.h>
#include <derive-c/alloc/test/template.h>
#include <derive-c/alloc/debug/template.h>
#include <derive-c/alloc/slab/template.h>
#include <derive-c/alloc/chunkedbump/template.h>

Go to the source code of this file.

Macros
#define	CAPACITY   512
#define	NAME   hybrid
#define	NAME   test_alloc
#define	NAME   dbg
#define	ALLOC   dbg
#define	BLOCK_SIZE   1024
#define	SLAB_SIZE   8096
#define	NAME   slab_large
#define	ALLOC   slab_large
#define	NAME   slab_large_alloc_dbg
#define	ALLOC   slab_large_alloc_dbg
#define	BLOCK_SIZE   32
#define	SLAB_SIZE   8096
#define	NAME   slab_small
#define	ALLOC   slab_small
#define	NAME   slab_small_alloc_dbg
#define	ALLOC   dbg
#define	BLOCK_SIZE   256
#define	NAME   chunked

Functions
static void	example_std ()
static void	example_hybridstatic ()
static void	example_test ()
static void	example_slab ()
static void	example_chunkedbump ()
int	main ()

Macro Definition Documentation

ALLOC [1/5]

#define ALLOC   dbg

Definition at line 47 of file alloc.c.

ALLOC [2/5]

#define ALLOC   slab_small

Definition at line 47 of file alloc.c.

ALLOC [3/5]

#define ALLOC   slab_large_alloc_dbg

Definition at line 47 of file alloc.c.

ALLOC [4/5]

#define ALLOC   slab_large

Definition at line 47 of file alloc.c.

ALLOC [5/5]

#define ALLOC   dbg

Definition at line 47 of file alloc.c.

BLOCK_SIZE [1/3]

#define BLOCK_SIZE   256

Definition at line 48 of file alloc.c.

BLOCK_SIZE [2/3]

#define BLOCK_SIZE   32

Definition at line 48 of file alloc.c.

BLOCK_SIZE [3/3]

#define BLOCK_SIZE   1024

Definition at line 48 of file alloc.c.

CAPACITY

#define CAPACITY   512

Definition at line 13 of file alloc.c.

NAME [1/8]

#define NAME   chunked

Definition at line 14 of file alloc.c.

NAME [2/8]

#define NAME   slab_small_alloc_dbg

Definition at line 14 of file alloc.c.

NAME [3/8]

#define NAME   slab_small

Definition at line 14 of file alloc.c.

NAME [4/8]

#define NAME   slab_large_alloc_dbg

Definition at line 14 of file alloc.c.

NAME [5/8]

#define NAME   slab_large

Definition at line 14 of file alloc.c.

NAME [6/8]

#define NAME   dbg

Definition at line 14 of file alloc.c.

NAME [7/8]

#define NAME   test_alloc

Definition at line 14 of file alloc.c.

NAME [8/8]

#define NAME   hybrid

Definition at line 14 of file alloc.c.

SLAB_SIZE [1/2]

#define SLAB_SIZE   8096

Definition at line 49 of file alloc.c.

SLAB_SIZE [2/2]

#define SLAB_SIZE   8096

Definition at line 49 of file alloc.c.

Function Documentation

example_chunkedbump()

void example_chunkedbump ( )

static

Definition at line 95 of file alloc.c.

                                  {
    DC_DEBUG_TRACE;
    DC_SCOPED(dbg) debug_alloc = dbg_new("chunked_example", stdout, stdalloc_get_ref());
    DC_SCOPED(chunked) alloc = chunked_new(&debug_alloc);
 
    void* small = chunked_allocate_uninit(&alloc, 64);
    void* large = chunked_allocate_uninit(&alloc, 512);
 
    dbg_debug(&debug_alloc, dc_debug_fmt_new(), stdout);
 
    chunked_deallocate(&alloc, small, 64);
    chunked_deallocate(&alloc, large, 512);
}

example_hybridstatic()

void example_hybridstatic ( )

static

Definition at line 17 of file alloc.c.

                                   {
    DC_DEBUG_TRACE;
    hybrid_buffer buf;
    DC_SCOPED(hybrid) alloc = hybrid_new(&buf, stdalloc_get_ref());
 
    void* ptr = hybrid_allocate_uninit(&alloc, 100);
    ptr = hybrid_reallocate(&alloc, ptr, 100, 200);
    hybrid_deallocate(&alloc, ptr, 200);
}

example_slab()

void example_slab ( )

static

Definition at line 67 of file alloc.c.

                           {
    DC_DEBUG_TRACE;
    DC_SCOPED(dbg) user_alloc = dbg_new("user_alloc", stdout, stdalloc_get_ref());
    DC_SCOPED(slab_large) large_slab = slab_large_new(&user_alloc);
    DC_SCOPED(slab_large_alloc_dbg)
    slab_large_alloc = slab_large_alloc_dbg_new("slab_large alloc", stdout, &large_slab);
    DC_SCOPED(slab_small) small_slab = slab_small_new(&slab_large_alloc);
    DC_SCOPED(slab_small_alloc_dbg)
    slab_small_alloc = slab_small_alloc_dbg_new("slab_small alloc", stdout, &small_slab);
 
    void* ptr1 = slab_small_alloc_dbg_allocate_uninit(&slab_small_alloc, 32);
    void* ptr2 =
        slab_small_alloc_dbg_allocate_uninit(&slab_small_alloc, 64); // Larger than block size (32)
    void* ptr3 = slab_small_alloc_dbg_allocate_uninit(&slab_small_alloc,
                                                      2048); // Larger than large block size (1024)
 
    dbg_debug(&user_alloc, dc_debug_fmt_new(), stdout);
 
    slab_small_alloc_dbg_deallocate(&slab_small_alloc, ptr1, 32);
    slab_small_alloc_dbg_deallocate(&slab_small_alloc, ptr2, 64);
    slab_small_alloc_dbg_deallocate(&slab_small_alloc, ptr3, 2048);
}

example_std()

void example_std ( )

static

Definition at line 6 of file alloc.c.

                          {
    DC_DEBUG_TRACE;
    void* ptr = stdalloc_allocate_uninit(stdalloc_get_ref(), 256);
    ptr = stdalloc_reallocate(stdalloc_get_ref(), ptr, 256, 512);
    stdalloc_deallocate(stdalloc_get_ref(), ptr, 512);
}

example_test()

void example_test ( )

static

Definition at line 32 of file alloc.c.

                           {
    DC_DEBUG_TRACE;
    DC_SCOPED(test_alloc) alloc = test_alloc_new(stdalloc_get_ref());
 
    test_alloc_allocate_uninit(&alloc, 128);
    test_alloc_debug(&alloc, dc_debug_fmt_new(), stdout);
    test_alloc_unleak(&alloc);
}

main()

int main

(

)

Examples

complex/employees.c, complex/prime_sieve.c, container/arena.c, container/bitset.c, container/map.c, container/queue.c, container/set.c, container/vector.c, utils/option.c, utils/result.c, and utils/string_builder.c.

Definition at line 109 of file alloc.c.

           {
    example_std();
    example_hybridstatic();
    example_test();
    example_slab();
    example_chunkedbump();
    return 0;
}