ppxscal/embedding_network huggingface dataset:
Analysis of Performability for Stochastic Models of Fault-Tolerant Systems
Authors: B R Iyer, L Donatiello, P Heidelberger
Venue: IEEE Transactions on Computers (1986)

Performability, a composite measure for the performance and reliability, may be interpreted as the probability density function of the aggregate reward obtained from a system during its mission time. For large mission times we show that known limit theorems lead to an asymptotic normal distribution for the aggregate reward. For finite mission times and Markovian models we obtain the expressions for all moments of performability and give recursions to compute coefficients involved in the expressions. We illustrate the use of the results through an example of a multiple processor computer system.
Some considerations for using approximate optimal queries
Authors: K. L. Kwok
Venue: Proceedings of the 10th annual international ACM SIGIR conference on Research and development in information retrieval (1987)

An optimal query has been defined as one which will recover all the known relevant documents of a query in their best probability of relevance ranking. We have slightly modified the definition so that it also allows one to trace its evolution from the original to the optimal via the various feedback stages. Such a query can be constructed by modifying the original query with terms from the known relevant documents. It is pointed out that such a term addition strategy differs materially from other approaches that add terms based on term association with all query terms, and calculated from the whole document collection. The effect of viewing a document as constituted of components, and hence affecting the weighting and retreival results of of the optimal query, is also discussed.
A content analysis of six introduction to computer science textbooks
Authors: H. Willis Means
Venue: Proceedings of the eighteenth SIGCSE technical symposium on Computer science education (1987)

A content analysis was conducted on three pairs of introduction to computer science textbooks to determine if there were any significant differences in their content. The results of the analysis seem to indicate that the content of major topics in earlier computer science texts is not signficantly different from more recent textbooks.
The Texas Instruments 34010 Graphics System Processor
Authors: Mike Asal, Graham Short, Tom Preston, Richard Simpson, Derek Roskell, Karl Guttag
Venue: IEEE Computer Graphics and Applications (1986)

The 34010 Graphics System Processor is a 32-bit graphics microprocessor capable of executing high-level languages. It combines a full general-purpose instruction set with a powerful set of graphics instructions that includes arithmetic as well as Boolean pixbits (pixel block transfers). Because it is completely programmable, the 34010 can be used in many different graphics and nongraphics applications. it was designed to support a wide range of display resolutions and pixel sizes, as well as applications such as page (laser) printers, ink jet printers, data compression, and facsimile transmission. The 34010 includes such system features as an on-board instruction cache, full interrupt capability, wait and hold functions, and display timing control, as well as test and emulation support. Unique among today's microprocessors, the 34010 addresses all memory down to the bit level with variably sized fields rather than the common byte or word addressing. For example, the 34010 can push a 5-bit quantity onto a stack. This field-processing capability is an integral part of the basic architecture.
Database performance evaluation in an indexed file environment
Authors: Jane Fedorowicz
Venue: ACM Transactions on Database Systems (TODS) (1987)

The use of database systems for managerial decision making often incorporates information-retrieval capabilities with numeric report generation. Of great concern to the user of such a system is the response time associated with issuing a query to the database. This study presents a procedure for estimating response time for one of the most frequently encountered physical storage mechanisms, the indexed file. The model provides a fairly high degree of accuracy, but is simple enough so that the cost of applying the model is not exorbitant. The model incorporates the knowledge that the distribution of access key occurrences is known to follow Zipf's law. It first estimates the access time required to complete the query, which includes the time needed for all input and output transactions, and CPU time used in performing the search. The effects of multiple users on an individual's response time are then assessed using a simple regression estimation technique. The two-step procedure allows for the separation of access time from multiuser influences.
Model-driven reasoning for diagnosis
Authors: J Yan
Venue: Issue 98 (October 1986) (1986)

We introduce the "model-driven reasoning" as an approach to diagnosing. Lucidness and explicitness of knowledge representation are emphasized. Good partitioning of diagnosis knowledge in the structure results in the attention focusing of interpretation and gives efficient reasoning power. The approach has been used in the design of a knowledge-based system for identifying paleo-depositional environments in oil prospecting.
Optimal directory placement on disk storage devices
Authors: A. R. Calderbank, E. G. Coffman,  Jr., Leopold Flatto
Venue: Journal of the ACM (JACM) (1988)

Two mathematical models dealing with optimal placement of directories on disk devices are analyzed. Storage addresses on the disk are approximated by points in the interval [0, 1]. Requests for information on the disk are represented by a sequence of file names. To process a request, a read-write head is first moved to a directory kept on the disk that specifies the address of the file, and then a head is moved to the specified address. The addresses are assumed to be independent and uniform on [0,1]. In the first model we consider a system of two heads separated by a fixed distance d and a directory situated at 0 &le; x &le; 1. In the second model we consider a system consisting of one head and n &ge; 2 directories at 0 &le; x1 < x2 < &hellip; < xn &le; 1. For both models we study the problem of finding those values of the parameters that minimize the expected head motion to process a request in statistical equilibrium.
Efficient incremental evaluation of aggregate values in attribute grammars
Authors: Roger Hoover, Tim Teitelbaum
Venue: ACM SIGPLAN Notices (1986)

Aggregate valued attributes, which store collections of keyed elements, are required in attribute grammars to communicate information from multiple definition sites to multiple use locations. For syntax directed editors and incremental compilers, symbol tables are represented as aggregate values. We present efficient algorithms for incrementally maintaining these aggregate values and give an incremental evaluation algorithm that restricts attribute propagation to attributes dependent only upon information within the aggregate value that has changed.
The VLSI Design of an Error-Trellis Syndrome Decoder for Certain Convolutional Codes
Authors: I S Reed, T L Truong, J M Jensen, I S Hsu
Venue: IEEE Transactions on Computers (1986)

In this paper a recursive algorithm using the error-trellis decoding technique is developed to decode certain convolutional codes (CC's). An example, illustrating the VLSI architecture of such a decoder, is given for a dual-k CC. It is demonstrated that such a decoder can be realized readily on a single chip with NMOS technology.
Logical modeling of temporal data
Authors: Arie Segev, Arie Shoshani
Venue: ACM SIGMOD Record (1987)

In this paper we examine the semantics and develop constructs for temporal data independent of any traditional data model, such as the relational or network data models. Unlike many other works which extend existing models to support temporal data, our purpose is to characterize the properties of temporal data and operators over them without being influenced by traditional models which were not specifically designed to model temporal data. We develop data constructs that represent sequences of temporal values, identify their semantic properties, and define operations over these structures.
Object-oriented spreadsheets: the analytic spreadsheet package
Authors: Kurt W. Piersol
Venue: ACM SIGPLAN Notices (1986)

The ASP package, a spreadsheet implemented in Smalltalk-80, is discussed. A description of the unique data manipulation features of ASP is given. A discussion of how these features arise from the Smalltalk-80 environment is included, with emphasis on features not common to all object oriented languages.
Approximation algorithms for shortest path motion planning
Authors: K. Clarkson
Venue: Proceedings of the nineteenth annual ACM symposium on Theory of computing (1987)

This paper gives approximation algorithms of solving the following motion planning problem: Given a set of polyhedral obstacles and points s and t, find a shortest path from s to t that avoids the obstacles. The paths found by the algorithms are piecewise linear, and the length of a path is the sum of the lengths of the line segments making up the path. Approximation algorithms will be given for versions of this problem in the plane and in three-dimensional space. The algorithms return an &egr;-short path, that is, a path with length within (1 + &egr;) of shortest. Let n be the total number of faces of the polyhedral obstacles, and &egr; a given value satisfying &Ogr; < &egr; &le; &pgr;. The algorithm for the planar case requires &Ogr;(n log n)/&egr; time to build a data structure of size &Ogr;(n/&egr;). Given points s and t, and &egr;-short path from s to t can be found with the use of the data structure in time &Ogr;(n/&egr; + n log n). The data structure is associated with a new variety of Voronoi diagram. Given obstacles S &sub; &Egr;3 and points s, t &egr; E3, an &egr;-short path between s and t can be found in &Ogr;(n2&lgr;(n) log(n/&egr;)/&egr;4 + n2 lognp log(n logp)) time, where p is the ratio of the length of the longest obstacle edge to the distance between s to t. The function &lgr;(n) = &agr;(n)&Ogr;(&agr;(n)&Ogr;(1)), where the &agr;(n) is a form of inverse of Ackermann's function. For log(1/&egr;) and log p that are &Ogr;(log n), this bound is &Ogr;(log n2(n)&lgr;(n)/&egr;4).
History, state and future of user interface management systems
Authors: Jonas Löwgren
Venue: ACM SIGCHI Bulletin (1988)

This paper is an attempt to survey the topic of User Interface Management Systems (UIMSs). We give a short account of the historical development of UIMSs, try to capture what is regarded as state of the art in the area, and examine the role of a UIMS in the process of software development. We also summarize several future research directions commonly recognized as important.
Bound hierarchies for multiple-class queuing networks
Authors: Derek L. Eager, Kenneth C. Sevcik
Venue: Journal of the ACM (JACM) (1986)

An algorithm for computing bounds on the performance measures of multiple-class, product-form queuing networks is presented. The algorithm offers the user a hierarchy of bounds with differing accuracy levels and computational cost requirements. Unlike previously proposed bounding algorithms, the algorithm is applicable to all of the types of product-form queuing networks that are commonly used in computer system and computer-communication network applications.
A new normal form for nested relations
Authors: Z. Meral Ozsoyoglu, Li-Yan Yuan
Venue: ACM Transactions on Database Systems (TODS) (1987)

We consider nested relations whose schemes are structured as trees, called scheme trees, and introduce a normal form for such relations, called the nested normal form. Given a set of attributes U, and a set of multivalued dependencies (MVDs) M over these attributes, we present an algorithm to obtain a nested normal form decomposition of U with respect to M. Such a decomposition has several desirable properties, such as explicitly representing a set of full and embedded MVDs implied by M, and being a faithful and nonredundant representation of U. Moreover, if the given set of MVDs is conflict-free, then the nested normal form decomposition is also dependency-preserving. Finally, we show that if M is conflict-free, then the set of root-to-leaf paths of scheme trees in nested normal form decomposition is precisely the unique 4NF decomposition [9, 16] of U with respect to M.
An approach to fault tolerance and error recovery in a parallel graph reduction machine: MaRS&mdash;a case study
Authors: Alessandro Contessa
Venue: ACM SIGARCH Computer Architecture News (1988)

This article deals with the issue of fault tolerance and error recovery in a parallel graph reduction computer such as the "MaRS" machine presently under development at CERT. This is a multiprocessor system with decentralized control and asynchronous, delayed communications between cooperating, tightly coupled processes. A solution for the problem of MaRS error recovery is derived, based on the machine's execution model (successive reductions performed on the program graph, i.e. evaluations on the functional expression to be computed) and on its architectural organization (a number of reduction units and memory units interconnected by a message switching network). Under the basic assumption that the errors generated by faults in Reduction and Communication Processors can be detected and confined so as to avoid system contamination, it is shown that a coherent and errorfree recovery state can be restored. Although specifically developed for the MaRS machine, this solution is in principle applicable to other machines using the graph reduction model.
White pebbles help
Authors: R Wilber
Venue: Proceedings of the seventeenth annual ACM symposium on Theory of computing (1985)

A family of directed acyclic graphs of vertex indegree 2 is constructed for which there are strategies of the black-white pebble game that use asymptotically fewer pebbles than the best strategies of the black pebble game. This shows that there are straight-line programs that can be evaluated nondeterministically with asymptotically less space than is required by any deterministic evaluation.
Sort sets in the relational model
Authors: Seymour Ginsburg, Richard Hull
Venue: Journal of the ACM (JACM) (1986)

The notion of sort set is introduced here to formalize the fact that certain database relations can be sorted so that two or more columns are simultaneously listed in order. This notion is shown to be applicable in several ways to enhance the efficiency of an implemented database. A characterization of when order dependency implies the existence of sort sets in a database is presented, along with several corollaries concerning complexity, Armstrong relations, and cliques of certain graphs. Sort-set dependencies are then introduced. A (finite) sound and complete set of inference rules for sort-set dependencies is presented, as well as a proof that there is no such set for functional and sort-set dependencies taken together. Deciding logical implication for sort-set dependencies is proved to be polynomial, but if functional dependencies are included the problem is co-NP-complete. Each set of sort-set and functional dependencies is shown to have an Armstrong relation. A natural generalization of Armstrong relation, here called separator, is given and then used to study the relationship between order and sort-set dependencies.
Prime rule-based methodologies give inadequate control
Authors: J R B Cockett, J Herrera
Venue: Proceedings of the ACM SIGART international symposium on Methodologies for intelligent systems (1986)

The use of rule-based methodologies in the development of Expert Systems is widespread. In order to provide good explanations in these systems it is desirable that the rules be prime. The difficulty of expressing control in such rules, and thus arriving at a desirable sequencing of events, has led to pragmatic additions to the basic methodology. Recent developments in the theory of decision processes have provided new insight into the form of a desirable sequencing. Prime rules, even when augmented by sophisticated control strategies, cannot generate from backward chaining all these desirable sequencings. Furthermore, if one of these desirable sequencings happens to be generated from prime rules it may be by luck rather than design.
Portability of software
Authors: Hermann Kaindl
Venue: ACM SIGPLAN Notices (1988)

This paper is based on experiences with several ports of large programs written in modern high-level languages. Even today, porting software is very often problematic and costly in practice. Thus it seems important to find out what can be learned from such experiences in order to solve these problems better in the future and consequently to reduce the related costs. First, a definition of the term port is given to clarify the important relationships of a program with the environments involved. A layered model is built around the standard of a programming language, and based on this model "rules" for writing portable programs are stated. It appears that both the layered model and the rules are principally valid for many important languages, in particular also Ada reg;. While this language will bring us a large step closer to portable software, we will have to face portability problems also in the future.
A Butler process for resource sharing on Spice machines
Authors: Roger B. Dannenberg, Peter G. Hibbard
Venue: ACM Transactions on Information Systems (TOIS) (1985)

A network of personal computers may contain a large amount of distributed computing resources. For a number of reasons it is desirable to share these resources, but sharing is complicated by issues of security and autonomy. A process known as the Butler addresses these problems and provides support for resource sharing. The Butler relies upon a capability-based accounting system called the Banker to monitor the use of local resources.
Debugging Parallel Programs with Instant Replay
Authors: T. J. LeBlanc, J. M. Mellor-Crummey
Venue: IEEE Transactions on Computers (1987)

The debugging cycle is the most common methodology for finding and correcting errors in sequential programs. Cyclic debugging is effective because sequential programs are usually deterministic. Debugging parallel programs is considerably more difficult because successive executions of the same program often do not produce the same results. In this paper we present a general solution for reproducing the execution behavior of parallel programs, termed Instant Replay. During program execution we save the relative order of significant events as they occur, not the data associated with such events. As a result, our approach requires less time and space to save the information needed for program replay than other methods. Our technique is not dependent on any particular form of interprocess communication. It provides for replay of an entire program, rather than individual processes in isolation. No centralized bottlenecks are introduced and there is no need for synchronized clocks or a globally consistent logical time. We describe a prototype implementation of Instant Replay on the BBN Butterfly Parallel Processor, and discuss how it can be incorporated into the debugging cycle for parallel programs.
Database schema design: an experimental comparison between normalization and information analysis
Authors: Peretz Shoval, Moshe Even-Chaime
Venue: ACM SIGMIS Database (1987)

This article compares two different methods for designing a data base schema-normalization and information analysis (IA). A set of design tasks was assigned to two groups of analysts who were trained to use the two methods in conjunction with the structured analysis method of system analysis. The results of the experiment revealed that the quality of the data base schemata designed using normalization was better than that designed using IA, that normalization required less time than IA to perform, and that the analysts preferred normalization.
The Load-Sharing Banyan Network
Authors: C -T A Lea
Venue: IEEE Transactions on Computers (1986)

Banyan networks, as well as many other self-routing networks, have a simple and regular topology, and can be easily diagnosed and maintained. However, like many other self- routing networks, Banyan networks have only one path between each input and output pair. Failures of a single link or node will make many paths unavailable, and certain traffic patterns can cause severe congestion in the networks.
A Generalized Message-Passing Mechanism for Communicating Sequential Processes
Authors: Patrick M. Lenders
Venue: IEEE Transactions on Computers (1988)

Bidirectional message-passing (bi-io), a novel symmetric communication mechanism for concurrent processes, is introduced and developed. The mechanism is symmetric in the sense that, in one atomic action, a message is transmitted in each direction between two processes. For some applications (tree structure, systolic arrays) this method is shown to have several advantages over conventional synchronization and communication primitives (mainly conciseness of programs, absence of certain types of deadlock). The mechanism is rigorously defined with a CSP-like syntax and a weakest-precondition semantics. Two systolic arrays are developed using bidirectional message-passing: a matrix-vector multiplier and a palindrome recognizer.
HAM: a general purpose hypertext abstract machine
Authors: Brad Campbell, Joseph, M. Goodman
Venue: Communications of the ACM (1988)

The HAM is a transaction-based server for a hyper text storage system. The server is designed to handle multiple users in a networked environment. The storage system consists of a collection of contexts, nodes, links, and attributes that make up a hypertext graph. The versatility of the HAM can be illustrated by showing how Guide buttons, intermedia webs, and NoteCard FileBoxes can be implemented using its storage model.
Software-controlled caches in the VMP multiprocessor
Authors: D. R. Cheriton, G. A. Slavenburg, P. D. Boyle
Venue: ACM SIGARCH Computer Architecture News (1986)

VMP is an experimental multiprocessor that follows the familiar basic design of multiple processors, each with a cache, connected by a shared bus to global memory. Each processor has a synchronous, virtually addressed, single master connection to its cache, providing very high memory bandwidth. An unusually large cache page size and fast sequential memory copy hardware make it feasible for cache misses to be handled in software, analogously to the handling of virtual memory page faults. Hardware support for cache consistency is limited to a simple state machine that monitors the bus and interrupts the processor when a cache consistency action is required.In this paper, we show how the VMP design provides the high memory bandwidth required by modern high-performance processors with a minimum of hardware complexity and cost. We also describe simple solutions to the consistency problems associated with virtually addressed caches. Simulation results indicate that the design achieves good performance providing data contention is not excessive.
BrouHaHa- A portable Smalltalk interpreter
Authors: Eliot Miranda
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1987)

BrouHaHa is a portable implementation of the Smalltalk-80 virtual machine interpreter. It is a more efficient redesign of the standard Smalltalk specification, and is tailored to suit conventional 32 bit microprocessors. This paper presents the major design changes and optimization techniques used in the BrouHaHa interpreter. The interpreter runs at 30% of the speed of the Dorado on a Sun 3/160 workstation. The implementation is portable because it is written in C.