ppxscal/embedding_network huggingface dataset:
Recoverable Distributed Shared Virtual Memory
Authors: Kun-Lung Wu, W. Kent Fuchs
Venue: IEEE Transactions on Computers (1990)

The problem of rollback recovery in distributed shared virtual environments, in which the shared memory is implemented in software in a loosely coupled distributed multicomputer system, is examined. A user-transparent checkpointing recovery scheme and a new twin-page disk storage management technique are presented for implementing recoverable distributed shared virtual memory. The checkpointing scheme can be integrated with the memory coherence protocol for managing the shared virtual memory. The twin-page disk design allows checkpointing to proceed in an incremental fashion without an explicit undo at the time of recovery. The recoverable distributed shared virtual memory allows the system to restart computation from a checkpoint without a global restart.
Formal Methods Applied to a Floating-Point Number System
Authors: Geoff Barrett
Venue: IEEE Transactions on Software Engineering (1989)

A formalization of the IEEE standard for binary floating-point arithmetic (ANSI/IEEE Std. 754-1985) is presented in the set-theoretic specification language Z. The formal specification is refined into four sequential components, which unpack the operands, perform the arithmetic, and pack and round the result. This refinement follows proven rules and so demonstrates a mathematically rigorous method of program development. In the course of the proofs, useful internal representations of floating-point numbers are specified. The procedures presented form the basis for the floating-point unit of the Inmos IMS T800 transputer.
Profile guided code positioning
Authors: Karl Pettis, Robert C. Hansen
Venue: ACM SIGPLAN Notices (1990)

This paper presents the results of our investigation of code positioning techniques using execution profile data as input into the compilation process. The primary objective of the positioning is to reduce the overhead of the instruction memory hierarchy. After initial investigation in the literature, we decided to implement two prototypes for the Hewlett-Packard Precision Architecture (PA-RISC). The first, built on top of the linker, positions code based on whole procedures. This prototype has the ability to move procedures into an order that is determined by a &ldquo;closest is best&rdquo; strategy. The second prototype, built on top of an existing optimizer package, positions code based on basic blocks within procedures. Groups of basic blocks that would be better as straight-line sequences are identified as chains. These chains are then ordered according to branch heuristics. Code that is never executed during the data collection runs can be physically separated from the primary code of a procedure by a technique we devised called procedure splitting. The algorithms we implemented are described through examples in this paper. The performance improvements from our work are also summarized in various tables and charts.
An Efficient TSC 1-out-of-3 Code Checker
Authors: A. M. Paschalis, C. Efstathiou, C. Halatsis
Venue: IEEE Transactions on Computers (1990)

A design method for a combinational totally self-checking (TSC) 1-out-of-3 code checker is presented. This method is not only simpler and more efficient than others, but is also successful in the case where more than one 1-out-of-3 code exists in a TSC system.
Static inference of modes and data dependencies in logic programs
Authors: Saumya K. Debray
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1989)

Mode and data dependency analyses find many applications in the generation of efficient executable code for logic programs. For example, mode information can be used to generate specialized unification instructions where permissible, to detect determinacy and functionality of programs, generate index structures more intelligently, reduce the amount of runtime tests in systems that support goal suspension, and in the integration of logic and functional languages. Data dependency information can be used for various source-level optimizing transformations, to improve backtracking behavior and to parallelize logic programs. This paper describes and proves correct an algorithm for the static inference of modes and data dependencies in a program. The algorithm is shown to be quite efficient for programs commonly encountered in practice.
An architecture framework for application-specific and scalable architectures
Authors: J. M. Mulder, R. J. Portier, A. Srivastava, R. in't Velt
Venue: ACM SIGARCH Computer Architecture News (1989)

Two major limitations concerning the design of cost-effective application-specific architectures are the recurrent costs of system-software development and hardware implementation, in particular VLSI implementation, for each architecture. The SCalable ARChitecture Experiment (SCARCE) aims to provide a framework for application-specific processor design. The framework allows scaling of functionality, implementation complexity, and performance. The SCARCE framework consists and will consist of: an architecture framework defining the constraints for the design of application-specific architectures; tools for synthesizing architectures from application or application-area; VLSI cell libraries and tools for quick generation of application-specific processors; a system-software platform which can be retargeted quickly to fit the application-specific architecture; This paper concentrates primarily on the architecture framework of SCARCE, but also presents briefly some software issues and outlines the process of generating VLSI processors.
The representation of multistage interconnection networks in queuing models of parallel systems
Authors: Peter G. Harrison
Venue: Journal of the ACM (JACM) (1990)

A major component of a parallel machine is its interconnection network (IN), which provides concurrent communication between the processing elements. It is common to use a multistage interconnection network (MIN) that is constructed using crossbar switches and introduces contention not only for destination addresses but also for internal links. Both types of contention are increased when nonlocal communication across a MIN becomes concentrated on a certain destination address, the hot-spot. This paper considers analytical models of asynchronous, circuit-switched INs in which partial paths are held during path building, beginning with a single crossbar and extending recursively to MINs. Since a path must be held between source and destination processors before data can be transmitted, switching networks are passive resources and queuing networks that include them do not therefore have product-form solutions. Using decomposition techniques, the flow-equivalent server (FES) that represents a bank of devices transmitting through a switching network is determined, under mild approximating assumptions. In the case of a full crossbar, the FES can be solved directly and the result can be applied recursively to model the MIN. Two cases are considered: one in which there is uniform routing and the other where there is a hot-spot at one of the output pins. Validation with respect to simulation for MINs with up to six stages (64-way switching) indicated a high degree of accuracy in the models.
Deep models, normative reasoning and legal expert systems
Authors: T. J. M. Bench-Capon
Venue: Proceedings of the 2nd international conference on Artificial intelligence and law (1989)

This paper discusses the role of deep models and deontic logic in legal expert systems. Whilst much research work insists on the importance of both these features, legal expert systems are being built using shallow models and no more propositional logic, and are claimed to be successful in use. There is then a prima facie conflict between findings of research and commercial practice, which this paper explores, and attempts to explain.
Software engineering team project group member evaluations: some empirical results
Authors: Hubert E. Dunsmore, David P. Moffet, Steven T. Ward
Venue: ACM SIGCSE Bulletin (1989)

Students in a software engineering course at Purdue University in the Fall of 1987 participated in team projects during and after which they completed Group Member Evaluation Forms. These evaluations revealed that: (1) project work load distribution is an area for improvement, (2) our students liked working in a team software development environment, (3) they were happy with their 4-5 person group sizes, (4) contribution critiques were very consistent (including self-critiques) and seemed to correlate well with perceived amount of work done, and (5) there was no consensus about how to handle parasites (i.e., students who do not contribute adequately to the team effort).
An object-oriented framework of pattern recognition systems
Authors: Norihiko Yoshida, Kouji Hino
Venue: ACM SIGPLAN Notices (1988)

In this paper, we describe a purely object-oriented framework of pattern recognition systems. Its aim is in dealing with knowledge representation issues in pattern recognition. In our approach, everything works in an entirely autonomous and decentralized manner. Even a search procedure for sample-concept matching is distributed onto every concept object itself by being implemented in what we introduced as the recursive agent-blackboard model. We developed an experimental prototype of character recognition systems in Smalltalk-80, which proved the ability of the object-oriented framework and the cooperative search procedure.
Reflections on participatory design: lessons from the trillium experience
Authors: Jeanette L. Blomberg, Austin Henderson
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

In recent years system engineers, product designers, and human interface designers have become increasingly interested in developing ways of involving users in the design and evolution of computer-based systems. Some have turned for guidance and inspiration to an approach to systems design pioneered in Scandinavia and often referred to as Participatory Design. In this paper we examine the development of a computer-based design tool, Trillium, which on the surface looked like an example of Participatory Design in that users were directly involved in the development of the technology. Our analysis leads us to conclude, however, that Trillium's development departed in critical ways from our current model of Participatory Design and to suggest that the manner in which users are involved in the development effort plays an important role in the success of the endeavor.
A synthetic visual environment with hand gesturing and voice input
Authors: D. Weimer, S. K. Ganapathy
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Wings for the mind (1989)

This paper describes a practical synthetic visual environment for use in CAD and teleoperation. Instead of using expensive head mounted display systems, we use a standard display and compute smooth shaded images using an AT T Pixel Machine. The interface uses a VPL DataGlove [9] to track the hand, bringing the synthetic world into the same space as the hand. Hand gesturing is used to implement a virtual control panel, and some 3D modeling tasks. When simple speech recognition was added it markedly improved the interface. We also outline what extensions might be needed for using this kind of interface for teleoperation.
Generating highly interactive user interfaces
Authors: C. Wiecha, W. Bennett, s. Boies, J. Gould
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Wings for the mind (1989)

Developers of User Interface Management Systems (UIMS) have demonstrated that separating the application from its user interface supports device independence and customization. Interfaces produced in UIMS are typically crafted by designers expert in human factors and graphic arts. Little attention has been paid, however, to capturing the knowledge of such experts so that interfaces might be automatically generated by the application of style rules to additional applications. This paper considers how toolkits and style rules can be structured so that the resulting interfaces take advantage of the best human factors and graphic arts knowledge, and are consistently styled.
Towards a large number of pipeline processors in a tightly coupled multiprocessor using no cache
Authors: A. Seznec, Y. Jegou
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

Need for performance exists in many scientific applications. The use of multiprocessor structures can not be avoided. The mapping of many applications on distributed supercomputers (e.g. hypercube structure) seems very difficult. On the other hand, performance on most of the large shared memory systems (CEDAR, RP3, ..) suffers from a very high latency of request on the shared memor; caches or local memories are often used to increase performance. Performance depends on a good management of the memory hierarchy (and of the synchronization mechanisms) by the programmer. In previous papers, we have pointed out that passing the WRITEs by the READs on a memory with hardware detection of Read After Write (RAW) hazards allows to reach correct performance on a pipeline processor on a very large spectrum of numerical algorithms even when using a memory with a high latency. It also enables to efficiently synchronize pipeline processors working directly on a shared memory in a relatively small tightly coupled multiprocessor (less than twenty pipeline processors). In this paper, we propose a possible structure of memory access for a tightly coupled multiprocessor with a large number of pipeline processors (64 or 256) working directly on a shared memory.
Exploiting recursion to simplify RPC communication architectures
Authors: D. R. Cheriton
Venue: ACM SIGCOMM Computer Communication Review (1988)

Current communication architectures suffer from a growing collection of protocols in the host operating systems, gateways and applications, resulting in increasing implementation and maintenance cost, unreliability and difficulties with interoperability. The remote procedure call (RPC) approach has been used in some distributed systems to contain the diversity of application layer protocols within the procedure call abstraction. However, the same technique cannot be applied to lower layer protocols without violating the strict notion of layers. In this paper, we show how the RPC approach can be used for lower layer protocols so that the resulting &ldquo;layer violations&rdquo; generate a simple recursive structure. The benefits of exploiting recursion in a communication architecture are similar to those realized from its use as a programming technique; the resulting protocol architecture minimizes the complexity and duplication of protocols and mechanism, thereby reducing the cost of implementation and verification. We also sketch a redesigned DoD Internet architecture that illustrates the potential benefits of this approach. This work was sponsored in part by the Defense Advanced Research Projects Agency under contract N00039-84-C-0211, by Digital Equipment Corporation, by the National Science Foundation Grant DCR-83-52048 and by ATT Information Systems.
Using APL2 in statistics
Authors: A. M. Sykes, A. G. Hawkes
Venue: Conference proceedings on APL as a tool of thought (1989)

The use of APL by professional statisticians is certainly one of the growth areas of APL users in Britain. The increasingly available second generation APL interpreters offer extra facilities that make it an even more attractive language for the jobbing statistician. In this paper, we present ways of using nested arrays and defined operators that are particularly suited to many commonly occurring problems in Statistics.
Distributed shared memory in a loosely coupled distributed system
Authors: B. D. Fleisch
Venue: Proceedings of the ACM workshop on Frontiers in computer communications technology (1987)

This work outlines the development and performance validation of an architecture for distributed shared memory in a loosely coupled distributed computing environment. This distributed shared memory may be used for communication and data exchange between communicants on different computing sites; the mechanism will operate transparently and in a distributed manner. This paper describes the architecture of this mechanism and metrics which will be used to measure its performance. We also discuss a number of issues related to the overall design and what research contribution such an implementation can provide to the computer science field.
Skip lists: a probabilistic alternative to balanced trees
Authors: William Pugh
Venue: Communications of the ACM (1990)

Skip lists are data structures that use probabilistic balancing rather than strictly enforced balancing. As a result, the algorithms for insertion and deletion in skip lists are much simpler and significantly faster than equivalent algorithms for balanced trees.
Fuzzy Multiple-Input Maximum and Minimum Circuits in Current Mode and their Analyses Using Bounded-Difference Equations
Authors: Mamoru Sasaki, Takahiro Inoue, Fumio Ueno, Yuji Shirai
Venue: IEEE Transactions on Computers (1990)

Multiple-input maximum and minimum circuits in current mode are proposed. The operation of these circuits is formulated using simultaneous bounded-difference equations. The exact analyses are performed by solving the bounded-difference equations. The accuracy of these circuits is better than the accuracy of binary tree realizations using two-input max/min circuits because no accumulation of errors occurs; furthermore, the operation speed is higher than the speed of the binary tree realization. The proposed circuits consist of only MOS transistors and are compatible with standard MOS fabrication processes. These circuits are useful building blocks for a real-time fuzzy controller and a fuzzy computer.
Combining Queueing Networks and Generalized Stochastic Petri Nets for the Solution of Complex Models of System Behavior
Authors: G. Balbo, S. C. Bruell, S. Ghanta
Venue: IEEE Transactions on Computers (1988)

A technique is presented whereby queueing network models and generalized stochastic Petri nets are combined in such a way as to exploit the best features of both modeling techniques. The resulting hierarchical modeling approach is useful in the solution of complex models of system behavior. The authors have chosen two examples from the recent literature to illustrate the power and scope of this technique. They also demonstrate how folding of the generalized stochastic Petri net models for these two examples is useful in obtaining efficiently solvable, approximate models (bounding models).
Collaboration awareness in support of collaboration transparency: requirements for the next generation of shared window systems
Authors: J. Chris Lauwers, Keith A. Lantz
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

Shared window systems enable existing applications to be shared in the context of a real-time teleconference. The development and successful use of several such systems, albeit within limited user communities, testifies to the merits of the basic idea. However, experience to date has suggested a number of areas that have not been adequately addressed, namely: spontaneous interactions, shared workspace management, floor control, and annotation and telepointing. This paper focuses on the ramifications, for the software designer, of various user requirements in these areas. While the recommendations that result are motivated by the desire to enable continued use of collaboration-transparent applications, addressing them involves the development of systems software that is distinctly collaboration-aware.
Empirical Learning as a Function of Concept Character
Authors: Larry Rendell, Howard Cho
Venue: Machine Learning (1990)

Concept learning depends on data character. To discover how, some researchers have used theoretical analysis to relate the behavior of idealized learning algorithms to classes of concepts. Others have developed pragmatic measures that relate the behavior of empirical systems such as ID3 and PLS1 to the kinds of concepts encountered in practice. But before learning behavior can be predicted, concepts and data must be characterized. Data characteristics include their number, error, &ldquo;size,&rdquo; and so forth. Although potential characteristics are numerous, they are constrained by the way one views concepts. Viewing concepts as functions over instance space leads to geometric characteristics such as concept size (the proportion of positive instances) and concentration (not too many &ldquo;peaks&rdquo;). Experiments show that some of these characteristics drastically affect the accuracy of concept learning. Sometimes data characteristics interact in non-intuitive ways&semi; for example, noisy data may degrade accuracy differently depending on the size of the concept. Compared with effects of some data characteristics, the choice of learning algorithm appears less important: performance accuracy is degraded only slightly when the splitting criterion is replaced with random selection. Analyzing such observations suggests directions for concept learning research.
Bounded quantifiers have interval models
Authors: Simon Martini
Venue: Proceedings of the 1988 ACM conference on LISP and functional programming (1988)

We propose a sound model for an extension of the language Fun, proposed by L. Cardelli and P. Wegner as a formalization of the notion of inheritance in the context of higher order polymorphic functional 1anguages. The model is obtained by modifying the Interval Model proposed by R. Cartwright, in order to accommodate bounded quantifiers and to obtain a sound structure. Our extension of the language supports also a general recursion operator for functions (but not for types).
The computation of polynomial greatest common divisors over an algebraic number field
Authors: Lars Langemyr, Scott McCallum
Venue: Journal of Symbolic Computation (1989)

We present a modular algorithm for computing the greatest common divisor of two polynomials over an algebraic number field. Our algorithm is an application of ideas of Brown and Collins. We use the Weinberger-Rothschild homomorphic scheme with the important change that we avoid factoring the modular image of the minimal polynomial. We perform a computing time analysis and report some empirical computing times.
The constituent object parser: syntactic structure matching for information retrieval
Authors: Douglas P. Metzler, Stephanie W. Haas
Venue: ACM Transactions on Information Systems (TOIS) (1989)

The Constituent Object Parser is a shallow syntactic parser designed to produce dependency tree representations of syntactic structure that can be used to specify the intended meanings of a sentence more precisely than can the key terms of the sentence alone. It is intended to improve the precision/recall performance of information retrieval and similar text processing applications by providing more powerful matching procedures. The dependency tree representation and the relationship between the intended use of this parser and its design is described, and several problems concerning the processing of ambiguous structures are discussed.