Mercurial > hg > xemacs-beta
annotate src/ntheap.c @ 5750:66d2f63df75f
Correct some spelling and formatting in behavior.el.
Mentioned in tracker issue 826, the third thing mentioned there (the file
name at the bottom of the file) had already been fixed.
lisp/ChangeLog addition:
2013-08-05 Aidan Kehoe <kehoea@parhasard.net>
* behavior.el:
(override-behavior):
Correct some spelling and formatting here, thank you Steven
Mitchell in tracker issue 826.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Mon, 05 Aug 2013 10:05:32 +0100 |
| parents | 4dee0387b9de |
| children |
| rev | line source |
|---|---|
| 428 | 1 /* Heap management routines for XEmacs on Windows NT. |
| 2 Copyright (C) 1994 Free Software Foundation, Inc. | |
| 3 | |
| 4 This file is part of XEmacs. | |
| 5 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
2367
diff
changeset
|
6 XEmacs is free software: you can redistribute it and/or modify it |
| 428 | 7 under the terms of the GNU General Public License as published by the |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
2367
diff
changeset
|
8 Free Software Foundation, either version 3 of the License, or (at your |
|
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
2367
diff
changeset
|
9 option) any later version. |
| 428 | 10 |
| 11 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 14 for more details. | |
| 15 | |
| 16 You should have received a copy of the GNU General Public License | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
2367
diff
changeset
|
17 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. |
| 428 | 18 Geoff Voelker (voelker@cs.washington.edu) 7-29-94 */ |
| 19 | |
| 20 /* Adapted for XEmacs by David Hobley <david@spook-le0.cia.com.au> */ | |
| 771 | 21 /* Synced with FSF Emacs 19.34.6 by Marc Paquette <marcpa@cam.org> |
| 22 (Note: Sync messages from Marc Paquette may indicate | |
| 23 incomplete synching, so beware.) | |
| 24 */ | |
| 428 | 25 |
| 814 | 26 /* This file has been Mule-ized, Ben Wing, 4-13-02. */ |
| 27 | |
| 428 | 28 #include <config.h> |
| 771 | 29 #include "lisp.h" |
| 428 | 30 |
| 814 | 31 #include "sysdep.h" |
| 771 | 32 #include "syswindows.h" |
| 428 | 33 |
| 34 /* This gives us the page size and the size of the allocation unit on NT. */ | |
| 35 SYSTEM_INFO sysinfo_cache; | |
| 36 unsigned long syspage_mask = 0; | |
| 37 | |
| 38 /* These are defined to get Emacs to compile, but are not used. */ | |
| 39 int edata; | |
| 40 int etext; | |
| 41 | |
| 42 /* Cache information describing the NT system for later use. */ | |
| 43 void | |
| 44 cache_system_info (void) | |
| 45 { | |
| 46 /* Cache page size, allocation unit, processor type, etc. */ | |
| 47 GetSystemInfo (&sysinfo_cache); | |
| 48 syspage_mask = sysinfo_cache.dwPageSize - 1; | |
| 49 } | |
| 50 | |
| 51 /* Round ADDRESS up to be aligned with ALIGN. */ | |
| 2367 | 52 URawbyte * |
| 53 round_to_next (URawbyte *address, unsigned long align) | |
| 428 | 54 { |
| 55 unsigned long tmp; | |
| 56 | |
| 57 tmp = (unsigned long) address; | |
| 58 tmp = (tmp + align - 1) / align; | |
| 59 | |
| 2367 | 60 return (URawbyte *) (tmp * align); |
| 428 | 61 } |
| 62 | |
| 63 /* Info for keeping track of our heap. */ | |
| 2367 | 64 URawbyte *data_region_base = UNINIT_PTR; |
| 65 URawbyte *data_region_end = UNINIT_PTR; | |
| 66 URawbyte *real_data_region_end = UNINIT_PTR; | |
| 428 | 67 unsigned long data_region_size = UNINIT_LONG; |
| 68 unsigned long reserved_heap_size = UNINIT_LONG; | |
| 69 | |
| 70 /* The start of the data segment. */ | |
| 2367 | 71 URawbyte * |
| 428 | 72 get_data_start (void) |
| 73 { | |
| 74 return data_region_base; | |
| 75 } | |
| 76 | |
| 77 /* The end of the data segment. */ | |
| 2367 | 78 URawbyte * |
| 428 | 79 get_data_end (void) |
| 80 { | |
| 81 return data_region_end; | |
| 82 } | |
| 83 | |
| 2367 | 84 static URawbyte * |
| 428 | 85 allocate_heap (void) |
| 86 { | |
| 87 /* The base address for our GNU malloc heap is chosen in conjunction | |
| 88 with the link settings for temacs.exe which control the stack size, | |
| 89 the initial default process heap size and the executable image base | |
| 90 address. The link settings and the malloc heap base below must all | |
| 91 correspond; the relationship between these values depends on how NT | |
| 92 and Win95 arrange the virtual address space for a process (and on | |
| 93 the size of the code and data segments in temacs.exe). | |
| 94 | |
| 95 The most important thing is to make base address for the executable | |
| 96 image high enough to leave enough room between it and the 4MB floor | |
| 97 of the process address space on Win95 for the primary thread stack, | |
| 98 the process default heap, and other assorted odds and ends | |
| 99 (eg. environment strings, private system dll memory etc) that are | |
| 100 allocated before temacs has a chance to grab its malloc arena. The | |
| 101 malloc heap base can then be set several MB higher than the | |
| 102 executable image base, leaving enough room for the code and data | |
| 103 segments. | |
| 104 | |
| 105 Because some parts of Emacs can use rather a lot of stack space | |
| 106 (for instance, the regular expression routines can potentially | |
| 107 allocate several MB of stack space) we allow 8MB for the stack. | |
| 108 | |
| 109 Allowing 1MB for the default process heap, and 1MB for odds and | |
| 110 ends, we can base the executable at 16MB and still have a generous | |
| 111 safety margin. At the moment, the executable has about 810KB of | |
| 112 code (for x86) and about 550KB of data - on RISC platforms the code | |
| 113 size could be roughly double, so if we allow 4MB for the executable | |
| 114 we will have plenty of room for expansion. | |
| 115 | |
| 116 Thus we would like to set the malloc heap base to 20MB. However, | |
| 117 Win95 refuses to allocate the heap starting at this address, so we | |
| 118 set the base to 27MB to make it happy. Since Emacs now leaves | |
| 119 28 bits available for pointers, this lets us use the remainder of | |
| 120 the region below the 256MB line for our malloc arena - 229MB is | |
| 121 still a pretty decent arena to play in! */ | |
| 122 | |
| 123 unsigned long base = 0x01B00000; /* 27MB */ | |
| 438 | 124 /* Temporary hack for the non-starting problem - use 28 (256Mb) rather than VALBITS (1Gb) */ |
| 125 unsigned long end = 1 << 28; /* 256MB */ | |
| 428 | 126 void *ptr = NULL; |
| 127 | |
| 128 #define NTHEAP_PROBE_BASE 1 | |
| 129 #if NTHEAP_PROBE_BASE /* This is never normally defined */ | |
| 130 /* Try various addresses looking for one the kernel will let us have. */ | |
| 131 while (!ptr && (base < end)) | |
| 132 { | |
| 133 reserved_heap_size = end - base; | |
| 134 ptr = VirtualAlloc ((void *) base, | |
| 135 get_reserved_heap_size (), | |
| 136 MEM_RESERVE, | |
| 137 PAGE_NOACCESS); | |
| 138 base += 0x00100000; /* 1MB increment */ | |
| 139 } | |
| 140 #else | |
| 141 reserved_heap_size = end - base; | |
| 142 ptr = VirtualAlloc ((void *) base, | |
| 143 get_reserved_heap_size (), | |
| 144 MEM_RESERVE, | |
| 145 PAGE_NOACCESS); | |
| 146 #endif | |
| 147 | |
| 2367 | 148 return (URawbyte *) ptr; |
| 428 | 149 } |
| 150 | |
| 151 | |
| 152 /* Emulate Unix sbrk. */ | |
| 153 void * | |
| 154 sbrk (unsigned long increment) | |
| 155 { | |
| 156 void *result; | |
| 157 long size = (long) increment; | |
| 158 | |
| 159 /* Allocate our heap if we haven't done so already. */ | |
| 160 if (data_region_base == UNINIT_PTR) | |
| 161 { | |
| 162 data_region_base = allocate_heap (); | |
| 163 if (!data_region_base) | |
| 164 return NULL; | |
| 165 | |
| 166 data_region_end = data_region_base; | |
| 167 real_data_region_end = data_region_end; | |
| 168 data_region_size = get_reserved_heap_size (); | |
| 169 } | |
| 170 | |
| 171 result = data_region_end; | |
| 172 | |
| 173 /* If size is negative, shrink the heap by decommitting pages. */ | |
| 174 if (size < 0) | |
| 175 { | |
| 176 int new_size; | |
| 2367 | 177 URawbyte *new_data_region_end; |
| 428 | 178 |
| 179 size = -size; | |
| 180 | |
| 181 /* Sanity checks. */ | |
| 182 if ((data_region_end - size) < data_region_base) | |
| 183 return NULL; | |
| 184 | |
| 185 /* We can only decommit full pages, so allow for | |
| 186 partial deallocation [cga]. */ | |
| 187 new_data_region_end = (data_region_end - size); | |
| 2367 | 188 new_data_region_end = (URawbyte *) |
| 428 | 189 ((long) (new_data_region_end + syspage_mask) & ~syspage_mask); |
| 190 new_size = real_data_region_end - new_data_region_end; | |
| 191 real_data_region_end = new_data_region_end; | |
| 192 if (new_size > 0) | |
| 193 { | |
| 194 /* Decommit size bytes from the end of the heap. */ | |
| 195 if (!VirtualFree (real_data_region_end, new_size, MEM_DECOMMIT)) | |
| 196 return NULL; | |
| 197 } | |
| 198 | |
| 199 data_region_end -= size; | |
| 200 } | |
| 201 /* If size is positive, grow the heap by committing reserved pages. */ | |
| 202 else if (size > 0) | |
| 203 { | |
| 204 /* Sanity checks. */ | |
| 205 if ((data_region_end + size) > | |
| 206 (data_region_base + get_reserved_heap_size ())) | |
| 207 return NULL; | |
| 208 | |
| 209 /* Commit more of our heap. */ | |
| 210 if (VirtualAlloc (data_region_end, size, MEM_COMMIT, | |
| 211 PAGE_READWRITE) == NULL) | |
| 212 return NULL; | |
| 213 data_region_end += size; | |
| 214 | |
| 215 /* We really only commit full pages, so record where | |
| 216 the real end of committed memory is [cga]. */ | |
| 2367 | 217 real_data_region_end = (URawbyte *) |
| 428 | 218 ((long) (data_region_end + syspage_mask) & ~syspage_mask); |
| 219 } | |
| 220 | |
| 221 return result; | |
| 222 } | |
| 223 | |
| 1330 | 224 #if !defined (HEAP_IN_DATA) && !defined (PDUMP) |
| 428 | 225 |
| 226 /* Recreate the heap from the data that was dumped to the executable. | |
| 227 EXECUTABLE_PATH tells us where to find the executable. */ | |
| 228 void | |
| 814 | 229 recreate_heap (Extbyte *executable_path) |
| 428 | 230 { |
| 442 | 231 /* First reserve the upper part of our heap. (We reserve first |
| 232 because there have been problems in the past where doing the | |
| 233 mapping first has loaded DLLs into the VA space of our heap.) */ | |
| 428 | 234 |
| 442 | 235 /* Query the region at the end of the committed heap */ |
| 236 void *tmp; | |
| 237 MEMORY_BASIC_INFORMATION info; | |
| 238 DWORD size; | |
| 2367 | 239 URawbyte *base = get_heap_end (); |
| 240 URawbyte *end = | |
| 814 | 241 base + get_reserved_heap_size () - get_committed_heap_size (); |
| 647 | 242 VirtualQuery (base, &info, sizeof (info)); |
| 442 | 243 if (info.State != MEM_FREE) |
| 814 | 244 { |
|
5384
3889ef128488
Fix misspelled words, and some grammar, across the entire source tree.
Jerry James <james@xemacs.org>
parents:
2367
diff
changeset
|
245 /* Oops, something has already reserved or committed it, nothing |
| 814 | 246 we can do but exit */ |
| 247 Extbyte buf[256]; | |
| 248 sprintf (buf, | |
| 249 "XEmacs cannot start because the memory region required " | |
| 250 "by the heap is not available.\n" | |
| 251 "(BaseAddress = 0x%lx, AllocationBase = 0x%lx, " | |
| 252 "Size = 0x%lx, State = %s, Type = %s)", | |
| 253 info.BaseAddress, info.AllocationBase, info.RegionSize, | |
|
5384
3889ef128488
Fix misspelled words, and some grammar, across the entire source tree.
Jerry James <james@xemacs.org>
parents:
2367
diff
changeset
|
254 info.State == MEM_COMMIT ? "COMMITTED" : "RESERVED", |
| 814 | 255 info.Type == MEM_IMAGE ? "IMAGE" : |
| 256 info.Type == MEM_MAPPED ? "MAPPED" : "PRIVATE"); | |
| 257 MessageBoxA (NULL, buf, "XEmacs", MB_OK | MB_ICONSTOP); | |
| 258 exit(1); | |
| 259 } | |
| 442 | 260 |
| 261 /* Now try and reserve as much as possible */ | |
| 647 | 262 size = min (info.RegionSize, (DWORD) (end - base)); |
| 442 | 263 tmp = VirtualAlloc (base, size, MEM_RESERVE, PAGE_NOACCESS); |
| 428 | 264 if (!tmp) |
| 814 | 265 { |
| 266 /* Can't reserve it, nothing we can do but exit */ | |
| 267 Extbyte buf[256]; | |
| 268 sprintf (buf, | |
| 269 "XEmacs cannot start because it couldn't reserve space " | |
| 270 "required for the heap.\n" | |
| 271 "(VirtualAlloc at 0x%lx of 0x%lx failed (%d))", | |
| 272 base, size, GetLastError()); | |
| 273 MessageBoxA (NULL, buf, "XEmacs", MB_OK | MB_ICONSTOP); | |
| 274 exit (1); | |
| 275 } | |
| 428 | 276 |
| 277 /* We read in the data for the .bss section from the executable | |
| 278 first and map in the heap from the executable second to prevent | |
| 279 any funny interactions between file I/O and file mapping. */ | |
| 280 read_in_bss (executable_path); | |
| 281 map_in_heap (executable_path); | |
| 282 | |
| 283 /* Update system version information to match current system. */ | |
| 284 cache_system_info (); | |
| 285 } | |
| 1330 | 286 |
| 287 #endif /* !defined (HEAP_IN_DATA) && !defined (PDUMP) */ | |
| 428 | 288 |
| 289 /* Round the heap up to the given alignment. */ | |
| 290 void | |
| 291 round_heap (unsigned long align) | |
| 292 { | |
| 293 unsigned long needs_to_be; | |
| 294 unsigned long need_to_alloc; | |
| 295 | |
| 296 needs_to_be = (unsigned long) round_to_next (get_heap_end (), align); | |
| 297 need_to_alloc = needs_to_be - (unsigned long) get_heap_end (); | |
| 298 | |
| 299 if (need_to_alloc) | |
| 300 sbrk (need_to_alloc); | |
| 301 } | |
| 302 | |
| 707 | 303 #if ((_MSC_VER >= 1000) && (_MSC_VER < 1300)) |
| 428 | 304 |
| 305 /* MSVC 4.2 invokes these functions from mainCRTStartup to initialize | |
| 306 a heap via HeapCreate. They are normally defined by the runtime, | |
| 307 but we override them here so that the unnecessary HeapCreate call | |
| 308 is not performed. */ | |
| 309 | |
| 707 | 310 /* MSVC 7.0 does not allow you to redefine _heap_init or _heap_term. */ |
| 311 | |
| 428 | 312 int __cdecl |
| 313 _heap_init (void) | |
| 314 { | |
| 315 /* Stepping through the assembly indicates that mainCRTStartup is | |
| 316 expecting a nonzero success return value. */ | |
| 317 return 1; | |
| 318 } | |
| 319 | |
| 320 void __cdecl | |
| 321 _heap_term (void) | |
| 322 { | |
| 323 return; | |
| 324 } | |
| 325 | |
| 326 #endif |