Linked Data Structures Research Articles

Java Virtual Machine support for object serialization

AbstractDistributed computing has become increasingly popular in the high‐performance community. Java's remote method invocation (RMI) provides a simple, yet powerful method for implementing parallel algorithms. The performance of RMI has been less than adequate, however, and object serialization is often identified as a major performance inhibitor. We believe that object serialization is best performed in the Java Virtual Machine (JVM), where information regarding object layout and hardware communication resources are readily available. We implement a subset of Java's object serialization protocol in native code, using the Java Native Interface (JNI) and JVM internals. Experiments show that our approach is up to eight times faster than Java's original object serialization protocol for array objects. Also, for linked data structures our approach obtains a moderate speedup and better scalability. Evaluation of our object serialization implementation in an RMI framework indicates that a higher throughput can be obtained. Parallel applications, written using RMI, obtain better speedups and scalability when this more efficient object serialization is used. Copyright © 2003 John Wiley & Sons, Ltd.

Automatic pool allocation for disjoint data structures

This paper presents an analysis technique and a novel program transformation that can enable powerful optimizations for entire linked data structures. The fully automatic transformation converts ordinary programs to use pool (aka region) allocation for heap-based data structures. The transformation relies on an efficient link-time interprocedural analysis to identify disjoint data structures in the program, to check whether these data structures are accessed in a type-safe manner, and to construct a Disjoint Data Structure Graph that describes the connectivity pattern within such structures. We present preliminary experimental results showing that the data structure analysis and pool allocation are effective for a set of pointer intensive programs in the Olden benchmark suite. To illustrate the optimizations that can be enabled by these techniques, we describe a novel pointer compression transformation and briefly discuss several other optimization possibilities for linked data structures.

Benchmark health considered harmful

In the past couple of years, a number of software and architectural techniques have been proposed for improving the performance of linked data structrues. These research ideas are often evaluated using the Olden benchmark suite [1]. Frequently, in such experients, the largest speed-up is attained for the benchmark called health . This article demonstrates that this benchmark is a micro-benchmark for enormous linked lists traversals, and not a good one at that. Given that linked lists of such size are not an efficient data structure, it is unlikely that this benchmark corresponds to any real program. Hence the benchmark should not be used. To demonstrate the inherent inefficiency in its use of linked data structures, the health program was modified algorithmically to generate the same output, while improving the execution time by over a factor of 200 on a 500Mhz Pentium II Xeon.

Instruction path coprocessors

This paper presents the concept of an Instruction Path Coprocessor (I-COP), which is a programmable on-chip coprocessor, with its own mini-instruction set, that operates on the core processor's instructions to transform them into an internal format that can be more efficiently executed. It is located off the critical path of the core processor to ensure that it does not negatively impact the core processor's cycle time or pipeline depth. An I-COP is highly versatile and can be used to implement different types of instruction transformations to enhance the IPC of the core processor. We study four potential applications of the I-COP to demonstrate the feasibility of this concept and investigate the design issues of such a coprocessor. A prototype instruction set for the I-COP is presented along with an implementation framework that facilitates achieving high I-COP performance. Initial results indicate that the I-COP is able to efficiently implement the trace cache fill unit as well as the register move, stride data prefetching and linked data structure prefetching trace optimizations.

A Visual Interface for Effortless Animation of C/C++ Programs

This paper introduces a software visualization system that (i) creates animations of programs without the programmer writing any animation code, and (ii) provides a window interface that automatically displays program information, explicitly showing the scope and context of its data, and allowing considerable control over animation displays. Programs are specified in textual form but the system creates high-level dynamic displays using bit-mapped graphics and window-interface technology. The dynamics of the displays make a program come to life. The current system was designed primarily for use in CS-I and CS-II courses. Therefore, it assumes that programs will use acyclic linked data structures and relatively small data sets. It provides the programmer no control over the animations and only limited control over the layout. However, we feel this is a reasonable trade-off for the ease of use the system provides.

Focusing in algorithm explanation

Algorithm animation attempts to explain an algorithm by visualizing interesting events of the execution of the implemented algorithm on some sample input. Algorithm explanation describes the algorithm on some adequate level of abstraction, states invariants, explains how important steps of the algorithm preserve the invariants, and abstracts from the input data up to the relevant properties. It uses a small focus onto the execution state. This paper is concerned with the explanation of algorithms on linked data structures. The thesis of the paper is that shape analysis of such algorithms produces abstract representations of such data structures, which focus on the active parts, i.e., the parts of the data structures, which the algorithm can access during it's next steps. The paper presents a concept of visually executing an algorithm on these abstract representations of data.

Linearity Analysis of Concurrent Logic Programs

Automatic memory management and the hiding of the notion of pointers are the prominent features of symbolic processing languages. They make programming easy and guarantee the safety of memory references. For the memory management of linked data structures, copying garbage collection is most widely used because of its simplicity and desirable properties. However, if certain properties about runtime storage allocation and the behavior of pointers can be obtaind by static analysis, a compiler may be able to generate object code closer to that of procedural programs. In the fields of parallel, distributed and real-time computation, it is highly desirable to be able to identify data structures in a program that can be managed without using garbage collection. To this end, this paper proposes a framework of linearity analysis for a concurrent logic language Moded Flat GHC, and proves its basic property. The purpose of linearity analysis is to distinguish between fragments of data structures that may be referenced by two or more pointers and those that cannot be referenced by two or more pointers. Data structures with only one reader are amenable to compile-time garbage collection or local reuse. The proposed framework of linearity analysis is constraint-based and involves both equality and implicational constraints. It has been implemented as part of klint v2, a static analyzer for KL1 programs.

Effective jump-pointer prefetching for linked data structures

Current techniques for prefetching linked data structures (LDS) exploit the work available in one loop iteration or recursive call to overlap pointer chasing latency. Jump pointers, which provide direct access to non-adjacent nodes, can be used for prefetching when loop and recursive procedure bodies are small and do not have sufficient work to overlap a long latency. This paper describes a framework for jump-pointer prefetching (JPP) that supports four prefetching idioms: queue, full, chain, and root jumping and three implementations: software-only, hardware-only, and a cooperative software/hardware technique. On a suite of pointer intensive programs, jump pointer prefetching reduces memory stall time by 72% for software, 83% for cooperative and 55% for hardware, producing speedups of 15%, 20% and 22% respectively.

Dependence based prefetching for linked data structures

We introduce a dynamic scheme that captures the accesspat-terns of linked data structures and can be used to predict future accesses with high accuracy. Our technique exploits the dependence relationships that exist between loads that produce addresses and loads that consume these addresses. By identzj+ing producer-consumer pairs, we construct a compact internal representation for the associated structure and its traversal. To achieve a prefetching eflect, a small prefetch engine speculatively traverses this representation ahead of the executing program. Dependence-based prefetching achieves speedups of up to 25% on a suite of pointer-intensive programs.

Dependence based prefetching for linked data structures

We introduce a dynamic scheme that captures the accesspat-terns of linked data structures and can be used to predict future accesses with high accuracy. Our technique exploits the dependence relationships that exist between loads that produce addresses and loads that consume these addresses. By identzj+ing producer-consumer pairs, we construct a compact internal representation for the associated structure and its traversal. To achieve a prefetching eflect, a small prefetch engine speculatively traverses this representation ahead of the executing program. Dependence-based prefetching achieves speedups of up to 25% on a suite of pointer-intensive programs.

Ownership types for flexible alias protection

Object-oriented programming languages allow inter-object aliasing. Although necessary to construct linked data structures and networks of interacting objects, aliasing is problematic in that an aggregate object's state can change via an alias to one of its components, without the aggregate being aware of any aliasing. Ownership types form a static type system that indicates object ownership. This provides a flexible mechanism to limit the visibility of object references and restrict access paths to objects, thus controlling a system's dynamic topology. The type system is shown to be sound, and the specific aliasing properties that a system's object graph satisfies are formulated and proven invariant for well-typed programs.

Design of a view-based DSS for location planning

This paper describes the design of a DSS for locating facility networks. The proposed DSS is based on the principle of dynamic data definitions. The declarative and procedural forms of knowledge involved are identified by a logical analysis of planning tasks. The DSS supports an iterating process of adjusting and evaluating plan options. A flexible and interactive problem solving environment is achieved by means of a user defined set of views that captures both forms of knowledge. Each view describes the system to be planned in terms of a set of variables and attached evaluation procedures. The views are dynamic and linked data structures, so that changes in one view automatically lead to updating all linked views. The DSS supports both the specification of the set of views and its application to solve a specific location problem.

Orientation-based differential geometric representations for computer vision applications

Orientation-based representations (OBR's) have many advantages. Three orientation-based differential geometric representations in computer vision literature are critically examined. The three representations are the extended Gaussian image (EGI), the support-function-based representation (SFBR), and the generalized Gaussian image (GGI). The scope of unique representation, invariant properties from matching considerations, computation and storage requirements, and relations between the three representations are analyzed. A constructive proof of the uniqueness of the SFBR for smooth surfaces is given. It is shown that an OBR using any combination of locally defined descriptors is insufficient to uniquely characterize a surface. It must contain either global descriptors or ordering information to uniquely characterize a surface. The GGI as it was originally introduced requires the recording of one principle vector. It is shown in this paper that this is unnecessary. This reduces the storage requirement of a GGI, therefore making it a more attractive representation. The key ideas of the GGI are to represent the multiple folds of a Gaussian image separately; the use of linked data structures to preserve ordering at all levels and between the folds; and the indexing of the data structures by the unit normal. It extends the EGI approach to a much wider range of applications.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Making data structures persistent

This paper is a study of persistence in data structures. Ordinary data structures are ephemeral in the sense that a change to the structure destroys the old version, leaving only the new version available for use. In contrast, a persistent structure allows access to any version, old or new, at any time. We develop simple, systematic, and efficient techniques for making linked data structures persistent. We use our techniques to devise persistent forms of binary search trees with logarithmic access, insertion, and deletion times and O(1) space bounds for insertion and deletion.

Local concurrent error detection and correction in data structures using virtual backpointers

Two linked data structures utilizing virtual backpointers, the virtual double-linked list (VDLL) and the B-tree with virtual backpointers (VBT), are described. Four experiments that provide example measurements of the capabilities (behavior under multiple error conditions) and performance (time overhead) of both local concurrent error detection and correction using sample VDLL and VBT instances are described. For these structures, double errors within a fixed-size checking window can be detected in constant time, and single errors detected during forward moves can be corrected in constant time.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Garbage collection of strings and linked data structures in real time

AbstractModern high‐level languages frequently need to collect garbage not only from regions of linked structures similar to LISP's dotted pairs, but also from string regions where data is organized as an array of characters. Some characteristics of string regions that make garbage collection particularly difficult are as follows: multiple pointers to the same characters within the array are allowed and encouraged; all possible character values are legitimate as data, so it is not possible to ‘mark’ a string by overwriting with a reserved character; and a character is generally much smaller than a pointer, so it is not possible to overwrite a single character value with a forwarding pointer to a new location for a particular string. This paper describes the addition of certain information to a string descriptor and enhancements to existing copying garbage collection algorithms that permit linked data structures and strings to be allocated and garbage collected from a shared region of memory in real time. This algorithm is real‐time in the sense that the time required for allocation of each basic unit of memory is bounded by a constant. An analysis of performance is reported, and comparisons are made with traditional garbage collection.

Numerical solution of hollow circular cylinders using finite element technique with parallel and columnly linked data structures

A procedure to obtain stiffness matrices for hollow circular cylinders is presented using finite element method. During the formation of the stiffness matrices a parallel data structure storage scheme is applied. After the completion of the stiffness matrix, Crout's method is employed to obtain the solution of a set of linear simultaneous equations. This method reduces the stiffness matrix or any other symmetric positive definite matrix to an upper triangular matrix. During the reduction procedure a columnly linked data structure is used in order to save computer storage. Finally, results are presented and compared with other methods.

Modules and type checking in PL/LL

The type system of a programming language system PL/LL is described. PL is a simple object oriented programming language and LL is a language for composing PL modules into programs. The goals of the PL/LL system are to enable the programming of efficient object-oriented computations and to provide the powerful linking language LL for facilitating the construction of large programs. The goal of the type system is to ensure efficient and secure object handling through a combination of static and dynamic type checking, and to preserve this property across module boundaries. The solution is based on (i) the module and linking concepts of LL, (ii) a language construct in PL for the safe creation of linked data structures, and (iii) a limited form of type polymorphism and type unification.

IDABES: An expert system for the preliminary stages of conceptual design of building energy systems

This paper describes the development of an expert system which carries out the preliminary stages of the concept design of energy systems for buildings. The concept design is based on the optimal search of a space, which includes all possible solutions, using heuristic knowledge about the problem. Problem knowledge is divided into five categories: domain knowledge; constraint knowledge; procedural knowledge; analysis algorithms and solution knowledge. This knowledge has been represented in an expert system, written in OPS5 and accessing FORTRAN-coded analysis and graphics routines. Domain, constraint and procedural knowledge have been implemented in a hierarchical manner using production rules and linked data structures.

Prtds — a pascal run‐time diagnostics system

AbstractA run‐time diagnostics system has been described that allows the user to interrogate a program fully in source language terms. In particular, dynamically created data structures are catered for. The diagnostics system allows all objects including those created dynamically to be interrogated and can display a graphical representation of linked data structures. This paper describes the implementation of such a system with the language Pascal on a GEC 4080.