Manipulation Of Data Structures Research Articles

X10

It is now well established that the device scaling predicted by Moore's Law is no longer a viable option for increasing the clock frequency of future uniprocessor systems at the rate that had been sustained during the last two decades. As a result, future systems are rapidly moving from uniprocessor to multiprocessor configurations, so as to use parallelism instead of frequency scaling as the foundation for increased compute capacity. The dominant emerging multiprocessor structure for the future is a Non-Uniform Cluster Computing (NUCC) system with nodes that are built out of multi-core SMP chips with non-uniform memory hierarchies, and interconnected in horizontally scalable cluster configurations such as blade servers. Unlike previous generations of hardware evolution, this shift will have a major impact on existing software. Current OO language facilities for concurrent and distributed programming are inadequate for addressing the needs of NUCC systems because they do not support the notions of non-uniform data access within a node, or of tight coupling of distributed nodes.We have designed a modern object-oriented programming language, X10, for high performance, high productivity programming of NUCC systems. A member of the partitioned global address space family of languages, X10 highlights the explicit reification of locality in the form of places }; lightweight activities embodied in async , future , foreach , and ateach constructs; a construct for termination detection ( finish ); the use of lock-free synchronization ( atomic blocks ); and the manipulation of cluster-wide global data structures. We present an overview of the X10 programming model and language, experience with our reference implementation, and results from some initial productivity comparisons between the X10 and Java™ languages.

Decision Procedures for Set-Valued Fields

A central feature of current object-oriented languages is the ability to dynamically instantiate user-defined container data structures such as lists, trees, and hash tables. Implementations of these data structures typically use references to dynamically allocated objects, which complicates reasoning about the resulting program. Reasoning is simplified if data structure operations are specified in terms of abstract sets of objects associated with each data structure. For example, an insertion into a data structure in this approach becomes simply an insertion into a dynamically changing set-valued field of an object, as opposed to a manipulation of a dynamically linked structure attached to the object.In this paper we explore reasoning techniques for programs that manipulate data structures specified using set-valued abstract fields associated with container objects. We compare the expressive power and the complexity of specification languages based on 1) decidable prefix vocabulary classes of first-order logic, 2) two-variable logic with counting, and 3) Nelson-Oppen combinations of multisorted theories. Such specification logics can be used for verification of object-oriented programs with supplied invariants. Moreover, by selecting an appropriate subset of properties expressible in such logic, the decision procedures for these logics enable automated computation of lattice operations in an abstract interpretation domain, as well as automated computation of abstract program semantics.

Thresholding technique with adaptive window selection for uneven lighting image

By adaptively selecting image window size based on the pyramid data structure manipulation of Lorentz information measure, a new technique for image thresholding is proposed. The advantage of this technique is its effectiveness in eliminating both uneven lighting disturbance and ghost objects. When applied to Otsu’s thresholding approach, it can provide accurate result under uneven lighting disturbance while using Otsu’s method alone cannot. Experimental results show the effectiveness of this method.

Verifying Programs that Manipulate Pointers: (Invited Talk)

This talk gives an overview of various approaches for verifying the correctness of programs that manipulate data structures using pointers.

Parallel elementwise processable functions in concurrent clean

The behaviour of concurrent and parallel programs can be specified in a functional style. Functional programming style has some inherent concurrent features. However, for a higher degree of expressing parallelism there is a need for new language constructs. In this paper, we introduce Concurrent Clean modules for evaluation strategies in order to control the evaluation degree, the dynamic behaviour, and the parallelism. The usage of the strategies will be illustrated by the parallel elementwise processing method. The implementation of the method in the lazy functional programming language Concurrent Clean operates with a two arguments two values elementwise processable function. In order to obtain abstract type specification for the generalised manipulation of the linear data structures like lists, arrays, and strict arrays, a linear data structure class module is defined. The programming style is skeleton based. Skeletons in functional languages are higher-order functions. The skeleton given in this paper represents a generalisation of the map function. It is triply parameterized: by an elementwise processable function, by type specification, and by the strategy parameter that defines the dynamic behaviour of the program.

Language-independent interactive data visualization

We introduce the Language-Independent Visualization Environment (LIVE) as a system for the visualization and manipulation of data structures and the computer programs that create and operate on them.LIVE interprets arbitrary programs containing arbitrary data structure definitions, showing diagrammatically the data that the process generates.It is language-independent in that a single program can be visualized in the syntax of multiple languages. LIVE is interactive in that not only does it show the effects of statements immediately as they occur at runtime, but it also generates new program source code automatically when the user manipulates the data on the screen. We anticipate that this tool will be most useful in a pedagogical setting such as a CS2 or data structures course, particularly with the introduction of pointers and linked structures.

A strategy for managing content complexity in algorithm animation

Computer animation is an excellent medium for capturing the dynamic nature of data structure manipulations, and can be used to advantage in the teaching of algorithms and data structures. A major educational issue is the necessity of providing a means for the student to manage the complexity of the material. We have addressed this issue in a multimedia teaching tool called "Algorithms in Action" by allowing students to view an algorithm at varying levels of detail. Starting with a high level pseudocode description of the algorithm, with accompanying high level animation and textual explanation, students can expand sections of the pseudocode to expose more detail. Animation and explanation are controlled in a coordinated fashion, becoming correspondingly more detailed as the pseudocode is expanded. The tool also supports dofferem , pdes. corresponding to different stages in the learning process. Student feedback suggests that the availability of multiple levels detail and the facility for the user to control the level of detail being viewed is an effective way to manage content complexity.

Points-to analysis for program understanding

Program understanding activities are more difficult for programs written in languages (such as C) that heavily make use of pointers for data structure manipulation, because the programmer needs to build a mental model of the memory use and of the pointers to its locations. Pointers also pose additional problems to the tools supporting program understanding, since they introduce additional dependences that have to be accounted for. This paper extends the flow insensitive context insensitive points-to analysis (PTA) algorithm proposed by Steensgaard, to cover arbitrary combinations of pointer dereferences, array subscripts and field selections. It exhibits interesting properties, among which scalability resulting from the low complexity and good performances is one. The results of the analysis are valuable by themselves, as their graphical display represents the points-to links between locations. They are also integrated with other program understanding techniques like, e.g., call graph construction, slicing, plan recognition and architectural recovery. The use of this algorithm in the framework of the program understanding environment CANTO is discussed.

Branching-time logic programming: the language Cactus and its applications

Temporal programming languages provide a powerful means for the description and implementation of dynamic systems. However, most temporal languages are based on linear time, a fact that renders them unsuitable for certain types of applications (such as expressing properties of non-deterministic programs). In this paper we introduce the new temporal logic programming language Cactus, which is based on a branching notion of time. In Cactus, the truth value of a predicate depends on a hidden time parameter which varies over a tree-like structure. As a result, Cactus can be used to express in a natural way non-deterministic computations or generally algorithms that involve the manipulation of tree data structures. Moreover, Cactus appears to be appropriate as the target language for compilers or program transformers. Cactus programs can be executed using BSLD-resolution, a proof procedure based on the notion of canonical temporal atoms/clauses.

Process fuzzy data for triggers and constraints in active object oriented databases

The object-oriented database management system has great promise as a future database technology because of its superior complex data structure manipulation, rich class structure, integration potential, and data reusability. An active database is another evolving technology which can generate new knowledge, execute commands, and maintain system integrity by means of triggers, constraints, and inference rules. Adding constraints and triggers into an object-oriented database creates an active object-oriented database which performs dynamic behaviors. However, both triggers and constraints may process data that arc qualitative, inexact, or uncertain. In this case, a fuzzy logic system may be utilized to improve performance by replacing fuzzy if-then rules as triggers or constraints. This study proposes adding a fuzzy class to the class library to solve fuzzy information problems.

Integrated Microscopy : From Design Philosophy to Applications

Microscopy and ObjectsObject oriented programming (OOP) has been used to develop computer applications for many years. It has proven very efficient for the manipulation of data structures that share common elements and evolve over time. We observed that this approach might prove invaluable for microscopy where we, as researchers, developers and end-users, have to deal with many media (images, spectra, electrical measurements, databases, simulations, etc.) to accomplish a given characterization project. Particularly, since these media evolve as researchers find new techniques and manufacturers improve their instruments. In addition, the goals and aims of a project may also change with time. The ability to reuse information that has already been acquired/generated then becomes crucial to success since this avoids the cost of repeating an analysis when information that was considered unimportant suddenly becomes of interest. In this context all results, acquisition parameters, instrument and processing tool settings, are relevant. The need for modularity, completeness and adaptation of information guided our design for the information structure used to develop the integrated characterization system. It is based on 3 types of small data objects. The first type carries the properties of each physical object (microscope, EDX spectrometer, specimen stage, sample, etc.). The second type carries acquired data such as images, spectra, etc. Finally, the last type of small data object carries the processed results such as hardness, composition, features sizes, distribution, etc. A characterization project can then be represented like any compound document as shown in figure 1. This architecture can be used inside applications as well as with storage devices (where objects are saved in compound files). Those objects can also contain hierarchy information such as the relationship between objects (i.e. “is subset of, , “is generator of, or “is defined by”).

LOGIC BASED PROGRAMMED STRUCTURE REWRITING SYSTEMS

This paper presents a new logic based framework for the formal treatment of graph rewriting systems as special cases of programmed rewriting systems for arbitrary relational structures. Considering its expressive power, the new formalism surpasses almost all variants of nonparallel algebraic as well as algorithmic graph grammar approaches by offering set-oriented pattern matching facilities as well as nonmonotonic reasoning capabilities for checking pre- and postconditions of rewrite rules. Furthermore, the formalism closes the gap between the operation-oriented manipulation of data structures by means of rewrite rules and the declaration-oriented description of data structures by means of logic based languages. Finally, the formalism even offers recursively defined (sub-)programs, by means of which the application of rewrite rules may be regulated. A denotational semantics definition for these (sub-)programs relies on a special variant of fixpoint theory for noncontinuous but monotonic functions.

Testing Language Containment for ω-Automata Using BDDs

ω-automata provide a well-established basis for the specification and verification of control-intensive systems. To verify that a system satisfies a given property ("task"), one specifies both the system and the task in terms of ω-automata, and then verifies that the ω-regular language of the system automaton is contained in that of the task automaton. This procedure, which is the basis of the COSPAN verification software, has been used in a number of commercial applications. However, its applicability is limited by the computational complexity of the ensuing language containment check, which tends to grow exponentially with the number of components in the system. While reduction techniques such as task decomposition and task-relative homomorphic reduction can greatly extend the complexity of systems which thus may be analyzed, there is a computational cost associated with such reductions as well. Moreover, the system complexity is the ultimate limiting factor. Recent advances in the manipulation of data-structures for binary decision diagrams (BDDs) have suggested that this data-structure may now facilitate checking language containment for far larger system models than has been hitherto possible. We have confirmed this by implementing new BDD-based language containment checks in COSPAN. We exhibit two such algorithms: one with a time advantage and the other with a space advantage. Each has increased significantly the size of system models which can be verified.

An associative architecture for genetic algorithm-based machine learning

Machine-based learning will eventually be applied to solve real-world problems. In this work, an associative architecture teams up with hybrid AI algorithms to solve a letter prediction problem with promising results. This article describes an investigation and simulation of a massively parallel learning classifier system (LCS) that was developed from a specialized associative architecture joined with hybrid AI algorithms. The LCS algorithms were specifically invented to computationally match a massively parallel computer architecture, which was a special-purpose design to support the inferencing and learning components of the LCS. The LCS's computationally intensive functions include rule matching, parent selection, replacement selection and, to a lesser degree, data structure manipulation. >

An experimental active memory based I/O subsystem

We describe an I/O subsystem based on an active memory called SWIM, designed for efficient storage and manipulation of data structures. The key architectural idea in SWIM is to put some processing logic inside each memory chip that allows it to perform data manipulation operations locally and to communicate with a disk or a communication line through a backend port. The processing logic is specially designed to perform operations such as pointer dereferencing, memory indirection, searching and bounds checking efficiently. The I/O subsystem is built using an interconnected ensemble of such memory logic pairs. This allows a complex I/O task to be distributed between a large number of small memory processors each doing a sub-task, while still retaining a common locus of control for higher level functions. This enables more powerful, scalable and robust designs for storage and communications subsystems that can support emerging network services, multimedia workstations and wireless PCS systems. A complete parallel hardware and software system constructed using an array of SWIM elements has been operational for over a year. We present the application of SWIM to three network functions that we have currently implemented: a national phone database server, a high performance IP router, and a call screening agent.

Integrating pointer variables into one-way constraint models

Pointer variables have long been considered useful for constructing and manipulating data structures in traditional programming languages. This article discusses how pointer variables can be integrated into one-way constraint models and indicates how these constraints can be usefully employed in user interfaces. Pointer variables allow constraints to model a wide array of dynamic application behavior, simplify the implementation of structured objects and demonstrational systems, and improve the storage and efficiency of constraint-based applications. This article presents two incremental algorithms—one lazy and one eager— for solving constraints with pointer variables. Both algorithms are capable of handling (1) arbitrary systems of one-way constraints, including constraints that involve cycles, and (2) editing models that allow multiple changes between calls to the constraint solver. These algorithms are fault tolerant in that they can handle and recover gracefully from formulas that crash due to programmer error. Constraints that use pointer variables have been implemented in a comprehensive user interface toolkit, Garnet, and our experience with applications written in Garnet have proven the usefulness of pointer variable constraints. Many large-scale applications have been implemented using these constraints.

The importance of non-data touching processing overheads in TCP/IP

We present detailed measurements of various processing overheads of the TCP/IP and UDP/IP protocol stacks on a DECstation 5000/200 running the Ultrix 4.2a operating system. These overheads include data-touching operations, such as the checksum computation and data movement, which are well known to be major time consumers. In this study, we also considered overheads due to non-data touching operations, such as network buffer manipulation, protocol-specific processing, operating system functions, data structure manipulations (other than network buffers), and error checking. We show that when one considers realistic message size distributions, where the majority of messages are small, the cumulative time consumed by the non-data touching overheads represents the majority of processing time. We assert that it will be difficult to significantly reduce the cumulative processing time due to non-data touching overheads.

Experimenting with HyTime architectural forms for hypertext interchange

Microcosm [3,4] is an open hypermedia system developed over the past four years at the University of Southampton. A fundamental feature of Microcosm is that no information concerning links is held in documents; instead all link information is held in external linkbases which contain the required details about the source and destination anchors of the links. This feature is particularly important as it enables third party applications to act as document viewers since it is not necessary to adapt the application to manipulate data structures that include link anchor information. Another feature of Microcosm is that it is composed of independent components (document viewers and link managers) which communicate by passing messages

An organization of sparse gauss elimination for solving partial differntial equations on distributed memory machines

AbstractA computational arrangement of Gauss elimination is presented for solving sparse, nonsymmetric linear systems arising from partial differential equation problems. It is particularly targeted for use on distributed memory message passing multiprocessor computers and it is presented and analyzed in this context. The objective of the algorithm is to exploit the sparsity (i.e., reducing computation, communication, and memory requirements) and to optimize the data structure manipulation overhead. The algorithm is based on the nested dissection approach, which starts with a large set of very sparse, completely independent subsystems and progresses in stages to a single, nearly dense system at the last stage. The computational efforts of each stage are roughly equal (almost exactly equal for model problems), yet the data structures appropriate for the first and last stages are quite different. Thus we use different types of data structures and algorithm components at different stages of the solution. The new organization is a combination of previous techniques including nested dissection, implicit block factorization, domain decomposition, fan‐in, fan‐out, up‐looking, down‐looking, and dynamic data structures. © 1993 John Wiley & Sons, Inc.

Hypermatrix Algebra: Theory

Algebraic manipulation of two-dimensional data structures—typical in image processing—requires operations more powerful than those afforded by classical matrix algebra. To this end, hypermatrix algebra provides a compact treatment of multidimensional objects and associated operations. Initially presented as array algebra, it uses a notation derived from tensor analysis. By extending matrix algebra with Kronecker products and matrix representations of shuffle permutations, a duality between the two algebras is shown. This serves as a means of transferring into the domain that is most convenient for a particular type of operation or representation. Hypermatrix algebra can be a powerful design tool for multidimensional massively parallel computing structures. A mathematical foundation for such an algebra is presented in this paper as a supplement to separate application notes.