ppxscal/embedding_network huggingface dataset:
Incremental distribution of timestamp packets: a new approach to distributed garbage collection
Authors: M. Schelvis
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1989)

A new algorithm for distributed garbage collection is presented. This algorithm collects distributed garbage incrementally and concurrently with user activity. It is the first incremental algorithm that is capable of collecting cyclic distributed garbage. Computational and network communication overhead are acceptable. Hosts may be temporarily inaccessible and synchronization between hosts is not necessary. The algorithm is based on asynchronous distribution of timestamp packets each containing a list of last-access times of some relevant remotely referenced objects. Finally, the correctness and time complexity of the algorithm are discussed.
Explaining ambiguity in a formal query language
Authors: Joseph A. Wald, Paul G. Sorenson
Venue: ACM Transactions on Database Systems (TODS) (1990)

The problem of generating reasonable natural language-like responses to queries formulated in nonnavigational query languages with logical data independence is addressed. An extended ER model, the Entity-Relationship-Involvement model, is defined which assists in providing a greater degree of logical data independence and the generation of natural language explanations of a query processor's interpretation of a query. These are accomplished with the addition of the concept of an involvement to the model. Based on involvement definitions in a formally defined data definition language, DDL, an innovative strategy for generating explanations is outlined and exemplified. In the conclusion, possible extensions to the approach are given.
A canonical form for parallel programs
Authors: D. E. Stevenson
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

We present a technique for analyzing a sequential program for possible parallelism. The technique is basically that used by compilers during optimization. The technique can be used without programming.
Towards fully abstract semantics for local variables
Authors: A. R. Meyer, K. Sieber
Venue: Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1988)

The Store Model of Halpern-Meyer-Trakhtenbrot is shown&mdash;after suitable repair&mdash;to be a fully abstract model for a limited fragment of ALGOL in which procedures do not take procedure parameters. A simple counter-example involving a parameter of program type shows that the model is not fully abstract in general. Previous proof systems for reasoning about procedures are typically sound for the HMT store model, so it follows that theorems about the counter-example are independent of such proof systems. Based on a generalization of standard cpo based models to structures called locally complete partial orders (lcpo's), improved models and stronger proof rules are developed to handle such examples.
Hard problems for simple logic programs
Authors: Yatin P. Saraiya
Venue: ACM SIGMOD Record (1990)

A number of optimizations have been proposed for Datalog programs involving a single intensional predicate (&ldquo;single-IDB programs&rdquo;). Examples include the detection of commutativity and separability ([Naug88],[RSUV89], [Ioan89a]) in linear logic programs, and the detection of ZYT-linearizability ([ZYT88], [RSUV89], [Sara89], [Sara90]) in nonlinear programs. We show that the natural generalizations of the commutativity and ZYT-linearizability problems (respectively, the sequencability and base-case linearizability problems) are undecidable. Our constructions involve the simulation of context-free grammars using single-IDB programs that have a bounded number of initialisation rules. The constructions may be used to show that containment (or equivalence) is undecidable for such programs, even if the programs are linear, or if each program contains a single recursive rule. These results tighten those of [Shmu87] and [Abit89].
Optimization using common random numbers, control variates and multiple comparisons with the best
Authors: W.-N. Yang
Venue: Proceedings of the 21st conference on Winter simulation (1989)

This paper considers the problem of determining the best of a finite number of system designs by simulation experimentation when the criterion of interest is maximum or minimum expected performance. This is a special case of the general problem of optimization via simulation. The proposed method is based on multiple comparisons with the best (MCB), due to Hsu, which constructs simultaneous interval estimates for the difference between the expected performance of each system design and the best of the other designs. We propose a refinement of Hsu's procedure through the use of two variance reduction techniques, common random numbers and control variates, that are particularly useful in simulation experiments. We show that the proposed procedure is better than standard MCB in the sense that it is more sensitive to differences in expected performance.
Development and evaluation of direct manipulation lists (poster session)
Authors: D. Beck, J. Elkerton
Venue: ACM SIGCHI Bulletin (1989)

Item selection from a large list is an important task in many interfaces. This research examined a direct manipulation list for browsing and retrieving information. With direct manipulation lists several different retrieval methods can be considered such as scrolling, paging, using string search methods, or using an "elevator". The question asked was which retrieval methods would lead to fast and efficient retrieval for different list lengths and levels of user familiarity with the lists. A 3 x 2 between-subjects factorial design was used with list sizes of 25, 50, and 100 items and users who were either familiar or unfamiliar with the lists. In this experiment, only use of an elevator and paging were studied due to the common use of elevators in many state-of-the-art interfaces and an initial experiment which showed that scrolling was not an efficient method. The results showed that the list size and user familiarity with the list were both significant factors in the retrieval time. A more detailed analysis of retrieval performance revealed that these effects could have been influenced by users having difficulty estimating the position of an item. Moreover, users in the middle of a list tended to use a single method (such as paging), despite the predicted and observed efficiency of using both paging and the elevator. Based upon these results, a new method for direct manipulation is proposed which separates the elevator into regions with specified ranges of items so that the user knows where items are in the list. A task analysis of this method shows promise in ease of use as compared to other methods.
Declarative expression of deductive database updates
Authors: S. Manchanda
Venue: Proceedings of the eighth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1989)

An update can be specified as a single database state transition, or as a sequence of queries and database state transitions. We give an extension of Datalog for expressing both types of update specifications on a logic database. The extension supports the simple and intuitive expression of basic update operations, hypothetical reasoning and update procedures. The extension possesses a possible-world semantics, and a sound and complete proof theory. Soundness and completeness is proved by showing that an update procedure can be mapped into a semantically equivalent Pure Prolog program. This means that the semantic and proof-theoretic results of Pure Prolog can be mapped into similar results for the Datalog extension.
Mixin-based inheritance
Authors: Gilad Bracha, William Cook
Venue: Proceedings of the European conference on object-oriented programming on Object-oriented programming systems, languages, and applications (1990)

The diverse inheritance mechanisms provided by Smalltalk, Beta, and CLOS are interpreted as different uses of a single underlying construct. Smalltalk and Beta differ primarily in the direction of class hierarchy growth. These inheritance mechanisms are subsumed in a new inheritance model based on composition of mixins, or abstract subclasses. This form of inheritance can also encode a CLOS multiple-inheritance hierarchy, although changes to the encoded hierarchy that would violate encapsulation are difficult. Practical application of mixin-based inheritance is illustrated in a sketch of an extension to Modula-3.
Investigating the effects of color
Authors: E. Hoadley
Venue: Communications of the ACM (1990)

A laboratory experiment studies the effects of color on a decision maker's ability to extract information from different graphical and tabular presentations. Results indicate color improves time performance for tables, pie charts and bar graphs, and accuracy performance for pie charts and line graphs.
A reliable and efficient multicast for broadband broadcast networks
Authors: A. Erramilli, R. P. Singh
Venue: Proceedings of the ACM workshop on Frontiers in computer communications technology (1987)

A reliable and efficient data transfer protocol is proposed for multicast applications in broadband broadcast networks. The protocol is based on negative acknowledgements, with several enhancements so that it matches most of the functionality of a positive acknowledgement based protocol. The protocol makes the best use of resources in the broadband network environment by conserving processing and trading off transmission and storage resources. The performance of this protocol is compared with the positive acknowledgement based protocol on the basis of maximum throughput as a function of group size for lecture and conference applications.
The white dwarf: a high-performance application-specific processor
Authors: A. Wolfe, M. Breternitz,  Jr., C. Stephens, A. L. Ting, D. B. Kirk
Venue: Proceedings of the 15th Annual International Symposium on Computer architecture (1988)

This paper presents the design and implementation of a high-performance special-purpose processor, called The White Dwarf, for accelerating finite element analysis algorithms. The White Dwarf CPU contains two Am29325 32-bit floating-point processors and one Am29332 32-bit ALU, and employs a wide-instruction word architecture in which the application algorithm is directly implemented in microcode. The entire system is VME-bus compatible and interfaces with a SUN 31160 host. The system's potential peak performance is 20 MFLOPS; a sustained computation rate in excess of 15 MFLOPS is expected. A potential speedup of between one and two orders of magnitude is possible. With a fully populated memory subsystem, the White Dwarf can accommodate finite element problems involving up to half a million nodes. The system is designed using an approach called Application-Specific Processor Design. A retargetable compiler has been developed which is capable of generating highly parallel and efficient code for the White Dwarf and other processors with similar architecture. System debuglintegration is in progress; a highly useful system is expected.
Sensitivity analysis of reliability and performability measures for multiprocessor systems
Authors: J. T. Blake, A. L. Reibman, K. S. Trivedi
Venue: ACM SIGMETRICS Performance Evaluation Review (1988)

Traditional evaluation techniques for multiprocessor systems use Markov chains and Markov reward models to compute measures such as mean time to failure, reliability, performance, and performability. In this paper, we discuss the extension of Markov models to include parametric sensitivity analysis. Using such analysis, we can guide system optimization, identify parts of a system model sensitive to error, and find system reliability and performability bottlenecks. As an example we consider three models of a 16 processor. 16 memory system. A network provides communication between the processors and the memories. Two crossbar-network models and the Omega network are considered. For these models, we examine the sensitivity of the mean time to failure, unreliability, and performability to changes in component failure rates. We use the sensitivities to identify bottlenecks in the three system models.
Incremental dynamic semantics for language-based programming environments
Authors: G. E. Kaiser
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1989)

Attribute grammars are a formal notation for expressing the static semantics of programming languages&mdash;those properties that can be derived from inspection of the program text. Attribute grammars have become popular as a mechanism for generating language-based programming environments that incrementally perform symbol resolution, type checking, code generation, and derivation of other static semantic properties as the program is modified. However, attribute grammars are not suitable for expressing dynamic semantics&mdash;those properties that reflect the history of program execution and/or user interactions with the programming environment. This paper presents action equations, an extension of attribute grammars suitable for specifying the static and the dynamic semantics of programming languages. It describes how action equations can be used to generate language-based programming environments that incrementally derive static and dynamic properties as the user modifies and debugs th e program.
Polynomial Time Learnability of Simple Deterministic Languages
Authors: Hiroki Ishizaka
Venue: Machine Learning (1990)

This paper is concerned with the problem of learning simple deterministic languages. The algorithm described in this paper is based on the theory of model inference given by Shapiro. In our setting, however, nonterminal membership queries, except for the start symbol, are not permitted. Extended equivalence queries are used instead. Nonterminals that are necessary for a correct grammar and their intended models are introduced automatically. We give an algorithm that, for any simple deterministic language L, outputs a grammar G in 2-standard form, such that L &equals; L(G), using membership queries and extended equivalence queries. We also show that the algorithm runs in time polynomial in the length of the longest counterexample and the number of nonterminals in a minimal grammar for L.
Optimal algorithms for Byzantine agreement
Authors: Paul Feldman, Silvio Micali
Venue: Proceedings of the twentieth annual ACM symposium on Theory of computing (1988)

We exhibit randomized Byzantine agreement (BA) algorithms achieving optimal running time and fault tolerance against all types of adversaries ever considered in the literature. Our BA algorithms do not require trusted parties, preprocessing, or non-constructive arguments. Given private communication lines, we show that n processors can reach BA in expected constant time in a syncronous network if any < n/3 faults occur in an asynchronous network if any < n/4 faults occur For both synchronous and asynchronous networks whose lines do not guarantee private communication, we may use cryptography to obtain algorithms optimal both in fault tolerance and running time against computationally bounded adversaries. (Thus, in this setting, we tolerate up to n/3 faults even in an asynchronous network.)
Page table management in local/remote architectures
Authors: M. A. Holliday
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

We conjecture that a paged memory with page migration by the operating system may be an effective system environment for a local/remote shared memory architecture executing a single parallel computation. Implementing a paged memory in such an architecture raises several issues with respect to page table management. These issues include page table placement, page table replication level, and page table storage overhead. We discuss these issues, propose alternative solutions, and present an experimental evaluation of the solutions. The experiments were conducted using software implemented page tables on a 32-node BBN Butterfly. The experiments have investigated the case of a single shared-memory parallel computation with one user process per processor. The implementation captures the costs of page table entry locking and reference information updating. Each user process has a copy of the computation's code and non-shared variables in local memory. Only shared data references use the page tables. A separate processor has a migration daemon that periodically unblocks itself and examines the page tables to make policy decisions concerning page migration. The conclusions drawn include that: 1) a fully replicated page-indexed page table significantly reduces network, memory, and lock contention in comparison to a single copy, 2) a fully replicated page-indexed page table faces a severe memory utilization problem in large-scale architectures, 3) a proposed approach based on inverted page tables appears to be a promising alternative to a fully replicated page-indexed page table.
A hypercube Ray-tracer
Authors: J. Salmon, J. Goldsmith
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

We describe a hypercube ray-tracing program for rendering computer graphics. For small models, which fit in the memory of a single processor, the ray-tracer uses a scattered decomposition of pixels to balance the load, and achieves a very high efficiency. The more interesting case of large models, which cannot be stored in a single processor, requires a decomposition of the model data as well as the pixels. We present algorithms for constructing a decomposition based upon information about the frequency with which different elements of the model are accessed. The resulting decomposition is approximately optimized to minimize communication and achieve load balance.
Detecting and decomposing self-overlapping curves
Authors: P. W. Shor, C. J. van Wyk
Venue: Proceedings of the fifth annual symposium on Computational geometry (1989)

Paint one side of a rubber disk black and the other side white; stretch the disk any way you wish in three-dimensional space, subject to the condition that from any point in space, if you look down you see either the white side of the disk or nothing at all. Now make the stretched disk transparent but color its boundary black; project its boundary into a plane that lies below the disk. The resulting curve is self-overlapping. We show how to test whether a given curve is self-overlapping, and how to count how many essentially different stretchings of the disk could give rise to the same curve.
DIANA: an intermediate language for Ada
Authors: Gernard Goos, William A. Wulf, Arthur Evans,  Jr., Kenneth J. Butler
Venue: Springer Lecture Notes In Computer Science; Vol. 161 (2000)

This document describes DIANA, a Descriptive Intermediate Attributed Notation for Ada, being both an introduction and reference manual for it. DIANA is an abstract data type such that each object of the type is a representation of an intermediate form of an Ada program. Although the initial uses of this form were for communication between the Front and Back Ends of an Ada compiler, it is also intended to be suitable for use with other tools in an Ada programming environment. DIANA resulted from a merger of the best properties of two earlier similar intermediate forms: TCOL and AIDA. &mdash;Author's Abstract &mdash;Abstract recommended by M. B. Wells, Las Cruces, NM
Contracts: specifying behavioral compositions in object-oriented systems
Authors: Richard Helm, Ian M. Holland, Dipayan Gangopadhyay
Venue: Proceedings of the European conference on object-oriented programming on Object-oriented programming systems, languages, and applications (1990)

Behavioral compositions, groups of interdependent objects cooperating to accomplish tasks, are an important feature of object-oriented systems. This paper introduces Contracts, a new technique for specifying behavioral compositions and the obligations on participating objects. Refinement and composition of contracts allows for the creation of large grain abstractions based on behavior, orthogonal to those provided by existing class constructs. Using contracts thus provides a basis and vocabulary for Interaction-Oriented design which greatly facilitates the early identification, abstraction and reuse of patterns of behavior in programs. Contracts differ from previous work in that they capture explicitly and abstractly the behavioral dependencies amongst cooperating objects. By explicitly stating these dependencies, contract also provide an effective aid for program understanding and reuse.
Polymer simulation on the hypercube
Authors: H-Q. Ding
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

The Monte Carlo simulation of a model polymer is implemented on the Mark III Hypercube computer under the CROS operating system. The polymer model and the simulation method are discussed. The key features of the implementation are given. The results show that hypercube computers are well suited for the polymer simulations.
On an installation of Buchberger's algorithm
Authors: Rüdiger Gebauer, H. Michael Möller
Venue: Journal of Symbolic Computation (1988)

Buchberger's algorithm calculates Groebner bases of polynomial ideals. Its efficiency dependsstrongly on practical criteria for detecting superfluous reductions. Buchberger recommends two criteria. The more important one is interpreted in this paper as a criterion for detecting redundant elements in a basis of a module of syzygies. We present a method for obtaining a reduced, nearly minimal basis of that module. The simple procedure for detecting (redundant syzygies and) superfluous reductions is incorporated now in our installation of Buchberger's algorithm in SCRATCHPAD II and REDUCE 3.3. The paper concludes with statistics stressing the good computational properties of these installations.
Computing with endomorphism ringsof modular representations
Authors: Gerhard J. A. Schneider
Venue: Journal of Symbolic Computation (1990)

This paper presents several new algorithms for computing properties of modular group representations including indecomposability, vertices and sources. These methods are all implemented as part of the CAYLEY system. New results obtained using these methods are presented.
Region Scheduling: An Approach for Detecting and Redistributing Parallelism
Authors: Rajiv Gupta, Mary Lou Soffa
Venue: IEEE Transactions on Software Engineering (1990)

Region scheduling, a technique applicable to both fine-grain and coarse-grain parallelism, uses a program representation that divides a program into regions consisting of source and intermediate level statements and permits the expression of both data and control dependencies. Guided by estimates of the parallelism present in regions, the region scheduler redistributes code, thus providing opportunities for parallelism in those regions containing insufficient parallelism compared to the capabilities of the executing architecture. The program representation and the transformations are applicable to both structured and unstructured programs, making region scheduling useful for a wide range of applications. The results of experiments conducted using the technique in the generation of code for a reconfigurable long instruction word architecture are presented. The advantages of region scheduling over trace scheduling are discussed.