ppxscal/embedding_network huggingface dataset:
Buckwheat: graph reduction on a shared-memory multiprocessor
Authors: Benjamin Goldberg
Venue: Proceedings of the 1988 ACM conference on LISP and functional programming (1988)

Buckwheat is a working implementation of a functional language on the Encore Multimax multiprocessor. It is based on a heterogeneous abstract machine model consisting of both graph reduction and stack oriented execution. Buckwheat consists of two major components: a compiler and a run-time system. The task of the compiler is to detect the exploitable parallelism in programs written in ALFL, a conventional functional language. The run-time system supports processor scheduling, dynamic typing and storage management. In this paper we describe the organization, execution model, and scheduling policies of the Buckwheat run-time system. A large number of experiments have been performed and we present the results.
Implementation of the conjugate gradient algorithm on a vector hypercube multiprocessor
Authors: C. Aykanat, F. Ozguner, D. S. Scott
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

In this paper, parallel implementation and vectorization of the Scaled Conjugate Gradient (SCG) algorithm for the solution of large sparse linear system of equations, on a vector hypercube multiprocessor (iPSC- VX), is described. Computations in the SCG algorithm consist mainly of matrix operations that can be vectorized and are implemented on the Vector Processor on each node of the hypercube. The implementation described here achieves efficient parallelization by overlapping vectorized computations with inter-node communication. A speed-up of 58 over a &micro;Vax II is obtained for large finite element meshes.
Delivery and discrimination: the Seine protocol
Authors: A. Gouda, N. Maxemchuk, U. Mukherji, K. Sabnani
Venue: Symposium proceedings on Communications architectures and protocols (1988)

We present two protocols for information exchange between multiple identical senders and a single receiver. At each instant, every sender sends one bit, and the bits from all of senders are or-ed together into one bit before being received by the receiver. If a sender has a data message to send, it sends the message bits one by one; otherwise it sends zero bits. Clearly, if the sending of two messages by two senders overlap, then the resulting &ldquo;collision&rdquo; can result in a corrupted message, i.e., one that was not sent by either sender. The function of the protocol is to deliver those and only those messages that are not corrupted by collision. (In other words, the receiver acts as a discriminating seine that catches and delivers only uncorrupted messages; hence the title.) The two protocols presented here are based on Manchester codes and general balanced codes, respectively.
Working set prefetching for cache memories
Authors: Eric E. Johnson
Venue: ACM SIGARCH Computer Architecture News (1989)

A variety of strategies has been proposed for fetching code and data into cache memories before it is explicitly referenced by a processor (prefetching), including both history-based and "prescient" strategies. Here, a strategy is described which treats cache blocks as components of a working set rather than merely as statistically related entities. Extension of this technique to global memory multiprocessors is discussed as a means to reduce memory contention during synchronized phase transitions.
Efficient dispersal of information for security, load balancing, and fault tolerance
Authors: Michael O. Rabin
Venue: Journal of the ACM (JACM) (1989)

An Information Dispersal Algorithm (IDA) is developed that breaks a file F of length L = &uharl; F&uharr; into n pieces Fi, l &le; i &le; n, each of length &uharl;Fi&uharr; = L/m, so that every m pieces suffice for reconstructing F. Dispersal and reconstruction are computationally efficient. The sum of the lengths &uharl;Fi&uharr; is (n/m) &middot; L. Since n/m can be chosen to be close to l, the IDA is space efficient. IDA has numerous applications to secure and reliable storage of information in computer networks and even on single disks, to fault-tolerant and efficient transmission of information in networks, and to communications between processors in parallel computers. For the latter problem provably time-efficient and highly fault-tolerant routing on the n-cube is achieved, using just constant size buffers.
Why a single parallelization strategy is not enough in knowledge bases
Authors: S. Cohen, O. Wolfson
Venue: Proceedings of the eighth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1989)

We argue that the appropriate parallelization strategy for logic-program evaluation depends on the program being evaluated. Therefore, this paper is concerned with the issues of program-classification, and parallelization-strategies. We propose five parallelization strategies that differ based on the following criteria. Their evaluation cost, the overhead of communication and synchronization among processors, and the programs to which they are applicable. In particular, we start our study with pure-parallelization, i.e., parallelization without overhead. An interesting class-structure of logic programs is demonstrated, when considering amenability to pure-parallelization. The relationship to the NC complexity class is discussed. Then we propose strategies that do incur an overhead, but are optimal in a sense that will be precisely defined. This paper makes the initial steps towards a theory of parallel logic-programming.
A p-adic approach to the computation ofGröbner bases
Authors: Franz Winkler
Venue: Journal of Symbolic Computation (1988)

A method for the p-adic lifting of a Grobner basis is presented. If F is a finite vector of polynomials in @?[x"1,...,x"1] and p is a lucky prime for F (it turns out that there are only finitely many unlucky primes) then in a first step the normalized reduced Grobner basis G^(^0^) for F modulo p is computed, together with matrices Y^(^0^) and R^(^0^) such that Y^(^0^), G^(^0^)=F (mod p) and R^(^0^). G^(^0^)=0(mod p), where the rows of R^(^0^) are the syzygies of G^(^0^) derived from the reduction of the S-polynomials of G^(^0^) to 0. These congruences can be lifted to congruences modulo p^i, for any natural number i, finally leading to the normalized reduced Grobner basis for F in @?[x"1,...,x"1].
The use of video in empirical research
Authors: L. Neal
Venue: ACM SIGCHI Bulletin (1989)

There are numerous advantages and disadvantages to the use of video in empirical research. In contrast, observation in conjunction with notetaking avoids some of the problems with video, but without providing many of the advantages. Rather than report on the results of empirical studies, this paper examines methodologies used to capture and record the results of experiments which were designed to better understand how users interact with a system and how to design systems to meet user's needs.
Compliant motion in a simple polygon
Authors: J. Friedman, J. Hershberger, J. Snoeyink
Venue: Proceedings of the fifth annual symposium on Computational geometry (1989)

We consider motion planning under the compliant motion model, in which a robot directed to walk into a wall may slide along it. We examine several variants of compliant motion planning for a point robot inside a simple polygon with n sides, where the goal is a fixed vertex or edge. For the case in which the robot moves with perfect control, we build a data structure that lets us in &Ogr;(log n) time determine the range of directions in which the robot can move from a query point to the goal in a single step. This structure lets us solve a variety of other problems: we can find a similar query data structure for multi-step paths; we can solve single-step problems allowing uncertainty in control and position sensing; and we can explicitly compute the set of all points that can reach the goal in a single step, even allowing uncertainty in control. Our algorithms run in &Ogr;(n log n) time and linear space; they use a novel method for maintaining convex hulls of simple paths that may be of independent interest.
An interactive environment for object-oriented music composition and sound synthesis
Authors: C. A. Scaletti, R. E. Johnson
Venue: ACM SIGPLAN Notices (1988)

Kyma is an object-oriented environment for music composition written in Smalltalk-80, which, in conjunction with a microprogrammable digital signal processor called the Platypus, provides the composer with a means for creating and manipulating Sound objects graphically with real-time sonic feedback via software synthesis. Kyma draws no distinctions between the materials and the structure of a composition; both are Sound objects. When a Sound object receives a message to play, it transforms itself into a microSound object, i.e. an object representation of itself in the microcode of the Platypus. Thus an object paradigm is used not only in the representation of Sound objects in Smalltalk-80 but also in the microcode representation of those Sound objects on the Platypus.
A Partial Scan Method for Sequential Circuits with Feedback
Authors: K.-T. Cheng, V. D. Agrawal
Venue: IEEE Transactions on Computers (1990)

A method of partial scan design is presented in which the selection of scan flip-flops is aimed at breaking up the cyclic structure of the circuit. Experimental data are given to show that the test generation complexity may grow exponentially with the length of the cycles in the circuit. This complexity grows only linearly with the sequential depth. Graph-theoretic algorithms are presented to select a minimal set of flip-flops for eliminating cycles and reducing the sequential depth. Tests for the resulting circuit are generated by a sequential logic test generator. An independent control of the scan clock allows insertion of scan sequences within the vector sequence produced by the test generator. An independent control of the scan clock allows insertion of scan sequences within the vector sequences produced by the test generator. 98% fault coverage is obtained for a 5000-gate circuit by scanning just 5% of the flip-flops.
An integrated Ada programming environment: AWA
Authors: G. Xing, H. Rau, B. Liu, J. Shen, M.-Y. Zhu
Venue: ACM SIGAda Ada Letters (1988)

Programming environments are one of the hottest research topics in today's computer science society. This report presents our initial efforts on understanding the concept of a programming environment and a first attempt on building an integrated Ada programming environment.
Algorithms for vertical and orthogonal L1 linear approximation of points
Authors: P. Yamamoto, K. Kato, K. Imai
Venue: Proceedings of the fourth annual symposium on Computational geometry (1988)

This paper presents algorithms for approximating a set of n points by a linear function, or a line, that minimizes the L1 norm of vertical and orthogonal distances. The algorithms find exact solutions based upon geometric properties of the problems as opposed to approximate solutions based upon existing numerical techniques. The algorithmic complexity of these problems appears not to have been investigated before our work in [9], although &Ogr;(n3) naive algorithms can be easily obtained based on some simple characteristics of optimal L1 solutions. In this paper, an &Ogr;(n) optimal time algorithm for the weighted vertical L1 problem is presented. The algorithm is based upon a modified multi-dimensional search technique which extends the applicability of the basic technique to a wider class of problems. An &Ogr;(n1.5 log2 n) algorithm is presented for the unweighted orthogonal problem, and an &Ogr;(n2) algorithm is presented for the weighted problem. An &OHgr;(n log n) lower bound for the orthogonal L1 problem is shown under a certain model of computation. Also, the complexity of solving the orthogonal L1 problem is related to the construction of the k-belt of an arrangement of lines.
Using active data in a UIMS
Authors: Tyson R. Henry, Scott E. Hudson
Venue: Proceedings of the 1st annual ACM SIGGRAPH symposium on User Interface Software (1988)

An active data model is one that not only stores data, but also acts upon changes to the data in ways that reflect application domain semantics. This paper introduces an active object-oriented model based on incremental attribute evaluation (one-way constraints) and discusses how it can be used to support a number of tasks in a User Interface Management System. It is shown how this model can provide unified support for lexical, syntactic, and semantic feedback, how the model supports the specification and implementation of dynamically changing graphical layouts, and how the model can be used as the basis for support of user extensible interfaces.
Efficient table-free sampling methods for the exponential, Cauchy, and normal distributions
Authors: Joachim H. Ahrens, Ulrich Dieter
Venue: Communications of the ACM (1988)

Three algorithms for sampling from exponential, Cauchy and normal distributions are developed. They are based on the "exact approximation" method, and their expected numbers of consumed uniform deviates are less than 1.04 per sample from the target distributions. The algorithms are simple and easily implemented in any desired precision. They require no space for long tables of auxiliary vectors, merely a few constants are needed. Nevertheless, their speed compares well with the performance of much more complex and table-aided sampling procedures.
On generating random permutations with arbitrary distributions
Authors: B. J. Oommen, D. T. H. Ng
Venue: Proceedings of the 17th conference on ACM Annual Computer Science Conference (1989)

Let @@@@ = {R1,R2,&hellip;,RM} be an ordered set of M elements where Ri < Rj whenever i < j. Let &pgr; be the set of permutations of @@@@. We consider the problem of randomly generating the elements of &pgr; according to a distribution G(&pgr;). Various algorithms including those due to Durstenfeld [D2, K1] and Moses et al [M1] are available for the case when the distribution G(&pgr;) is a uniform distribution (i.e., where all the elements of &pgr; are generated with equal probability). In this paper we consider the case when the distribution G(&pgr;) is not necessarily uniform. We present a strategy for specifying the distribution G(&pgr;) and propose a technique for generating the elements of the &pgr; according to the distribution G(&pgr;). Applications of the technique to generate &ldquo;almost sorted lists&rdquo; and in the Travelling Salesman Problem have been presented. Finally, simulation results have been included which demonstrate the power of the Random Permutation Generation (RPG) technique.
The TI Advanced Scientific Computer
Authors: Harvey G. Cragon, W. Joe Watson
Venue: Computer (1989)

The authors describe some of the design decisions that determined the architecture and implementation of the Advanced Scientific Computer (ASC). They explain why certain design decisions were made, with a retrospective evaluation. They discuss the architecture, central processor, peripheral processor, circuits and packaging, and cooling. Looking back over this twenty-year project, the authors evaluate their design decisions.
Exploiting horizontal and vertical concurrency via the HPSm microprocessor
Authors: Wen-mei W. Hwu, Yale N. Patt
Venue: ACM SIGMICRO Newsletter (1988)

HPSm is a single-chip microarchitecture designed and implemented at the University of California to achieve high performance. The approach is to exploit both vertical and horizontal concurracy in the microarchitecture. Experiments have been conducted to demonstrate the effectivenese of HPSm as compared is a popular single-chip microarchitecture, the Berkeley RISC/SPUR. Evaluations have been done with both central intensive and hosting point intensive benchmarks. For both types of benchmarks, we show that the HPSm microarchitecture achieves significant speedup ever the RISC/SPUR microarchitecture implemented with the same fabrication technology.
A Kernel for High-Performance Multicast Communications
Authors: Jason Gait
Venue: IEEE Transactions on Computers (1989)

A kernel is described, called the link kernel, for high-performance interprocess communication among shared-memory multiprocessors using an Ethernet. The link kernel provides asynchronous multicast communication service without protocol overhead. Links are created by listeners, and processes may be simultaneously talkers and listeners. Processes access links through a global link table. Multicast addresses are site-independent, so communication is independent of process locations in the network. Communication is asynchronous, so much of the overhead of message management is masked by parallel computation.
OdeView: the graphical interface to Ode
Authors: R. Agrawal, N. H. Gehani, J. Srinivasan
Venue: ACM SIGMOD Record (1990)

OdeView is the graphical front end for Ode, an object-oriented database system and environment. Ode's data model supports data encapsulation, type inheritance, and complex objects. OdeView provides facilities for examining the database schema (i.e., the object type or class hierarchy), examining class definitions, browsing objects, following chains of references starting from an object, synchronized browsing, displaying selected portions of objects (projection), and retrieving objects with specific characteristics (selection). OdeView does not need to know about the internals of Ode objects. Consequently, the internals of specific classes are not hardwired into OdeView and new classes can be added to the Ode database without requiring any changes to or recompilation of OdeView. Just as OdeView does not know about the object internals, class functions (methods) for displaying objects are written without knowing about the specifics of the windowing software used by OdeView or the graphical user interface provided by it. In this paper, we present OdeView, and discuss its design and implementation.
Solving algebraic equations: Combining Buchberger's algorithm with multivariate factorization
Authors: S. R. Czapor
Venue: Journal of Symbolic Computation (1989)

We present a modification of Buchberger's algorithm (using the lexicographic term ordering), which is better suited to the problem of solving algebraic equations. Empirical results suggest that this scheme does indeed broaden the applicability and limits of the Grobner basis method.
Merging Thesauri: Principles and Evaluation
Authors: H. Mili, R. Rada
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

An investigation is reported of ways to take advantage of the semantics in thesauri to improve: (1) indexing by providing descriptions of documents as sets of terms from the thesaurus; and (2) retrieval by assessing the relevance of documents to a query. Thesauri need to be updated to account for the evolution of the field they cover. Accordingly, various augmentation algorithms and methods to assess the usefulness of these augmentations are being studied. The augmentations consist of merging two existing thesauri. By keeping a consistent level of complexity among the structure manipulated by the merging algorithm, the reasoning method, and the evaluation procedure, an improvement of the performance of the merged thesaurus on both document indexing and retrieval is demonstrated.
Summary of changes to Fortran draft
Authors: Jeanne C. Adams, Jerrold L. Wagener
Venue: ACM SIGPLAN Fortran Forum (1989)

In response to comments received from public review of the first draft proposed Fortran standard (X3J3/S8.104), a number of changes have been made and a revised draft proposed standard (X3J3/S8.112) has now been released for further public review. The following outline summarizes the technical changes that were made on the basis of the first review. A rationale for the major changes is also presented.
On the complexity of computing syzygies
Authors: David Bayer, Michael Stillman
Venue: Journal of Symbolic Computation (1988)

We give a self-contained exposition of Mayr & Meyer's example of a polynomial ideal exhibiting double exponential degrees for the ideal membership problem, and generalise this example to exhibit minimal syzygies of double exponential degree. This demonstrates the existence of subschemes of projective space of double exponential regularity.
The input/output complexity of transitive closure
Authors: Jeffrey D. Ullman, Mihalis Yannakakis
Venue: ACM SIGMOD Record (1990)

Suppose a directed graph has its arcs stored in secondary memory, and we wish to compute its transitive closure, also storing the result in secondary memory. We assume that an amount of main memory capable of holding s &ldquo;values&rdquo; is available, and that s lies between n, the number of nodes of the graph, and e, the number of arcs. The cost measure we use for algorithms is the I/O complexity of Kung and Hong, where we count 1 every time a value is moved into main memory from secondary memory, or vice versa. In the dense case, where e is close to n2, we show that I/O equal to &Ogr;(n3 / &radic;s) is sufficient to compute the transitive closure of an n-node graph, using main memory of size s. Moreover, it is necessary for any algorithm that is &ldquo;standard,&rdquo; in a sense to be defined precisely in the paper. Roughly, &ldquo;standard&rdquo; means that paths are constructed only by concatenating arcs and previously discovered paths. This class includes the usual algorithms that work for the generalization of transitive closure to semiring problems. For the sparse case, we show that I/O equal to &Ogr;(n2 &radic;e/s) is sufficient, although the algorithm we propose meets our definition of &ldquo;standard&rdquo; only if the underlying graph is acyclic. We also show that &OHgr;(n2 &radic;e/s) is necessary for any standard algorithm in the sparse case. That settles the I/O complexity of the sparse/acyclic case, for standard algorithms. It is unknown whether this complexity can be achieved in the sparse, cyclic case, by a standard algorithm, and it is unknown whether the bound can be beaten by nonstandard algorithms. We then consider a special kind of standard algorithm, in which paths are constructed only by concatenating arcs and old paths, never by concatenating two old paths. This restriction seems essential if we are to take advantage of sparseness. Unfortunately, we show that almost another factor of n I/O is necessary. That is, there is an algorithm in this class using I/O &Ogr;(n3 &radic;e/s) for arbitrary sparse graphs, including cyclic ones. Moreover, every algorithm in the restricted class must use &OHgr;(n3 &radic;e/s/log3 n) I/O, on some cyclic graphs.
An operational requirement description model for open systems
Authors: M. Hallman
Venue: Proceedings of the 10th international conference on Software engineering (1988)

Requirement engineering has been successfully applied to many superficial problems, but there has been little evidence of transfer to complex system construction. In this paper we present a new conceptual model which is for incomplete requirement descriptions. The model is especially designed for supporting the requirement specification and the analysis of open systems. An analysis of existing models and languages shows the main problem in requirement engineering: the harmony between a well-defined basic model and a convenient language. The new model REMOS combines the complex requirements of open systems with the basic characteristics of transaction-oriented systems. Transaction-oriented systems are fault-tolerant and offer security and privacy mechanisms. Such systems provide such excellent properties - why don't we already profit from it during requirement specification? The model REMOS and the applicative language RELOS take advantage of transaction properties. The idea REMOS is based on is the definition of scenarios and communicating subsystems. REMOS guides the users to making their requirements more clear, and RELOS offers a medium for requirement definition.