[tkreuzer] 55518: [FREELDR] - Enable new heap code and cleanup the heap, releasing unused memory, before starting reactos - Gives our kernel about 4MB additional memory, which - at the current leak...
9 Feb
2012
9 Feb
'12
8:01 p.m.
Author: tkreuzer
Date: Thu Feb 9 20:01:10 2012
New Revision: 55518
URL: http://svn.reactos.org/svn/reactos?rev=55518&view=rev
Log:
[FREELDR]
- Enable new heap code and cleanup the heap, releasing unused memory, before starting
reactos
- Gives our kernel about 4MB additional memory, which - at the current leak rate - means
around 8 minutes longer before it runs out of memory :)
- Using the temp heap for all temporary allocations should increase the amount of saved
space
Removed:
trunk/reactos/boot/freeldr/freeldr/mm/heap.c
trunk/reactos/boot/freeldr/freeldr/rtl/bget.c
Modified:
trunk/reactos/boot/freeldr/freeldr/CMakeLists.txt
trunk/reactos/boot/freeldr/freeldr/windows/wlmemory.c
Modified: trunk/reactos/boot/freeldr/freeldr/CMakeLists.txt
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/CMake…
==============================================================================
--- trunk/reactos/boot/freeldr/freeldr/CMakeLists.txt [iso-8859-1] (original)
+++ trunk/reactos/boot/freeldr/freeldr/CMakeLists.txt [iso-8859-1] Thu Feb 9 20:01:10
2012
@@ -54,7 +54,7 @@
inifile/parse.c
mm/meminit.c
mm/mm.c
- mm/heap.c
+ mm/heap_new.c
reactos/registry.c
reactos/arcname.c
reactos/archwsup.c
@@ -155,7 +155,6 @@
list(APPEND FREELDR_BASE_SOURCE
bootmgr.c # This file is compiled with custom definitions
freeldr.c
- rtl/bget.c
rtl/libsupp.c)
if (NOT MSVC)
Removed: trunk/reactos/boot/freeldr/freeldr/mm/heap.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/mm/he…
==============================================================================
--- trunk/reactos/boot/freeldr/freeldr/mm/heap.c [iso-8859-1] (original)
+++ trunk/reactos/boot/freeldr/freeldr/mm/heap.c (removed)
@@ -1,157 +1,0 @@
-/*
- * FreeLoader
- * Copyright (C) 2006-2008 Aleksey Bragin <aleksey(a)reactos.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#include <freeldr.h>
-#include <debug.h>
-
-//#define MM_DBG 1 // needs #define BufStats 1 in bget.c
-
-ULONG MmMaximumHeapAlloc;
-
-DBG_DEFAULT_CHANNEL(MEMORY);
-
-VOID MmInitializeHeap(PVOID PageLookupTable)
-{
- ULONG PagesNeeded = 0;
- ULONG HeapStart = 0;
-
- // Find contigious memory block for HEAP:STACK
- PagesNeeded = HEAP_PAGES + STACK_PAGES;
- HeapStart = MmFindAvailablePages(PageLookupTable, TotalPagesInLookupTable, PagesNeeded,
FALSE);
-
- if (HeapStart == 0)
- {
- UiMessageBox("Critical error: Can't allocate heap!");
- return;
- }
-
- // Initialize BGET
- bpool((PVOID)(HeapStart << MM_PAGE_SHIFT), PagesNeeded << MM_PAGE_SHIFT);
-
- // Mark those pages as used
- MmMarkPagesInLookupTable(PageLookupTableAddress, HeapStart, PagesNeeded,
LoaderOsloaderHeap);
-
- TRACE("Heap initialized, base 0x%08x, pages %d\n", (HeapStart <<
MM_PAGE_SHIFT), PagesNeeded);
-}
-
-PVOID MmHeapAlloc(ULONG MemorySize)
-{
- PVOID Result;
-
- if (MemorySize > MM_PAGE_SIZE)
- {
- WARN("Consider using other functions to allocate %d bytes of memory!\n",
MemorySize);
- }
-
- // Get the buffer from BGET pool
- Result = bget(MemorySize);
-
- if (Result == NULL)
- {
- ERR("Heap allocation for %d bytes failed\n", MemorySize);
- }
-#ifdef MM_DBG
- {
- LONG CurAlloc, TotalFree, MaxFree, NumberOfGets, NumberOfRels;
-
- // Gather some stats
- bstats(&CurAlloc, &TotalFree, &MaxFree, &NumberOfGets,
&NumberOfRels);
- if (CurAlloc > MmMaximumHeapAlloc) MmMaximumHeapAlloc = CurAlloc;
-
- TRACE("Current alloc %d, free %d, max alloc %lx, allocs %d, frees %d\n",
- CurAlloc, TotalFree, MmMaximumHeapAlloc, NumberOfGets, NumberOfRels);
- }
-#endif
- return Result;
-}
-
-VOID MmHeapFree(PVOID MemoryPointer)
-{
- // Release the buffer to the pool
- brel(MemoryPointer);
-}
-
-
-PVOID
-NTAPI
-ExAllocatePool(
- IN POOL_TYPE PoolType,
- IN SIZE_T NumberOfBytes)
-{
- return MmHeapAlloc(NumberOfBytes);
-}
-
-#undef ExAllocatePoolWithTag
-PVOID
-NTAPI
-ExAllocatePoolWithTag(
- IN POOL_TYPE PoolType,
- IN SIZE_T NumberOfBytes,
- IN ULONG Tag)
-{
- return MmHeapAlloc(NumberOfBytes);
-}
-
-#undef ExFreePool
-VOID
-NTAPI
-ExFreePool(
- IN PVOID P)
-{
- MmHeapFree(P);
-}
-
-#undef ExFreePoolWithTag
-VOID
-NTAPI
-ExFreePoolWithTag(
- IN PVOID P,
- IN ULONG Tag)
-{
- ExFreePool(P);
-}
-
-PVOID
-NTAPI
-RtlAllocateHeap(
- IN PVOID HeapHandle,
- IN ULONG Flags,
- IN SIZE_T Size)
-{
- PVOID ptr;
-
- ptr = MmHeapAlloc(Size);
- if (ptr && (Flags & HEAP_ZERO_MEMORY))
- {
- RtlZeroMemory(ptr, Size);
- }
-
- return ptr;
-}
-
-BOOLEAN
-NTAPI
-RtlFreeHeap(
- IN PVOID HeapHandle,
- IN ULONG Flags,
- IN PVOID HeapBase)
-{
- MmHeapFree(HeapBase);
- return TRUE;
-}
Removed: trunk/reactos/boot/freeldr/freeldr/rtl/bget.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/rtl/b…
==============================================================================
--- trunk/reactos/boot/freeldr/freeldr/rtl/bget.c [iso-8859-1] (original)
+++ trunk/reactos/boot/freeldr/freeldr/rtl/bget.c (removed)
@@ -1,1599 +1,0 @@
-/*
-
- B G E T
-
- Buffer allocator
-
- Designed and implemented in April of 1972 by John Walker, based on the
- Case Algol OPRO$ algorithm implemented in 1966.
-
- Reimplemented in 1975 by John Walker for the Interdata 70.
- Reimplemented in 1977 by John Walker for the Marinchip 9900.
- Reimplemented in 1982 by Duff Kurland for the Intel 8080.
-
- Portable C version implemented in September of 1990 by an older, wiser
- instance of the original implementor.
-
- Souped up and/or weighed down slightly shortly thereafter by Greg
- Lutz.
-
- AMIX edition, including the new compaction call-back option, prepared
- by John Walker in July of 1992.
-
- Bug in built-in test program fixed, ANSI compiler warnings eradicated,
- buffer pool validator implemented, and guaranteed repeatable test
- added by John Walker in October of 1995.
-
- This program is in the public domain.
-
- 1. This is the book of the generations of Adam. In the day that God
- created man, in the likeness of God made he him;
- 2. Male and female created he them; and blessed them, and called
- their name Adam, in the day when they were created.
- 3. And Adam lived an hundred and thirty years, and begat a son in
- his own likeness, and after his image; and called his name Seth:
- 4. And the days of Adam after he had begotten Seth were eight
- hundred years: and he begat sons and daughters:
- 5. And all the days that Adam lived were nine hundred and thirty
- years: and he died.
- 6. And Seth lived an hundred and five years, and begat Enos:
- 7. And Seth lived after he begat Enos eight hundred and seven years,
- and begat sons and daughters:
- 8. And all the days of Seth were nine hundred and twelve years: and
- he died.
- 9. And Enos lived ninety years, and begat Cainan:
- 10. And Enos lived after he begat Cainan eight hundred and fifteen
- years, and begat sons and daughters:
- 11. And all the days of Enos were nine hundred and five years: and
- he died.
- 12. And Cainan lived seventy years and begat Mahalaleel:
- 13. And Cainan lived after he begat Mahalaleel eight hundred and
- forty years, and begat sons and daughters:
- 14. And all the days of Cainan were nine hundred and ten years: and
- he died.
- 15. And Mahalaleel lived sixty and five years, and begat Jared:
- 16. And Mahalaleel lived after he begat Jared eight hundred and
- thirty years, and begat sons and daughters:
- 17. And all the days of Mahalaleel were eight hundred ninety and
- five years: and he died.
- 18. And Jared lived an hundred sixty and two years, and he begat
- Enoch:
- 19. And Jared lived after he begat Enoch eight hundred years, and
- begat sons and daughters:
- 20. And all the days of Jared were nine hundred sixty and two years:
- and he died.
- 21. And Enoch lived sixty and five years, and begat Methuselah:
- 22. And Enoch walked with God after he begat Methuselah three
- hundred years, and begat sons and daughters:
- 23. And all the days of Enoch were three hundred sixty and five
- years:
- 24. And Enoch walked with God: and he was not; for God took him.
- 25. And Methuselah lived an hundred eighty and seven years, and
- begat Lamech.
- 26. And Methuselah lived after he begat Lamech seven hundred eighty
- and two years, and begat sons and daughters:
- 27. And all the days of Methuselah were nine hundred sixty and nine
- years: and he died.
- 28. And Lamech lived an hundred eighty and two years, and begat a
- son:
- 29. And he called his name Noah, saying, This same shall comfort us
- concerning our work and toil of our hands, because of the ground
- which the LORD hath cursed.
- 30. And Lamech lived after he begat Noah five hundred ninety and
- five years, and begat sons and daughters:
- 31. And all the days of Lamech were seven hundred seventy and seven
- years: and he died.
- 32. And Noah was five hundred years old: and Noah begat Shem, Ham,
- and Japheth.
-
- And buffers begat buffers, and links begat links, and buffer pools
- begat links to chains of buffer pools containing buffers, and lo the
- buffers and links and pools of buffers and pools of links to chains of
- pools of buffers were fruitful and they multiplied and the Operating
- System looked down upon them and said that it was Good.
-
-
- INTRODUCTION
- ============
-
- BGET is a comprehensive memory allocation package which is easily
- configured to the needs of an application. BGET is efficient in
- both the time needed to allocate and release buffers and in the
- memory overhead required for buffer pool management. It
- automatically consolidates contiguous space to minimise
- fragmentation. BGET is configured by compile-time definitions,
- Major options include:
-
- * A built-in test program to exercise BGET and
- demonstrate how the various functions are used.
-
- * Allocation by either the "first fit" or "best fit"
- method.
-
- * Wiping buffers at release time to catch code which
- references previously released storage.
-
- * Built-in routines to dump individual buffers or the
- entire buffer pool.
-
- * Retrieval of allocation and pool size statistics.
-
- * Quantisation of buffer sizes to a power of two to
- satisfy hardware alignment constraints.
-
- * Automatic pool compaction, growth, and shrinkage by
- means of call-backs to user defined functions.
-
- Applications of BGET can range from storage management in
- ROM-based embedded programs to providing the framework upon which
- a multitasking system incorporating garbage collection is
- constructed. BGET incorporates extensive internal consistency
- checking using the <assert.h> mechanism; all these checks can be
- turned off by compiling with NDEBUG defined, yielding a version of
- BGET with minimal size and maximum speed.
-
- The basic algorithm underlying BGET has withstood the test of
- time; more than 25 years have passed since the first
- implementation of this code. And yet, it is substantially more
- efficient than the native allocation schemes of many operating
- systems: the Macintosh and Microsoft Windows to name two, on which
- programs have obtained substantial speed-ups by layering BGET as
- an application level memory manager atop the underlying system's.
-
- BGET has been implemented on the largest mainframes and the lowest
- of microprocessors. It has served as the core for multitasking
- operating systems, multi-thread applications, embedded software in
- data network switching processors, and a host of C programs. And
- while it has accreted flexibility and additional options over the
- years, it remains fast, memory efficient, portable, and easy to
- integrate into your program.
-
-
- BGET IMPLEMENTATION ASSUMPTIONS
- ===============================
-
- BGET is written in as portable a dialect of C as possible. The
- only fundamental assumption about the underlying hardware
- architecture is that memory is allocated is a linear array which
- can be addressed as a vector of C "char" objects. On segmented
- address space architectures, this generally means that BGET should
- be used to allocate storage within a single segment (although some
- compilers simulate linear address spaces on segmented
- architectures). On segmented architectures, then, BGET buffer
- pools may not be larger than a segment, but since BGET allows any
- number of separate buffer pools, there is no limit on the total
- storage which can be managed, only on the largest individual
- object which can be allocated. Machines with a linear address
- architecture, such as the VAX, 680x0, Sparc, MIPS, or the Intel
- 80386 and above in native mode, may use BGET without restriction.
-
-
- GETTING STARTED WITH BGET
- =========================
-
- Although BGET can be configured in a multitude of fashions, there
- are three basic ways of working with BGET. The functions
- mentioned below are documented in the following section. Please
- excuse the forward references which are made in the interest of
- providing a roadmap to guide you to the BGET functions you're
- likely to need.
-
- Embedded Applications
- ---------------------
-
- Embedded applications typically have a fixed area of memory
- dedicated to buffer allocation (often in a separate RAM address
- space distinct from the ROM that contains the executable code).
- To use BGET in such an environment, simply call bpool() with the
- start address and length of the buffer pool area in RAM, then
- allocate buffers with bget() and release them with brel().
- Embedded applications with very limited RAM but abundant CPU speed
- may benefit by configuring BGET for BestFit allocation (which is
- usually not worth it in other environments).
-
- Malloc() Emulation
- ------------------
-
- If the C library malloc() function is too slow, not present in
- your development environment (for example, an a native Windows or
- Macintosh program), or otherwise unsuitable, you can replace it
- with BGET. Initially define a buffer pool of an appropriate size
- with bpool()--usually obtained by making a call to the operating
- system's low-level memory allocator. Then allocate buffers with
- bget(), bgetz(), and bgetr() (the last two permit the allocation
- of buffers initialised to zero and [inefficient] re-allocation of
- existing buffers for compatibility with C library functions).
- Release buffers by calling brel(). If a buffer allocation request
- fails, obtain more storage from the underlying operating system,
- add it to the buffer pool by another call to bpool(), and continue
- execution.
-
- Automatic Storage Management
- ----------------------------
-
- You can use BGET as your application's native memory manager and
- implement automatic storage pool expansion, contraction, and
- optionally application-specific memory compaction by compiling
- BGET with the BECtl variable defined, then calling bectl() and
- supplying functions for storage compaction, acquisition, and
- release, as well as a standard pool expansion increment. All of
- these functions are optional (although it doesn't make much sense
- to provide a release function without an acquisition function,
- does it?). Once the call-back functions have been defined with
- bectl(), you simply use bget() and brel() to allocate and release
- storage as before. You can supply an initial buffer pool with
- bpool() or rely on automatic allocation to acquire the entire
- pool. When a call on bget() cannot be satisfied, BGET first
- checks if a compaction function has been supplied. If so, it is
- called (with the space required to satisfy the allocation request
- and a sequence number to allow the compaction routine to be called
- successively without looping). If the compaction function is able
- to free any storage (it needn't know whether the storage it freed
- was adequate) it should return a nonzero value, whereupon BGET
- will retry the allocation request and, if it fails again, call the
- compaction function again with the next-higher sequence number.
-
- If the compaction function returns zero, indicating failure to
- free space, or no compaction function is defined, BGET next tests
- whether a non-NULL allocation function was supplied to bectl().
- If so, that function is called with an argument indicating how
- many bytes of additional space are required. This will be the
- standard pool expansion increment supplied in the call to bectl()
- unless the original bget() call requested a buffer larger than
- this; buffers larger than the standard pool block can be managed
- "off the books" by BGET in this mode. If the allocation function
- succeeds in obtaining the storage, it returns a pointer to the new
- block and BGET expands the buffer pool; if it fails, the
- allocation request fails and returns NULL to the caller. If a
- non-NULL release function is supplied, expansion blocks which
- become totally empty are released to the global free pool by
- passing their addresses to the release function.
-
- Equipped with appropriate allocation, release, and compaction
- functions, BGET can be used as part of very sophisticated memory
- management strategies, including garbage collection. (Note,
- however, that BGET is *not* a garbage collector by itself, and
- that developing such a system requires much additional logic and
- careful design of the application's memory allocation strategy.)
-
-
- BGET FUNCTION DESCRIPTIONS
- ==========================
-
- Functions implemented in this file (some are enabled by certain of
- the optional settings below):
-
- void bpool(void *buffer, bufsize len);
-
- Create a buffer pool of <len> bytes, using the storage starting at
- <buffer>. You can call bpool() subsequently to contribute
- additional storage to the overall buffer pool.
-
- void *bget(bufsize size);
-
- Allocate a buffer of <size> bytes. The address of the buffer is
- returned, or NULL if insufficient memory was available to allocate
- the buffer.
-
- void *bgetz(bufsize size);
-
- Allocate a buffer of <size> bytes and clear it to all zeroes. The
- address of the buffer is returned, or NULL if insufficient memory
- was available to allocate the buffer.
-
- void *bgetr(void *buffer, bufsize newsize);
-
- Reallocate a buffer previously allocated by bget(), changing its
- size to <newsize> and preserving all existing data. NULL is
- returned if insufficient memory is available to reallocate the
- buffer, in which case the original buffer remains intact.
-
- void brel(void *buf);
-
- Return the buffer <buf>, previously allocated by bget(), to the
- free space pool.
-
- void bectl(int (*compact)(bufsize sizereq, int sequence),
- void *(*acquire)(bufsize size),
- void (*release)(void *buf),
- bufsize pool_incr);
-
- Expansion control: specify functions through which the package may
- compact storage (or take other appropriate action) when an
- allocation request fails, and optionally automatically acquire
- storage for expansion blocks when necessary, and release such
- blocks when they become empty. If <compact> is non-NULL, whenever
- a buffer allocation request fails, the <compact> function will be
- called with arguments specifying the number of bytes (total buffer
- size, including header overhead) required to satisfy the
- allocation request, and a sequence number indicating the number of
- consecutive calls on <compact> attempting to satisfy this
- allocation request. The sequence number is 1 for the first call
- on <compact> for a given allocation request, and increments on
- subsequent calls, permitting the <compact> function to take
- increasingly dire measures in an attempt to free up storage. If
- the <compact> function returns a nonzero value, the allocation
- attempt is re-tried. If <compact> returns 0 (as it must if it
- isn't able to release any space or add storage to the buffer
- pool), the allocation request fails, which can trigger automatic
- pool expansion if the <acquire> argument is non-NULL. At the time
- the <compact> function is called, the state of the buffer
- allocator is identical to that at the moment the allocation
- request was made; consequently, the <compact> function may call
- brel(), bpool(), bstats(), and/or directly manipulate the buffer
- pool in any manner which would be valid were the application in
- control. This does not, however, relieve the <compact> function
- of the need to ensure that whatever actions it takes do not change
- things underneath the application that made the allocation
- request. For example, a <compact> function that released a buffer
- in the process of being reallocated with bgetr() would lead to
- disaster. Implementing a safe and effective <compact> mechanism
- requires careful design of an application's memory architecture,
- and cannot generally be easily retrofitted into existing code.
-
- If <acquire> is non-NULL, that function will be called whenever an
- allocation request fails. If the <acquire> function succeeds in
- allocating the requested space and returns a pointer to the new
- area, allocation will proceed using the expanded buffer pool. If
- <acquire> cannot obtain the requested space, it should return NULL
- and the entire allocation process will fail. <pool_incr>
- specifies the normal expansion block size. Providing an <acquire>
- function will cause subsequent bget() requests for buffers too
- large to be managed in the linked-block scheme (in other words,
- larger than <pool_incr> minus the buffer overhead) to be satisfied
- directly by calls to the <acquire> function. Automatic release of
- empty pool blocks will occur only if all pool blocks in the system
- are the size given by <pool_incr>.
-
- void bstats(bufsize *curalloc, bufsize *totfree,
- bufsize *maxfree, long *nget, long *nrel);
-
- The amount of space currently allocated is stored into the
- variable pointed to by <curalloc>. The total free space (sum of
- all free blocks in the pool) is stored into the variable pointed
- to by <totfree>, and the size of the largest single block in the
- free space pool is stored into the variable pointed to by
- <maxfree>. The variables pointed to by <nget> and <nrel> are
- filled, respectively, with the number of successful (non-NULL
- return) bget() calls and the number of brel() calls.
-
- void bstatse(bufsize *pool_incr, long *npool,
- long *npget, long *nprel,
- long *ndget, long *ndrel);
-
- Extended statistics: The expansion block size will be stored into
- the variable pointed to by <pool_incr>, or the negative thereof if
- automatic expansion block releases are disabled. The number of
- currently active pool blocks will be stored into the variable
- pointed to by <npool>. The variables pointed to by <npget> and
- <nprel> will be filled with, respectively, the number of expansion
- block acquisitions and releases which have occurred. The
- variables pointed to by <ndget> and <ndrel> will be filled with
- the number of bget() and brel() calls, respectively, managed
- through blocks directly allocated by the acquisition and release
- functions.
-
- void bufdump(void *buf);
-
- The buffer pointed to by <buf> is dumped on standard output.
-
- void bpoold(void *pool, int dumpalloc, int dumpfree);
-
- All buffers in the buffer pool <pool>, previously initialised by a
- call on bpool(), are listed in ascending memory address order. If
- <dumpalloc> is nonzero, the contents of allocated buffers are
- dumped; if <dumpfree> is nonzero, the contents of free blocks are
- dumped.
-
- int bpoolv(void *pool);
-
- The named buffer pool, previously initialised by a call on
- bpool(), is validated for bad pointers, overwritten data, etc. If
- compiled with NDEBUG not defined, any error generates an assertion
- failure. Otherwise 1 is returned if the pool is valid, 0 if an
- error is found.
-
-
- BGET CONFIGURATION
- ==================
-*/
-
-/*#define TestProg 20000*/ /* Generate built-in test program
- if defined. The value specifies
- how many buffer allocation attempts
- the test program should make. */
-
-#define SizeQuant 4 /* Buffer allocation size quantum:
- all buffers allocated are a
- multiple of this size. This
- MUST be a power of two. */
-#ifdef MM_DBG
-
-#define BufDump 1 /* Define this symbol to enable the
- bpoold() function which dumps the
- buffers in a buffer pool. */
-
-#define BufValid 1 /* Define this symbol to enable the
- bpoolv() function for validating
- a buffer pool. */
-
-#define DumpData 1 /* Define this symbol to enable the
- bufdump() function which allows
- dumping the contents of an allocated
- or free buffer. */
-
-#define BufStats 1 /* Define this symbol to enable the
- bstats() function which calculates
- the total free space in the buffer
- pool, the largest available
- buffer, and the total space
- currently allocated. */
-
-#define FreeWipe 1 /* Wipe free buffers to a guaranteed
- pattern of garbage to trip up
- miscreants who attempt to use
- pointers into released buffers. */
-
-#define BestFit 1 /* Use a best fit algorithm when
- searching for space for an
- allocation request. This uses
- memory more efficiently, but
- allocation will be much slower. */
-
-#define BECtl 1 /* Define this symbol to enable the
- bectl() function for automatic
- pool space control. */
-#else
-#endif
-
-#include <stdio.h>
-
-int TuiPrintf(const char *format, ... );
-#define printf TuiPrintf
-
-#ifdef lint
-#define NDEBUG /* Exits in asserts confuse lint */
-/* LINTLIBRARY */ /* Don't complain about def, no ref */
-extern char *sprintf(); /* Sun includes don't define sprintf */
-#endif
-
-#define NDEBUG
-
-#include <assert.h>
-#include <memory.h>
-
-#ifdef BufDump /* BufDump implies DumpData */
-#ifndef DumpData
-#define DumpData 1
-#endif
-#endif
-
-#ifdef DumpData
-#include <ctype.h>
-#endif
-
-/* Declare the interface, including the requested buffer size type,
- bufsize. */
-
-#include "bget.h"
-
-#define MemSize int /* Type for size arguments to memxxx()
- functions such as memcmp(). */
-
-/* Queue links */
-
-struct qlinks {
- struct bfhead *flink; /* Forward link */
- struct bfhead *blink; /* Backward link */
-};
-
-/* Header in allocated and free buffers */
-
-struct bhead {
- bufsize prevfree; /* Relative link back to previous
- free buffer in memory or 0 if
- previous buffer is allocated. */
- bufsize bsize; /* Buffer size: positive if free,
- negative if allocated. */
-};
-#define BH(p) ((struct bhead *) (p))
-
-/* Header in directly allocated buffers (by acqfcn) */
-
-struct bdhead {
- bufsize tsize; /* Total size, including overhead */
- struct bhead bh; /* Common header */
-};
-#define BDH(p) ((struct bdhead *) (p))
-
-/* Header in free buffers */
-
-struct bfhead {
- struct bhead bh; /* Common allocated/free header */
- struct qlinks ql; /* Links on free list */
-};
-#define BFH(p) ((struct bfhead *) (p))
-
-static struct bfhead freelist = { /* List of free buffers */
- {0, 0},
- {&freelist, &freelist}
-};
-
-
-#ifdef BufStats
-static bufsize totalloc = 0; /* Total space currently allocated */
-static long numget = 0, numrel = 0; /* Number of bget() and brel() calls */
-#ifdef BECtl
-static long numpblk = 0; /* Number of pool blocks */
-static long numpget = 0, numprel = 0; /* Number of block gets and rels */
-static long numdget = 0, numdrel = 0; /* Number of direct gets and rels */
-#endif /* BECtl */
-#endif /* BufStats */
-
-#ifdef BECtl
-
-/* Automatic expansion block management functions */
-
-static int (*compfcn) _((bufsize sizereq, int sequence)) = NULL;
-static void *(*acqfcn) _((bufsize size)) = NULL;
-static void (*relfcn) _((void *buf)) = NULL;
-
-static bufsize exp_incr = 0; /* Expansion block size */
-static bufsize pool_len = 0; /* 0: no bpool calls have been made
- -1: not all pool blocks are
- the same size
- >0: (common) block size for all
- bpool calls made so far
- */
-#endif
-
-/* Minimum allocation quantum: */
-
-#define QLSize (sizeof(struct qlinks))
-#define SizeQ ((SizeQuant > QLSize) ? SizeQuant : QLSize)
-
-#define V (void) /* To denote unwanted returned values */
-
-/* End sentinel: value placed in bsize field of dummy block delimiting
- end of pool block. The most negative number which will fit in a
- bufsize, defined in a way that the compiler will accept. */
-
-#define ESent ((bufsize) (-(((1L << (sizeof(bufsize) * 8 - 2)) - 1) * 2) - 2))
-
-/* BGET -- Allocate a buffer. */
-
-void *bget(requested_size)
- bufsize requested_size;
-{
- bufsize size = requested_size;
- struct bfhead *b;
-#ifdef BestFit
- struct bfhead *best;
-#endif
- void *buf;
-#ifdef BECtl
- int compactseq = 0;
-#endif
-
- assert(size > 0);
-
- if (size < SizeQ) { /* Need at least room for the */
- size = SizeQ; /* queue links. */
- }
-#ifdef SizeQuant
-#if SizeQuant > 1
- size = (size + (SizeQuant - 1)) & (~(SizeQuant - 1));
-#endif
-#endif
-
- size += sizeof(struct bhead); /* Add overhead in allocated buffer
- to size required. */
-
-#ifdef BECtl
- /* If a compact function was provided in the call to bectl(), wrap
- a loop around the allocation process to allow compaction to
- intervene in case we don't find a suitable buffer in the chain. */
-
- while (1) {
-#endif
- b = freelist.ql.flink;
-#ifdef BestFit
- best = &freelist;
-#endif
-
-
- /* Scan the free list searching for the first buffer big enough
- to hold the requested size buffer. */
-
-#ifdef BestFit
- while (b != &freelist) {
- if (b->bh.bsize >= size) {
- if ((best == &freelist) || (b->bh.bsize < best->bh.bsize)) {
- best = b;
- }
- }
- b = b->ql.flink; /* Link to next buffer */
- }
- b = best;
-#endif /* BestFit */
-
- while (b != &freelist) {
- if ((bufsize) b->bh.bsize >= size) {
-
- /* Buffer is big enough to satisfy the request. Allocate it
- to the caller. We must decide whether the buffer is large
- enough to split into the part given to the caller and a
- free buffer that remains on the free list, or whether the
- entire buffer should be removed from the free list and
- given to the caller in its entirety. We only split the
- buffer if enough room remains for a header plus the minimum
- quantum of allocation. */
-
- if ((b->bh.bsize - size) > (SizeQ + (sizeof(struct bhead)))) {
- struct bhead *ba, *bn;
-
- ba = BH(((char *) b) + (b->bh.bsize - size));
- bn = BH(((char *) ba) + size);
- assert(bn->prevfree == b->bh.bsize);
- /* Subtract size from length of free block. */
- b->bh.bsize -= size;
- /* Link allocated buffer to the previous free buffer. */
- ba->prevfree = b->bh.bsize;
- /* Plug negative size into user buffer. */
- ba->bsize = -(bufsize) size;
- /* Mark buffer after this one not preceded by free block. */
- bn->prevfree = 0;
-
-#ifdef BufStats
- totalloc += size;
- numget++; /* Increment number of bget() calls */
-#endif
- buf = (void *) ((((char *) ba) + sizeof(struct bhead)));
- return buf;
- } else {
- struct bhead *ba;
-
- ba = BH(((char *) b) + b->bh.bsize);
- assert(ba->prevfree == b->bh.bsize);
-
- /* The buffer isn't big enough to split. Give the whole
- shebang to the caller and remove it from the free list. */
-
- assert(b->ql.blink->ql.flink == b);
- assert(b->ql.flink->ql.blink == b);
- b->ql.blink->ql.flink = b->ql.flink;
- b->ql.flink->ql.blink = b->ql.blink;
-
-#ifdef BufStats
- totalloc += b->bh.bsize;
- numget++; /* Increment number of bget() calls */
-#endif
- /* Negate size to mark buffer allocated. */
- b->bh.bsize = -(b->bh.bsize);
-
- /* Zero the back pointer in the next buffer in memory
- to indicate that this buffer is allocated. */
- ba->prevfree = 0;
-
- /* Give user buffer starting at queue links. */
- buf = (void *) &(b->ql);
- return buf;
- }
- }
- b = b->ql.flink; /* Link to next buffer */
- }
-#ifdef BECtl
-
- /* We failed to find a buffer. If there's a compact function
- defined, notify it of the size requested. If it returns
- TRUE, try the allocation again. */
-
- if ((compfcn == NULL) || (!(*compfcn)(size, ++compactseq))) {
- break;
- }
- }
-
- /* No buffer available with requested size free. */
-
- /* Don't give up yet -- look in the reserve supply. */
-
- if (acqfcn != NULL) {
- if (size > exp_incr - sizeof(struct bhead)) {
-
- /* Request is too large to fit in a single expansion
- block. Try to satisy it by a direct buffer acquisition. */
-
- struct bdhead *bdh;
-
- size += sizeof(struct bdhead) - sizeof(struct bhead);
- if ((bdh = BDH((*acqfcn)((bufsize) size))) != NULL) {
-
- /* Mark the buffer special by setting the size field
- of its header to zero. */
- bdh->bh.bsize = 0;
- bdh->bh.prevfree = 0;
- bdh->tsize = size;
-#ifdef BufStats
- totalloc += size;
- numget++; /* Increment number of bget() calls */
- numdget++; /* Direct bget() call count */
-#endif
- buf = (void *) (bdh + 1);
- return buf;
- }
-
- } else {
-
- /* Try to obtain a new expansion block */
-
- void *newpool;
-
- if ((newpool = (*acqfcn)((bufsize) exp_incr)) != NULL) {
- bpool(newpool, exp_incr);
- buf = bget(requested_size); /* This can't, I say, can't
- get into a loop. */
- return buf;
- }
- }
- }
-
- /* Still no buffer available */
-
-#endif /* BECtl */
-
- return NULL;
-}
-
-/* BGETZ -- Allocate a buffer and clear its contents to zero. We clear
- the entire contents of the buffer to zero, not just the
- region requested by the caller. */
-
-void *bgetz(size)
- bufsize size;
-{
- char *buf = (char *) bget(size);
-
- if (buf != NULL) {
- struct bhead *b;
- bufsize rsize;
-
- b = BH(buf - sizeof(struct bhead));
- rsize = -(b->bsize);
- if (rsize == 0) {
- struct bdhead *bd;
-
- bd = BDH(buf - sizeof(struct bdhead));
- rsize = bd->tsize - sizeof(struct bdhead);
- } else {
- rsize -= sizeof(struct bhead);
- }
- assert(rsize >= size);
- V memset(buf, 0, (MemSize) rsize);
- }
- return ((void *) buf);
-}
-
-/* BGETR -- Reallocate a buffer. This is a minimal implementation,
- simply in terms of brel() and bget(). It could be
- enhanced to allow the buffer to grow into adjacent free
- blocks and to avoid moving data unnecessarily. */
-
-void *bgetr(buf, size)
- void *buf;
- bufsize size;
-{
- void *nbuf;
- bufsize osize; /* Old size of buffer */
- struct bhead *b;
-
- if ((nbuf = bget(size)) == NULL) { /* Acquire new buffer */
- return NULL;
- }
- if (buf == NULL) {
- return nbuf;
- }
- b = BH(((char *) buf) - sizeof(struct bhead));
- osize = -b->bsize;
-#ifdef BECtl
- if (osize == 0) {
- /* Buffer acquired directly through acqfcn. */
- struct bdhead *bd;
-
- bd = BDH(((char *) buf) - sizeof(struct bdhead));
- osize = bd->tsize - sizeof(struct bdhead);
- } else
-#endif
- osize -= sizeof(struct bhead);
- assert(osize > 0);
- V memcpy((char *) nbuf, (char *) buf, /* Copy the data */
- (MemSize) ((size < osize) ? size : osize));
- brel(buf);
- return nbuf;
-}
-
-/* BREL -- Release a buffer. */
-
-void brel(buf)
- void *buf;
-{
- struct bfhead *b, *bn;
-
- b = BFH(((char *) buf) - sizeof(struct bhead));
-#ifdef BufStats
- numrel++; /* Increment number of brel() calls */
-#endif
- assert(buf != NULL);
-
-#ifdef BECtl
- if (b->bh.bsize == 0) { /* Directly-acquired buffer? */
- struct bdhead *bdh;
-
- bdh = BDH(((char *) buf) - sizeof(struct bdhead));
- assert(b->bh.prevfree == 0);
-#ifdef BufStats
- totalloc -= bdh->tsize;
- assert(totalloc >= 0);
- numdrel++; /* Number of direct releases */
-#endif /* BufStats */
-#ifdef FreeWipe
- V memset((char *) buf, 0x55,
- (MemSize) (bdh->tsize - sizeof(struct bdhead)));
-#endif /* FreeWipe */
- assert(relfcn != NULL);
- (*relfcn)((void *) bdh); /* Release it directly. */
- return;
- }
-#endif /* BECtl */
-
- /* Buffer size must be negative, indicating that the buffer is
- allocated. */
-
- if (b->bh.bsize >= 0) {
- bn = NULL;
- }
- assert(b->bh.bsize < 0);
-
- /* Back pointer in next buffer must be zero, indicating the
- same thing: */
-
- assert(BH((char *) b - b->bh.bsize)->prevfree == 0);
-
-#ifdef BufStats
- totalloc += b->bh.bsize;
- assert(totalloc >= 0);
-#endif
-
- /* If the back link is nonzero, the previous buffer is free. */
-
- if (b->bh.prevfree != 0) {
-
- /* The previous buffer is free. Consolidate this buffer with it
- by adding the length of this buffer to the previous free
- buffer. Note that we subtract the size in the buffer being
- released, since it's negative to indicate that the buffer is
- allocated. */
-
- register bufsize size = b->bh.bsize;
-
- /* Make the previous buffer the one we're working on. */
- assert(BH((char *) b - b->bh.prevfree)->bsize == b->bh.prevfree);
- b = BFH(((char *) b) - b->bh.prevfree);
- b->bh.bsize -= size;
- } else {
-
- /* The previous buffer isn't allocated. Insert this buffer
- on the free list as an isolated free block. */
-
- assert(freelist.ql.blink->ql.flink == &freelist);
- assert(freelist.ql.flink->ql.blink == &freelist);
- b->ql.flink = &freelist;
- b->ql.blink = freelist.ql.blink;
- freelist.ql.blink = b;
- b->ql.blink->ql.flink = b;
- b->bh.bsize = -b->bh.bsize;
- }
-
- /* Now we look at the next buffer in memory, located by advancing from
- the start of this buffer by its size, to see if that buffer is
- free. If it is, we combine this buffer with the next one in
- memory, dechaining the second buffer from the free list. */
-
- bn = BFH(((char *) b) + b->bh.bsize);
- if (bn->bh.bsize > 0) {
-
- /* The buffer is free. Remove it from the free list and add
- its size to that of our buffer. */
-
- assert(BH((char *) bn + bn->bh.bsize)->prevfree == bn->bh.bsize);
- assert(bn->ql.blink->ql.flink == bn);
- assert(bn->ql.flink->ql.blink == bn);
- bn->ql.blink->ql.flink = bn->ql.flink;
- bn->ql.flink->ql.blink = bn->ql.blink;
- b->bh.bsize += bn->bh.bsize;
-
- /* Finally, advance to the buffer that follows the newly
- consolidated free block. We must set its backpointer to the
- head of the consolidated free block. We know the next block
- must be an allocated block because the process of recombination
- guarantees that two free blocks will never be contiguous in
- memory. */
-
- bn = BFH(((char *) b) + b->bh.bsize);
- }
-#ifdef FreeWipe
- V memset(((char *) b) + sizeof(struct bfhead), 0x55,
- (MemSize) (b->bh.bsize - sizeof(struct bfhead)));
-#endif
- assert(bn->bh.bsize < 0);
-
- /* The next buffer is allocated. Set the backpointer in it to point
- to this buffer; the previous free buffer in memory. */
-
- bn->bh.prevfree = b->bh.bsize;
-
-#ifdef BECtl
-
- /* If a block-release function is defined, and this free buffer
- constitutes the entire block, release it. Note that pool_len
- is defined in such a way that the test will fail unless all
- pool blocks are the same size. */
-
- if (relfcn != NULL &&
- ((bufsize) b->bh.bsize) == (pool_len - sizeof(struct bhead))) {
-
- assert(b->bh.prevfree == 0);
- assert(BH((char *) b + b->bh.bsize)->bsize == ESent);
- assert(BH((char *) b + b->bh.bsize)->prevfree == b->bh.bsize);
- /* Unlink the buffer from the free list */
- b->ql.blink->ql.flink = b->ql.flink;
- b->ql.flink->ql.blink = b->ql.blink;
-
- (*relfcn)(b);
-#ifdef BufStats
- numprel++; /* Nr of expansion block releases */
- numpblk--; /* Total number of blocks */
- assert(numpblk == numpget - numprel);
-#endif /* BufStats */
- }
-#endif /* BECtl */
-}
-
-#ifdef BECtl
-
-/* BECTL -- Establish automatic pool expansion control */
-
-void bectl(compact, acquire, release, pool_incr)
- int (*compact) _((bufsize sizereq, int sequence));
- void *(*acquire) _((bufsize size));
- void (*release) _((void *buf));
- bufsize pool_incr;
-{
- compfcn = compact;
- acqfcn = acquire;
- relfcn = release;
- exp_incr = pool_incr;
-}
-#endif
-
-/* BPOOL -- Add a region of memory to the buffer pool. */
-
-void bpool(buf, len)
- void *buf;
- bufsize len;
-{
- struct bfhead *b = BFH(buf);
- struct bhead *bn;
-
-#ifdef SizeQuant
- len &= ~(SizeQuant - 1);
-#endif
-#ifdef BECtl
- if (pool_len == 0) {
- pool_len = len;
- } else if (len != pool_len) {
- pool_len = -1;
- }
-#ifdef BufStats
- numpget++; /* Number of block acquisitions */
- numpblk++; /* Number of blocks total */
- assert(numpblk == numpget - numprel);
-#endif /* BufStats */
-#endif /* BECtl */
-
- /* Since the block is initially occupied by a single free buffer,
- it had better not be (much) larger than the largest buffer
- whose size we can store in bhead.bsize. */
-
- assert(len - sizeof(struct bhead) <= -((bufsize) ESent + 1));
-
- /* Clear the backpointer at the start of the block to indicate that
- there is no free block prior to this one. That blocks
- recombination when the first block in memory is released. */
-
- b->bh.prevfree = 0;
-
- /* Chain the new block to the free list. */
-
- assert(freelist.ql.blink->ql.flink == &freelist);
- assert(freelist.ql.flink->ql.blink == &freelist);
- b->ql.flink = &freelist;
- b->ql.blink = freelist.ql.blink;
- freelist.ql.blink = b;
- b->ql.blink->ql.flink = b;
-
- /* Create a dummy allocated buffer at the end of the pool. This dummy
- buffer is seen when a buffer at the end of the pool is released and
- blocks recombination of the last buffer with the dummy buffer at
- the end. The length in the dummy buffer is set to the largest
- negative number to denote the end of the pool for diagnostic
- routines (this specific value is not counted on by the actual
- allocation and release functions). */
-
- len -= sizeof(struct bhead);
- b->bh.bsize = (bufsize) len;
-#ifdef FreeWipe
- V memset(((char *) b) + sizeof(struct bfhead), 0x55,
- (MemSize) (len - sizeof(struct bfhead)));
-#endif
- bn = BH(((char *) b) + len);
- bn->prevfree = (bufsize) len;
- /* Definition of ESent assumes two's complement! */
- assert((~0) == -1);
- bn->bsize = ESent;
-}
-
-#ifdef BufStats
-
-/* BSTATS -- Return buffer allocation free space statistics. */
-
-void bstats(curalloc, totfree, maxfree, nget, nrel)
- bufsize *curalloc, *totfree, *maxfree;
- long *nget, *nrel;
-{
- struct bfhead *b = freelist.ql.flink;
-
- *nget = numget;
- *nrel = numrel;
- *curalloc = totalloc;
- *totfree = 0;
- *maxfree = -1;
- while (b != &freelist) {
- assert(b->bh.bsize > 0);
- *totfree += b->bh.bsize;
- if (b->bh.bsize > *maxfree) {
- *maxfree = b->bh.bsize;
- }
- b = b->ql.flink; /* Link to next buffer */
- }
-}
-
-#ifdef BECtl
-
-/* BSTATSE -- Return extended statistics */
-
-void bstatse(pool_incr, npool, npget, nprel, ndget, ndrel)
- bufsize *pool_incr;
- long *npool, *npget, *nprel, *ndget, *ndrel;
-{
- *pool_incr = (pool_len < 0) ? -exp_incr : exp_incr;
- *npool = numpblk;
- *npget = numpget;
- *nprel = numprel;
- *ndget = numdget;
- *ndrel = numdrel;
-}
-#endif /* BECtl */
-#endif /* BufStats */
-
-#ifdef DumpData
-
-/* BUFDUMP -- Dump the data in a buffer. This is called with the user
- data pointer, and backs up to the buffer header. It will
- dump either a free block or an allocated one. */
-
-void bufdump(buf)
- void *buf;
-{
- struct bfhead *b;
- unsigned char *bdump;
- bufsize bdlen;
-
- b = BFH(((char *) buf) - sizeof(struct bhead));
- assert(b->bh.bsize != 0);
- if (b->bh.bsize < 0) {
- bdump = (unsigned char *) buf;
- bdlen = (-b->bh.bsize) - sizeof(struct bhead);
- } else {
- bdump = (unsigned char *) (((char *) b) + sizeof(struct bfhead));
- bdlen = b->bh.bsize - sizeof(struct bfhead);
- }
-
- while (bdlen > 0) {
- int i, dupes = 0;
- bufsize l = bdlen;
- char bhex[50], bascii[20];
-
- if (l > 16) {
- l = 16;
- }
-
- for (i = 0; i < l; i++) {
- V sprintf(bhex + i * 3, "%02X ", bdump[i]);
- bascii[i] = isprint(bdump[i]) ? bdump[i] : ' ';
- }
- bascii[i] = 0;
- V printf("%-48s %s\n", bhex, bascii);
- bdump += l;
- bdlen -= l;
- while ((bdlen > 16) && (memcmp((char *) (bdump - 16),
- (char *) bdump, 16) == 0)) {
- dupes++;
- bdump += 16;
- bdlen -= 16;
- }
- if (dupes > 1) {
- V printf(
- " (%d lines [%d bytes] identical to above line
skipped)\n",
- dupes, dupes * 16);
- } else if (dupes == 1) {
- bdump -= 16;
- bdlen += 16;
- }
- }
-}
-#endif
-
-#ifdef BufDump
-
-/* BPOOLD -- Dump a buffer pool. The buffer headers are always listed.
- If DUMPALLOC is nonzero, the contents of allocated buffers
- are dumped. If DUMPFREE is nonzero, free blocks are
- dumped as well. If FreeWipe checking is enabled, free
- blocks which have been clobbered will always be dumped. */
-
-void bpoold(buf, dumpalloc, dumpfree)
- void *buf;
- int dumpalloc, dumpfree;
-{
- struct bfhead *b = BFH(buf);
-
- while (b->bh.bsize != ESent) {
- bufsize bs = b->bh.bsize;
-
- if (bs < 0) {
- bs = -bs;
- V printf("Allocated buffer: size %6ld bytes.\n", (long) bs);
- if (dumpalloc) {
- bufdump((void *) (((char *) b) + sizeof(struct bhead)));
- }
- } else {
- char *lerr = "";
-
- assert(bs > 0);
- if ((b->ql.blink->ql.flink != b) ||
- (b->ql.flink->ql.blink != b)) {
- lerr = " (Bad free list links)";
- }
- V printf("Free block: size %6ld bytes.%s\n",
- (long) bs, lerr);
-#ifdef FreeWipe
- lerr = ((char *) b) + sizeof(struct bfhead);
- if ((bs > sizeof(struct bfhead)) && ((*lerr != 0x55) ||
- (memcmp(lerr, lerr + 1,
- (MemSize) (bs - (sizeof(struct bfhead) + 1))) != 0))) {
- V printf(
- "(Contents of above free block have been overstored.)\n");
- bufdump((void *) (((char *) b) + sizeof(struct bhead)));
- } else
-#endif
- if (dumpfree) {
- bufdump((void *) (((char *) b) + sizeof(struct bhead)));
- }
- }
- b = BFH(((char *) b) + bs);
- }
-}
-#endif /* BufDump */
-
-#ifdef BufValid
-
-/* BPOOLV -- Validate a buffer pool. If NDEBUG isn't defined,
- any error generates an assertion failure. */
-
-int bpoolv(buf)
- void *buf;
-{
- struct bfhead *b = BFH(buf);
-
- while (b->bh.bsize != ESent) {
- bufsize bs = b->bh.bsize;
-
- if (bs < 0) {
- bs = -bs;
- } else {
- char *lerr = "";
-
- assert(bs > 0);
- if (bs <= 0) {
- return 0;
- }
- if ((b->ql.blink->ql.flink != b) ||
- (b->ql.flink->ql.blink != b)) {
- V printf("Free block: size %6ld bytes. (Bad free list
links)\n",
- (long) bs);
- assert(0);
- return 0;
- }
-#ifdef FreeWipe
- lerr = ((char *) b) + sizeof(struct bfhead);
- if ((bs > sizeof(struct bfhead)) && ((*lerr != 0x55) ||
- (memcmp(lerr, lerr + 1,
- (MemSize) (bs - (sizeof(struct bfhead) + 1))) != 0))) {
- V printf(
- "(Contents of above free block have been overstored.)\n");
- bufdump((void *) (((char *) b) + sizeof(struct bhead)));
- assert(0);
- return 0;
- }
-#endif
- }
- b = BFH(((char *) b) + bs);
- }
- return 1;
-}
-#endif /* BufValid */
-
- /***********************\
- * *
- * Built-in test program *
- * *
- \***********************/
-
-#ifdef TestProg
-
-#define Repeatable 1 /* Repeatable pseudorandom sequence */
- /* If Repeatable is not defined, a
- time-seeded pseudorandom sequence
- is generated, exercising BGET with
- a different pattern of calls on each
- run. */
-#define OUR_RAND /* Use our own built-in version of
- rand() to guarantee the test is
- 100% repeatable. */
-
-#ifdef BECtl
-#define PoolSize 300000 /* Test buffer pool size */
-#else
-#define PoolSize 50000 /* Test buffer pool size */
-#endif
-#define ExpIncr 32768 /* Test expansion block size */
-#define CompactTries 10 /* Maximum tries at compacting */
-
-#define dumpAlloc 0 /* Dump allocated buffers ? */
-#define dumpFree 0 /* Dump free buffers ? */
-
-#ifndef Repeatable
-extern long time();
-#endif
-
-extern char *malloc();
-extern int free _((char *));
-
-static char *bchain = NULL; /* Our private buffer chain */
-static char *bp = NULL; /* Our initial buffer pool */
-
-#include <math.h>
-
-#ifdef OUR_RAND
-
-static unsigned long int next = 1;
-
-/* Return next random integer */
-
-int rand()
-{
- next = next * 1103515245L + 12345;
- return (unsigned int) (next / 65536L) % 32768L;
-}
-
-/* Set seed for random generator */
-
-void srand(seed)
- unsigned int seed;
-{
- next = seed;
-}
-#endif
-
-/* STATS -- Edit statistics returned by bstats() or bstatse(). */
-
-static void stats(when)
- char *when;
-{
- bufsize cural, totfree, maxfree;
- long nget, nfree;
-#ifdef BECtl
- bufsize pincr;
- long totblocks, npget, nprel, ndget, ndrel;
-#endif
-
- bstats(&cural, &totfree, &maxfree, &nget, &nfree);
- V printf(
- "%s: %ld gets, %ld releases. %ld in use, %ld free, largest = %ld\n",
- when, nget, nfree, (long) cural, (long) totfree, (long) maxfree);
-#ifdef BECtl
- bstatse(&pincr, &totblocks, &npget, &nprel, &ndget, &ndrel);
- V printf(
- " Blocks: size = %ld, %ld (%ld bytes) in use, %ld gets, %ld
frees\n",
- (long)pincr, totblocks, pincr * totblocks, npget, nprel);
- V printf(" %ld direct gets, %ld direct frees\n", ndget, ndrel);
-#endif /* BECtl */
-}
-
-#ifdef BECtl
-static int protect = 0; /* Disable compaction during bgetr() */
-
-/* BCOMPACT -- Compaction call-back function. */
-
-static int bcompact(bsize, seq)
- bufsize bsize;
- int seq;
-{
-#ifdef CompactTries
- char *bc = bchain;
- int i = rand() & 0x3;
-
-#ifdef COMPACTRACE
- V printf("Compaction requested. %ld bytes needed, sequence %d.\n",
- (long) bsize, seq);
-#endif
-
- if (protect || (seq > CompactTries)) {
-#ifdef COMPACTRACE
- V printf("Compaction gave up.\n");
-#endif
- return 0;
- }
-
- /* Based on a random cast, release a random buffer in the list
- of allocated buffers. */
-
- while (i > 0 && bc != NULL) {
- bc = *((char **) bc);
- i--;
- }
- if (bc != NULL) {
- char *fb;
-
- fb = *((char **) bc);
- if (fb != NULL) {
- *((char **) bc) = *((char **) fb);
- brel((void *) fb);
- return 1;
- }
- }
-
-#ifdef COMPACTRACE
- V printf("Compaction bailed out.\n");
-#endif
-#endif /* CompactTries */
- return 0;
-}
-
-/* BEXPAND -- Expand pool call-back function. */
-
-static void *bexpand(size)
- bufsize size;
-{
- void *np = NULL;
- bufsize cural, totfree, maxfree;
- long nget, nfree;
-
- /* Don't expand beyond the total allocated size given by PoolSize. */
-
- bstats(&cural, &totfree, &maxfree, &nget, &nfree);
-
- if (cural < PoolSize) {
- np = (void *) malloc((unsigned) size);
- }
-#ifdef EXPTRACE
- V printf("Expand pool by %ld -- %s.\n", (long) size,
- np == NULL ? "failed" : "succeeded");
-#endif
- return np;
-}
-
-/* BSHRINK -- Shrink buffer pool call-back function. */
-
-static void bshrink(buf)
- void *buf;
-{
- if (((char *) buf) == bp) {
-#ifdef EXPTRACE
- V printf("Initial pool released.\n");
-#endif
- bp = NULL;
- }
-#ifdef EXPTRACE
- V printf("Shrink pool.\n");
-#endif
- free((char *) buf);
-}
-
-#endif /* BECtl */
-
-/* Restrict buffer requests to those large enough to contain our pointer and
- small enough for the CPU architecture. */
-
-static bufsize blimit(bs)
- bufsize bs;
-{
- if (bs < sizeof(char *)) {
- bs = sizeof(char *);
- }
-
- /* This is written out in this ugly fashion because the
- cool expression in sizeof(int) that auto-configured
- to any length int befuddled some compilers. */
-
- if (sizeof(int) == 2) {
- if (bs > 32767) {
- bs = 32767;
- }
- } else {
- if (bs > 200000) {
- bs = 200000;
- }
- }
- return bs;
-}
-
-int main()
-{
- int i;
- double x;
-
- /* Seed the random number generator. If Repeatable is defined, we
- always use the same seed. Otherwise, we seed from the clock to
- shake things up from run to run. */
-
-#ifdef Repeatable
- V srand(1234);
-#else
- V srand((int) time((long *) NULL));
-#endif
-
- /* Compute x such that pow(x, p) ranges between 1 and 4*ExpIncr as
- p ranges from 0 to ExpIncr-1, with a concentration in the lower
- numbers. */
-
- x = 4.0 * ExpIncr;
- x = log(x);
- x = exp(log(4.0 * ExpIncr) / (ExpIncr - 1.0));
-
-#ifdef BECtl
- bectl(bcompact, bexpand, bshrink, (bufsize) ExpIncr);
- bp = malloc(ExpIncr);
- assert(bp != NULL);
- bpool((void *) bp, (bufsize) ExpIncr);
-#else
- bp = malloc(PoolSize);
- assert(bp != NULL);
- bpool((void *) bp, (bufsize) PoolSize);
-#endif
-
- stats("Create pool");
- V bpoolv((void *) bp);
- bpoold((void *) bp, dumpAlloc, dumpFree);
-
- for (i = 0; i < TestProg; i++) {
- char *cb;
- bufsize bs = pow(x, (double) (rand() & (ExpIncr - 1)));
-
- assert(bs <= (((bufsize) 4) * ExpIncr));
- bs = blimit(bs);
- if (rand() & 0x400) {
- cb = (char *) bgetz(bs);
- } else {
- cb = (char *) bget(bs);
- }
- if (cb == NULL) {
-#ifdef EasyOut
- break;
-#else
- char *bc = bchain;
-
- if (bc != NULL) {
- char *fb;
-
- fb = *((char **) bc);
- if (fb != NULL) {
- *((char **) bc) = *((char **) fb);
- brel((void *) fb);
- }
- continue;
- }
-#endif
- }
- *((char **) cb) = (char *) bchain;
- bchain = cb;
-
- /* Based on a random cast, release a random buffer in the list
- of allocated buffers. */
-
- if ((rand() & 0x10) == 0) {
- char *bc = bchain;
- int i = rand() & 0x3;
-
- while (i > 0 && bc != NULL) {
- bc = *((char **) bc);
- i--;
- }
- if (bc != NULL) {
- char *fb;
-
- fb = *((char **) bc);
- if (fb != NULL) {
- *((char **) bc) = *((char **) fb);
- brel((void *) fb);
- }
- }
- }
-
- /* Based on a random cast, reallocate a random buffer in the list
- to a random size */
-
- if ((rand() & 0x20) == 0) {
- char *bc = bchain;
- int i = rand() & 0x3;
-
- while (i > 0 && bc != NULL) {
- bc = *((char **) bc);
- i--;
- }
- if (bc != NULL) {
- char *fb;
-
- fb = *((char **) bc);
- if (fb != NULL) {
- char *newb;
-
- bs = pow(x, (double) (rand() & (ExpIncr - 1)));
- bs = blimit(bs);
-#ifdef BECtl
- protect = 1; /* Protect against compaction */
-#endif
- newb = (char *) bgetr((void *) fb, bs);
-#ifdef BECtl
- protect = 0;
-#endif
- if (newb != NULL) {
- *((char **) bc) = newb;
- }
- }
- }
- }
- }
- stats("\nAfter allocation");
- if (bp != NULL) {
- V bpoolv((void *) bp);
- bpoold((void *) bp, dumpAlloc, dumpFree);
- }
-
- while (bchain != NULL) {
- char *buf = bchain;
-
- bchain = *((char **) buf);
- brel((void *) buf);
- }
- stats("\nAfter release");
-#ifndef BECtl
- if (bp != NULL) {
- V bpoolv((void *) bp);
- bpoold((void *) bp, dumpAlloc, dumpFree);
- }
-#endif
-
- return 0;
-}
-#endif
Modified: trunk/reactos/boot/freeldr/freeldr/windows/wlmemory.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/windo…
==============================================================================
--- trunk/reactos/boot/freeldr/freeldr/windows/wlmemory.c [iso-8859-1] (original)
+++ trunk/reactos/boot/freeldr/freeldr/windows/wlmemory.c [iso-8859-1] Thu Feb 9 20:01:10
2012
@@ -202,8 +202,11 @@
//PKTSS Tss;
//BOOLEAN Status;
- //
- // Creating a suitable memory map for the Windows can be tricky, so let's
+ /* Cleanup heap */
+ HeapCleanupAll();
+
+ //
+ // Creating a suitable memory map for Windows can be tricky, so let's
// give a few advices:
// 1) One must not map the whole available memory pages to PDE!
// Map only what's needed - 16Mb, 24Mb, 32Mb max I think,
4706
days inactive
4706
days old
0 comments
1 participants
participants (1)
-
tkreuzer＠svn.reactos.org