Memory Management Algorithm Research Articles

Garbage Collection: Algorithms for Automatic Dynamic Memory Management by Richard Jones and Rafael Lins, John Wiley & Sons, 1996.

<i>Garbage Collection: Algorithms for Automatic Dynamic Memory Management</i> by Richard Jones and Rafael Lins, John Wiley &amp; Sons, 1996.

An Efficient Memory Management Algorithm for Client-Server Database Management Systems

Due to the recent improvements in the price/performance characteristics of workstations and the networking capabilities, the client-server system architecture has become a target for database systems. A client-server database management system (DBMS) provides the management of a database that resides on a client-server system. Data-access requests of the clients are handled by the database servers. The whole database is stored on the disks that can be accessed by only the servers, and in order to reduce disk accesses, copies of database items can be cached in the global memory which comprises the memories of all the computers connected to the system. Designing efficient global memory management algorithms helps the transactions experience less disk input/output (I/O) during their execution. In this paper, we propose a global memory management algorithm for client-server DBMSs which aims to reduce disk I/O by increasing the portion of the database available in global memory. Performance of the algorithm is examined by a comparison with some previously proposed algorithms, using a simulation model designed for studying various performance issues in client-server DBMSs. Conditions for which the new algorithm provides significant improvements in the overall throughput of the system are identified.

The UC Berkeley System for Interactive Visualization of Large Architectural Models

Realistic-looking architectural models with furniture may consist of millions of polygons and require gigabytes of data—far than today's workstations can render at interactive frame rates or store in physical memory. We have developed data structures and algorithms for identifying a small portion of a large model to load into memory and render during each frame of an interactive walkthrough. Our algorithms rely upon an efficient display database that represents a building model as a set of objects, each of which can be described at multiple levels of detail, and contains an index of spatial cells with precomputed cell-to-cell and cell-to-object visibility information. As the observer moves through the model interactively, a real-time visibility algorithm traces sightline beams through transparent cell boundaries to determine a small set of objects potentially visible to the observer. An optimization algorithm dynamically selects a level of detail and rendering algorithm with which to display each potentially visible object to meet a userspecified target frame time. Throughout, memory management algorithms predict observer motion and prefetch objects from disk that may become visible during imminent frames. This paper describes an interactive building walkthrough system that uses these data structures and algorithms to maintain interactive frame rates during visualization of very large models. So far, the implementation supports models whose major occluding surfaces are axis-aligned rectangles (e.g., typical buildings). This system is able to maintain over twenty frames per second with little noticeable detail elision during interactive walkthroughs of a building model containing over one million polygons.

A toolkit for parallel functional programming

AbstractOur toolkit for the design and implementation of parallel functional programs supports the stepwise development of parallel programs from a high level sequential specification to an optimised parallel implementation. The toolkit is used as follows: The algorithm to be implemented is specified in a functional language. The program is debugged and tested using an interpreter. The program is compiled for a sequential machine. Its performance is analysed and improved. Annotation‐driven transformations are applied to the program to indicate parallel tasks. Simulations at task level, basic block level and bus transaction level make it possible to analyse the parallel performance of the program at three levels of detail. When the performance is optimised using the simulators, the program is executed on a genuine parallel machine. Several programs have been developed with the toolkit. A program that simulates tidal flow in an estuary of the North sea is presented as a case study to demonstrate the merits of the toolkit when developing complex parallel programs.The toolkit not only supports the design of parallel applications, it also allows the study of important concepts in parallel computer architecture. These include the behaviour of cached memory systems, bus protocols, scheduling algorithms and memory management algorithms.

A fault tolerant hybrid memory structure and memory management algorithms

This paper proposes a cost effective fault tolerant memory structure. It uses the modified status of virtual memory pages as the basis to propose a system with two classes of memory. One class is for modified pages, and the other is for pages not modified. The term hybrid memory system is used to describe this system. Results show the cost savings for a hybrid system over a traditional fault tolerant system. Hybrid virtual memory algorithms are proposed for the system. The traditional lifetime and space-time measures of virtual memory algorithms are extended for the hybrid algorithms. This includes "cost-weighted" measures to reflect the fact that the two classes of memory may have different resource allocation constraints. A theoretical result is presented for the effect of combining the hybrid lifetime functions. Finally, a framework for developing hybrid algorithms is presented with experimental results illustrating the analysis. It is shown that the lifetime measure for the hybrid policies can show improvements over traditional algorithms.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Managing memory for real-time queries

The demanding performance objectives that real-time database systems (RTDBS) face necessitate the use of priority resource scheduling. This paper introduces a Priority Memory Management (PMM) algorithm that is designed to schedule queries in RTDBS. PMM attempts to minimize the number of missed deadlines by adapting both its multiprogramming level and its memory allocation strategy to the characteristics of the offered workload. A series of simulation experiments confirms that PMM's admission control and memory allocation mechanisms are very effective for real-time query scheduling.

Memory management algorithms for optimistic parallel simulation

This paper studies the space complexity of an optimistic parallel simulation protocol called Time Warp. We evaluate four Time Warp memory management algorithms: fossil collection, message sendback, cancelback and artificial rollback. We identify two criteria in designing Time Warp memory management algorithms. Criterion 1 tests if a memory management algorithm ensures that Time Warp simulation always stops (either completes or terminates when memory is exhausted). If an algorithm does not satisfy this criterion, then the simulation may be trapped in an infinite loop. Criterion 2 tests if a memory management algorithm is independent of processor parameters (e.g., number of processors available for the parallel simulation, processor speed and interprocessor communication costs). We show that if an algorithm satisfies this second criterion, then the amount of memory consumed by Time Warp simulation is bounded by the amount consumed by sequential simulation. For algorithms that do not have full control of uncommitted objects (e.g., fossil collection and message sendback), Criterion 2 is not satisfied in general. For algorithms that have full control of uncommitted objects (e.g., cancelback and artificial rollback), special treatments are necessary to satisfy Criterion 1 (i.e., to ensure that the algorithms do not cancel future objects such that global virtual time never advances).

Evaluating models of memory allocation

Because dynamic memory management is an important part of a large class of computer programs, high-performance algorithms for dynamic memory management have been and will continue to be of considerable interest. The goal of this research is to explore the size and accuracy of synthetic models of program allocation behavior. These models, if accurate enough, proved an attractive alternative to algorithm evaluation based on trace-driven simulation using actual traces. Based on our analysis, we conclude that even relatively simple synthetic models can effectively emulate the allocation behavior of well-behaved programs. However, even the most complex models we investigate can only roughly approximate the behavior of more complex programs and/or allocation policies. While synthetic models have been used to evaluate the performance of dynamic memory management algorithms, our results show that these models can be inaccurate and must be used with care. Given current trends toward more complex applications and allocation algorithms, the synthetic models we investigate are likely to be even less accurate in the future.

A methodology for implementing highly concurrent data objects

A concurrent object is a data structure shared by concurrent processes. Conventional techniques for implementing concurrent objects typically rely on critical sections ; ensuring that only one process at a time can operate on the object. Nevertheless, critical sections are poorly suited for asynchronous systems: if one process is halted or delayed in a critical section, other, nonfaulty processes will be unable to progress. By contrast, a concurrent object implementation is lock free if it always guarantees that some process will complete an operation in a finite number of steps, and it is wait free if it guarantees that each process will complete an operation in a finite number of steps. This paper proposes a new methodology for constructing lock-free and wait-free implementations of concurrent objects. The object's representation and operations are written as stylized sequential programs, with no explicit synchronization. Each sequential operation is atutomatically transformed into a lock-free or wait-free operation using novel synchronization and memory management algorithms. These algorithms are presented for a multiple instruction/multiple data (MIMD) architecture in which n processes communicate by applying atomic read, write, load_linked, and store_conditional operations to a shared memory.

The measured cost of conservative garbage collection

AbstractBecause dynamic memory management is an important part of a large class of computer programs, high‐performance algorithms for dynamic memory management have been, and will continue to be, of considerable interest. Experience indicates that for many programs, dynamic storage allocation is so important that programmers feel compelled to write and use their own domain‐specific allocators to avoid the overhead of system libraries. As an alternative to explicit storage management techniques, conservative garbage collection has been suggested as an important algorithm for dynamic storage management in C programs. In this paper, I evaluate the costs of different dynamic storage management algorithms, including domain‐specific allocators, widely‐used general‐purpose allocators, and a publicly available conservative garbage collection algorithm. Surprisingly, I find that programmer enhancements often have little effect on program performance. I also find that the true cost of conservative garbage collection is not the CPU overhead, but the memory system overhead of the algorithm. I conclude that conservative garbage collection is a promising alternative to explicit storage management and that the performance of conservative collection is likely to improve in the future. C programmers should now seriously consider using conservative garbage collection instead of explicitly calling free in programs they write.

Empirical measurements of six allocation-intensive C programs

Dynamic memory management is an important part of a large class of computer programs and high-performance algorithms for dynamic memory management have been, and will continue to be, of considerable interest. This paper presents empirical data from a collection of six allocation-intensive C programs. Extensive statistics about the allocation behavior of the programs measured, including the distributions of object sizes, lifetimes, and interarrival times, are presented. This data is valuable for the following reasons: first, the data from these programs can be used to design high-performance algorithms for dynamic memory management. Second, these programs can be used as a benchmark test suite for evaluating and comparing the performance of different dynamic memory management algorithms. Finally, the data presented gives readers greater insight into the storage allocation patterns of a broad range of programs. The data presented in this paper is an abbreviated version of more extensive statistics that are publically available on the internet.

A Methodology for Implementing Highly Concurrent Data Objects

A concurrent object is a data structure shared by concurrent processes. Conventional techniques for implementing concurrent objects typically rely on critical sections; ensuring that only one process at a time can operate on the object. Nevertheless, critical sections are poorly suited for asynchronous systems: if one process is halted or delayed in a critical section, other, nonfaulty processes will be unable to progress. By contrast, a concurrent object implementation is lock free if it always guarantees that some process will complete an operation in a finite number of steps, and it is wait free if it guarantees that each process will complete an operation in a finite number of steps. This paper proposes a new methodology for constructing lock-free and wait-free implementations of concurrent objects. The object's representation and operations are written as stylized sequential programs, with no explicit synchronization. Each sequential operation is atutomatically transformed into a lock-free or wait-free operation using novel synchronization and memory management algorithms. These algorithms are presented for a multiple instruction/multiple data (MIMD) architecture in which n processes communicate by applying atomic read, write, load_linked, and store_conditional operations to a shared memory.

Compiler-directed data prefetching in multiprocessors with memory hierarchies

Memory hierarchies are used by multiprocessor systems to reduce large memory access times. It is necessary to automatically manage such a hierarchy, to obtain effective memory utilization. In this paper, we discuss the various issues involved in obtaining an optimal memory management strategy for a memory hierarchy. We present an algorithm for finding the earliest point in a program that a block of data can be prefetched. This determination is based on the control and data dependencies in the program. Such a method is an integral part of more general memory management algorithms. We demonstrate our method's potential by using static analysis to estimate the performance improvement afforded by our prefetching strategy and to analyze the reference patterns in a set of Fortran benchmarks. We also study the effectiveness of prefetching in a realistic shared-memory system using an RTL-level simulator and real codes. This differs from previous studies by considering prefetching benefits in the presence of network contention.

A methodology for implementing highly concurrent data structures

A concurrent object is a data structure shared by concurrent processes. Conventional techniques for implementing concurrent objects typically rely on critical sections : ensuring that only one process at a time can operate on the object. Nevertheless, critical sections are poorly suited for asynchronous systems: if one process is halted or delayed in a critical section, other, non-faulty processes will be unable to progress. By contrast, a concurrent object implementation is non-blocking if it always guarantees that some process will complete an operation in a finite number of steps, and it is wait-free if it guarantees that each process will complete an operation in a finite number of steps. This paper proposes a new methodology for constructing non-blocking and wait-free implementations of concurrent objects. The object's representation and operations are written as stylized sequential programs, with no explicit synchronization. Each sequential operation is automatically transformed into a non-blocking or wait-free operation using novel synchronization and memory management algorithms. These algorithms are presented for a multiple instruction/multiple data (MIMD) architecture in which n processes communicate by applying read, write , and compare&amp;swap operations to a shared memory.

Concurrent algorithms for real-time memory management

The conflict between the performance demands of real-time systems and the shared-resource needs of high-level languages (Ada in particular) is examined. Shared memory requires carefully designed concurrency control, but the traditional approach, which is to embed the entire allocate-release implementation code in critical sections, is unsuitable for real-time applications because it results in excessively high response time. The design and performance of three memory-management systems for real-time applications are evaluated, and it is shown that one system, an optimized optimistic version, does deliver performance that is acceptable for real-time applications. >

Improving locality of reference in a garbage-collecting memory management system

Modern Lisp systems make heavy use of a garbage-collecting style of memory management. Generally, the locality of reference in garbage-collected systems has been very poor. In virtual memory systems, this poor locality of reference generally causes a large amount of wasted time waiting on page faults or uses excessively large amounts of main memory. An adaptive memory management algorithm, described in this article, allows substantial improvement in locality of reference. Performance measurements indicate that page-wait time typically is reduced by a factor of four with constant memory size and disk technology. Alternately, the size of memory typically can be reduced by a factor of two with constant performance.

Worst case performance of weighted buddy systems

In this paper we have studied the worst case performance of the weighted buddy system of memory management. Specifically we have derived lower bounds of two system parameters NETREQ and NETALLOC for a weighted buddy system in case of unrestricted request sequence and stated a few preliminary results for those parameters in case of allocation only request sequence. We have also given bounds for the same system parameters for exact-fit memory management algorithms to compare the results with those for buddy systems.

A page-swapping prototype for VM/HPO

This paper discusses a series of changes that were made to a system running the Virtual Machine/System Product with the High Performance Option to enhance paging. The motivation and the background for these enhancements are discussed, and the design of a series of experimental paging subsystems is described and contrasted with the old design: specifically, the new algorithms for main memory management, block paging, working set identification, trimming, prepaging, page replacement, page-out device selection, and page-out slot selection. The performance impact of these changes is illustrated by results of benchmark measurements, which are then contrasted to measurements without the enhancements. Some things learned in running the prototype are discussed and conclusions drawn.

A computer science courseware factory

A model for computer science courseware development within universities is proposed. This model asserts that masters level graduate and undergraduate students are a valuable software development resource that can be utilized to design, prototype, field test, and refine quality courseware. To support this contention four prototype courseware packages are used to briefly describe the Visible Algorithms project at Northridge. These packages provide tutorials on, and graphic animations of: linked list, binary tree, B-tree, and memory management algorithms.

WSCLOCK—a simple and effective algorithm for virtual memory management

A new virtual memory management algorithm WSCLOCK has been synthesized from the local working set (WS) algorithm, the global CLOCK algorithm, and a new load control mechanism for auxiliary memory access. The new algorithm combines the most useful feature of WS—a natural and effective load control that prevents thrashing—with the simplicity and efficiency of CLOCK. Studies are presented to show that the performance of WS and WSCLOCK are equivalent, even if the savings in overhead are ignored.