ppxscal/embedding_network huggingface dataset:
Analysis and Comparison of Cache Coherence Protocols for a Packet-Switched Multiprocessor
Authors: Q. Yang, L. N. Bhuyan, B.-C. Liu
Venue: IEEE Transactions on Computers (1989)

Analytical models are developed for seven existing cache protocols, namely, Write-Once, Write-Through, Synapse, Berkeley, Illinois, Firefly, and Dragon. The protocols are implemented on a multiprocessor with a packet-switched shared bus. The models are based on queuing networks that consist of both open and closed classes of customers. The models incorporate the requests for invalidation signals, write-through, and write-back operations, and the solution is based on the mean value analysis (MVA) algorithm. The performance of these protocols under various system parameters is compared on the basis of the models. It is found that Firefly and Dragon perform better than the others.
Reliability mechanisms for ADAMS
Authors: S. H. Son, J. L. Pfaltz
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

The goal of checkpointing in database management systems is to save database states on a separate secure device so that the database can be recovered when errors and failures occur. This paper presents a non-interfering checkpointing mechanism being developed for ADAMS. Instead of waiting for a consistent state to occur, our checkpointing approach constructs a state that would result by completing the transactions that are in progress when the global checkpoint begins. The checkpointing algorithm is executed concurrently with transaction activity while constructing a transaction-consistent checkpoint on disk, without requiring the database quiesce. This property of non-interference is highly desirable to real-time applications, where restricting transaction activity during the checkpointing operation is in many cases not feasible. Two main properties of this checkpointing algorithm are global consistency and reduced interference, both of which are crucial for achieving high availability.
Hypertext, narrative, and consciousness
Authors: M. Joyce, N. Kaplan, J. McDaid, S. Moulthrop
Venue: Proceedings of the second annual ACM conference on Hypertext (1989)

This panel attempts to initiate a dialogue on the implications of hypertext between information theorists and literary theorists, writers of texts and designers of text systems. Though the panelists base their views on several years of practical work with hypertext in education, they are concerned with broader social and conceptual problems raised by this technology &mdash; its likely effect on the way we teach ourselves and others to understand texts and the way we use those texts to construct an orderly (or disorderly) world. It seems important to raise these issues at Hypertext '89 because hypertext is rapidly being recognized by humanists as a crucial and revolutionary enterprise. This recognition creates an opportunity for humanists and scientists to convene a productive dialogue which could have great significance both for hypertext and for the future of the humanities. We hope for a frank and free-ranging exchange of views and emphasize that this is a forum for questioning and controversy, not a series of monologues. Each panelist will deliver a ten-minute position statement, with the remaining hour of the session devoted to discussion. Abstracts of the three presentations follow.
An Improved Hardware Implementation of the Fault-Tolerant Clock Synchronization Algorithm for Large Multiprocessor Systems
Authors: Bong-Rak Choi, Kyu Ho Park, Myunghwan Kim
Venue: IEEE Transactions on Computers (1990)

An improved implementation of clock synchronization of multiprocessor systems in the presence of malicious faults is proposed. The proposed hardware implementation for the reference clock selection has a lower gate complexity, smaller time delay, and greater flexibility than the previously published implementation. The improvement is achieved by replacing the sorter with a counting encoder and comparators and by introducing threshold generation logic with programmable registers. The scheme has a gate complexity of O(n) and a delay of O(log n), where n is the total number of inputs to a particular clock, and is programmable for different values of n and m, the maximum number of faults.
UNIX Emacs: a retrospective (lessons for flexible system design)
Authors: Nathaniel S. Borenstein, James Gosling
Venue: Proceedings of the 1st annual ACM SIGGRAPH symposium on User Interface Software (1988)

UNIX Emacs is well-known and widely used as a text editor that has been extended in a remarkable number of directions, not always wisely. Because it is programmable in a powerful yet simple programming language, Emacs has been used as a development tool for the construction of some remarkably complex user-oriented programs. Indeed, it has served as both a user interface management system and a user interface toolkit, though it was designed as neither. In this paper, we discuss the features that have made it so popular for user interface development, in an attempt to derive lessons of value for more powerful and more systematically designed systems in the future.
Reference history, page size, and migration daemons in local/remote architectures
Authors: M. A. Holliday
Venue: ACM SIGARCH Computer Architecture News (1989)

We address the problem of paged main memory management in the local/remote architecture subclass of shared memory multiprocessors. We consider the case where the operating system has primary responsibility and uses page migration as its main tool. We identify some of the key issues with respect to architectural support (reference history maintenance, and page size), and operating system mechanism (duration between daemon passes, and number of migration daemons). The experiments were conducted using software implemented page tables on 32-node BBN Butterfly Plus&trade;. Several numeral programs with both synthetic and real data were used as the workload. The primary conclusion is that for the cases considered migration was at best marginally effective. On the other hand, practical migration mechanisms were robust and never significantly degraded performance. The specific results include: 1) Referenced bits with aging can closely approximate Usage fields, 2) larger page sizes are beneficial except when the page is large enough to include locality sets of two processes, and 3) multiple migration daemons can be useful. Only small regions of the space of architectural, system, and workload parameters were explored. Further investigation of other parameter combinations is clearly warranted.
A loop-detect packet based self stabilizing bridge protocol for extended-LANs
Authors: P. Bielkowicz, G. Parr
Venue: ACM SIGCOMM Computer Communication Review (1989)

It has become the trend for network managers to require redundant bridges as back-up for bridge/link failures. The inherent problem with such a scheme is that it causes certain packets to loop continuously around the topology causing severe degradation to the performance of the overall system. Various solutions to the problem of combating this phenomenon exist, most notably the Spanning Tree Algorithm (STA) by Perlman [2]. Solutions based on a loop detect packet have been proposed previously [1]. but were never given enough thought to make it a viable alternative to work based on the STA. It is hoped to show a more powerful loop detect packet based algorithm in this paper. The problems which have plagued the previous loop detect approach [1] will be seen to be dealt with, and further extensions proposed. This algorithm is for multiple port local/remote bridges.
Finding minimum-cost circulations by canceling negative cycles
Authors: Andrew Goldberg, Robert Tarjan
Venue: Proceedings of the twentieth annual ACM symposium on Theory of computing (1988)

A classical algorithm for finding a minimum-cost circulation consists of repeatedly finding a residual cycle of negative cost and canceling it by pushing enough flow around the cycle to saturate an arc. We show that a judicious choice of cycles for canceling leads to a polynomial bound on the number of iterations in this algorithm. This gives a very simple strongly polynomial algorithm that uses no scaling. A variant of the algorithm that uses dynamic trees runs in O(nm(log n) min{log(nC), mlog n}) time on a network of n vertices, m arcs, and arc costs of maximum absolute value C. This bound is comparable to those of the fastest previously known algorithms.
On the equivalence of an Egd to a set of Fd's
Authors: Marc H. Graham, Ke Wang
Venue: Journal of the ACM (JACM) (1990)

The question &ldquo;Is a given join dependency equivalent to some set of multivalued dependencies?&rdquo; led to the development of acyclicity theory [1]. The central question of this paper is: &ldquo;Is a given equality-generating dependency equivalent to a set of functional dependencies?&rdquo; An algorithm is presented that answers that question in polynomial time without using the chase process and, in the case of a &ldquo;yes&rdquo; answer, can be used to find (a cover of) the set of functional dependencies involved. This question is also related to the similar question about join dependencies and multivalued dependencies by proving a result about the hypergraph representation of an egd. It is interesting to note that a minimal representation of an egd must be &bgr;-acyclic for the egd to be equivalent to a set of fd's, in contrast to the jd/mvd case, in which only &agr;-acyclicity is needed. The &bgr;-acyclicity of an egd not necessarily minimal is always sufficient for the egd to be equivalent to a set of fd's as shown. Finally, the algorithm is extended for a single egd to answer the question whether a set of egd's with the same right-hand-side column is equivalent to a set of fd's.
Systemic implications of leap and an improved two-part cursor
Authors: J. Raskin
Venue: ACM SIGCHI Bulletin (1989)

The lowly text cursor is a non-issue for most interface designers. Nonetheless, current text cursor designs suffer from at least two problems: one-off errors and a lack of visibility of function. These problems are exacerbated in an editing environment which uses the extremely fast Leap cursor-moving technology.This paper presents solutions to these cursor design problems and reveals the surprising way many other aspects of system design can be improved as a consequence of designing the cursor correctly.
TRAPEDS: producing traces for multicomputers via execution driven simulation
Authors: C. B. Stunkel, W. K. Fuchs
Venue: Proceedings of the 1989 ACM SIGMETRICS international conference on Measurement and modeling of computer systems (1989)

Trace-driven simulation is an important aid in performance analysis of computer systems. Capturing address traces for these simulations is a difficult problem for single processors and particularly for multicomputers. Even when existing trace methods can be used on multicomputers, the amount of collected data typically grows with the number of processors, so I/O and trace storage costs increase. A new technique is presented in this paper which modifies the executable code to dynamically collect the address trace from the user code and analyzes this trace during the execution of the program. This method helps resolve the I/O and storage problems and facilitates parallel analysis of the address trace. If a trace stored on disk is desired, the generated trace information can also be written to files during execution, with a resultant drop in program execution speed. An initial implementation on the Intel iPSC/2 hypercube multicomputer is detailed, and sample simulation results are presented. The effect of this trace collection method on execution time is illustrated.
A note on the relational calculus
Authors: C. J. Date
Venue: ACM SIGMOD Record (1989)

We examine a logical anomaly in Codd's relational calculus [1], according to which queries can occasionally return somewhat surprising results.
Application and database design&mdash;putting it off
Authors: Christopher J. Shaw
Venue: ACM SIGMOD Record (1988)

There seems to be two major schools of thought about designing database application systems: System design is mandatory, say the methodologers. How can you ever build a system unless you first determine in detail what it should do? System design is impossible, say the prototypists. How can you ever build a system if you must first determine in detail what it should do?
Improving the accuracy of touch screens: an experimental evaluation of three strategies
Authors: R. L. Potter, L. J. Weldon, B. Shneiderman
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (1988)

A study comparing the speed, accuracy, and user satisfaction of three different touch screen strategies was performed. The purpose of the experiment was to evaluate the merits of the more intricate touch strategies that are possible on touch screens that return a continuous stream of touch data. The results showed that a touch strategy providing continuous feedback until a selection was confirmed had fewer errors than other touch strategies. The implications of the results for touch screens containing small, densely-packed targets were discussed.
High speed circuit testing using ultrafast optical techniques
Authors: G. Mourou
Venue: Microelectronic Engineering (1988)

The electro-optic effect in conjunction with short optical pulses makes possible noninvasive wafer-level testing of integrated circuits. By using this particular technology, testing can be performed over a terahertz bandwidth and with micrometer resolution. Applications to digital integrated circuits and monolithic millimeter-wave integrated circuits (MMIC) have been demonstrated.
A new approach to the maximum-flow problem
Authors: Andrew V. Goldberg, Robert E. Tarjan
Venue: Journal of the ACM (JACM) (1988)

All previously known efficient maximum-flow algorithms work by finding augmenting paths, either one path at a time (as in the original Ford and Fulkerson algorithm) or all shortest-length augmenting paths at once (using the layered network approach of Dinic). An alternative method based on the preflow concept of Karzanov is introduced. A preflow is like a flow, except that the total amount flowing into a vertex is allowed to exceed the total amount flowing out. The method maintains a preflow in the original network and pushes local flow excess toward the sink along what are estimated to be shortest paths. The algorithm and its analysis are simple and intuitive, yet the algorithm runs as fast as any other known method on dense graphs, achieving an O(n3) time bound on an n-vertex graph. By incorporating the dynamic tree data structure of Sleator and Tarjan, we obtain a version of the algorithm running in O(nm log(n2/m)) time on an n-vertex, m-edge graph. This is as fast as any known method for any graph density and faster on graphs of moderate density. The algorithm also admits efficient distributed and parallel implementations. A parallel implementation running in O(n2log n) time using n processors and O(m) space is obtained. This time bound matches that of the Shiloach-Vishkin algorithm, which also uses n processors but requires O(n2) space.
A designer's perspective of the Hawk multiprocessor operating system kernel
Authors: V. P. Holmes, D. L. Harris
Venue: ACM SIGOPS Operating Systems Review (1989)

The Hawk operating system kernel was specifically designed and implemented to support real-time applications on the SANDAC V embedded multiprocessor. The kernel provides a tasking model for program decomposition and supports message passing, synchronization, as well as other ancillary services. The kernel primitives have a Unix trade;-like system call interface to the C language and were designed to provide users a choice of level of abstraction, yet perform efficiently and behave predictably. Many design choices were limited by the type of environment the system was intended to support, namely, hard-real-time for missions of short duration. The system has been implemented and has supported applications for nearly two years. Measurements of kernel performance are herein reported. This paper is an overview of the Hawk kernel and a look backward at the decisions that were made in its design.
Optimized Synthesis of Concurrently Checked Controllers
Authors: Régis Leveugle, Gabrièle Saucier
Venue: IEEE Transactions on Computers (1990)

A method for introducing online test facilities in a controller with a very low overhead is presented. This online test consists of detecting illegal paths in the control flow graph. These illegal paths may be due either to permanent faults or to transient errors. The state code flow is compacted through polynomial division. An implicit justifying signature method is applied at the state code level and ensures identical signatures before each join mode of the control flow graph. The signatures are then independent of the path followed previously in the graph, and the comparison to reference data is greatly facilitated. This property is obtained by a state assignment, nearly without area overhead. The controllers can then be checked by signature analysis, either by a built-in monitor or by an external checker.
An expert system for UNIX problem resolution
Authors: Salvatore Mamone
Venue: ACM SIGART Bulletin (1990)

Many organizations regardless of their size and type, require an experienced systems professional staff to maintain their computer equipment and to help in resolving problems. Using an expert system can enable staff members to resolve many trivial problems, giving more time to the support staff for installation, performance monitoring, and solving complex problems. This article describes such an expert system, which was written to support an R amp; D organization. The version currently in use can recognize 40% of the known problems that staff members encounter. This percent is based on a historical record of previously logged problems. Although the system is written for a UNIX dagger; and SUN environment, its structure could be used to implement a similar system for different hardware and software.
Virtual environments and interactivity: windows to the future
Authors: C. Conn, J. Lanier, M. Minsky, S. Fisher, A. Druin
Venue: ACM SIGGRAPH 89 Panel Proceedings (1989)

I really apologize. I promised everyone I would come out wearing the data suit, but it just slipped my mind and I never got around to it. Actually Marvin Minsky was saying that the thing to do would be to come out with nothing on because that would be the perfect interface to the computer. So I kind of shunned the whole thing off at that point.We just heard Nicholas Negroponte ask us -- "how do we communicate with computers?" Well, that's why this panel is here today. We'll be discussing virtual environments and interactivity with some of the people who have been doing a lot of work in this field. I was interviewing a lot of people last night at the parties about virtual environments and I realized that everyone has their own idea of what their virtual environment will be. Some want to interact more, others less. Some want little people running around on the screen bringing them all sorts of messages or images. We'll be hearing about a lot of different types of interactivity on our panel today.I'd like to point out that Margaret's slide should also include the MIT Media Lab as well as UNC.I'm going to show some tapes and do some talking later on so I'd like start of by introducing Jaron Lanier. He's the guy with the dreadlocks you've seen at the Silicon Graphics booth. He has an amazing collection of musical instruments from all over the world and when he plays them, he transports you to other times and other places. He's a designer of programming languages and he started VPL, the company that brought you the glove, Jaron.
Type theories and object-oriented programmimg
Authors: Scott Danforth, Chris Tomlinson
Venue: ACM Computing Surveys (CSUR) (1988)

Object-oriented programming is becoming a popular approach to the construction of complex software systems. Benefits of object orientation include support for modular design, code sharing, and extensibility. In order to make the most of these advantages, a type theory for objects and their interactions should be developed to aid checking and controlled derivation of programs and to support early binding of code bodies for efficiency. As a step in this direction, this paper surveys a number of existing type theories and examines the manner and extent to which these theories are able to represent the ideas found in object-oriented programming. Of primary interest are the models provided by type theories for abstract data types and inheritance, and the major portion of this paper is devoted to these topics. Code fragments illustrative of the various approaches are provided and discussed. The introduction provides an overview of object-oriented programming and types in programming languages; the summary provides a comparative evaluation of the reviewed typing systems, along with suggestions for future work.
Available instruction-level parallelism for superscalar and superpipelined machines
Authors: N. P. Jouppi, D. W. Wall
Venue: ACM SIGARCH Computer Architecture News (1989)

Superscalar machines can issue several instructions per cycle. Superpipelined machines can issue only one instruction per cycle, but they have cycle times shorter than the latency of any functional unit. In this paper these two techniques are shown to be roughly equivalent ways of exploiting instruction-level parallelism. A parameterizable code reorganization and simulation system was developed and used to measure instruction-level parallelism for a series of benchmarks. Results of these simulations in the presence of various compiler optimizations are presented. The average degree of superpipelining metric is introduced. Our simulations suggest that this metric is already high for many machines. These machines already exploit all of the instruction-level parallelism available in many non-numeric applications, even without parallel instruction issue or higher degrees of pipelining.
Improving the performance of the Kernighan-Lin and simulated annealing graph bisection algorithms
Authors: T. Bui, C. Heigham, C. Jones, T. Leighton
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

In this paper, we compare the performance of two popular graph bisection algorithms. We also present an empirical study of a new heuristic, first proposed in [B87], that dramatically improves the performance of these bisection algorithms on graphs with small (&le; 4) average degree.
A Debugger for Ada Tasking
Authors: Anne R. Brindle, Richard N. Taylor, David F. Martin
Venue: IEEE Transactions on Software Engineering (1989)

The capabilities needed in an Ada debugger are discussed in light of the language's tasking constructs, and the design for a debugger is presented which operates in concert with a single-processor Ada interpreter. This debugger design demonstrates the extensions to sequential debugging techniques that are necessary to handle concurrency, and shows that significant debugging functionality can be provided even without the inclusion of automatic error diagnosis methods. The issues considered include isolation of effects and display of the full dynamic execution status, both of which are essential to diagnosis of concurrent programs.