|
118
|
1 /* Block-relocating memory allocator.
|
|
10432
|
2 Copyright (C) 1993, 1995 Free Software Foundation, Inc.
|
|
118
|
3
|
|
|
4 This file is part of GNU Emacs.
|
|
|
5
|
|
|
6 GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
7 it under the terms of the GNU General Public License as published by
|
|
10432
|
8 the Free Software Foundation; either version 2, or (at your option)
|
|
118
|
9 any later version.
|
|
|
10
|
|
|
11 GNU Emacs is distributed in the hope that it will be useful,
|
|
|
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
14 GNU General Public License for more details.
|
|
|
15
|
|
|
16 You should have received a copy of the GNU General Public License
|
|
|
17 along with GNU Emacs; see the file COPYING. If not, write to
|
|
14186
|
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
19 Boston, MA 02111-1307, USA. */
|
|
118
|
20
|
|
|
21 /* NOTES:
|
|
|
22
|
|
3591
|
23 Only relocate the blocs necessary for SIZE in r_alloc_sbrk,
|
|
118
|
24 rather than all of them. This means allowing for a possible
|
|
9596
|
25 hole between the first bloc and the end of malloc storage. */
|
|
118
|
26
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
27 #ifdef emacs
|
|
1403
|
28
|
|
4696
|
29 #include <config.h>
|
|
577
|
30 #include "lisp.h" /* Needed for VALBITS. */
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
31
|
|
1403
|
32 #undef NULL
|
|
|
33
|
|
1451
|
34 /* The important properties of this type are that 1) it's a pointer, and
|
|
|
35 2) arithmetic on it should work as if the size of the object pointed
|
|
|
36 to has a size of 1. */
|
|
3109
|
37 #if 0 /* Arithmetic on void* is a GCC extension. */
|
|
1451
|
38 #ifdef __STDC__
|
|
|
39 typedef void *POINTER;
|
|
|
40 #else
|
|
1729
|
41
|
|
|
42 #ifdef HAVE_CONFIG_H
|
|
|
43 #include "config.h"
|
|
|
44 #endif
|
|
|
45
|
|
1451
|
46 typedef char *POINTER;
|
|
1729
|
47
|
|
1451
|
48 #endif
|
|
3109
|
49 #endif /* 0 */
|
|
|
50
|
|
|
51 /* Unconditionally use char * for this. */
|
|
|
52 typedef char *POINTER;
|
|
1451
|
53
|
|
|
54 typedef unsigned long SIZE;
|
|
|
55
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
56 /* Declared in dispnew.c, this version doesn't screw up if regions
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
57 overlap. */
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
58 extern void safe_bcopy ();
|
|
1403
|
59
|
|
17845
|
60 #ifdef DOUG_LEA_MALLOC
|
|
|
61 #define M_TOP_PAD -2
|
|
|
62 extern int mallopt ();
|
|
|
63 #else
|
|
10785
|
64 extern int __malloc_extra_blocks;
|
|
17845
|
65 #endif
|
|
10785
|
66
|
|
10747
|
67 #else /* not emacs */
|
|
1403
|
68
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
69 #include <stddef.h>
|
|
1403
|
70
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
71 typedef size_t SIZE;
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
72 typedef void *POINTER;
|
|
1403
|
73
|
|
|
74 #include <unistd.h>
|
|
|
75 #include <malloc.h>
|
|
|
76 #include <string.h>
|
|
|
77
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
78 #define safe_bcopy(x, y, z) memmove (y, x, z)
|
|
10747
|
79 #define bzero(x, len) memset (x, 0, len)
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
80
|
|
10747
|
81 #endif /* not emacs */
|
|
|
82
|
|
|
83 #include "getpagesize.h"
|
|
118
|
84
|
|
|
85 #define NIL ((POINTER) 0)
|
|
|
86
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
87 /* A flag to indicate whether we have initialized ralloc yet. For
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
88 Emacs's sake, please do not make this local to malloc_init; on some
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
89 machines, the dumping procedure makes all static variables
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
90 read-only. On these machines, the word static is #defined to be
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
91 the empty string, meaning that r_alloc_initialized becomes an
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
92 automatic variable, and loses its value each time Emacs is started up. */
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
93 static int r_alloc_initialized = 0;
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
94
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
95 static void r_alloc_init ();
|
|
118
|
96
|
|
577
|
97 /* Declarations for working with the malloc, ralloc, and system breaks. */
|
|
|
98
|
|
9596
|
99 /* Function to set the real break value. */
|
|
1401
|
100 static POINTER (*real_morecore) ();
|
|
118
|
101
|
|
9596
|
102 /* The break value, as seen by malloc. */
|
|
118
|
103 static POINTER virtual_break_value;
|
|
|
104
|
|
9596
|
105 /* The address of the end of the last data in use by ralloc,
|
|
|
106 including relocatable blocs as well as malloc data. */
|
|
118
|
107 static POINTER break_value;
|
|
|
108
|
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
109 /* This is the size of a page. We round memory requests to this boundary. */
|
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
110 static int page_size;
|
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
111
|
|
1595
|
112 /* Whenever we get memory from the system, get this many extra bytes. This
|
|
|
113 must be a multiple of page_size. */
|
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
114 static int extra_bytes;
|
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
115
|
|
118
|
116 /* Macros for rounding. Note that rounding to any value is possible
|
|
9596
|
117 by changing the definition of PAGE. */
|
|
118
|
118 #define PAGE (getpagesize ())
|
4230
df4d091e603e
(ALIGNED, ROUNDUP): Use `unsigned long int' instead of `unsigned int' for
Roland McGrath <roland@gnu.org>
diff
changeset
|
119 #define ALIGNED(addr) (((unsigned long int) (addr) & (page_size - 1)) == 0)
|
df4d091e603e
(ALIGNED, ROUNDUP): Use `unsigned long int' instead of `unsigned int' for
Roland McGrath <roland@gnu.org>
diff
changeset
|
120 #define ROUNDUP(size) (((unsigned long int) (size) + page_size - 1) \
|
df4d091e603e
(ALIGNED, ROUNDUP): Use `unsigned long int' instead of `unsigned int' for
Roland McGrath <roland@gnu.org>
diff
changeset
|
121 & ~(page_size - 1))
|
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
122 #define ROUND_TO_PAGE(addr) (addr & (~(page_size - 1)))
|
|
118
|
123
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
124 #define MEM_ALIGN sizeof(double)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
125 #define MEM_ROUNDUP(addr) (((unsigned long int)(addr) + MEM_ALIGN - 1) \
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
126 & ~(MEM_ALIGN - 1))
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
127
|
|
9596
|
128 /* Data structures of heaps and blocs. */
|
|
|
129
|
|
|
130 /* The relocatable objects, or blocs, and the malloc data
|
|
|
131 both reside within one or more heaps.
|
|
|
132 Each heap contains malloc data, running from `start' to `bloc_start',
|
|
|
133 and relocatable objects, running from `bloc_start' to `free'.
|
|
|
134
|
|
|
135 Relocatable objects may relocate within the same heap
|
|
|
136 or may move into another heap; the heaps themselves may grow
|
|
|
137 but they never move.
|
|
|
138
|
|
|
139 We try to make just one heap and make it larger as necessary.
|
|
14036
|
140 But sometimes we can't do that, because we can't get contiguous
|
|
9596
|
141 space to add onto the heap. When that happens, we start a new heap. */
|
|
|
142
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
143 typedef struct heap
|
|
118
|
144 {
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
145 struct heap *next;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
146 struct heap *prev;
|
|
9596
|
147 /* Start of memory range of this heap. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
148 POINTER start;
|
|
9596
|
149 /* End of memory range of this heap. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
150 POINTER end;
|
|
9596
|
151 /* Start of relocatable data in this heap. */
|
|
|
152 POINTER bloc_start;
|
|
|
153 /* Start of unused space in this heap. */
|
|
|
154 POINTER free;
|
|
9666
|
155 /* First bloc in this heap. */
|
|
|
156 struct bp *first_bloc;
|
|
|
157 /* Last bloc in this heap. */
|
|
|
158 struct bp *last_bloc;
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
159 } *heap_ptr;
|
|
118
|
160
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
161 #define NIL_HEAP ((heap_ptr) 0)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
162 #define HEAP_PTR_SIZE (sizeof (struct heap))
|
|
118
|
163
|
|
9596
|
164 /* This is the first heap object.
|
|
|
165 If we need additional heap objects, each one resides at the beginning of
|
|
|
166 the space it covers. */
|
|
|
167 static struct heap heap_base;
|
|
|
168
|
|
|
169 /* Head and tail of the list of heaps. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
170 static heap_ptr first_heap, last_heap;
|
|
577
|
171
|
|
|
172 /* These structures are allocated in the malloc arena.
|
|
|
173 The linked list is kept in order of increasing '.data' members.
|
|
|
174 The data blocks abut each other; if b->next is non-nil, then
|
|
11146
|
175 b->data + b->size == b->next->data.
|
|
|
176
|
|
|
177 An element with variable==NIL denotes a freed block, which has not yet
|
|
|
178 been collected. They may only appear while r_alloc_freeze > 0, and will be
|
|
|
179 freed when the arena is thawed. Currently, these blocs are not reusable,
|
|
14036
|
180 while the arena is frozen. Very inefficient. */
|
|
11146
|
181
|
|
118
|
182 typedef struct bp
|
|
|
183 {
|
|
|
184 struct bp *next;
|
|
|
185 struct bp *prev;
|
|
|
186 POINTER *variable;
|
|
|
187 POINTER data;
|
|
|
188 SIZE size;
|
|
14036
|
189 POINTER new_data; /* temporarily used for relocation */
|
|
11146
|
190 struct heap *heap; /* Heap this bloc is in. */
|
|
118
|
191 } *bloc_ptr;
|
|
|
192
|
|
|
193 #define NIL_BLOC ((bloc_ptr) 0)
|
|
|
194 #define BLOC_PTR_SIZE (sizeof (struct bp))
|
|
|
195
|
|
9596
|
196 /* Head and tail of the list of relocatable blocs. */
|
|
118
|
197 static bloc_ptr first_bloc, last_bloc;
|
|
|
198
|
|
11146
|
199 static int use_relocatable_buffers;
|
|
|
200
|
|
|
201 /* If >0, no relocation whatsoever takes place. */
|
|
|
202 static int r_alloc_freeze_level;
|
|
|
203
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
204
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
205 /* Functions to get and return memory from the system. */
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
206
|
|
9596
|
207 /* Find the heap that ADDRESS falls within. */
|
|
|
208
|
|
|
209 static heap_ptr
|
|
|
210 find_heap (address)
|
|
|
211 POINTER address;
|
|
|
212 {
|
|
|
213 heap_ptr heap;
|
|
|
214
|
|
|
215 for (heap = last_heap; heap; heap = heap->prev)
|
|
|
216 {
|
|
|
217 if (heap->start <= address && address <= heap->end)
|
|
|
218 return heap;
|
|
|
219 }
|
|
|
220
|
|
|
221 return NIL_HEAP;
|
|
|
222 }
|
|
|
223
|
|
|
224 /* Find SIZE bytes of space in a heap.
|
|
|
225 Try to get them at ADDRESS (which must fall within some heap's range)
|
|
|
226 if we can get that many within one heap.
|
|
|
227
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
228 If enough space is not presently available in our reserve, this means
|
|
14036
|
229 getting more page-aligned space from the system. If the returned space
|
|
|
230 is not contiguous to the last heap, allocate a new heap, and append it
|
|
9596
|
231
|
|
|
232 obtain does not try to keep track of whether space is in use
|
|
|
233 or not in use. It just returns the address of SIZE bytes that
|
|
|
234 fall within a single heap. If you call obtain twice in a row
|
|
|
235 with the same arguments, you typically get the same value.
|
|
|
236 to the heap list. It's the caller's responsibility to keep
|
|
|
237 track of what space is in use.
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
238
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
239 Return the address of the space if all went well, or zero if we couldn't
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
240 allocate the memory. */
|
|
9596
|
241
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
242 static POINTER
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
243 obtain (address, size)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
244 POINTER address;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
245 SIZE size;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
246 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
247 heap_ptr heap;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
248 SIZE already_available;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
249
|
|
9596
|
250 /* Find the heap that ADDRESS falls within. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
251 for (heap = last_heap; heap; heap = heap->prev)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
252 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
253 if (heap->start <= address && address <= heap->end)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
254 break;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
255 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
256
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
257 if (! heap)
|
|
9596
|
258 abort ();
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
259
|
|
9596
|
260 /* If we can't fit SIZE bytes in that heap,
|
|
|
261 try successive later heaps. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
262 while (heap && address + size > heap->end)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
263 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
264 heap = heap->next;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
265 if (heap == NIL_HEAP)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
266 break;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
267 address = heap->bloc_start;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
268 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
269
|
|
9596
|
270 /* If we can't fit them within any existing heap,
|
|
|
271 get more space. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
272 if (heap == NIL_HEAP)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
273 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
274 POINTER new = (*real_morecore)(0);
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
275 SIZE get;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
276
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
277 already_available = (char *)last_heap->end - (char *)address;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
278
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
279 if (new != last_heap->end)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
280 {
|
|
9596
|
281 /* Someone else called sbrk. Make a new heap. */
|
|
|
282
|
|
|
283 heap_ptr new_heap = (heap_ptr) MEM_ROUNDUP (new);
|
|
|
284 POINTER bloc_start = (POINTER) MEM_ROUNDUP ((POINTER)(new_heap + 1));
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
285
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
286 if ((*real_morecore) (bloc_start - new) != new)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
287 return 0;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
288
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
289 new_heap->start = new;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
290 new_heap->end = bloc_start;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
291 new_heap->bloc_start = bloc_start;
|
|
9596
|
292 new_heap->free = bloc_start;
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
293 new_heap->next = NIL_HEAP;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
294 new_heap->prev = last_heap;
|
|
9666
|
295 new_heap->first_bloc = NIL_BLOC;
|
|
|
296 new_heap->last_bloc = NIL_BLOC;
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
297 last_heap->next = new_heap;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
298 last_heap = new_heap;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
299
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
300 address = bloc_start;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
301 already_available = 0;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
302 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
303
|
|
9596
|
304 /* Add space to the last heap (which we may have just created).
|
|
|
305 Get some extra, so we can come here less often. */
|
|
|
306
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
307 get = size + extra_bytes - already_available;
|
|
9596
|
308 get = (char *) ROUNDUP ((char *)last_heap->end + get)
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
309 - (char *) last_heap->end;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
310
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
311 if ((*real_morecore) (get) != last_heap->end)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
312 return 0;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
313
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
314 last_heap->end += get;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
315 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
316
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
317 return address;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
318 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
319
|
|
9596
|
320 /* Return unused heap space to the system
|
|
|
321 if there is a lot of unused space now.
|
|
|
322 This can make the last heap smaller;
|
|
|
323 it can also eliminate the last heap entirely. */
|
|
|
324
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
325 static void
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
326 relinquish ()
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
327 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
328 register heap_ptr h;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
329 int excess = 0;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
330
|
|
9596
|
331 /* Add the amount of space beyond break_value
|
|
|
332 in all heaps which have extend beyond break_value at all. */
|
|
|
333
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
334 for (h = last_heap; h && break_value < h->end; h = h->prev)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
335 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
336 excess += (char *) h->end - (char *) ((break_value < h->bloc_start)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
337 ? h->bloc_start : break_value);
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
338 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
339
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
340 if (excess > extra_bytes * 2 && (*real_morecore) (0) == last_heap->end)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
341 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
342 /* Keep extra_bytes worth of empty space.
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
343 And don't free anything unless we can free at least extra_bytes. */
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
344 excess -= extra_bytes;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
345
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
346 if ((char *)last_heap->end - (char *)last_heap->bloc_start <= excess)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
347 {
|
|
9666
|
348 /* This heap should have no blocs in it. */
|
|
|
349 if (last_heap->first_bloc != NIL_BLOC
|
|
|
350 || last_heap->last_bloc != NIL_BLOC)
|
|
|
351 abort ();
|
|
|
352
|
|
9596
|
353 /* Return the last heap, with its header, to the system. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
354 excess = (char *)last_heap->end - (char *)last_heap->start;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
355 last_heap = last_heap->prev;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
356 last_heap->next = NIL_HEAP;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
357 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
358 else
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
359 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
360 excess = (char *) last_heap->end
|
|
9596
|
361 - (char *) ROUNDUP ((char *)last_heap->end - excess);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
362 last_heap->end -= excess;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
363 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
364
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
365 if ((*real_morecore) (- excess) == 0)
|
|
19999
|
366 {
|
|
|
367 /* If the system didn't want that much memory back, adjust
|
|
|
368 the end of the last heap to reflect that. This can occur
|
|
|
369 if break_value is still within the original data segment. */
|
|
|
370 last_heap->end += excess;
|
|
|
371 /* Make sure that the result of the adjustment is accurate.
|
|
|
372 It should be, for the else clause above; the other case,
|
|
|
373 which returns the entire last heap to the system, seems
|
|
|
374 unlikely to trigger this mode of failure. */
|
|
|
375 if (last_heap->end != (*real_morecore) (0))
|
|
|
376 abort ();
|
|
|
377 }
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
378 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
379 }
|
|
10682
|
380
|
|
|
381 /* Return the total size in use by relocating allocator,
|
|
|
382 above where malloc gets space. */
|
|
|
383
|
|
|
384 long
|
|
|
385 r_alloc_size_in_use ()
|
|
|
386 {
|
|
|
387 return break_value - virtual_break_value;
|
|
|
388 }
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
389
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
390 /* The meat - allocating, freeing, and relocating blocs. */
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
391
|
|
577
|
392 /* Find the bloc referenced by the address in PTR. Returns a pointer
|
|
9596
|
393 to that block. */
|
|
118
|
394
|
|
|
395 static bloc_ptr
|
|
|
396 find_bloc (ptr)
|
|
|
397 POINTER *ptr;
|
|
|
398 {
|
|
|
399 register bloc_ptr p = first_bloc;
|
|
|
400
|
|
|
401 while (p != NIL_BLOC)
|
|
|
402 {
|
|
|
403 if (p->variable == ptr && p->data == *ptr)
|
|
|
404 return p;
|
|
|
405
|
|
|
406 p = p->next;
|
|
|
407 }
|
|
|
408
|
|
|
409 return p;
|
|
|
410 }
|
|
|
411
|
|
|
412 /* Allocate a bloc of SIZE bytes and append it to the chain of blocs.
|
|
1249
|
413 Returns a pointer to the new bloc, or zero if we couldn't allocate
|
|
|
414 memory for the new block. */
|
|
118
|
415
|
|
|
416 static bloc_ptr
|
|
|
417 get_bloc (size)
|
|
|
418 SIZE size;
|
|
|
419 {
|
|
1249
|
420 register bloc_ptr new_bloc;
|
|
9596
|
421 register heap_ptr heap;
|
|
118
|
422
|
|
1249
|
423 if (! (new_bloc = (bloc_ptr) malloc (BLOC_PTR_SIZE))
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
424 || ! (new_bloc->data = obtain (break_value, size)))
|
|
1249
|
425 {
|
|
|
426 if (new_bloc)
|
|
|
427 free (new_bloc);
|
|
|
428
|
|
|
429 return 0;
|
|
|
430 }
|
|
|
431
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
432 break_value = new_bloc->data + size;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
433
|
|
118
|
434 new_bloc->size = size;
|
|
|
435 new_bloc->next = NIL_BLOC;
|
|
1013
|
436 new_bloc->variable = (POINTER *) NIL;
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
437 new_bloc->new_data = 0;
|
|
118
|
438
|
|
9596
|
439 /* Record in the heap that this space is in use. */
|
|
|
440 heap = find_heap (new_bloc->data);
|
|
|
441 heap->free = break_value;
|
|
|
442
|
|
9666
|
443 /* Maintain the correspondence between heaps and blocs. */
|
|
|
444 new_bloc->heap = heap;
|
|
|
445 heap->last_bloc = new_bloc;
|
|
|
446 if (heap->first_bloc == NIL_BLOC)
|
|
|
447 heap->first_bloc = new_bloc;
|
|
|
448
|
|
9596
|
449 /* Put this bloc on the doubly-linked list of blocs. */
|
|
118
|
450 if (first_bloc)
|
|
|
451 {
|
|
|
452 new_bloc->prev = last_bloc;
|
|
|
453 last_bloc->next = new_bloc;
|
|
|
454 last_bloc = new_bloc;
|
|
|
455 }
|
|
|
456 else
|
|
|
457 {
|
|
|
458 first_bloc = last_bloc = new_bloc;
|
|
|
459 new_bloc->prev = NIL_BLOC;
|
|
|
460 }
|
|
|
461
|
|
|
462 return new_bloc;
|
|
|
463 }
|
|
9666
|
464
|
|
9596
|
465 /* Calculate new locations of blocs in the list beginning with BLOC,
|
|
|
466 relocating it to start at ADDRESS, in heap HEAP. If enough space is
|
|
|
467 not presently available in our reserve, call obtain for
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
468 more space.
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
469
|
|
9596
|
470 Store the new location of each bloc in its new_data field.
|
|
|
471 Do not touch the contents of blocs or break_value. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
472
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
473 static int
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
474 relocate_blocs (bloc, heap, address)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
475 bloc_ptr bloc;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
476 heap_ptr heap;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
477 POINTER address;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
478 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
479 register bloc_ptr b = bloc;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
480
|
|
11146
|
481 /* No need to ever call this if arena is frozen, bug somewhere! */
|
|
|
482 if (r_alloc_freeze_level)
|
|
|
483 abort();
|
|
|
484
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
485 while (b)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
486 {
|
|
9596
|
487 /* If bloc B won't fit within HEAP,
|
|
|
488 move to the next heap and try again. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
489 while (heap && address + b->size > heap->end)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
490 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
491 heap = heap->next;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
492 if (heap == NIL_HEAP)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
493 break;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
494 address = heap->bloc_start;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
495 }
|
|
118
|
496
|
|
9596
|
497 /* If BLOC won't fit in any heap,
|
|
|
498 get enough new space to hold BLOC and all following blocs. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
499 if (heap == NIL_HEAP)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
500 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
501 register bloc_ptr tb = b;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
502 register SIZE s = 0;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
503
|
|
9596
|
504 /* Add up the size of all the following blocs. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
505 while (tb != NIL_BLOC)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
506 {
|
|
11146
|
507 if (tb->variable)
|
|
|
508 s += tb->size;
|
|
|
509
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
510 tb = tb->next;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
511 }
|
|
1595
|
512
|
|
9596
|
513 /* Get that space. */
|
|
|
514 address = obtain (address, s);
|
|
|
515 if (address == 0)
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
516 return 0;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
517
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
518 heap = last_heap;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
519 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
520
|
|
9596
|
521 /* Record the new address of this bloc
|
|
|
522 and update where the next bloc can start. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
523 b->new_data = address;
|
|
11146
|
524 if (b->variable)
|
|
|
525 address += b->size;
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
526 b = b->next;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
527 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
528
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
529 return 1;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
530 }
|
|
118
|
531
|
|
9666
|
532 /* Reorder the bloc BLOC to go before bloc BEFORE in the doubly linked list.
|
|
|
533 This is necessary if we put the memory of space of BLOC
|
|
|
534 before that of BEFORE. */
|
|
|
535
|
|
|
536 static void
|
|
|
537 reorder_bloc (bloc, before)
|
|
|
538 bloc_ptr bloc, before;
|
|
|
539 {
|
|
|
540 bloc_ptr prev, next;
|
|
|
541
|
|
|
542 /* Splice BLOC out from where it is. */
|
|
|
543 prev = bloc->prev;
|
|
|
544 next = bloc->next;
|
|
9596
|
545
|
|
9666
|
546 if (prev)
|
|
|
547 prev->next = next;
|
|
|
548 if (next)
|
|
|
549 next->prev = prev;
|
|
|
550
|
|
|
551 /* Splice it in before BEFORE. */
|
|
|
552 prev = before->prev;
|
|
|
553
|
|
|
554 if (prev)
|
|
|
555 prev->next = bloc;
|
|
|
556 bloc->prev = prev;
|
|
|
557
|
|
|
558 before->prev = bloc;
|
|
|
559 bloc->next = before;
|
|
|
560 }
|
|
|
561
|
|
|
562 /* Update the records of which heaps contain which blocs, starting
|
|
|
563 with heap HEAP and bloc BLOC. */
|
|
|
564
|
|
|
565 static void
|
|
|
566 update_heap_bloc_correspondence (bloc, heap)
|
|
9596
|
567 bloc_ptr bloc;
|
|
|
568 heap_ptr heap;
|
|
|
569 {
|
|
|
570 register bloc_ptr b;
|
|
|
571
|
|
9666
|
572 /* Initialize HEAP's status to reflect blocs before BLOC. */
|
|
|
573 if (bloc != NIL_BLOC && bloc->prev != NIL_BLOC && bloc->prev->heap == heap)
|
|
|
574 {
|
|
|
575 /* The previous bloc is in HEAP. */
|
|
|
576 heap->last_bloc = bloc->prev;
|
|
|
577 heap->free = bloc->prev->data + bloc->prev->size;
|
|
|
578 }
|
|
|
579 else
|
|
|
580 {
|
|
|
581 /* HEAP contains no blocs before BLOC. */
|
|
|
582 heap->first_bloc = NIL_BLOC;
|
|
|
583 heap->last_bloc = NIL_BLOC;
|
|
|
584 heap->free = heap->bloc_start;
|
|
|
585 }
|
|
|
586
|
|
9596
|
587 /* Advance through blocs one by one. */
|
|
|
588 for (b = bloc; b != NIL_BLOC; b = b->next)
|
|
|
589 {
|
|
9666
|
590 /* Advance through heaps, marking them empty,
|
|
|
591 till we get to the one that B is in. */
|
|
9596
|
592 while (heap)
|
|
|
593 {
|
|
|
594 if (heap->bloc_start <= b->data && b->data <= heap->end)
|
|
|
595 break;
|
|
|
596 heap = heap->next;
|
|
9666
|
597 /* We know HEAP is not null now,
|
|
|
598 because there has to be space for bloc B. */
|
|
|
599 heap->first_bloc = NIL_BLOC;
|
|
|
600 heap->last_bloc = NIL_BLOC;
|
|
9596
|
601 heap->free = heap->bloc_start;
|
|
|
602 }
|
|
9666
|
603
|
|
|
604 /* Update HEAP's status for bloc B. */
|
|
9596
|
605 heap->free = b->data + b->size;
|
|
9666
|
606 heap->last_bloc = b;
|
|
|
607 if (heap->first_bloc == NIL_BLOC)
|
|
|
608 heap->first_bloc = b;
|
|
|
609
|
|
|
610 /* Record that B is in HEAP. */
|
|
|
611 b->heap = heap;
|
|
9596
|
612 }
|
|
|
613
|
|
|
614 /* If there are any remaining heaps and no blocs left,
|
|
9666
|
615 mark those heaps as empty. */
|
|
9596
|
616 heap = heap->next;
|
|
|
617 while (heap)
|
|
|
618 {
|
|
9666
|
619 heap->first_bloc = NIL_BLOC;
|
|
|
620 heap->last_bloc = NIL_BLOC;
|
|
9596
|
621 heap->free = heap->bloc_start;
|
|
|
622 heap = heap->next;
|
|
|
623 }
|
|
|
624 }
|
|
9666
|
625
|
|
9596
|
626 /* Resize BLOC to SIZE bytes. This relocates the blocs
|
|
|
627 that come after BLOC in memory. */
|
|
|
628
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
629 static int
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
630 resize_bloc (bloc, size)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
631 bloc_ptr bloc;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
632 SIZE size;
|
|
118
|
633 {
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
634 register bloc_ptr b;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
635 heap_ptr heap;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
636 POINTER address;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
637 SIZE old_size;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
638
|
|
11146
|
639 /* No need to ever call this if arena is frozen, bug somewhere! */
|
|
|
640 if (r_alloc_freeze_level)
|
|
|
641 abort();
|
|
|
642
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
643 if (bloc == NIL_BLOC || size == bloc->size)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
644 return 1;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
645
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
646 for (heap = first_heap; heap != NIL_HEAP; heap = heap->next)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
647 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
648 if (heap->bloc_start <= bloc->data && bloc->data <= heap->end)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
649 break;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
650 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
651
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
652 if (heap == NIL_HEAP)
|
|
9596
|
653 abort ();
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
654
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
655 old_size = bloc->size;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
656 bloc->size = size;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
657
|
|
9596
|
658 /* Note that bloc could be moved into the previous heap. */
|
|
|
659 address = (bloc->prev ? bloc->prev->data + bloc->prev->size
|
|
|
660 : first_heap->bloc_start);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
661 while (heap)
|
|
118
|
662 {
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
663 if (heap->bloc_start <= address && address <= heap->end)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
664 break;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
665 heap = heap->prev;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
666 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
667
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
668 if (! relocate_blocs (bloc, heap, address))
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
669 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
670 bloc->size = old_size;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
671 return 0;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
672 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
673
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
674 if (size > old_size)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
675 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
676 for (b = last_bloc; b != bloc; b = b->prev)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
677 {
|
|
11146
|
678 if (!b->variable)
|
|
|
679 {
|
|
|
680 b->size = 0;
|
|
|
681 b->data = b->new_data;
|
|
|
682 }
|
|
|
683 else
|
|
|
684 {
|
|
|
685 safe_bcopy (b->data, b->new_data, b->size);
|
|
|
686 *b->variable = b->data = b->new_data;
|
|
|
687 }
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
688 }
|
|
11146
|
689 if (!bloc->variable)
|
|
|
690 {
|
|
|
691 bloc->size = 0;
|
|
|
692 bloc->data = bloc->new_data;
|
|
|
693 }
|
|
|
694 else
|
|
|
695 {
|
|
|
696 safe_bcopy (bloc->data, bloc->new_data, old_size);
|
|
|
697 bzero (bloc->new_data + old_size, size - old_size);
|
|
|
698 *bloc->variable = bloc->data = bloc->new_data;
|
|
|
699 }
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
700 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
701 else
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
702 {
|
|
1595
|
703 for (b = bloc; b != NIL_BLOC; b = b->next)
|
|
|
704 {
|
|
11146
|
705 if (!b->variable)
|
|
|
706 {
|
|
|
707 b->size = 0;
|
|
|
708 b->data = b->new_data;
|
|
|
709 }
|
|
|
710 else
|
|
|
711 {
|
|
|
712 safe_bcopy (b->data, b->new_data, b->size);
|
|
|
713 *b->variable = b->data = b->new_data;
|
|
|
714 }
|
|
1595
|
715 }
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
716 }
|
|
1595
|
717
|
|
9666
|
718 update_heap_bloc_correspondence (bloc, heap);
|
|
9596
|
719
|
|
|
720 break_value = (last_bloc ? last_bloc->data + last_bloc->size
|
|
|
721 : first_heap->bloc_start);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
722 return 1;
|
|
1595
|
723 }
|
|
9666
|
724
|
|
9596
|
725 /* Free BLOC from the chain of blocs, relocating any blocs above it.
|
|
|
726 This may return space to the system. */
|
|
118
|
727
|
|
|
728 static void
|
|
|
729 free_bloc (bloc)
|
|
|
730 bloc_ptr bloc;
|
|
|
731 {
|
|
9666
|
732 heap_ptr heap = bloc->heap;
|
|
|
733
|
|
11146
|
734 if (r_alloc_freeze_level)
|
|
|
735 {
|
|
|
736 bloc->variable = (POINTER *) NIL;
|
|
|
737 return;
|
|
|
738 }
|
|
|
739
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
740 resize_bloc (bloc, 0);
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
741
|
|
118
|
742 if (bloc == first_bloc && bloc == last_bloc)
|
|
|
743 {
|
|
|
744 first_bloc = last_bloc = NIL_BLOC;
|
|
|
745 }
|
|
|
746 else if (bloc == last_bloc)
|
|
|
747 {
|
|
|
748 last_bloc = bloc->prev;
|
|
|
749 last_bloc->next = NIL_BLOC;
|
|
|
750 }
|
|
|
751 else if (bloc == first_bloc)
|
|
|
752 {
|
|
|
753 first_bloc = bloc->next;
|
|
|
754 first_bloc->prev = NIL_BLOC;
|
|
|
755 }
|
|
|
756 else
|
|
|
757 {
|
|
|
758 bloc->next->prev = bloc->prev;
|
|
|
759 bloc->prev->next = bloc->next;
|
|
|
760 }
|
|
|
761
|
|
9666
|
762 /* Update the records of which blocs are in HEAP. */
|
|
|
763 if (heap->first_bloc == bloc)
|
|
|
764 {
|
|
10747
|
765 if (bloc->next != 0 && bloc->next->heap == heap)
|
|
9666
|
766 heap->first_bloc = bloc->next;
|
|
|
767 else
|
|
|
768 heap->first_bloc = heap->last_bloc = NIL_BLOC;
|
|
|
769 }
|
|
|
770 if (heap->last_bloc == bloc)
|
|
|
771 {
|
|
10747
|
772 if (bloc->prev != 0 && bloc->prev->heap == heap)
|
|
9666
|
773 heap->last_bloc = bloc->prev;
|
|
|
774 else
|
|
|
775 heap->first_bloc = heap->last_bloc = NIL_BLOC;
|
|
|
776 }
|
|
|
777
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
778 relinquish ();
|
|
118
|
779 free (bloc);
|
|
|
780 }
|
|
|
781
|
|
577
|
782 /* Interface routines. */
|
|
|
783
|
|
1249
|
784 /* Obtain SIZE bytes of storage from the free pool, or the system, as
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
785 necessary. If relocatable blocs are in use, this means relocating
|
|
1249
|
786 them. This function gets plugged into the GNU malloc's __morecore
|
|
|
787 hook.
|
|
|
788
|
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
789 We provide hysteresis, never relocating by less than extra_bytes.
|
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
790
|
|
1249
|
791 If we're out of memory, we should return zero, to imitate the other
|
|
|
792 __morecore hook values - in particular, __default_morecore in the
|
|
|
793 GNU malloc package. */
|
|
118
|
794
|
|
|
795 POINTER
|
|
|
796 r_alloc_sbrk (size)
|
|
|
797 long size;
|
|
|
798 {
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
799 register bloc_ptr b;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
800 POINTER address;
|
|
118
|
801
|
|
10767
|
802 if (! r_alloc_initialized)
|
|
|
803 r_alloc_init ();
|
|
|
804
|
|
118
|
805 if (! use_relocatable_buffers)
|
|
1401
|
806 return (*real_morecore) (size);
|
|
118
|
807
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
808 if (size == 0)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
809 return virtual_break_value;
|
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
810
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
811 if (size > 0)
|
|
118
|
812 {
|
|
9596
|
813 /* Allocate a page-aligned space. GNU malloc would reclaim an
|
|
|
814 extra space if we passed an unaligned one. But we could
|
|
14036
|
815 not always find a space which is contiguous to the previous. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
816 POINTER new_bloc_start;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
817 heap_ptr h = first_heap;
|
|
9596
|
818 SIZE get = ROUNDUP (size);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
819
|
|
9596
|
820 address = (POINTER) ROUNDUP (virtual_break_value);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
821
|
|
9596
|
822 /* Search the list upward for a heap which is large enough. */
|
|
|
823 while ((char *) h->end < (char *) MEM_ROUNDUP ((char *)address + get))
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
824 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
825 h = h->next;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
826 if (h == NIL_HEAP)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
827 break;
|
|
9596
|
828 address = (POINTER) ROUNDUP (h->start);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
829 }
|
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
830
|
|
9596
|
831 /* If not found, obtain more space. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
832 if (h == NIL_HEAP)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
833 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
834 get += extra_bytes + page_size;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
835
|
|
11146
|
836 if (! obtain (address, get))
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
837 return 0;
|
|
1249
|
838
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
839 if (first_heap == last_heap)
|
|
9596
|
840 address = (POINTER) ROUNDUP (virtual_break_value);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
841 else
|
|
9596
|
842 address = (POINTER) ROUNDUP (last_heap->start);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
843 h = last_heap;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
844 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
845
|
|
9596
|
846 new_bloc_start = (POINTER) MEM_ROUNDUP ((char *)address + get);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
847
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
848 if (first_heap->bloc_start < new_bloc_start)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
849 {
|
|
11146
|
850 /* This is no clean solution - no idea how to do it better. */
|
|
|
851 if (r_alloc_freeze_level)
|
|
|
852 return NIL;
|
|
|
853
|
|
|
854 /* There is a bug here: if the above obtain call succeeded, but the
|
|
|
855 relocate_blocs call below does not succeed, we need to free
|
|
|
856 the memory that we got with obtain. */
|
|
|
857
|
|
9596
|
858 /* Move all blocs upward. */
|
|
11146
|
859 if (! relocate_blocs (first_bloc, h, new_bloc_start))
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
860 return 0;
|
|
577
|
861
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
862 /* Note that (POINTER)(h+1) <= new_bloc_start since
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
863 get >= page_size, so the following does not destroy the heap
|
|
9596
|
864 header. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
865 for (b = last_bloc; b != NIL_BLOC; b = b->prev)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
866 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
867 safe_bcopy (b->data, b->new_data, b->size);
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
868 *b->variable = b->data = b->new_data;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
869 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
870
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
871 h->bloc_start = new_bloc_start;
|
|
9596
|
872
|
|
9666
|
873 update_heap_bloc_correspondence (first_bloc, h);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
874 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
875 if (h != first_heap)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
876 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
877 /* Give up managing heaps below the one the new
|
|
9596
|
878 virtual_break_value points to. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
879 first_heap->prev = NIL_HEAP;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
880 first_heap->next = h->next;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
881 first_heap->start = h->start;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
882 first_heap->end = h->end;
|
|
9596
|
883 first_heap->free = h->free;
|
|
9666
|
884 first_heap->first_bloc = h->first_bloc;
|
|
|
885 first_heap->last_bloc = h->last_bloc;
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
886 first_heap->bloc_start = h->bloc_start;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
887
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
888 if (first_heap->next)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
889 first_heap->next->prev = first_heap;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
890 else
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
891 last_heap = first_heap;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
892 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
893
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
894 bzero (address, size);
|
|
118
|
895 }
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
896 else /* size < 0 */
|
|
118
|
897 {
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
898 SIZE excess = (char *)first_heap->bloc_start
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
899 - ((char *)virtual_break_value + size);
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
900
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
901 address = virtual_break_value;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
902
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
903 if (r_alloc_freeze_level == 0 && excess > 2 * extra_bytes)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
904 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
905 excess -= extra_bytes;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
906 first_heap->bloc_start
|
|
9666
|
907 = (POINTER) MEM_ROUNDUP ((char *)first_heap->bloc_start - excess);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
908
|
|
9596
|
909 relocate_blocs (first_bloc, first_heap, first_heap->bloc_start);
|
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
910
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
911 for (b = first_bloc; b != NIL_BLOC; b = b->next)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
912 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
913 safe_bcopy (b->data, b->new_data, b->size);
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
914 *b->variable = b->data = b->new_data;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
915 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
916 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
917
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
918 if ((char *)virtual_break_value + size < (char *)first_heap->start)
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
919 {
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
920 /* We found an additional space below the first heap */
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
921 first_heap->start = (POINTER) ((char *)virtual_break_value + size);
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
922 }
|
|
118
|
923 }
|
|
|
924
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
925 virtual_break_value = (POINTER) ((char *)address + size);
|
|
9666
|
926 break_value = (last_bloc
|
|
|
927 ? last_bloc->data + last_bloc->size
|
|
|
928 : first_heap->bloc_start);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
929 if (size < 0)
|
|
9596
|
930 relinquish ();
|
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
931
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
932 return address;
|
|
118
|
933 }
|
|
|
934
|
|
|
935 /* Allocate a relocatable bloc of storage of size SIZE. A pointer to
|
|
|
936 the data is returned in *PTR. PTR is thus the address of some variable
|
|
1249
|
937 which will use the data area.
|
|
|
938
|
|
11146
|
939 The allocation of 0 bytes is valid.
|
|
|
940 In case r_alloc_freeze is set, a best fit of unused blocs could be done
|
|
|
941 before allocating a new area. Not yet done.
|
|
|
942
|
|
1249
|
943 If we can't allocate the necessary memory, set *PTR to zero, and
|
|
|
944 return zero. */
|
|
118
|
945
|
|
|
946 POINTER
|
|
|
947 r_alloc (ptr, size)
|
|
|
948 POINTER *ptr;
|
|
|
949 SIZE size;
|
|
|
950 {
|
|
|
951 register bloc_ptr new_bloc;
|
|
|
952
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
953 if (! r_alloc_initialized)
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
954 r_alloc_init ();
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
955
|
|
9596
|
956 new_bloc = get_bloc (MEM_ROUNDUP (size));
|
|
1249
|
957 if (new_bloc)
|
|
|
958 {
|
|
|
959 new_bloc->variable = ptr;
|
|
|
960 *ptr = new_bloc->data;
|
|
|
961 }
|
|
|
962 else
|
|
|
963 *ptr = 0;
|
|
118
|
964
|
|
|
965 return *ptr;
|
|
|
966 }
|
|
|
967
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
968 /* Free a bloc of relocatable storage whose data is pointed to by PTR.
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
969 Store 0 in *PTR to show there's no block allocated. */
|
|
118
|
970
|
|
|
971 void
|
|
|
972 r_alloc_free (ptr)
|
|
|
973 register POINTER *ptr;
|
|
|
974 {
|
|
|
975 register bloc_ptr dead_bloc;
|
|
|
976
|
|
10767
|
977 if (! r_alloc_initialized)
|
|
|
978 r_alloc_init ();
|
|
|
979
|
|
118
|
980 dead_bloc = find_bloc (ptr);
|
|
|
981 if (dead_bloc == NIL_BLOC)
|
|
|
982 abort ();
|
|
|
983
|
|
|
984 free_bloc (dead_bloc);
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
985 *ptr = 0;
|
|
10682
|
986
|
|
10747
|
987 #ifdef emacs
|
|
10682
|
988 refill_memory_reserve ();
|
|
10747
|
989 #endif
|
|
118
|
990 }
|
|
|
991
|
|
1087
|
992 /* Given a pointer at address PTR to relocatable data, resize it to SIZE.
|
|
1249
|
993 Do this by shifting all blocks above this one up in memory, unless
|
|
|
994 SIZE is less than or equal to the current bloc size, in which case
|
|
|
995 do nothing.
|
|
118
|
996
|
|
11146
|
997 In case r_alloc_freeze is set, a new bloc is allocated, and the
|
|
14036
|
998 memory copied to it. Not very efficient. We could traverse the
|
|
11146
|
999 bloc_list for a best fit of free blocs first.
|
|
|
1000
|
|
1249
|
1001 Change *PTR to reflect the new bloc, and return this value.
|
|
|
1002
|
|
|
1003 If more memory cannot be allocated, then leave *PTR unchanged, and
|
|
|
1004 return zero. */
|
|
118
|
1005
|
|
|
1006 POINTER
|
|
|
1007 r_re_alloc (ptr, size)
|
|
|
1008 POINTER *ptr;
|
|
|
1009 SIZE size;
|
|
|
1010 {
|
|
1087
|
1011 register bloc_ptr bloc;
|
|
118
|
1012
|
|
10767
|
1013 if (! r_alloc_initialized)
|
|
|
1014 r_alloc_init ();
|
|
|
1015
|
|
11146
|
1016 if (!*ptr)
|
|
|
1017 return r_alloc (ptr, size);
|
|
|
1018 if (!size)
|
|
|
1019 {
|
|
|
1020 r_alloc_free (ptr);
|
|
|
1021 return r_alloc (ptr, 0);
|
|
|
1022 }
|
|
|
1023
|
|
1087
|
1024 bloc = find_bloc (ptr);
|
|
|
1025 if (bloc == NIL_BLOC)
|
|
118
|
1026 abort ();
|
|
|
1027
|
|
11146
|
1028 if (size < bloc->size)
|
|
|
1029 {
|
|
|
1030 /* Wouldn't it be useful to actually resize the bloc here? */
|
|
|
1031 /* I think so too, but not if it's too expensive... */
|
|
|
1032 if ((bloc->size - MEM_ROUNDUP (size) >= page_size)
|
|
|
1033 && r_alloc_freeze_level == 0)
|
|
|
1034 {
|
|
|
1035 resize_bloc (bloc, MEM_ROUNDUP (size));
|
|
|
1036 /* Never mind if this fails, just do nothing... */
|
|
|
1037 /* It *should* be infallible! */
|
|
|
1038 }
|
|
|
1039 }
|
|
|
1040 else if (size > bloc->size)
|
|
|
1041 {
|
|
|
1042 if (r_alloc_freeze_level)
|
|
|
1043 {
|
|
|
1044 bloc_ptr new_bloc;
|
|
|
1045 new_bloc = get_bloc (MEM_ROUNDUP (size));
|
|
|
1046 if (new_bloc)
|
|
|
1047 {
|
|
|
1048 new_bloc->variable = ptr;
|
|
|
1049 *ptr = new_bloc->data;
|
|
|
1050 bloc->variable = (POINTER *) NIL;
|
|
|
1051 }
|
|
|
1052 else
|
|
|
1053 return NIL;
|
|
|
1054 }
|
|
|
1055 else
|
|
|
1056 {
|
|
|
1057 if (! resize_bloc (bloc, MEM_ROUNDUP (size)))
|
|
|
1058 return NIL;
|
|
|
1059 }
|
|
|
1060 }
|
|
118
|
1061 return *ptr;
|
|
|
1062 }
|
|
8951
|
1063
|
|
|
1064 /* Disable relocations, after making room for at least SIZE bytes
|
|
|
1065 of non-relocatable heap if possible. The relocatable blocs are
|
|
|
1066 guaranteed to hold still until thawed, even if this means that
|
|
|
1067 malloc must return a null pointer. */
|
|
9596
|
1068
|
|
8951
|
1069 void
|
|
|
1070 r_alloc_freeze (size)
|
|
|
1071 long size;
|
|
|
1072 {
|
|
10767
|
1073 if (! r_alloc_initialized)
|
|
|
1074 r_alloc_init ();
|
|
|
1075
|
|
8951
|
1076 /* If already frozen, we can't make any more room, so don't try. */
|
|
|
1077 if (r_alloc_freeze_level > 0)
|
|
|
1078 size = 0;
|
|
|
1079 /* If we can't get the amount requested, half is better than nothing. */
|
|
|
1080 while (size > 0 && r_alloc_sbrk (size) == 0)
|
|
|
1081 size /= 2;
|
|
|
1082 ++r_alloc_freeze_level;
|
|
|
1083 if (size > 0)
|
|
|
1084 r_alloc_sbrk (-size);
|
|
|
1085 }
|
|
|
1086
|
|
|
1087 void
|
|
|
1088 r_alloc_thaw ()
|
|
|
1089 {
|
|
11146
|
1090
|
|
|
1091 if (! r_alloc_initialized)
|
|
|
1092 r_alloc_init ();
|
|
|
1093
|
|
8951
|
1094 if (--r_alloc_freeze_level < 0)
|
|
|
1095 abort ();
|
|
11146
|
1096
|
|
14036
|
1097 /* This frees all unused blocs. It is not too inefficient, as the resize
|
|
11146
|
1098 and bcopy is done only once. Afterwards, all unreferenced blocs are
|
|
|
1099 already shrunk to zero size. */
|
|
|
1100 if (!r_alloc_freeze_level)
|
|
|
1101 {
|
|
|
1102 bloc_ptr *b = &first_bloc;
|
|
|
1103 while (*b)
|
|
|
1104 if (!(*b)->variable)
|
|
|
1105 free_bloc (*b);
|
|
|
1106 else
|
|
|
1107 b = &(*b)->next;
|
|
|
1108 }
|
|
8951
|
1109 }
|
|
11146
|
1110
|
|
118
|
1111
|
|
|
1112 /* The hook `malloc' uses for the function which gets more space
|
|
|
1113 from the system. */
|
|
|
1114 extern POINTER (*__morecore) ();
|
|
|
1115
|
|
9596
|
1116 /* Initialize various things for memory allocation. */
|
|
118
|
1117
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1118 static void
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1119 r_alloc_init ()
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1120 {
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1121 if (r_alloc_initialized)
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1122 return;
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1123
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1124 r_alloc_initialized = 1;
|
|
1401
|
1125 real_morecore = __morecore;
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1126 __morecore = r_alloc_sbrk;
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1127
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1128 first_heap = last_heap = &heap_base;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1129 first_heap->next = first_heap->prev = NIL_HEAP;
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1130 first_heap->start = first_heap->bloc_start
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1131 = virtual_break_value = break_value = (*real_morecore) (0);
|
|
1403
|
1132 if (break_value == NIL)
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1133 abort ();
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1134
|
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1135 page_size = PAGE;
|
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1136 extra_bytes = ROUNDUP (50000);
|
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1137
|
|
17845
|
1138 #ifdef DOUG_LEA_MALLOC
|
|
|
1139 mallopt (M_TOP_PAD, 64 * 4096);
|
|
|
1140 #else
|
|
10785
|
1141 /* Give GNU malloc's morecore some hysteresis
|
|
|
1142 so that we move all the relocatable blocks much less often. */
|
|
|
1143 __malloc_extra_blocks = 64;
|
|
17845
|
1144 #endif
|
|
10785
|
1145
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1146 first_heap->end = (POINTER) ROUNDUP (first_heap->start);
|
|
5063
|
1147
|
|
|
1148 /* The extra call to real_morecore guarantees that the end of the
|
|
|
1149 address space is a multiple of page_size, even if page_size is
|
|
|
1150 not really the page size of the system running the binary in
|
|
|
1151 which page_size is stored. This allows a binary to be built on a
|
|
|
1152 system with one page size and run on a system with a smaller page
|
|
9596
|
1153 size. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1154 (*real_morecore) (first_heap->end - first_heap->start);
|
|
5063
|
1155
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1156 /* Clear the rest of the last page; this memory is in our address space
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1157 even though it is after the sbrk value. */
|
|
5063
|
1158 /* Doubly true, with the additional call that explicitly adds the
|
|
|
1159 rest of that page to the address space. */
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1160 bzero (first_heap->start, first_heap->end - first_heap->start);
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1161 virtual_break_value = break_value = first_heap->bloc_start = first_heap->end;
|
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1162 use_relocatable_buffers = 1;
|
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1163 }
|
|
18757
|
1164
|
|
|
1165 #if defined (emacs) && defined (DOUG_LEA_MALLOC)
|
|
|
1166
|
|
|
1167 /* Reinitialize the morecore hook variables after restarting a dumped
|
|
|
1168 Emacs. This is needed when using Doug Lea's malloc from GNU libc. */
|
|
|
1169 void
|
|
|
1170 r_alloc_reinit ()
|
|
|
1171 {
|
|
|
1172 /* Only do this if the hook has been reset, so that we don't get an
|
|
|
1173 infinite loop, in case Emacs was linked statically. */
|
|
|
1174 if (__morecore != r_alloc_sbrk)
|
|
|
1175 {
|
|
|
1176 real_morecore = __morecore;
|
|
|
1177 __morecore = r_alloc_sbrk;
|
|
|
1178 }
|
|
|
1179 }
|
|
|
1180 #endif
|
|
|
1181
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1182 #ifdef DEBUG
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1183 #include <assert.h>
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1184
|
|
10767
|
1185 void
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1186 r_alloc_check ()
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1187 {
|
|
10766
|
1188 int found = 0;
|
|
|
1189 heap_ptr h, ph = 0;
|
|
|
1190 bloc_ptr b, pb = 0;
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1191
|
|
10766
|
1192 if (!r_alloc_initialized)
|
|
|
1193 return;
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1194
|
|
10766
|
1195 assert (first_heap);
|
|
|
1196 assert (last_heap->end <= (POINTER) sbrk (0));
|
|
|
1197 assert ((POINTER) first_heap < first_heap->start);
|
|
|
1198 assert (first_heap->start <= virtual_break_value);
|
|
|
1199 assert (virtual_break_value <= first_heap->end);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1200
|
|
10766
|
1201 for (h = first_heap; h; h = h->next)
|
|
|
1202 {
|
|
|
1203 assert (h->prev == ph);
|
|
|
1204 assert ((POINTER) ROUNDUP (h->end) == h->end);
|
|
14953
|
1205 #if 0 /* ??? The code in ralloc.c does not really try to ensure
|
|
|
1206 the heap start has any sort of alignment.
|
|
|
1207 Perhaps it should. */
|
|
10766
|
1208 assert ((POINTER) MEM_ROUNDUP (h->start) == h->start);
|
|
14953
|
1209 #endif
|
|
10766
|
1210 assert ((POINTER) MEM_ROUNDUP (h->bloc_start) == h->bloc_start);
|
|
|
1211 assert (h->start <= h->bloc_start && h->bloc_start <= h->end);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1212
|
|
10766
|
1213 if (ph)
|
|
|
1214 {
|
|
|
1215 assert (ph->end < h->start);
|
|
|
1216 assert (h->start <= (POINTER)h && (POINTER)(h+1) <= h->bloc_start);
|
|
|
1217 }
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1218
|
|
10766
|
1219 if (h->bloc_start <= break_value && break_value <= h->end)
|
|
|
1220 found = 1;
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1221
|
|
10766
|
1222 ph = h;
|
|
|
1223 }
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1224
|
|
10766
|
1225 assert (found);
|
|
|
1226 assert (last_heap == ph);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1227
|
|
10766
|
1228 for (b = first_bloc; b; b = b->next)
|
|
|
1229 {
|
|
|
1230 assert (b->prev == pb);
|
|
|
1231 assert ((POINTER) MEM_ROUNDUP (b->data) == b->data);
|
|
|
1232 assert ((SIZE) MEM_ROUNDUP (b->size) == b->size);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1233
|
|
10766
|
1234 ph = 0;
|
|
|
1235 for (h = first_heap; h; h = h->next)
|
|
|
1236 {
|
|
|
1237 if (h->bloc_start <= b->data && b->data + b->size <= h->end)
|
|
|
1238 break;
|
|
|
1239 ph = h;
|
|
|
1240 }
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1241
|
|
10766
|
1242 assert (h);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1243
|
|
10766
|
1244 if (pb && pb->data + pb->size != b->data)
|
|
|
1245 {
|
|
|
1246 assert (ph && b->data == h->bloc_start);
|
|
|
1247 while (ph)
|
|
|
1248 {
|
|
|
1249 if (ph->bloc_start <= pb->data
|
|
|
1250 && pb->data + pb->size <= ph->end)
|
|
|
1251 {
|
|
|
1252 assert (pb->data + pb->size + b->size > ph->end);
|
|
|
1253 break;
|
|
|
1254 }
|
|
|
1255 else
|
|
|
1256 {
|
|
|
1257 assert (ph->bloc_start + b->size > ph->end);
|
|
|
1258 }
|
|
|
1259 ph = ph->prev;
|
|
|
1260 }
|
|
|
1261 }
|
|
|
1262 pb = b;
|
|
|
1263 }
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1264
|
|
10766
|
1265 assert (last_bloc == pb);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1266
|
|
10766
|
1267 if (last_bloc)
|
|
|
1268 assert (last_bloc->data + last_bloc->size == break_value);
|
|
|
1269 else
|
|
|
1270 assert (first_heap->bloc_start == break_value);
|
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1271 }
|
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1272 #endif /* DEBUG */
|
