ppxscal/embedding_network huggingface dataset:
Effect of storage allocation/reclamation methods on parallelism and storage requirements
Authors: M. Kumar
Venue: Proceedings of the 14th annual international symposium on Computer architecture (1987)

The write after read/write synchronizations (the anti- and output-dependence constraints) inhibit the parallelism exhibited by Fortran programs. These constraints can be avoided by allocating storage for the values generated in a program dynamically, so that multiple values associated with the same variable can co-exist. The additional parallelism obtained by dynamically allocating storage for a subset of variables in a program, and the extra storage required for doing so, are scrutinized for a set of scientific/engineering applications. It is shown that on allocating storage dynamically for all scalar variables in the program, several hundred Fortran statements can be executed concurrently per cycle. On allocating storage dynamically for array elements too, the further increase in parallelism is less than a factor of ten. Finally, if storage is allocated statically for all variables, the available parallelism is usually under 10 Fortran-statements/cycle. The storage required for dynamic allocation can be two orders of magnitude above that required for the execution of the program on a conventional machine.
Computer crimes and the current legislation
Authors: Syed Shahabuddin
Venue: ACM SIGSAC Review (1987)

Computers are becoming more affordable and, therefore, more accessible. This accessibility provides a unique opportunity for potential criminals to commit computer crimes. These crimes could and do cause serious problems for businesses and the society. Therefore, securing computer data should be the top priority of the society. Many security measures along with good legislation could go a long way to help secure the data. Many states have passed legislation to help prevent computer crimes. In addition, there are many hardware and software available to help secure the computer data. All these measures are discussed in this paper.
Slowing down sorting networks to obtain faster sorting algorithms
Authors: Richard Cole
Venue: Journal of the ACM (JACM) (1987)

Megiddo introduced a technique for using a parallel algorithm for one problem to construct an efficient serial algorithm for a second problem. This paper provides a general method that trims a factor of O(log n) time (or more) for many applications of this technique.
Replicated procedure call
Authors: Eric C Cooper
Venue: ACM SIGOPS Operating Systems Review (1986)

A new mechanism for constructing highly available distributed programs is described. It combines remote procedure call with replication of program modules for fault tolerance.The set of replicas of a module is called a troupe. In a program constructed from troupes, what appears to the programmer as a single inter-module procedure call results in a replicated procedure call. A distributed program constructed in this way will continue to function as long as at least one member of each troupe survives.The semantics of replicated procedure calls and troupes are defined and algorithms are presented that support these semantics.
Selecting expert system frameworks within the Bayesian theory
Authors: S W Norton
Venue: Proceedings of the ACM SIGART international symposium on Methodologies for intelligent systems (1986)

Because of the impact that the choice of an expert system framework has on the success of expert system projects, it is important for anyone evaluating expert systems and expert system tools, whether casually or critically, to consider a variety of issues. As background, this paper provides a general description of the expert systems paradigm, and detailed descriptions of two expert system frameworks for reasoning under uncertainty. Although both of the expert systems described have roots in the Bayesian theory, their differences are significant enough to fuel a discussion of the most significant issues in evaluating the applicability of particular expert system frameworks. We cover knowledge representation and knowledge structures, the initial phases of knowledge engineering, tuning and validating the knowledge base, as well as utilization of the finished expert system.
The correction of ill-formed input using history-based expectation with applications to speech understanding
Authors: Pamela K. Fink, Alan W. Biermann
Venue: Computational Linguistics (1986)

A method for error correction of ill-formed input is described that acquires dialogue patterns in typical usage and uses these patterns to predict new inputs. Error correction is done by strongly biasing parsing toward expected meanings unless clear evidence from the input shows the current sentence is not expected. A dialogue acquisition and tracking algorithm is presented along with a description of its implementation in a voice interactive system. A series of tests are described that show the power of the error correction methodology when stereotypic dialogue occurs.
The mutual exclusion problem: part I&mdash;a theory of interprocess communication
Authors: Leslie Lamport
Venue: Journal of the ACM (JACM) (1986)

A novel formal theory of concurrent systems that does not assume any atomic operations is introduced. The execution of a concurrent program is modeled as an abstract set of operation executions with two temporal ordering relations: &ldquo;precedence&rdquo; and &ldquo;can causally affect&rdquo;. A primitive interprocess communication mechanism is then defined. In Part II, the mutual exclusion is expressed precisely in terms of this model, and solutions using the communication mechanism are given.
SPD: A Humanized Documentation Technology
Authors: Motoei Azuma, Tetsu Tabata, Yoshihiro Oki, Susumu Kamiya
Venue: IEEE Transactions on Software Engineering (1985)

The SPD (Structured Programming Diagram) is a documentation technology used to design well structured programs. With SPD, designers can easily express functional structure, control structure, and physical layout of a program on one sheet of paper. Its straightforward expression appeals to both document writers and readers. SPD concept and conventions are introduced in this paper. SPD usage is then explained with a program design example. Other documentation technologies used in coordination with SPD are briefly touched upon. Finally, SPD reputation and evolution in the last ten years are reviewed.
Microprogram control of a Prolog machine
Authors: Kiyomi Koyama
Venue: ACM SIGMICRO Newsletter (1986)

A Prolog machine design and its control are described. The machine features two-stage pipelining, a triple bus interconnection data path and support for concurrent control of micro-operations. The objective of this design is to improve execution of a Prolog processor by simultaneously performing multiple micro-operations. Capabilities of concurrent operation support are described in detail and demonstrated using some example Prolog functions. Two-stage pipeline technique as applied to non-deterministic control of Prolog program execution will be presented.
On Linear Skewing Schemes and d-Ordered Vectors
Authors: A. G. Wijshoff, J. Van Leeuwen
Venue: IEEE Transactions on Computers (1987)

Linear skewing schemes were introduced by Kuck et al. in the nineteen sixties, to provide a simple class of storage mappings for N × N matrices for use in vector processors with a large number of memory banks. Conditions on linear skewing schemes that guarantee conflict-free access to rows, columns, and/or (anti-) diagonals are usually presented in terms of conditions on so-called d-ordered vectors. We shall argue that these formulations are mathematically imprecise, and revise and extend the existing theory. Several claims are proved to bound the minimum number of memory banks needed for successful linear skewing by, e.g., the smallest prime number = N.
The use of Logo in an introductory computer science course
Authors: Dale Shaffer
Venue: ACM SIGCSE Bulletin (1986)

The use of LOGO as a first language in Computer Science is examined and compared to the use of Applesoft BASIC. The method for demonstrating LOGO's adequacy is based on comparisons with ACM's CS1 model.
Control procedures for slotted Aloha systems that achieve stability
Authors: L P Clare
Venue: Proceedings of the ACM SIGCOMM conference on Communications architectures protocols (1986)

A class of slotted ALOHA dynamic control strategies is considered. These strategies are simple to implement and can yield lossless and stable operation for arbitrarily large user populations with aggregate arrival rates below e-1 packets/slot. An ergodicity analysis is given that provides conditions on the system parameters, such that any specified set of control parameters that satisfies the given conditions is guaranteed to yield stable performance. The system state is modelled as a two-dimensional Markov chain that incorporates the backlog (the number of packets awaiting retransmission) and the estimate of the backlog. The geometrical concepts are illustrated by figures corresponding to an example case. Simulation results are presented that compare alternative control schemes.
Knowledge-based processing/interpretation of oceanographic satellite data
Authors: M G Thomason, R E Blake, M Lybanon
Venue: Proceedings of the ACM SIGART international symposium on Methodologies for intelligent systems (1986)

An expert system is being developed as a step towards a more automated environment for processing satellite data of a region of the Atlantic Ocean and for interpreting the data with respect to mesoscale events. Oceanic events of interest include the Gulf Stream boundaries, warm-core rings, and cold-core rings.
A Probabilistic Pipeline Algorithm for K Selection on the Tree Machine
Authors: Albert G. Greenberg, Udi Manber
Venue: IEEE Transactions on Computers (1987)

We consider the problem of selecting the kth largest of n inputs, where initially the inputs are stored in the n leaf processors of the 2n - 1 processor tree machine. A probabilistic algorithm is presented that implements a type of pipelining to solve the problem in a simple data driven fashion, with each processor maintaining just a constant amount of state information. On any problem instance, t
Automated application programming environment
Authors: Yap S. Chua, Charles N. Winton
Venue: ACM SIGAPL APL Quote Quad (1986)

With the availability of high-performance, low-cost hardware, APL provides a cost-effective means of developing custom software for the small business environment, and perhaps the best alternative to trying to adapt to an off-the-shelf package. Since APL does not inherently deal with system specific screen manipulation and file management techniques, programming these interface requirements from APL is typically tedious, potentially reducing the attractiveness of APL as the development language. Strategies for dealing with the realities of screen and file management in the context of small business systems are discussed in this paper. Low level functions with universal application are described along with code generation utilities to automatically produce the user and file interfaces for application packages. The programmer makes use of the screen and file management utilities to specify screen I/O and file management requirements resulting in a set of automatically generated screen and file functions for use with the application program. Thus, the programmer is relieved of the tedious task of dealing with the programming of the user and file interfaces and can concentrate on the &ldquo;core&rdquo; of the application program. Furthermore, system specific code in the application program (for displays and files) minimally affects portability since the utilities confine such code to a handful of low level functions. A working example of a small business system constructed with the assistance of screen and file management utilities is discussed.
A comment on &ldquo;a fast parallel algorithm for thinning digital patterns&rdquo;
Authors: H. E. Lü, P. S. P. Wang
Venue: Communications of the ACM (1986)

A fast parallel thinning algorithm for digital patterns is presented. This algorithm is an improved version of the algorithms introduced by Zhang and Suen [5] and Stefanelli and Rosenfeld [3]. An experiment using an Apple II and an Epson printer was conducted. The results show that the improved algorithm overcomes some of the disadvantages found in [5] by preserving necessary and essential structures for certain patterns which should not be deleted and maintains very fast speed, from about 1.5 to 2.3 times faster than the four-step and two-step methods described in [3] although the resulting skeletons look basically the same.
GOEDEL: A computer language for symbolic algebraic calculations&mdash;an introduction by examples
Authors: Dieter W Ebner
Venue: ACM SIGSAM Bulletin (1986)

GOEDEL is a language for the description of general symbolic manipulations. In this generality GOEDEL can be compared with LISP. However, GOEDEL is much higher than LISP and is more oriented to the application for algebraic calculations. Concerte mathematical manipulations e.g. of polynomials are realized by the invokation of GOEDEL procedures.
Extending the Noninterference Version of MLS for SAT
Authors: J. Thomas Haigh, William D. Young
Venue: IEEE Transactions on Software Engineering (1987)

A noninterference formulation of MLS applicable to the Secure Ada® Target (SAT) Abstract Model is developed. An analogous formulation is developed to handle the SAT type enforcement policy. Unwinding theorems are presented for both MLS and Multidomain Security (MDS) and the SAT Abstract Model is shown to satisfy both MLS and MDS. Generalizations and extensions are also considered.
Processor Utilization in a Linearly Connected Parallel Processing System
Authors: Michael R. Fellows, Michael A. Langston
Venue: IEEE Transactions on Computers (1988)

The authors study the problem of assigning program fragments to a system of processing elements in which low-level operations are performed in parallel. Such a system is said to be linearly connected if each processing element can only communicate directly with its two nearest neighbors. They show that the problem of determining whether a perfect assignment exists is NP-complete but can be solved in linear time if the number of processing elements is fixed. They demonstrate that the related problem of determining whether any assignment exists which can be performed in a given number of machine cycles is NP-complete. For this problem, the objective of which corresponds to minimizing the program fragment's execution time, the authors also investigate the behavior of classes of near-optimal heuristic algorithms. This present evidence to indicate that guaranteeing acceptable worst-case performance is a very difficult problem as well.
A model of file server performance for a heterogeneous distributed system
Authors: K K Ramakrishnan
Venue: ACM SIGCOMM Computer Communication Review (1986)

In this paper, we study the performance characteristics of a client-server style distributed system by a queueing network model. The system being modeled was based on an experimental distributed system currently being prototyped. As a specific detailed case study, we have evaluated the performance of a file server. A file server is a key component to achieve the data sharing necessary in a distributed system. The file server is probably the most heavily used resource of the distributed system and as a result, its performance is critical to the success of the system. The primary goal of the study was to identify and quantify the effects of the bottlenecks in the server and assess design alternatives to enhance performance. In particular, the improvements due to file caching, outboarding transport functions and the effect of multiple network interfaces were studied. We model in detail the various stages of processing of a request to a file server. Parameterization of the model was achieved by initial measurements made on the prototype system. An important characteristic modeled was the buffer overflow from the network interfaces. This required the approximate solution of a non-product-form queueing network.
Experience with a FORTH-like language
Authors: J E Jonak
Venue: ACM SIGPLAN Notices (1986)

Extensible and threaded code language FORTH is very popular among amateur programmers but only few professionals admit they use it or are prepared to describe their experience.The author has been using a directly threaded variation of FORTH, called F, for development of a couple of software products. And although convinced of the language usefulness as an implementation tool he would like to point out a few problem areas which he encountered during the development and life time of these products.
Vector Computer Memory Bank Contention
Authors: David H. Bailey
Venue: IEEE Transactions on Computers (1987)

A number of recent vector supercomputer designs have featured main memories with very large capacities, and presumably even larger memories are planned for future generations. While the memory chips used in these computers can store much larger amounts of data than before, their operation speeds are rather slow when compared to the significantly faster CPU (central processing unit) circuitry in new supercomputer designs. A consequence of this speed disparity between CPU's and main memory is that memory access times and memory bank reservation times (as measured in CPU ticks) are sharply increased from previous generations.
Implementation of Argus
Authors: B. Liskov, D. Curtis, P. Johnson, R. Scheifer
Venue: Proceedings of the eleventh ACM Symposium on Operating systems principles (1987)

Argus is a programming language and system developed to support the construction and execution of distributed programs. This paper describes the implementation of Argus, with particular emphasis on the way we implement atomic actions, because this is where Argus differs most from other implemented systems. The paper also discusses the performance of Argus. The cost of actions is quite reasonable, indicating that action systems like Argus are practical.
Fast recognition of circular objects in digital images
Authors: Frederick R. Hill
Venue: ACM SIGSMALL/PC Notes (1987)

Occasions arise when it become necessary to rapidly recognize circular objects in digital images. One such application involves the testing of manufacturing runs of antibiotics for potency. The procedure is fairly simple in that by measuring the zones of inhibition produced by diluted samples of the antibiotics on bacterial culture dishes, and comparing these measurements to a set of standard measurements, the potency of the particular run can easily be determined. The problem arises in that multiple sets of measurements need to be made to insure statistical significance and most drugs can only be produced in relatively small lots. The result is that literally thousands of measurements must be made every day in a typical laboratory. In this paper, we discuss an algorithm that can be implemented on an IBM PC using a variety of frame grabber video boards to measure the diameters of zones of inhibition quickly, and to reject data from zones which are not circular.
An Asynchronous, Distributed Flow Control Algorithm for Rate Allocation in Computer Networks
Authors: Berverly A. Sanders
Venue: IEEE Transactions on Computers (1988)

An asynchronous, distributed algorithm is presented that determines the optimal transmission rate allocation in computer networks with virtual circuit routing. The flow control problem is formulated as a gradient hill-climbing algorithm. It is distributed, since the entry node for each virtual circuit iteratively computes the rate allocation for that virtual circuit. The entry node communicates with the associated user during each interaction and obtains information about the rest of the network by sending control packets along the virtual circuit. It is shown that all of the necessary information to solve the optimization problem can be obtained in this fashion and that the algorithm will converge, even though there is no synchronization between nodes and some computations are made with outdated information.
On computing optimized input probabilities for random tests
Authors: H.-J. Wunderlich
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

Self testing of integrated circuits by random patterns has several technical and economical advantages. But there exists a large number of circuits which cannot be randomly tested, since the fault coverage achieved that way would be too low. In this paper we show that this problem can be solved by unequiprobable random patterns, and an efficient procedure is presented computing the specific optimal probability for each primary input of a combinational network. Those optimized random patterns can be produced on the chip during self test or off the chip in order to accelerate fault simulation and test pattern generation.
On the minimal synchronism needed for distributed consensus
Authors: Danny Dolev, Cynthia Dwork, Larry Stockmeyer
Venue: Journal of the ACM (JACM) (1987)

Reaching agreement is a primitive of distributed computing. Whereas this poses no problem in an ideal, failure-free environment, it imposes certain constraints on the capabilities of an actual system: A system is viable only if it permits the existence of consensus protocols tolerant to some number of failures. Fischer et al. have shown that in a completely asynchronous model, even one failure cannot be tolerated. In this paper their work is extended: Several critical system parameters, including various synchrony conditions, are identified and how varying these affects the number of faults that can be tolerated is examined. The proofs expose general heuristic principles that explain why consensus is possible in certain models but not possible in others.
Automatic Creation of Object Hierarchies for Ray Tracing
Authors: Jeffrey Goldsmith, John Salmon
Venue: IEEE Computer Graphics and Applications (1987)

Intersection calculations dominate the run time of canonical ray tracers. A common algorithm to reduce the number of intersection tests required is the intersection of rays with a tree of extents, rather than the whole database of objects. A shortcoming of this method is that these trees are difficult to generate. Additionally, manually generated trees can be poor, greatly reducing the run-time improvement available. We present methods for evaluation of these trees in approximate number of intersection calculations required and for automatic generation of good trees. These methods run in O(nlogn) expected time where n is the number of objects in the scene. We report some examples of speedups.
Access methods for text
Authors: Chris Faloutsos
Venue: ACM Computing Surveys (CSUR) (1985)

This paper compares text retrieval methods intended for office systems. The operational requirements of the office environment are discussed, and retrieval methods from database systems and from information retrieval systems are examined. We classify these methods and examine the most interesting representatives of each class. Attempts to speed up retrieval with special purpose hardware are also presented, and issues such as approximate string matching and compression are discussed. A qualitative comparison of the examined methods is presented. The signature file method is discussed in more detail.
A new approach to all pairs shortest paths in planar graphs
Authors: G. N. Frederickson
Venue: Proceedings of the nineteenth annual ACM symposium on Theory of computing (1987)

An algorithm is presented for generating a succinct encoding of all pairs shortest path information in a directed planar graph G with real-valued edge costs but no negative cycles. The algorithm runs in &Ogr;(pn) time, where n is the number of vertices in G, and p is the minimum cardinality of a subset of the faces that cover all vertices, taken over all planar embeddings of G. Linear-time algorithms are presented for various subproblems including that of finding an appropriate embedding of G and a corresponding face-on-vertex covering of cardinality &Ogr;(p), and of generating all pairs shortest path information in a directed outerplanar graph.