ppxscal/embedding_network huggingface dataset:
Fast parallel algorithms for chordal graphs
Authors: J. Naor, M. Naor A. Schaffer
Venue: Proceedings of the nineteenth annual ACM symposium on Theory of computing (1987)

We present an NC algorithm for recognizing chordal graphs, and we present NC algorithms for finding the following objects on chordal graphs: all maximal cliques, an intersection graph representation, an optimal coloring, a perfect elimination scheme, a maximum independent set, a minimum clique cover, and the chromatic polynomial. The well known polynomial algorithms for these problems seem highly sequential, and therefore a different approach is needed to find parallel algorithms.
A user interface for deaf-blind people (preliminary report)
Authors: Richard Ladner, randy Day, Dennis Gentry, Karin Meyer, Scott Rose
Venue: ACM SIGCHI Bulletin (1986)

A user interface suitable for deaf-blind users is presented and justified. The interface is designed for small paperless Braille displays, large font visual displays, or other low-bandwidth displays. Some of the key properties of the interface are that it uses a hierarchical approach to structure both commands and data, has a small universal command set, and has pervasive editing capability. DBNet, a system employing the user interface, has been built and tested with deaf-blind users. DBNet will provide various communication services to the deaf-blind community including electronic news, mail, and bulletin boards.
Non-deterministic modelling of logical queries in deductive databases
Authors: Hussien Aly, Z. Meral Ozsoyoglu
Venue: ACM SIGMOD Record (1987)

We propose a technique based on Petri Nets formalism to model logic queries in deductive databases. The model is called PNLP (Petri Net model for Logic Programs), and it has a simple formal description and a graphical representation. The PNLP model explicitly represents the relationships between rules and predicates. It is general and flexible enough to demonstrate the flow of control in different algorithms used to evaluate recursive logic queries. In fact the model unifies the level of description of these algorithms, and facilitates identifying similarities and differences between them. The inherent non-determinism in the PNLP model may also be useful in recognizing the parallelism within Horn-clause logic programs. In this paper, the PNLP model is described, and its functionality is demonstrated by modeling several existing algorithms for recursive query evaluation.
A performance analysis of view materialization strategies
Authors: Eric N. Hanson
Venue: ACM SIGMOD Record (1987)

The conventional way to process commands for relational views is to use query modification to translate the commands into ones on the base relations. An alternative approach has been proposed recently, whereby materialized copies of views are kept, and incrementally updated immediately after each modification of the database. A related scheme exists, in which update of materialized views is deferred until just before data is retrieved from the view. A performance analysis is presented comparing the cost of query modification, immediate view maintenance, and deferred view maintenance. Three different models of the structure of views are given a simple selection and projection of one relation, the natural join of two relations, and an aggregate (e.g. the sum of values in a column) over a selection-projection view. The results show that the choice of the most efficient view maintenance method depends heavily on the structure of the database, the view definition, and the type of query and update activity present.
A hardware accelerator for maze routing
Authors: Y. Won, S. Sahni, Y. El-ziq
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

A hardware accelerator for the maze routing problem is developed. This accelerator consists of three 3 stage pipelines. Banked memory is used to avoid memory read/write conflicts and obtain maximum efficiency.
Built-In Testing of Memory Using an On-Chip Compact Testing Scheme
Authors: K Kinoshita, K K Saluja
Venue: IEEE Transactions on Computers (1986)

In this paper we study the problem of testing RAM. A new fault model, which encompasses the existing fault models, is proposed. We then propose a scheme of testing faults from the new fault model using built-in testing techniques. We introduce concept of p-hard and determine the complexity of the extra hardware required for built-in self-testing on our hardness scale. A novel approach using microcoded ROM for implementation of built-in testing is also proposed and its complexity is determined.
&ldquo;?&rdquo;: a context-sensitive help system based on hypertext
Authors: W. Lee
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

Commercial on-line help systems are still largely text-based used TTY interfaces, even on bitmap graphics workstations. Context-sensitive help for on-screen objects on workstations is one important feature lacking in today's help systems. This paper describes a new system called &ldquo;?&lrdquo;1 based on hyper-text which mixes text, graphics and movies and allows the user to peruse the entire help database through the use of reference buttons.
The program dependence graph and its use in optimization
Authors: Jeanne Ferrante, Karl J. Ottenstein, Joe D. Warren
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1987)

In this paper we present an intermediate program representation, called the program dependence graph (PDG), that makes explicit both the data and control dependences for each operation in a program. Data dependences have been used to represent only the relevant data flow relationships of a program. Control dependences are introduced to analogously represent only the essential control flow relationships of a program. Control dependences are derived from the usual control flow graph. Many traditional optimizations operate more efficiently on the PDG. Since dependences in the PDG connect computationally related parts of the program, a single walk of these dependences is sufficient to perform many optimizations. The PDG allows transformations such as vectorization, that previously required special treatment of control dependence, to be performed in a manner that is uniform for both control and data dependences. Program transformations that require interaction of the two dependence types can also be easily handled with our representation. As an example, an incremental approach to modifying data dependences resulting from branch deletion or loop unrolling is introduced. The PDG supports incremental optimization, permitting transformations to be triggered by one another and applied only to affected dependences.
Concurrency versus availability: atomicity mechanisms for replicated data
Authors: Maurice Herlihy
Venue: ACM Transactions on Computer Systems (TOCS) (1987)

A replicated object is a typed data object that is stored redundantly at multiple locations to enhance availability. Most techniques for managing replicated data have a two-level structure: At the higher level, a replica-control protocol reconstructs the object's state from its distributed components, and at the lower level, a standard concurrency-control protocol synchronizes accesses to the individual components. This paper explores an alternative approach to managing replicated data by presenting two replication methods in which concurrency control and replica management are handled by a single integrated protocol. These integrated protocols permit more concurrency than independent protocols, and they allow availability and concurrency to be traded off: Constraints on concurrency may be relaxed if constraints on availability are tightened, and vice versa. In general, constraints on concurrency and availability cannot be minimized simultaneously.
Optimal chaining in expression trees
Authors: David Bernstein, Haran Boral, Ron Y. Pinter
Venue: ACM SIGPLAN Notices (1986)

Chaining is the ability to pipeline two or more vector instructions on Cray-1 like machines. We show how to optimally use this feature to compute (vector) expression trees, in the context of automatic code-generation. We present a linear-time scheduling algorithm for finding an optimal order of evaluation for a machine with a bounded number of registers.
The 1984-1985 Taulbee survey
Authors: David Gries
Venue: Communications of the ACM (1986)

Presented here is the Computer Science Board's survey on the production and employment of Ph.D.'s and faculty in computer science and engineering.
A rule-based placement system for printed wiring boards
Authors: G. Odawara, T. Hamuro, K. Iijima, T. Yoshino, Y. Dai
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

This paper describes a rule-based placement technique, which plays a key-role in the automatic layout system for Printed Wiring Boards. It is based on classification of bus-structures and other functional or structural features of PWB's. Experiments have demonstrated that this technique is superior to the conventional algorithms, and the result has almost the same quality as the skillful designers' placement.
Identifying Error-Prone Software An Empirical Study
Authors: Vincent Y. Shen, Tze-Jie Yu, Stephen M. Thebaut, Lorri R. Paulsen
Venue: IEEE Transactions on Software Engineering (1985)

A major portion of the effort expended in developing commercial software today is associated with program testing. Schedule and/ or resource constraints frequently require that testing be conducted so as to uncover the greatest number of errors possible in the time allowed. In this paper we describe a study undertaken to assess the potential usefulness of various product-and process-related measures in identifying error-prone software. Our goal was to establish an empirical basis for the efficient utilization of limited testing resources using objective, measurable criteria. Through a detailed analysis of three software products and their error discovery histories, we have found simple metrics related to the amount of data and the structural complexity of programs to be of value for this purpose.
Circular self-test path: a low-cost BIST technique
Authors: A. Krasniewski, S. Pilarski
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

A new technique for designing self-testing VLSI circuits, referred to as Circular Self-Test Path, is presented The Circular Self-Test Path is a feedback shift register (output of the last flip-flop is supplied to the first flip-flop) with a data compaction capability. A distinguishing attribute of self-testing chips designed using this technique is a low silicon area overhead, slightly exceeding that of scan path designs. A theoretical analysis and comprehensive simulation experiments we performed to demonstrate that the effectiveness of test pattern generation for the circular self-test path is comparable to that of an ideal pseudorandom test generator.
Using the VAX/VMS lock manager with Ada tasks
Authors: James J. Maloney
Venue: ACM SIGAda Ada Letters (1988)

The VAX/VMS Lock Manager is a powerful, general purpose facility that provides various levels of granularity for concurrent access to shared resources. However, its support for the Ada language is limited, in that it cannot recognize situatio where Ada tasks (which are implemented as part of one process in VAX/VMS Ada) are competing for a resource. In such situations, t VAX/VMS Lock Manager is most likely to assume that there is a deadlock (within a process) on a resource.This paper presents a possible solution to this problem, developing, via stepwise refinement, a "Multi-Threaded Lock Package," which can be used by Ada programs using Ada tasks. The paper also presents some special problems when dealing with concurrency in general, and provides an example of how to use Ada tasks with families of entries.
Implementing functional languages on a combinator-based reduction machine
Authors: S. M. Sarwar, S. J. Hahn, J. A. Davis
Venue: ACM SIGPLAN Notices (1988)

This paper describes the results of a study done at Iowa State University as part of a larger effort to develop a fine-grained parallel architecture [5]. The goal is to find most heavily used combinators using Turner's method of graph reduction for a wide range of programming styles. The study shows thai there are families and strings of combinators that are used frequently. Optimization of such combinators promises an efficient sequential reduction machine based upon the combinator model.
ASK is transportable in half a dozen ways
Authors: Bozena H. Thompson, Frederick B. Thompson
Venue: ACM Transactions on Information Systems (TOIS) (1985)

This paper is a discussion of the technical issues and solutions encountered in making the ASK System transportable. A natural language system can be &ldquo;transportable&rdquo; in a number of ways. Although transportability to a new domain is most prominent, other ways are also important if the system is to have viability in the commercial marketplace. On the one hand, transporting a system to a new domain may start with the system prior to adding any domain of knowledge and extend it to incorporate the new domain. On the other hand, one may wish to add to a system that already has knowledge of one domain the knowledge concerning a second domain, that is, to extend the system to cover this second domain. In the context of ASK, it has been natural to implement extending and then achieve transportability as a special case. In this paper, we consider six ways in which the ASK System can be extended to include new capabilities: to a new domain, to a new object type, to access data from a foreign database, to a new natural language, to a new programming language, to a new computer family. Special-purpose applications, such as those to accommodate standard office tasks, would make use of these various means of extension.
Automated Analysis of Discrete Communication Behavior
Authors: Kevin Rea, Robert de B. Johnston
Venue: IEEE Transactions on Software Engineering (1987)

An objective methodology for the specification and analysis of communicating processes is presented. It is based on an algebraic theory that is a formalization of a particular state machine model. The approach recognizes the fact that the complexity of system interactions is such that computer aid is not only appropriate but necessary for any practical design methodology.
An object oriented extension to APL
Authors: Jean Jacques Girardot, Sega Sako
Venue: Proceedings of the international conference on APL: APL in transition (1987)

This paper describes an object oriented extension of APL, which is currently being implemented in a new APL system. This extension is integrated in a rather conservative way to APL. However, all the paradigms of object oriented languages (message passing, instance variables, methods, classes and inheritance) are made available to the user, without losing any of the successful features of APL. The paper first explains what are the interests of object oriented programming, and what is expected from this introduction in the language. It then discusses syntactic and semantic choices, and shows how the selected solutions fit the philosophy of APL. An example of this new style of programming in APL is proposed, then the internals of the implementation are presented, showing that this new possibility is made available at the cost of a minimal system overhead. Finally, the paper discusses about the results obtained so far.
Organizing a live call-in TV show about computers
Authors: William E. Mihalo
Venue: Proceedings of the 15th annual ACM SIGUCCS conference on User Services (1987)

A live, call-in television show is an environment conducive for answering quick questions. It also provides user services staff with an opportunity for distributing information quickly to a large audience without relying on the more traditional mechanisms of documentation or online help This paper describes the steps that were taken to develop and produce a live, call-in television show. It also provides some background about how local community resources were used for producing the show (the show was produced with no budget), how the television show was broadcast and what the response was to the show. Some recommendations are made for user services personnel who may be interested in replicating the approach described in this paper. The television show described in this paper was made when the author was working for a state-run university in Northwest Indiana.
Multigrid Algorithms on the Hypercube Multiprocessor
Authors: T F Chan, Y Saad
Venue: IEEE Transactions on Computers (1986)

This paper examines several ways of implementing multigrid algorithms on the hypercube multiprocessor. We consider both the standard multigrid algorithms and a concurrent version proposed by Gannon and Van Rosendale. We present several mappings of the mesh points onto the nodes of the cube. The main property of these mappings, which are based on binary reflected Gray codes, is that the distance between neighboring grid points remains constant from one grid level to another. This results in a communication effective implementation of multigrid algorithms on the hypercube multiprocessor.
Software Engineering for User Interfaces
Authors: Stephen W. Draper, Donald A. Norman
Venue: IEEE Transactions on Software Engineering (1985)

The discipline of software engineering can be extended in a natural way to deal with the issues raised by a systematic approach to the design of human-machine interfaces. Two main points are made: that the user should be treated as part of the system being designed, and that projects should be organized to take account of the current (small) state of a priori knowledge about how to design interfaces.
The decline and fall of Operating Systems I
Authors: Charles M. Shub
Venue: Proceedings of the eighteenth SIGCSE technical symposium on Computer science education (1987)

This paper examines the changes in the undergraduate course on Operating Systems both from the perspective of the ACM curriculum recommendations and the perspective of the topical coverage in popular textbooks. It concludes that the course and the expectations of the course have changed over the years. The net effect of these changes has been towards less substance and less preparation for students emerging from the course. The paper begins by discussing the changes in ACM curricular guidelines. That section is followed by two sections that trace the changes recommended by the curricular guidelines to their implementations in both the older and newer generations of textbooks. These are followed by a brief discussion of the literature describing Operating Systems courses and their projects. Finally conclusions are drawn and recommendations are made.
A parallel algorithm for execution of production systems on HMESH architecture
Authors: S. B. Tien, C. S. Raghavendra
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

In this paper, the parallelism of production systems is studied and divided into 6 levels &mdash; attribute level, precondition level, production (rule) level, working memory element level, parallel action level, and multiple rule firing. An algorithm for parallel execution of production systems to run on a HMESH structure[Ragh 1986] is proposed. It uses large number of PE's (4,096 to 65,536) to accommodate large production systems with one thousand to 16 thousand rules. The hierarchy of buses in HMESH structure provides flexible partitioning of PE's into different sizes such that different partitions can perform their processing simultaneously. This matches the need in executing the rule-based production systems by partitioning the rules into disjoint and independent sets. The algorithm, using the HMESH structure, can make the communication among PE's simple and regular to avoid overheads such as bus contention, access conflicts, etc. It exploits various levels of parallelism in production systems.
An Ada course for upper-level undergraduates
Authors: Mark Temte
Venue: ACM SIGCSE Bulletin (1986)

As the Ada programming language becomes established, it will have an impact on computer education. In the short term, there will be a need to provide Ada exposure to mature upper-level undergraduates who are already skilled in other languages. Although language proficiency is important, this exposure should not focus on language features but rather on the support Ada provides to modern software engineering practice. The content of a course providing such an exposure is described together with a pedagogical approach that proved to be quite successful.
Proving Liveness and Termination of Systolic Arrays Using Communicating Finite State Machines
Authors: Mohamed G. Gouda, Hui-Seng Lee
Venue: IEEE Transactions on Software Engineering (1985)

We model a systolic array as a network of, mostly identical, communicating finite state machines that exchange messages over one-to-one, unbounded, FIFO channels. Each machine has a cyclic behavior; in each cycle, a machine first receives one message from each of its input channels, then sends one message to each of its output channels. If in a cycle a machine does not have any data message to send to one of its output channels, it sends a null message instead; thus, machines exchange two types of messages, data and null. We characterize the liveness and termination properties for such networks, and discuss two algorithms that can be used to decide these properties for any given network. We apply these algorithms to establish the liveness and termination properties of four systolic array examples. These examples include a linear matrix-vector multiplier, a linear priority queue, and a search tree.
IC interconnect routing in a multiprocessing environment
Authors: Nelson Brady, Ed Downs
Venue: ACM SIGDA Newsletter (1986)

This article explores the possibilities of IC interconnection routing in a multiprocessing environment. Some knowledge of multiprocessing environments and the interconnection routing problem is assumed. Multiprocesing approaches to the related problems of device placement and design rule checking are also being investigated, but will not be discussed here due to space limitations.
Knowledge-based simulation at RAND
Authors: Jeff Rothenberg
Venue: ACM SIGSIM Simulation Digest (1988)

The current object-oriented simulation paradigm is a powerful discrete-state modeling technique that allows modelers to encapsulate the definitions of objects while allowing users to view models at meaningful levels. Yet object-oriented simulation has many limitations, notably its inability to answer questions that go beyond the "What if...?" analysis that is the traditional domain of simulation. The following describes ongoing research by the Knowledge-Based Simulation project (KBSim) at RAND to extend object-oriented simulation in fundamental ways.
Experiences with a Feedback Version Development Methodology
Authors: Farokh B. Bastani
Venue: IEEE Transactions on Software Engineering (1985)

In the development of programs for novel applications, a series of design-implementation phases may be necessary in order to acquire a deeper understanding of the problem. This paper develops a feedback version development approach incorporating systematic knowledge integration techniques. Our experiences in applying these methods to various projects are also discussed.
Representation of Uncertainty in Computer Vision Using Fuzzy Sets
Authors: T L Huntsberger, C Rangarajan, S N Jayaramamurthy
Venue: IEEE Transactions on Computers (1986)

Uncertainty in computer vision can arise at various levels. It can occur in the low level in the raw sensor input, and extends all the way through intermediate and higher levels. Ideally, at any level where decisions are being made on the basis of previous processing steps, a computer vision system must have sufficient flexibility for representation of uncertainty in any of these levels.