ppxscal/embedding_network huggingface dataset:
Computing signal delay in general RC networks by tree/link partitioning
Authors: P. K. Cahn, K. Karplus
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

Most RC simulators only handle tree networks, not arbitrary networks. We present an algorithm for computing signal delays in general RC networks using the RC-tree computation as the primary operation. We partition a given network into a spanning tree and link branches. Then we compute the signal delay of the spanning tree, and update the signal delay as we incrementally add the links back to reconstruct the original network. If m is the number of link branches, this algorithm requires m(m&oplus;1)/2 updates and m&oplus;1 tree delay evaluations. All the tree delay evaluations involve computing signal delays with the same resistive spanning tree, but with different values for the capacitors.
STATEMATE: A Working Environment for the Development of Complex Reactive Systems
Authors: David Harel, Amir Pnueli, Hagi Lachover, Amnon Naamad, Michal Politi, Rivi Sherman, Aharon Shtull-Trauring, Mark Trakhtenbrot
Venue: IEEE Transactions on Software Engineering (1990)

STATEMATE is a set of tools, with a heavy graphical orientation, intended for the specification, analysis, design, and documentation of large and complex reactive systems. It enables a user to prepare, analyze, and debug diagrammatic, yet precise, descriptions of the system under development from three interrelated points of view, capturing structure, functionality, and behavior. These views are represented by three graphical languages, the most intricate of which is the language of statecharts, used to depict reactive behavior over time. In addition to the use of statecharts, the main novelty of STATEMATE is in the fact that it understands the entire descriptions perfectly, to the point of being able to analyze them for crucial dynamic properties, to carry out rigorous executions and simulations of the described system, and to create running code automatically. These features are invaluable when it comes to the quality and reliability of the final outcome.
Heuristic software partitioning algorithms for distributed real-time applications
Authors: H. Xin, Z. Hong, C. Xiyao
Venue: Proceedings of the 10th international conference on Software engineering (1988)

This paper deals with the problems of software partition for distributed real-time applications. The software partitioning models analyzed are those that take maximizing the efficiency in resource utilization for their objective, while observing the constraints on CPU throughput, memory space available, maximally allowed task execution time, and the order of module execution. The problem of software partition based on the models is proven to be NP-complete. There is no efficient partitioning algorithm for the models. We present two heuristic software partitioning algorithms.
The Use of Self Checks and Voting in Software Error Detection: An Empirical Study
Authors: Nancy G. Leveson, Stephen S. Cha, John C. Knight, Timothy J. Shimeall
Venue: IEEE Transactions on Software Engineering (1990)

The results of an empirical study of software error detection using self checks and N-version voting are presented. Working independently, each of 24 programmers first prepared a set of self checks using just the requirements specification of an aerospace application, and then each added self checks to an existing implementation of that specification. The modified programs were executed to measure the error-detection performance of the checks and to compare this with error detection using simple voting among multiple versions. The analysis of the checks revealed that there are great differences in the ability of individual programmers to design effective checks. It was found that some checks that might have been effective failed to detect an error because they were badly placed, and there were numerous instances of checks signaling nonexistent errors. In general, specification-based checks alone were not as effective as specification-based checks combined with code-based checks. Self checks made it possible to identify faults that had not been detected previously by voting 28 versions of the program over a million randomly generated inputs. This appeared to result from the fact that the self checks could examine the internal state of the executing program, whereas voting examines only final results of computations. If internal states had to be identical in N-version voting systems, then there would be no reason to write multiple versions.
2-D Invariant Object Recognition Using Distributed Associative Memory
Authors: Harry Wechsler, George Lee Zimmerman
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

Complex-log conformal mapping is combined with a distributed associative memory to create a system that recognizes objects regardless of changes in rotation or scale. Information recalled from the memorized database is used to classify an object, reconstruct the memorized version of the object, and estimate the magnitude of changes in scale or rotation. The system response is resistant to moderate amounts of noise and occlusion. Several experiments using real gray-scale images are presented to show the feasibility of the approach.
A hierarchical description of the Hermix distributed operating system
Authors: Yolande Berbers, Pierre Verbaeten
Venue: Proceedings of the 1988 ACM SIGSMALL/PC symposium on ACTES (1988)

Distributed operating systems are often structured in a server oriented way, where some system tasks are performed by server processes. For modularity reasons, Hermix is build of a minimal kernel and many small servers; however to get a reasonable performance we use tools to merge servers together or to integrate them in our kernel. In this paper we analyze the most basic services needed in server oriented systems. We give a description of these basic services and place them in a hierarchical structure. Servers usually handle services from different layers and can therefore not be ordered hierarchically. Our hierarchical description gives a better insight in the relationships between inter-process communication, memory management based on swapping and both low level and high level process management.
A very fast substring search algorithm
Authors: Daniel M. Sunday
Venue: Communications of the ACM (1990)

This article describes a substring search algorithm that is faster than the Boyer-Moore algorithm. This algorithm does not depend on scanning the pattern string in any particular order. Three variations of the algorithm are given that use three different pattern scan orders. These include: (1) a &ldquo;Quick Search&rdquo; algorithm; (2) a &ldquo;Maximal Shift&rdquo; and (3) an &ldquo;Optimal Mismatch&rdquo; algorithm.
A message driven OR-parallel machine
Authors: S. A. Delgado-Rannauro, T. J. Reynolds
Venue: ACM SIGARCH Computer Architecture News (1989)

A message driven architecture for the execution of OR-parallel logic languages is proposed. The computational model is based on well known compilation techniques for Logic Languages. We present first the multiple binding mechanism for the OR-parallel Prolog architecture and the corresponding OR-parallel abstract machine is described. A scheduling algorithm which does not rely upon the availability of global data structures to direct the search for work is discussed. The message driven processor, the processing node of the parallel machine, is designed to interact with a shared global address space and to efficiently process messages from other processing nodes. We discuss some of the results obtained from a high level functional simulator of the message driven machine.
A general-purpose algorithm for analyzing concurrent programs
Authors: Richard N. Taylor
Venue: Communications of the ACM (1983)

Developing and verifying concurrent programs presents several problems. A static analysis algorithm is presented here that addresses the following problems: how processes are synchronized, what determines when programs are run in parallel, and how errors are detected in the synchronization structure. Though the research focuses on Ada, the results can be applied to other concurrent programming languages such as CSP.
The group paradigm for concurrency control
Authors: Amr El Abbadi, Sam Toueg
Venue: Proceedings of the 1988 ACM SIGMOD international conference on Management of data (1988)

We propose a paradigm for developing, describing and proving the correctness of concurrency control protocols for replicated databases in the presence of failures or communication restrictions. Our approach is to hierarchically divide the problem of achieving one-copy serializability by introducing the notion of a &ldquo;group&rdquo; that is a higher level of abstraction than transactions. Instead of dealing with the overall problem of serializing all transactions, our paradigm divides the problem into two simpler ones. (1) A local policy for each group that ensures a total order of all transactions in that group. (2) A global policy that ensures a correct serialization of all groups. We use the paradigm to demonstrate the similarities between several concurrency control protocols by comparing the way they achieve correctness.
A Heuristically-Aided Algorithm for Mutual Exclusion in Distributed Systems
Authors: Mukesh Singhal
Venue: IEEE Transactions on Computers (1989)

A heuristically-aided algorithm to achieve mutual exclusion in distributed systems is presented which has better performance characteristics than previously proposed algorithms. The algorithm makes use of state information, which is defined as the set of states of mutual exclusion processes in the system. Each site maintains information about the state of other sites and uses it to deduce a subset of sites likely to have the token. Consequently, the number of messages exchanged for a critical section invocation is a random variable between 0 and n (n is the number of sites in the system). It is shown that the algorithm achieves mutual exclusion and is free from deadlock and starvation. The effects of a site crash are discussed, as are those of a communication-medium failure on the proposed algorithm. Methods of recovery from these failures are suggested. The performance of the algorithm is studied using a simulation technique (and an analytic technique for low and heavy traffics of requests for critical section execution).
Computer aided program design experiments: diagrammatic versus textual material
Authors: Ernest C. Ackermann, William R. Pope
Venue: ACM SIGCSE Bulletin (1989)

An experiment was conducted to determine if using a computer aided diagrammatic approach to design offered advantages to undergraduate students in the several stages of preparing and implementing programs. Results were obtained which favored the use of a computer aided diagrammatic tool. The greatest benefit was realized in the later stages of coding and implementation rather than in the design stage itself. Overall, the diagrammatic classes completed assignments in 27% less time than the classes using a textual approach without any measurable loss of quality. The research was a joint effort of the Naval Surface Warfare Center and Mary Washington College.
A parallel processing course for undergraduates
Authors: D. G. Hyde
Venue: ACM SIGCSE Bulletin (1989)

We argue that a parallel processing course should be offered to undergraduate computer science majors. A major component of such a course should be a series of programming laboratories where the student can investigate the strengths and weaknesses of different parallel architectures. The student should design and debug parallel algorithms on the different parallel models. We propose a cost effective solution to the teaching of the course which uses simulators and Transputer-based parallel accelerators in a personal computer or workstation environment.
The 1987-88 Taulbee Survey Report
Authors: D. Gries, D. Marsh
Venue: Computer (1989)

This report describes the results of a survey completed in December 1988 on the production and employment of PhDs and faculty in PhD-granting computer science/engineering departments during the 1987-88 academic year. All 127 computer science (CS) departments (115 US and 12 Canadian) participated. In addition, 34 departments offering the PhD in computer engineering (CE) were included. Throughout the report. CE statistics are reported separately so that comparisons with previous years can be made for CS. The intent is to merge all statistics for CS and CE after several years.
Concurrency in the undergraduate curriculum
Authors: Ronald J. Leach, Jeffrey A. Brumfield, Michael B. Feldman, Charles M. Shub
Venue: ACM SIGCSE Bulletin (1988)

Concurrency is a major trend in computer science; it can be taught from the point of view of operating systems, programming languages, algorithm design, database design, software engineering, systems engineering, and computer architecture. The panel will address the following questions among others: When should students be exposed to concurrency? In traditional or non-traditional courses? How many times? What must a programmer know about implementation? Must applications programmers now become experts in operating systems? What are the appropriate paradigms for development of concurrent programming in education?
Computational geometry on hypercube computers
Authors: R. Miller, Q. F. Stout
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

This paper gives hypercube algorithms for some simple problems involving geometric properties of sets of points. The properties considered emphasize aspects of convexity and domination. Efficient algorithms are given for both fine-grain and medium-grain hypercube computers. For both serial and parallel computers, sorting plays an important role in geometric algorithms for determining simple properties, often being the dominant component of the time. On a hypercube computer the time required to sort is still not fully understood, so the times of some of our algorithms for unsorted data are not completely determined. For the fine-grain model using worst case timing we show that if the data is presorted then faster algorithms are possible, if sorting one item per processor requires time growing faster than the dimension of the hypercube. For both models we show that faster algorithms are possible for point sets generated randomly, when time is measured using expected time. Our algorithms are developed for sets of planar points, with several of them extending to sets of points in spaces of higher dimension.
Tree LANs with collision avoidance: protocol, switch architecture, and simulated performance
Authors: T. Suda, S. Morris, T. Nguyen
Venue: Symposium proceedings on Communications architectures and protocols (1988)

Packet collisions and their resolution create a performance bottleneck in random access LANs. A hardware solution to this problem is to use collision avoidance switches. These switches allow the implementation of random access protocols without the penalty of collisions among packets. We describe the designs of some tree LANs that use collision avoidance switches. The collision avoidance LANs we describe are broadcast star and CAMB tree (Collision Avoidance Multiple Broadcast tree). We next present a possible implementation of a collision avoidance switch using currently available photonic devices. Finally, we show the performance of broadcast star and CAMB tree networks using simulations.
Performance analysis and fundamental performance tradeoffs for CLV optical disks
Authors: Stavros Christodoulakis, Daniel Alexander Ford
Venue: Proceedings of the 1988 ACM SIGMOD international conference on Management of data (1988)

CLV type optical disks is a very large and important class of optical disk technology, of which CD-ROM disks form a subclass. In this paper we present a model of retrieval from CLV optical disks. We then provide exact and approximate results analyzing the retrieval performance from them. Our analysis takes into account disks with and without a mirror in the read mechanism, small objects completely placed within block boundaries, placement that allows block boundary crossing, as well as very large objects (such as documents) placed within files. In the second part of the paper we describe some fundamental implications of physical data base design for data bases stored on CLV optical disks. We show that very significant performance gains may be realized by appropriate design.
Experience with D-BUS architecture for a design automation framework
Authors: E. C. VanHorn, R. R. Rezac
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

The complexity of computer product development has increased dramatically, because of the large volume of data, and the need to integrate sophisticated CAE/CAD/CAM/CIM tools. Since any system to address this need must evolve over time, Digital Equipment Corporation chose to develop the D-BUS architecture for internal use as a design automation framework. The architecture stresses approaches to information management for integration of tools and organizations. Experience indicates that the architectural approach was a correct one, but that additional services were needed.
All-to-All Broadcast by Flooding in Communications Networks
Authors: Donald M. Topkis
Venue: IEEE Transactions on Computers (1989)

The author establishes the worst-case time complexity of all-to-all broadcast, which involves the simultaneous broadcast of messages from each node in a network to each other node, as with the dissemination of network status information for adaptive routing in ARPANET, by flooding. It it shown to be almost two times the optimum. This suboptimality of flooding results from the selection method permitting some message(s) to be consistently blocked by others. It is possible to avoid such blocking and attain the optimal worst-case time complexity by flooding within a spanning subtree. Simulations examine the performance of all-to-all broadcast by flooding using different selection methods. The best overall performance came using random selection, with FIFO next best, followed by LIFO, and in-order last. This relative performance is consistent with the hypothesis that flooding will generally perform better if implemented with a selection method that tends to avoid having some message(s) consistently blocked by others. Simulations show that the optimal worst-case time complexity is rarely exceeded, and then by only a relatively small amount.
Resourceful systems for fault tolerance, reliability, and safety
Authors: Russell J. Abbott
Venue: ACM Computing Surveys (CSUR) (1990)

Above all, it is vital to recognize that completely guaranteed behavior is impossible and that there are inherent risks in relying on computer systems in critical environments. The unforeseen consequences are often the most disastrous [Neumann 1986]. Section 1 of this survey reviews the current state of the art of system reliability, safety, and fault tolerance. The emphasis is on the contribution of software to these areas. Section 2 reviews current approaches to software fault tolerance. It discusses why some of the assumptions underlying hardware fault tolerance do not hold for software. It argues that the current software fault tolerance techniques are more accurately thought of as delayed debugging than as fault tolerance. It goes on to show that in providing both backtracking and executable specifications, logic programming offers most of the tools currently used in software fault tolerance. Section 3 presents a generalization of the recovery block approach to software fault tolerance, called resourceful systems. Systems are resourceful if they are able to determine whether they have achieved their goals or, if not, to develop and carry out alternate plans. Section 3 develops an approach to designing resourceful systems based upon a functionally rich architecture and an explicit goal orientation.
On the inclusion properties for multi-level cache hierarchies
Authors: J.-L. Baer, W.-H. Wang
Venue: Proceedings of the 15th Annual International Symposium on Computer architecture (1988)

The inclusion property is essential in reducing the cache coherence complexity for multiprocessors with multilevel cache hierarchies. We give some necessary and sufficient conditions for imposing the inclusion property for fully- and set-associative caches which allow different block sizes at different levels of the hierarchy. Three multiprocessor structures with a two-level cache hierarchy (single cache extension, multiport second-level cache, bus-based) are examined. The feasibility of imposing the inclusion property in these structures is discussed. This leads us to propose a new inclusion-coherence mechanism for two-level bus-based architectures.
Real-time concurrent collection on stock multiprocessors
Authors: A. W. Appel, J. R. Ellis, K. Li
Venue: ACM SIGPLAN Notices (1988)

We've designed and implemented a copying garbage-collection algorithm that is efficient, real-time, concurrent, runs on commercial uniprocessors and shared-memory multiprocessors, and requires no change to compilers. The algorithm uses standard virtual-memory hardware to detect references to &ldquo;from space&rdquo; objects and to synchronize the collector and mutator threads. We've implemented and measured a prototype running on SRC's 5-processor Firefly. It will be straightforward to merge our techniques with generational collection. An incremental, non-concurrent version could be implemented easily on many versions of Unix.
Testing different methods of deconvolution for electron beam measured waveforms
Authors: Erich Plies, Michael Schweizer
Venue: Microelectronic Engineering (1988)

Deconvolution of electron beam measured waveforms is a signal processing procedure aiming to improve the time resolution. We have tested different deconvolution algorithms in the time and frequency domains which are more or less equally sensitive to existing noise but differ in their computing times. An improvement of the measured edge rise time by a factor of 2-6 can be achieved. We recommend two simple and fast deconvolution methods which are stable and can be applied relatively blindly.
When objects collide experiences with reusing multiple class hierarchies
Authors: Lucy M. Berlin
Venue: Proceedings of the European conference on object-oriented programming on Object-oriented programming systems, languages, and applications (1990)

Well-designed reusable class libraries are often incompatible due to architectural mismatches such as error-handling and composition conventions. We identify five pragmatic dimensions along which combinations of subsystems must match, and present detailed examples of conflicts resulting from mismatches. Examples are drawn from our experiences of integrating five subsystem-level class hierarchies into an object-oriented hypertext platform. We submit that effective reuse will require that these pragmatic decisions be explicitly identified in descriptions of reusable software. Such descriptions will enable developers to identify and combine subsystems whose architectures are compatible.