Standard Implementation Techniques Research Articles

Genetic Algorithm Based Design of Combinational Logic Circuits Using Universal Logic Modules

A new approach for the evolutionary design of combinational logic circuits using Genetic Algorithm and 2-1 multiplexers is presented. Binary multiplexer is the only design unit used. Repeated use of the same element reduces the manufacturing cost which is of prime importance in VLSI design. Any Boolean function can be realized using 2-1 multiplexers with this method. The performance of the circuits evolved was compared with standard implementation technique. Power, area, and delay involved were analyzed using Synopsys design compiler. With the proposed technique, the number of modules needed is reduced significantly, thereby reducing the power, area, cost and delay.

Numerical simulation of mode-III fracture incorporating interfacial mechanics

Continuum surface methods, including the Sendova–Walton theory, offer a novel approach to fracture modeling in which boundary mechanics are used to augment the classical linear elastic fracture mechanics model for improved prediction of material behavior near fracture surfaces. These methods would be extremely useful in design simulations, but would require numerical implementation which to date has not been available. This has not been previously addressed due to the higher-order tangential derivatives appearing in the fracture surface boundary conditions which make standard implementation techniques, such as the finite element method, a challenge to implement. We propose a method for this implementation which involves reformulating the fracture boundary conditions to remove these higher-order derivatives in the case of mode-III fracture. We also present the initial results of our finite element implementation, which verify the improved stress and displacement field predictions near fracture surfaces.

A simple typed intermediate language for object-oriented languages

Traditional class and object encodings are difficult to use in practical type-preserving compilers because of the complexity of the encodings. We propose a simple typed intermediate language for compiling object-oriented languages and prove its soundness. The key ideas are to preserve lightweight notions of classes and objects instead of compiling them away and to separate name-based subclassing from structure-based subtyping. The language can express standard implementation techniques for both dynamic dispatch and runtime type tests. It has decidable type checking even with subtyping between quantified types with different bounds. Because of its simplicity, the language is a more suitable starting point for a practical type-preserving compiler than traditional encoding techniques.

Garbage collection for a client-server persistent object store

We describe an efficient server-based algorithm for garbage collecting persistent object stores in a client-server environmnet. The algorithm is incremental and runs concurrently with client transactions. Unlike previous algorithms, it does not hold any transactional locks on data and does non require callbacks to clients. It is fault-tolerant, but performs very little logging. The algorithm has been designed to be integrated into existing systems, and therefore it works with standard implementation techniques such as Two-Phase Locking and Write-Ahead-Logging. In addition, it supports client-server performance optimizations such as client caching and flexible management of client buffers. We describe an implementation of the algorithm in the EXODUS storage manager and present the results of a performance study of the implementation.

Compile-time memory reuse in logic programming languages through update in place

Standard implementation techniques for single-assignment languages modify a data structure without destroying the original, which may subsequently be accessed. Instead a variant structure is created by using newly allocated cells to represent the changed portion and to replace any cell that references a newly allocated cell. The rest of the original structure is shared by the variant. The effort required to leave the original uncorrupted is unnecessary when the program will never reference the original again. This effort includes allocating and initializing new cells, as well as garbage collecting replaced cells. This article specifies a transformation system that introduces update-in-place operations, making Prolog programs update recursive data structures much as an imperative program would. The article introduces the notion of a reuse map, which formalizes reallocation decisions. Because optimal memory reuse is intractable, a heuristical method is presented that performs well in practice. Small Prolog programs that manipulate recursive data structures have their speed increased up to about five times (naive recurse), not counting any speedup obtained by avoiding garbage collection. Quicksort is about three times as fast, merge-sort about one and a half, matrix transposition about twice, and Gaussian elimination is about 1.2 times as fast.