src/mm/memory.h

   1 /* src/mm/memory.h - macros for memory management
   2
   3    Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
   4    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
   5    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
   6    J. Wenninger, Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23    02110-1301, USA.
  24
  25    $Id: memory.h 7812 2007-04-25 18:51:03Z twisti $
  26
  27 */
  28
  29
  30 #ifndef _MEMORY_H
  31 #define _MEMORY_H
  32
  33 /* forward typedefs ***********************************************************/
  34
  35 typedef struct dumpblock_t dumpblock_t;
  36 typedef struct dumpinfo_t  dumpinfo_t;
  37
  38 #include "config.h"
  39
  40 #include <string.h>
  41
  42 #include "vm/types.h"
  43
  44
  45 /* ATTENTION: We need to define dumpblock_t and dumpinfo_t before
  46    internal includes, as we need dumpinfo_t as nested structure in
  47    threadobject. */
  48
  49 /* dumpblock ******************************************************************/
  50
  51 #define DUMPBLOCKSIZE    2 << 13    /* 2 * 8192 bytes */
  52 #define ALIGNSIZE        8
  53
  54 struct dumpblock_t {
  55         dumpblock_t *prev;
  56         u1          *dumpmem;
  57         s4           size;
  58 };
  59
  60
  61 /* dump_allocation *************************************************************
  62
  63    This struct is used to record dump memory allocations for ENABLE_MEMCHECK.
  64
  65 *******************************************************************************/
  66
  67 #if defined(ENABLE_MEMCHECK)
  68 typedef struct dump_allocation_t dump_allocation_t;
  69
  70 struct dump_allocation_t {
  71         dump_allocation_t *next;
  72         u1                *mem;
  73         s4                 useddumpsize;
  74         s4                 size;
  75 };
  76 #endif
  77
  78
  79 /* dumpinfo *******************************************************************/
  80
  81 struct dumpinfo_t {
  82         dumpblock_t       *currentdumpblock;        /* the current top-most block */
  83         s4                 allocateddumpsize;     /* allocated bytes in this area */
  84         s4                 useddumpsize;          /* used bytes in this dump area */
  85 #if defined(ENABLE_MEMCHECK)
  86         dump_allocation_t *allocations;       /* list of allocations in this area */
  87 #endif
  88 };
  89
  90
  91 /* internal includes **********************************************************/
  92
  93 #include "mm/gc-common.h"
  94
  95
  96 /*
  97 ---------------------------- Interface description -----------------------
  98
  99 There are two possible choices for allocating memory:
 100
 101         1.   explicit allocating / deallocating
 102
 103                         mem_alloc ..... allocate a memory block
 104                         mem_free ...... free a memory block
 105                         mem_realloc ... change size of a memory block (position may change)
 106                         mem_usage ..... amount of allocated memory
 107
 108
 109         2.   explicit allocating, automatic deallocating
 110
 111                         dump_alloc .... allocate a memory block in the dump area
 112                         dump_realloc .. change size of a memory block (position may change)
 113                         dump_size ..... marks the current top of dump
 114                         dump_release .. free all memory requested after the mark
 115
 116
 117 There are some useful macros:
 118
 119         NEW (type) ....... allocate memory for an element of type `type`
 120         FREE (ptr,type) .. free memory
 121
 122         MNEW (type,num) .. allocate memory for an array
 123         MFREE (ptr,type,num) .. free memory
 124
 125         MREALLOC (ptr,type,num1,num2) .. enlarge the array to size num2
 126
 127 These macros do the same except they operate on the dump area:
 128
 129         DNEW,  DMNEW, DMREALLOC   (there is no DFREE)
 130
 131
 132 -------------------------------------------------------------------------------
 133
 134 Some more macros:
 135
 136         MEMORY_ALIGN (pos, size) ... make pos divisible by size. always returns an
 137                                  address >= pos.
 138
 139
 140         OFFSET (s,el) ....... returns the offset of 'el' in structure 's' in bytes.
 141
 142         MCOPY (dest,src,type,num) ... copy 'num' elements of type 'type'.
 143
 144
 145 */
 146
 147 #define MEMORY_ALIGN(pos,size) ((((pos) + (size) - 1) / (size)) * (size))
 148 #define PADDING(pos,size)     (MEMORY_ALIGN((pos),(size)) - (pos))
 149 #define OFFSET(s,el)          ((s4) ((ptrint) &(((s*) 0)->el)))
 150
 151
 152 #define NEW(type)             ((type *) mem_alloc(sizeof(type)))
 153 #define FREE(ptr,type)        mem_free((ptr), sizeof(type))
 154
 155 #define MNEW(type,num)        ((type *) mem_alloc(sizeof(type) * (num)))
 156 #define MFREE(ptr,type,num)   mem_free((ptr), sizeof(type) * (num))
 157
 158 #define MREALLOC(ptr,type,num1,num2) mem_realloc((ptr), sizeof(type) * (num1), \
 159                                                         sizeof(type) * (num2))
 160
 161
 162 #define DNEW(type)            ((type *) dump_alloc(sizeof(type)))
 163 #define DMNEW(type,num)       ((type *) dump_alloc(sizeof(type) * (num)))
 164 #define DMREALLOC(ptr,type,num1,num2) dump_realloc((ptr), sizeof(type) * (num1), \
 165                                                           sizeof(type) * (num2))
 166
 167 #define MCOPY(dest,src,type,num) memcpy((dest), (src), sizeof(type) * (num))
 168 #define MSET(ptr,byte,type,num) memset((ptr), (byte), sizeof(type) * (num))
 169 #define MZERO(ptr,type,num)     MSET(ptr,0,type,num)
 170 #define MMOVE(dest,src,type,num) memmove((dest), (src), sizeof(type) * (num))
 171
 172 #define CNEW(type,num)        ((type *) memory_cnew(sizeof(type) * (num)))
 173 #define CFREE(ptr,num)        memory_cfree((ptr),(num))
 174
 175
 176 /* GC macros ******************************************************************/
 177
 178 /* Uncollectable memory which can contain references */
 179
 180 #define GCNEW_UNCOLLECTABLE(type,num) ((type *) heap_alloc_uncollectable(sizeof(type) * (num)))
 181
 182 #define GCNEW(type)           heap_allocate(sizeof(type), true, NULL)
 183 #define GCMNEW(type,num)      heap_allocate(sizeof(type) * (num), true, NULL)
 184
 185 #define GCFREE(ptr)           heap_free((ptr))
 186
 187
 188 /* function prototypes ********************************************************/
 189
 190 /* initializes the memory subsystem */
 191 bool memory_init(void);
 192
 193 void *memory_mmap_anon(void *addr, size_t len, int prot, int flags);
 194
 195 void *memory_cnew(s4 size);
 196 void  memory_cfree(void *p, s4 size);
 197
 198 void *mem_alloc(s4 size);
 199 void  mem_free(void *m, s4 size);
 200 void *mem_realloc(void *src, s4 len1, s4 len2);
 201
 202 #if defined(ENABLE_THREADS)
 203 bool  memory_start_thread(void);
 204 #endif
 205
 206 void *dump_alloc(s4 size);
 207 void *dump_realloc(void *src, s4 len1, s4 len2);
 208 s4    dump_size(void);
 209 void  dump_release(s4 size);
 210
 211 #endif /* _MEMORY_H */
 212
 213
 214 /*
 215  * These are local overrides for various environment variables in Emacs.
 216  * Please do not remove this and leave it at the end of the file, where
 217  * Emacs will automagically detect them.
 218  * ---------------------------------------------------------------------
 219  * Local variables:
 220  * mode: c
 221  * indent-tabs-mode: t
 222  * c-basic-offset: 4
 223  * tab-width: 4
 224  * End:
 225  */