src/cairo-tg-allocator-private.h

   1 #ifndef CAIRO_TG_ALLOCATOR_H
   2 #define CAIRO_TG_ALLOCATOR_H
   3
   4 #include "cairoint.h"
   5
   6 typedef struct _cairo_tg_mem_chunk cairo_tg_mem_chunk_t;
   7
   8 struct _cairo_tg_mem_chunk
   9 {
  10     cairo_tg_mem_chunk_t    *next;
  11     uint8_t                 *buffer;
  12     int                     chunk_size;
  13     int                     remaining_size;
  14 };
  15
  16 typedef struct _cairo_tg_mono_allocator
  17 {
  18    cairo_tg_mem_chunk_t     *chunk_head;
  19    int                      chunk_size;
  20 } cairo_tg_mono_allocator_t;
  21
  22 static inline cairo_tg_mem_chunk_t *
  23 _cairo_tg_mem_chunk_create (int chunk_size)
  24 {
  25     cairo_tg_mem_chunk_t *chunk;
  26
  27     chunk = (cairo_tg_mem_chunk_t *) malloc (sizeof (cairo_tg_mem_chunk_t) + chunk_size);
  28
  29     if (chunk)
  30     {
  31         chunk->next = NULL;
  32         chunk->buffer = (uint8_t *) chunk + sizeof (cairo_tg_mem_chunk_t);
  33         chunk->chunk_size = chunk_size;
  34         chunk->remaining_size = chunk_size;
  35     }
  36
  37     return chunk;
  38 }
  39
  40 static inline void
  41 _cairo_tg_mem_chunk_destroy (cairo_tg_mem_chunk_t *chunk)
  42 {
  43     free (chunk);
  44 }
  45
  46 static inline cairo_status_t
  47 _cairo_tg_mono_allocator_init (cairo_tg_mono_allocator_t *allocator, int chunk_size)
  48 {
  49     cairo_tg_mem_chunk_t *chunk;
  50
  51     chunk = _cairo_tg_mem_chunk_create (chunk_size);
  52
  53     if (! chunk)
  54         return CAIRO_STATUS_NO_MEMORY;
  55
  56     allocator->chunk_size = chunk_size;
  57     allocator->chunk_head = chunk;
  58
  59     return CAIRO_STATUS_SUCCESS;
  60 }
  61
  62 static inline void
  63 _cairo_tg_mono_allocator_fini (cairo_tg_mono_allocator_t *allocator)
  64 {
  65     cairo_tg_mem_chunk_t *chunk = allocator->chunk_head, *next;
  66
  67     while (chunk != NULL)
  68     {
  69         next = chunk->next;
  70         _cairo_tg_mem_chunk_destroy (chunk);
  71         chunk = next;
  72     }
  73
  74     allocator->chunk_head = NULL;
  75 }
  76
  77 static inline void *
  78 _cairo_tg_mono_allocator_alloc (cairo_tg_mono_allocator_t *allocator, int size)
  79 {
  80     cairo_tg_mem_chunk_t *chunk = allocator->chunk_head;
  81     int chunk_size;
  82
  83     if (chunk && chunk->remaining_size >= size)
  84     {
  85         void *buffer = (void*)(chunk->buffer + chunk->chunk_size - chunk->remaining_size);
  86         chunk->remaining_size -= size;
  87         return buffer;
  88     }
  89
  90     chunk_size = MAX (allocator->chunk_size, size);
  91
  92     chunk = _cairo_tg_mem_chunk_create (chunk_size);
  93
  94     if (chunk == NULL)
  95         return NULL;
  96
  97     chunk->next = allocator->chunk_head;
  98     chunk->buffer = (uint8_t *) chunk + sizeof (cairo_tg_mem_chunk_t);
  99     chunk->chunk_size = chunk_size;
 100     chunk->remaining_size = chunk_size - size;
 101
 102     allocator->chunk_head = chunk;
 103
 104     return (void *) chunk->buffer;
 105 }
 106
 107 static inline void
 108 _cairo_tg_mono_allocator_reset (cairo_tg_mono_allocator_t *allocator)
 109 {
 110     cairo_tg_mem_chunk_t *chunk = allocator->chunk_head, *next;
 111     cairo_tg_mem_chunk_t *stock = NULL;
 112
 113     while (chunk != NULL)
 114     {
 115         next = chunk->next;
 116
 117         if (stock)
 118             _cairo_tg_mem_chunk_destroy (chunk);
 119         else
 120             stock = chunk;
 121
 122         chunk = next;
 123     }
 124
 125     if (stock)
 126     {
 127         stock->next = NULL;
 128         stock->remaining_size = stock->chunk_size;
 129     }
 130
 131     allocator->chunk_head = stock;
 132 }
 133
 134 #endif /* CAIRO_TG_ALLOCATOR_H */