Browse Prior Art Database

Run Time Memory Management Algorithm/Supervisor and WatchDog Support Program

IP.com Disclosure Number: IPCOM000117650D
Original Publication Date: 1996-Apr-01
Included in the Prior Art Database: 2005-Mar-31
Document File: 4 page(s) / 177K

Publishing Venue

IBM

Related People

Lambertus, JJJ: AUTHOR

Abstract

Management of memory is a growing requirement. Paging systems are being created to allow huge programs to load and execute with less memory requirements. Memory option items, such as "non-pageable memory", brings a decisive performance enhancement. By allowing a memory segment to be described as "non-pageable" also allows a beast known as thrashing or eventually the inability to page memory at all due to memory fragmentation. There needs to be a way to limit the thrashing/fragmentation possibility. Two solutions are: Run Time

This text was extracted from an ASCII text file.
This is the abbreviated version, containing approximately 50% of the total text.

Run Time Memory Management Algorithm/Supervisor and WatchDog Support
Program

      Management of memory is a growing requirement.  Paging systems
are being created to allow huge programs to load and execute with
less memory requirements.  Memory option items, such as "non-pageable
memory", brings a decisive performance enhancement.  By allowing a
memory segment to be described as "non-pageable" also allows a beast
known as thrashing or eventually the inability to page memory at all
due to memory fragmentation.  There needs to be a way to limit the
thrashing/fragmentation possibility.  Two solutions are:  Run Time

Memory Management Algorithm and Run Time Memory Supervisor and
Watchdog Support (MSWS) Program.

      Because software developers seek to optimize performance of
their software, many software products choose to "lock" (also
referred to as "non-pageable" memory in this disclosure) memory so
that paging does not occur on a particular memory segment.  By not
waiting for a memory segment to be paged in, the program simply goes
right to execution, thus saving the time to page.  So many programs
may be doing this that the right (or maybe the word is wrong)
combinations of programs (and the loading of), could lock memory
segments in a scattered fashion and fragment memory so badly that
some programs may not even be able to load, let alone thrash.  This
frustration has led to the "RUN TIME MEMORY MANAGEMENT ALGORITHM" and
the "RUN TIME MEMORY SUPERVISOR AND WATCHDOG SUPPORT (MSWS) PROGRAM".

      The idea is not to eliminate the function of declaring
"non-pageable" memory segments, but rather supervise and manage these
"locked" segments using a new methodology and program.

      At compile time, memory allocation segments can be declared as
"locked" or "NON-PAGEABLE".  The memory segments of a program are
loaded when the program is selected to execute.  The problem is that
the next available memory slot (of the right size) is chosen for the
load address and all additional system memory allocations are done
contiguously (if possible).  Keep in mind that paging and the loading
and unloading of programs may have fragmented memory.  This forces
page or load mechanisms to load the page or program at the first
available slot that it fits in.  Any additional memory allocations
and/or pages are also subject to this methodology.  When the programs
are loaded and the memory allocations are performed, the
"non-pageable" or "locked", is situated right where the load occurs
(Fig. 1).

      After executing for a while (program loading, unloading and
paging taking place), memory could look like Fig. 2.  As can be seen,
memory is starting to become very fragmented.  Smaller programs could
load and execute, but the larger programs may not be able to load or
be paged back in for execution.  In today's environment, a message
may be displayed that indicated that a program could not load and
that the user should remove...