ppxscal/embedding_network huggingface dataset:
A chaotic asynchronous algorithm for computing the fixed point of a nonnegative matrix of unit spectral radius
Authors: Boris Lubachevsky, Debasis Mitra
Venue: Journal of the ACM (JACM) (1986)

Given a nonnegative, irreducible matrix P of spectral radius unity, there exists a positive vector &pgr; such that &pgr; = &pgr;P. If P also happens to be stochastic, then &pgr; gives the stationary distribution of the Markov chain that has state-transition probabilities given by the elements of P. This paper gives an algorithm for computing &pgr; that is particularly well suited for parallel processing. The main attraction of our algorithm is that the timing and sequencing restrictions on individual processors are almost entirely eliminated and, consequently, the necessary coordination between processors is negligible and the enforced idle time is also negligible. Under certain mild and easily satisfied restrictions on P and on the implementation of the algorithm, x(.), the vectors of computed values are proved to converge to within a positive, finite constant of proportionality of &pgr;. It is also proved that a natural measure of the projective distance of x(.) from &pgr; vanishes geometrically fast, and at a rate for which a lower bound is given. We have conducted extensive experiments on random matrices P, and the results show that the improvement over the parallel implementation of the synchronous version of the algorithm is substantial, sometimes exceeding the synchronization penalty to which the latter is always subject.
PS-Algol's device-independent output statement
Authors: P. C. Philbrow, I. Armour, M. P. Atkinson, J. Livingstone
Venue: ACM SIGPLAN Notices (1988)

We describe a language-level approach to device-independent output. The paper moves from an abstract discussion through to the provision of destinations for PS-algol's print statement. Some feedback from programmers is presented, and conclusions drawn.
The dependability problem: Introduction and verification of fault tolerance for a very complex system
Authors: A. Avižienis
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

The Advanced Automation System must meet availability requirements that pose new and severe challenges to designers and analysts of fault-tolerant systems. The problems of introducing sufficient fault tolerance and verifying its effectiveness are discussed in the context of AAS requirements.
Performance through memory
Authors: Hector Garcia-Molina, Lawrence R. Rogers
Venue: Proceedings of the 1987 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1987)

Two of the most important parameters of a computer are its processor speed and physical memory size. We study the relationship between these two parameters by experimentally evaluating the intrinsic memory and processor requirements of various applications. We also explore how hardware prices are changing the cost effectiveness of these two resources. Our results indicate that several important applications are &ldquo;memory-bound,&rdquo; i.e., can benefit more from increased memory than from a faster processor.
Advanced compiler optimizations for supercomputers
Authors: David A. Padua, Michael J. Wolfe
Venue: Communications of the ACM (1986)

Compilers for vector or multiprocessor computers must have certain optimization features to successfully generate parallel code.
Design and realization of MLM: a multilingual machine
Authors: F. M G Franca, N. Q. Vasconcelos, E. S T Fernandes
Venue: ACM SIGMICRO Newsletter (1986)

This paper describes the design and realization of MLM, a Multi-Lingual machine whose main goal is to provide support for teaching and research in Microprogramming and Computer Architecture. MLM is based on a standard (non-microprogrammable) minicomputer whose microarchitecture has been modified in order to satisfy the requirements of a multi-lingual environment. The resulting machine is microprogrammable, offers facilities for interpreting different target repertoires, and has means to switch from one instruction set to another. MLM implements the concept of dynamic microprogramming, and in its current version there are two control stores defining two conventional levels at any time: the first is the conventional level fixed by the host manufacturer (in PROM); the second may be specified by the user. In addition to the design and implementation issues, the paper also outlines the research potential of MLM and describes the current stage of the work.
An efficient retargetable microcode generator
Authors: M. Balakrishnan, P. C P Bhatt, B. B. Madan
Venue: Proceedings of the 19th annual workshop on Microprogramming (1986)

This paper presents a microcode generator, which accepts a source program (algorithm) and a target description (microarchitecture) as input and generates microcode to implement the algorithm on the defined microarchitecture. The target description is similar to the outputs produced by datapath synthesis phase in hardware design packages. Thus, it can be incorporated to synthesise a microprogrammed control. The microcode generator is based on an algorithm which preserves retargetability without sacrificing on design time. This is achieved by implementing the generator in two phases: in the first phase, a set of 'feasible' register transfer operations (called base-set) is generated from the microarchitecture description. In the second phase, translation is carried out by simply searching and matching the source program statements with the base-set.
Adaptive record clustering
Authors: C. T. Yu, Cheing-mei Suen, K. Lam, M. K. Siu
Venue: ACM Transactions on Database Systems (TODS) (1985)

An algorithm for record clustering is presented. It is capable of detecting sudden changes in users' access patterns and then suggesting an appropriate assignment of records to blocks. It is conceptually simple, highly intuitive, does not need to classify queries into types, and avoids collecting individual query statistics. Experimental results indicate that it converges rapidly; its performance is about 50 percent better than that of the total sort method, and about 100 percent better than that of randomly assigning records to blocks.
A Test Design Methodology for Protocol Testing
Authors: B. Sarikaya, G. v. Bochmann, E. Cerny
Venue: IEEE Transactions on Software Engineering (1987)

Communication protocol testing can be done with a test architecture consisting of remote Lower Tester and local Upper Tester processes. For real protocols, tests can be designed based on the formal specification of the protocol which uses an extended finite state machine model. The specification is transformed into a simpler form consisting of normal form transitions. It can then be modeled by a control and a data flow graph. The graphs are decomposed into subtours and data flow functions, respectively. Tests are designed by considering parameter variations of the input primitives of each data flow function and determining the expected outputs. The methodology gives complete test coverage of all data flow functions and control paths in the specification. Functional fault models are proposed for functions that are not formally specified.
A Reconfiguration Scheme for Yield Enhancement of Large Area Binary Tree Architectures
Authors: Michael C. Howells, Vinod K. Agarwal
Venue: IEEE Transactions on Computers (1988)

A reconfiguration scheme is presented that is suitable for both yield and reliability enhancement of large-area VLSI implementations of binary tree architectures. The approach proposed makes use of partially global redundancy to allow clustered effects to be tolerated. The binary tree is cut a few levels above the leaves to form an upper subtree and many lower subtrees, with spare processors being grouped adjacent to the root of each lower subtree. Redundant links with programmable switches are used to permit reconfiguration. The cost of the scheme, in terms of redundant hardware, is comparable to that of other schemes. An O(N) H-tree layout is used. In comparison to existing schemes, the proposed scheme gives much better yield and better reliability.
Discrete discriminant models: a performance simulation with reference to expert systems' applications
Authors: Ben Pinkowski
Venue: Proceedings of the 20th annual symposium on Simulation (1987)

Monte Carlo simulation experiments are used to assess performance of seven models for discrete discriminant analysis. Discriminant rules are obtained for binary observation vectors from training samples drawn from two-group populations. Performance is evaluated primarily in terms of the error rate observed in the training and test samples for populations characterized by small and unequal training sample sizes, log-likelihood reversals, various correlation structures, and missing values. Some models are superior for certain population structures, and an attempt is made to identify data set characteristics that favor a particular model. Applications of the models are discussed, including their use as components in expert systems, and an expert system for consulting on discriminant analysis problems is reviewed.
Kardamom&mdash;a dataflow database machine for real-time applications
Authors: Gunter von Bultzingsloewen, Klaus R. Dittrich
Venue: ACM SIGMOD Record (1988)

In real-time applications, database systems have to cope with requirements different from those prevailing in a commercial environment. High performance in the presence of complex queries and high reliability are the most crucial issues. To comply with these, it seems promising to adopt techniques which have been proposed in the context of database machines, such as parallel query processing, filtering, and data flow control. In this paper we present the concepts and the design of the data flow database machine KARDAMOM which is mainly geared towards real-time applications and is currently being developed at FZI Karlsruhe.
Highly concurrent scalar processing
Authors: P. Y T Hsu, E. S. Davidson
Venue: Proceedings of the 13th annual international symposium on Computer architecture (1986)

High speed scalar processing is an essential characteristic of high performance general purpose computer systems. Highly concurrent execution of scalar code is difficult due to data dependencies and conditional branches. This paper proposes an architectural concept called guarded instructions to reduce the penalty of conditional branches in deeply pipelined processors. A code generation heuristic, the decision tree scheduling technique, reorders instructions in a complex of basic blocks so as to make efficient use of guarded instructions. Performance evaluation of several benchmarks are presented, including a module from the UNIX kernel. Even with these difficult scalar code examples, a speedup of two is achievable by using conventional pipelined uniprocessors augmented by guard instructions, and a speedup of three or more can be achieved using processors with parallel instruction pipelines.
Typesetting APL using TROFF
Authors: Leroy J. Dickey
Venue: Proceedings of the international conference on APL: APL in transition (1987)

In this paper it is explained how we developed an APL preprocessor to work with TROFF and a laser printer for typesetting APL text along with equations, tables, and ordinary text. In doing this work, we addressed these problems: (1) the representation of APL material, (2) the development of a language to control the APL font, and (3) the design of a pre-processor.
On the teaching of Ada in an undergraduate computer science curriculum
Authors: Wing C. Tam, Michael A. Erlinger
Venue: ACM SIGCSE Bulletin (1987)

Traditionally beginning undergraduate computer science students are taught a high level programming language. Since the early 1970's Pascal has become the de facto standard introductory programming language. With the creation of Ada, its standardization, and the availability of validated compilers, there is considerable discussion concerning the introduction of Ada into the computer science curriculum. This paper discusses the approach taken by the Computer Science Department at Harvey Mudd College.
A practical arbitrary look-ahead LR parsing technique
Authors: Manuel E. Bermudez, Karl M. Schimpf
Venue: ACM SIGPLAN Notices (1986)

We present a practical technique that provides an LR (0) parser with either fixed or arbitrary look-ahead. The construction algorithm is based on certain paths in the LR (0) state diagram, which must be restricted to a maximum length m. The technique determines the amount of look-ahead required, and the user is spared the task of guessing it. Instead, the user provides m. In situations where single symbol look-ahead is sufficient, the corresponding grammar class (called LAR (m )) is identical to the NQLALR (1) class. For practical grammars that require arbitrary look-ahead, the storage requirements typically do not exceed an amount linear in the size of the corresponding LR (0) parser. The technique is shown to work for a practical programming language grammar, and has been used to solve particular cases of the PL/1 keyword problem.
Strictness analysis and denotational abstract interpretation
Authors: F. Nielson
Venue: Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages (1987)

A theory of abstract interpretation [CoCo79] is developed for a typed &lgr;-calculus. The typed &lgr;-calculus is the &ldquo;static&rdquo; part of a two-level denotational metalanguage for which abstract interpretation was developed in [Nie86]. The present development relaxes a condition imposed in [Nie86] and this suffices to make the framework applicable to strictness analysis for the &lgr;-calculus. This shows the possibility of a general theory (and hence a system) for the analysis of functional programs. Furthermore, it gives more insight into the relative precision of the various analyses. In particular, it is shown that a collecting (static [CoCo79]) semantics exists, thus answering a problem left open in [BHA86].
Charcoal sketching: returning control to the artist
Authors: Teresa W. Bleser, John L. Sibert, J. Patrick McGee
Venue: ACM Transactions on Graphics (TOG) (1988)

Background: Traditional paint programs can be criticized on the grounds that they provide fewer degrees of freedom than conventional artistic media. Mouse or tablet input devices usually provide only (x, y) spatial information. Thus most paint programs allow continuous control of the path of a stroke, but render it with a single &ldquo;brush shape&rdquo; of fixed size and orientation and use menus, either stationary or appearing, for such tasks as changing &ldquo;brush&rdquo; shapes. This produces two distinct discontinuities for the artist. First is a physical discontinuity: stopping the act of drawing and making a brush selection using a different physical device, or using the same device to point at a menu selection. A second discontinuity is the cognitive one involved with deciphering the menu contents and making a selection. Although the second may be minimized by using iconic menus, these interruptions of the drawing act make it difficult or impossible for the artist to maintain the kind of continuous control over his or her medium that is required. A particular example of this level of control is the continuous and immediate control that an artist maintains when sketching with a piece of charcoal or a pencil. By manipulating the implement, the artist can change the shape of its contact point with the drawing surface. By changes in pressure exerted with the implement against the surface, it is possible to control both the darkness (value) and width (weight) of the line. All of these factors are controlled by the artist in real time and with continuous feedback. Both Greene [2] and Strassman [4] have presented methods for capturing more of the artist's &ldquo;gesture&rdquo; in the rendered stroke. However, Greene's technique depends on a special-purpose input device and Strassman's does not work in real time. Hill [3] describes a two-handed paintbrush with the off hand controlling a valuator that varies the 'brush width. The technique described here represents another way to provide such control to the user of an interactive paint program. It uses off-the-shelf hardware, is easy to implement, and works in real time. As a single-handed technique, it takes advantage of the artist's skill with existing media.
Using Gaussian elimination for computation of the central difference equation coefficients
Authors: Sandra J Cynar
Venue: ACM SIGNUM Newsletter (1987)

The Gaussian elimination method has been widely used for solutions of sets of linear equations for a very long time. This paper describes another use for the Gaussian elimination techniques. An algorithm will be developed for computing the coefficients for the central difference expressions approximating the first or second derivative of any order error by expressing the problem in matrix notation and applying Gaussian techniques for the solution.
A review of recent developments in solving ODEs
Authors: Gopal K. Gupta, Ron Sacks-Davis, Peter E. Tescher
Venue: ACM Computing Surveys (CSUR) (1985)

Mathematical models when simulating the behavior of physical, chemical, and biological systems often include one or more ordinary differential equations (ODEs). To study the system behavior predicted by a model, these equations are usually solved numerically. Although many of the current methods for solving ODEs were developed around the turn of the century, the past 15 years or so has been a period of intensive research. The emphasis of this survey is on the methods and techniques used in software for solving ODEs. ODEs can be classified as stiff or nonstiff, and may be stiff for some parts of an interval and nonstiff for others. We discuss stiff equations, why they are difficult to solve, and methods and software for solving both nonstiff and stiff equations. We conclude this review by looking at techniques for dealing with special problems that may arise in some ODEs, for example, discontinuities. Although important theoretical developments have also taken place, we report only those developments which have directly affected the software and provide a review of this research. We present the basic concepts involved but assume that the reader has some background in numerical computing, such as a first course in numerical methods.
On approximation behavior and implementation of the greedy triangulation for convex planar point sets
Authors: A Lingas
Venue: Proceedings of the second annual symposium on Computational geometry (1986)

Manacher and Zorbrist conjectured that the greedy triangulation heuristic for minimum weight triangulation of n-point planar point sets yields solutions within an &Ogr;(n&egr;), &egr; < 1, factor of the optimum. We prove the conjecture in the case when the point set is convex by finding basic, geometric and combinatoric properties of greedy triangulations in the convex case. Our result contrasts with Kirkpatrick's &OHgr;(n) bound on the approximation factor of the Delauney triangulation heuristic which holds for convex, planar n-point sets. To support the conjecture of Manacher and Zorbrist, we also show that the greedy triangulation heuristic for minimum weight triangulation of a (non-necessarily convex) polygon yields solutions at most h times longer than the optimum where h is the diameter of the tree dual to the produced greedy triangulation of the polygon. On the other hand, we present an implementation of the greedy triangulation heuristic for an n-vertex convex point set or a convex polygon taking &Ogr;(n2) time and &Ogr;(n) space which improves Gilbert's &Ogr;(n2logn)-time and &Ogr;(n2)-space bound in this case. To derive the latter result, we show that given a convex polygon P, one can find for all vertices v of P a shortest diagonal of P incident to v in linear time.
Test Schedules for VLSI Circuits Having Built-In Test Hardware
Authors: M. S. Abadir, M. A. Breuer
Venue: IEEE Transactions on Computers (1986)

In this correspondence, the concept of a test schema which describes how a test methodology is to execute is introduced. We also introduce the powerful concept of an I path which is used to transfer data unchanged from one place in a circuit to another. The process of embedding a test schema into an actual circuit is described. This produces a test plan for the circuit which specifies the sequence of actions that need to be carried out to execute the test. A theory of test plan execution overlap is presented, and is used as the basis for constructing test schedules with optimal execution times.
Modular Concurrency Control and Failure Recovery
Authors: Lui Sha, John Lehoczky, E. Douglas Jensen
Venue: IEEE Transactions on Computers (1988)

An approach to concurrency control is presented; it is based on the decomposition of both the database and the individual transactions. This approach is a generalization of serializability theory in that the set of permissible transaction schedules contains all the serializable schedules. In addition to providing a higher degree of concurrency than that provided by serializability theory, this approach retains three important properties associated with serializability: the consistency of the database is preserved, the individual transactions are executed correctly, and the concurrency control approach is modular. The authors formalize the last concept. The associated failure recovery procedure is presented, as is the concept of failure safety (i.e. failure tolerance).
The pioneer days of scientific computing in Switzerland
Authors: M. Gutknecht
Venue: Proceedings of the ACM conference on History of scientific and numeric computation (1987)

Scientific computing was established in Switzerland by E. Stiefel, assisted by H. Rutishauser, A.P. Speiser, and others. We cover the years from the foundation of the Institute for Applied Mathematics at the ETH in 1948 to the completion of the ERMETH, the electronic computer built in this institute, in 1956/57. In this period, Stiefel's team also solved a large number of real-world computational problems on another computer, Zuse's Z4, rented by the institute. Along with this work went major contributions to numerical analysis by Rutishauser and Stiefel, and Rutishauser's seminal work on compiling programs, which was later followed by his strong commitment in ALGOL. We have tried to include some background information and to complement H.R. Schwarz's article [Scw81] on the same subject.
Semantics of EqL
Authors: Bharat Jayaraman
Venue: IEEE Transactions on Software Engineering (1988)

We present the formal semantics of a novel language, called EqL, for first-order functional and Horn logic programming. An EqL program is a set of conditional pattern-directed rules, where the conditions are expressed as a conjunction of equations. The programming paradigm provided by this language may be called equational programming. The declarative semantics of equations is given in terms of their complete set of solutions, and the operational semantics for solving equations is an extension of reduction, called object refinement. The correctness of the operational semantics is established through soundness and completeness theorems. Examples are given to illustrate the language and its semantics.
Integer Multiplication and Division on the HP Precision Architecture
Authors: Daniel J. Magenheimer, Liz Peters, Karl W. Pettis, Dan Zuras
Venue: IEEE Transactions on Computers (1988)

In recent years, many architectural design efforts have focused on maximizing performance for frequently executed, simple instructions. The authors describe how a small set of primitive instructions combined with what is considered careful frequency analysis and clever programming allows the Hewlett-Packard (HP) Precision Architecture integer multiplication and division implementation to provide adequate performance at little or no hardware cost.