ppxscal/embedding_network huggingface dataset:
Synchronization problems and UNIX System V
Authors: N. Dunstan
Venue: ACM SIGCSE Bulletin (1989)

The synchronization of concurrent processes is of great importance in multiprocessing operating systems and a general discussion, together with an exposition of classic synchronization problems, has traditionally appeared in operating systems texts. UNIX System V has a variety of mechanisms for for process synchronization which embody both shared memory and message passing techniques. This paper outlines those mechanisms and presents a set of classic synchronization problems with coded solutions in C for the UNIX System V environment. It also describes how they may be used to illustrate different synchronization techniques in the context of teaching about operating systems.
Performance Evaluation of a Dataflow Architecture
Authors: Dipak Ghosal, Laxmi N. Bhuyan
Venue: IEEE Transactions on Computers (1990)

The formulation and validation of an analytical approach for the performance evaluation of the Manchester dataflow computer is discussed. The analytical approach is based on closed queuing network models. The average parallelism of the dataflow graph being executed on the dataflow architecture is shown to be related to the population of the closed network. The model of the dataflow computer is validated by comparing the analytical results to those obtained from the prototype Manchester dataflow computer and from simulation. The bottleneck centers in the prototype machine have been identified through the model, and various architectural modifications have been investigated from performance considerations.
A 3-D Contour Segmentation Scheme Based on Curvature and Torsion
Authors: N. Kehtarnavaz, J. P. deFigueiredo
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

The Darboux vector contains both the curvature and torsion of a three-dimensional (3-D) image as its components. Curvature measures how sharply a curve is turning while torsion measures the extent of its twist in 3-D space. Curvature and torsion completely define the shape of a 3-D curve. A scheme is presented that uses the length of this vector, also called the total curvature, for the segmentation of 3-D contours. A quintic B-spline is used in this formulation to obtain the total curvature for noisy data. Examples of nonnoisy and noisy data illustrate the merit of the scheme.
Partitioning by probability condensation
Authors: J. Blanks
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

A partitioning model is formulated in which components are assigned probabilities of being placed in bins separated by partitions. The expected number of nets crossing partitions is a quadratic function of these probabilities. Minimization of this expected value forces condensation of the probabilities into a &ldquo;definite&rdquo; state representing a very good partitioning. The bipartitioning case is treated explicitly.
Designing documentation to compensate for delocalized plans
Authors: Elliot Soloway, Robin Lampert, Stan Letovsky, David Littman, Jeannine Pinto
Venue: Communications of the ACM (1988)

Conceptual representation methods play a significant role in facilitating the software process. Recent studies explore and clarify the use of these representations and their impact on progress.
Automatic parsing of degenerate quadric-surface intersections
Authors: R. T. Farouki, C. Neff, M. A. O'Conner
Venue: ACM Transactions on Graphics (TOG) (1989)

In general, two quadric surfaces intersect in a nonsingular quartic space curve. Under special circumstances, however, this intersection may &ldquo;degenerate&rdquo; into a quartic with a double point, or a composite of lines, conics, and twisted cubics whose degrees, counted over the complex projective domain, sum to four. Such degenerate forms are important since they occur with surprising frequency in practice and, unlike the generic case, they admit rational parameterizations. Invoking concepts from classical algebraic geometry, we formulate the condition for a degenerate intersection in terms of the vanishing of a polynomial expression in the quadric coefficients. When this is satisfied, we apply a multivariate polynomial factorization algorithm to the projecting cone of the intersection curve. Factors of this cone which correspond to intersection components &ldquo;at infinity&rdquo; may be removed a priori. A careful examination of the remaining cone factors then facilitates the identification and parameterization of the various real, affine intersection elements that may arise: isolated points, lines, conics, cubics, and singular quartics. The procedure is essentially automatic (avoiding the tedium of case-by-case analyses), encompasses the full range of quadric forms, and is amenable to implementation in exact (symbolic) arithmetic.
Quasi-static typing
Authors: Satish Thatte
Venue: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

We present a new approach to dynamic typing in a static framework. Our main innovation is the use of structural subtyping for dynamic types based on the idea that possible dynamic typing as a property should be inherited by objects of all types. Two properties of our system set it apart from existing systems which combine static and dynamic typing: all tagging and checking takes place via implicit coercions, and the semantics of dynamic typing is representation independent. The latter property leads to a significant increase in expressive power&mdash;for instance it allows us to define a general call-by-value fixpoint operator. The resulting system&mdash;which we call quasi-static typing&mdash;is a seamless merger of static and dynamic typing. The system divides programs into three categories: well-typed, ill-typed and ambivalent programs. Ill-typed programs contain expressions that are guaranteed to go wrong. Run-time checking is limited to doubtful function applications in ambivalent programs. Conceptually, quasi-static typing takes place in an unusual two-phase process&mdash;a first phase infers types and coercions and a second plausibility checking phase identifies ill-typed programs. The typing rules allow minimal typing judgements and plausibility checking can be characterized as simplification via a canonical set of rewrite rules. The two phase process can therefore be implemented with a one pass algorithm.
Control strategies for two-player games
Authors: Bruce Abramson
Venue: ACM Computing Surveys (CSUR) (1989)

Computer games have been around for almost as long as computers. Most of these games, however, have been designed in a rather ad hoc manner because many of their basic components have never been adequately defined. In this paper some deficiencies in the standard model of computer games, the minimax model, are pointed out and the issues that a general theory must address are outlined. Most of the discussion is done in the context of control strategies, or sets of criteria for move selection. A survey of control strategies brings together results from two fields: implementations of real games and theoretical predictions derived on simplified game-trees. The interplay between these results suggests a series of open problems that have arisen during the course of both analytic experimentation and practical experience as the basis for a formal theory.
Goal-oriented laboratory development in CS/EE
Authors: Keith Barker, A. Wayne Bennett, Gordon E. Stokes, Mike Lucas, Maarten van Swaay
Venue: ACM SIGCSE Bulletin (1988)

The IEEE Computer Society's Educational Activities Board with the strong support of the ACM is tackling the problem of laboratory development, maintenance and support. The LABORATORY MONOGRAPH SERIES is intended to provide help to those setting up laboratory programs and as an outlet for those who wish to publish in a practical-oriented educational area.
Rule representation and management in conceptbase
Authors: M. Jarke, M. Jeusfeld
Venue: ACM SIGMOD Record (1989)

ConceptBase is an experimental knowledge base management system for design applications, especially in the software engineering area. The knowledge representation language it supports, CML/Telos, combines the functionalities of deductive and temporal databases with structural object orientation. In this paper, we demonstrate how to exploit a process-oriented software data model that uses just the object-oriented structural language kernel, to bootstrap efficient internal representations of the rule sub-language.
Tools for interaction with the creative process of composition
Authors: T. Schiphorst, T. Calvert, C. Lee, C. Welman, S. Gaudet
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

This paper explores the nature of creative composition particularly as it applies to dance, and describes the development of interactive computer based tools to assist the composer. The hierarchical nature of the composition process calls for an interface which allows the composer the flexibility to move back and forth between alternate views and conceptual levels of abstraction. COMPOSE, an interactive system for the composition of dance has been implemented on Silicon Graphics and Apple workstations. The user visually composes in space and in time using menus of postures and sequences. Paths can be edited and an animation of the dance composition allows the final result to be evaluated.
Monotone circuits for connectivity require super-logarithmic depth
Authors: Mauricio Karchmer, Avi Wigderson
Venue: Proceedings of the twentieth annual ACM symposium on Theory of computing (1988)

We prove that every monotone circuit which tests st-connectivity of an undirected graph on n nodes has depth &OHgr;(log2n). This implies a superpolynomial (n&OHgr;(log n)) lower bound on the size of any monotone formula for st-connectivity. The proof draws intuition from a new characterization of circuit depth in terms of communication complexity. It uses counting arguments and Extremal Set Theory. Within the same framework, we also give a very simple and intuitive proof of a depth analogue of a theorem of Krapchenko concerning formula size lower bounds.
Implementing Gauss Jordan on a hypercube multicomputer
Authors: A. Gerasoulis, N. Missirlis, I. Nelken, R. Peskin
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

We consider the solution of dense algebraic systems on the NCUBE hypercube via the Gauss Jordan method. Advanced loop interchange techniques are used to determine the appropriate algorithm for MIMD architectures. For a computer with p = n processors, we show that Gauss Jordan is competitive to Gaussian elimination when pivoting is not used. We experiment with three mappings of columns to processors: block, wrap and reflection. We demonstrate that load balancing the processors results in a considerable reduction of execution time.
On Addition and Multiplication with Hensel Codes
Authors: Christopher J. Zarowski, Howard C. Card
Venue: IEEE Transactions on Computers (1990)

It has been stated by R.N. Gorgui-Naguib and R.A. King (1986) that the operations of addition and multiplication on Hensel codes originally defined by E.V. Krishnamurthy, T.M. Rao, and K. Subramanian (1975) are seriously in error in that it is possible to add/subtract or multiply Hensel codes and not get a valid Hensel code. It is shown that it is the presence of so-called invalid Farey fractions that results in the need to modify the original arithmetic operations. However, this also results in the Hensel codes becoming redundant. The authors show how to include the invalid Farey fractions such that it is possible to compute with their Hensel codings without the need to map back and forth between the rationals and their Hensel codings. This provides an alternative to the method of Gorgui-Naguib and King. Unfortunately, it turns out that Hensel codes of a large size will be needed in practice, even for relatively small problems.
Linda Meets Unix
Authors: William Leler
Venue: Computer (1990)

The limitations of the shared-memory and distributed-memory models for explicit parallel programming are discussed and a new model, the Linda parallel communication paradigm which was designed specifically for parallel programming, is examined. Processes communicate in Linda by way of a shared data space called tuple space which acts something like an associative memory, since tuples are identified by matching on a key rather than using a specific address. This model is adapted for use as the basis of a new class of operating systems and a specific instance, QIX, is presented. Like Linda, this operating system model can support both the shared-memory and the distributed-memory styles of programming. Thus, it provides the benefits of both, while avoiding hardware dependencies. QIX also incorporates a novel scheme for name resolution that is easier to use than other methods and provides significant benefits in the operating system and it directly supports communication between programs written in different languages.
A One-Pass Two-Operation Process to Detect the Skeletal Pixels on the 4-Distance Transform
Authors: C. Arcelli, G. S. Di Baja
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

A skeletonizing procedure is illustrated that is based on the notion of multiple pixels as well as on the use of the 4-distance transform. The set of the skeletal pixels is identified within one sequential raster scan of the picture where the 4-distance transform is stored. Two local conditions, introduced to characterize the multiple pixels are employed. Since the set of the skeletal pixels is at most two pixels wide, the skeleton can be obtained on completion of an additional inspection of the picture, during which time standard removal operations are applied. Besides being correct and computationally convenient, the procedure produces a labeled skeleton, i.e. a skeleton whose adequacy for shape description purposes is generally acknowledged.
Unification: a multidisciplinary survey
Authors: Kevin Knight
Venue: ACM Computing Surveys (CSUR) (1989)

The unification problem and several variants are presented. Various algorithms and data structures are discussed. Research on unification arising in several areas of computer science is surveyed; these areas include theorem proving, logic programming, and natural language processing. Sections of the paper include examples that highlight particular uses of unification and the special problems encountered. Other topics covered are resolution, higher order logic, the occur check, infinite terms, feature structures, equational theories, inheritance, parallel algorithms, generalization, lattices, and other applications of unification. The paper is intended for readers with a general computer science background&mdash;no specific knowledge of any of the above topics is assumed.
Functional Refinement and Nested Objects for Object-Oriented Design
Authors: Pankaj Jalote
Venue: IEEE Transactions on Software Engineering (1989)

An extended object-oriented design methodology is proposed which incorporates a top-down, stepwise refinement approach in a coherent fashion. The extended object-oriented design methodology also includes a phase of progressive object refinement to support the nesting of objects, which would allow entities in real life that are composed of subentities to be modeled. A design example is included, and experiences encountered using this methodology in a course are described.
Typographic style is more than cosmetic
Authors: Paul W. Oman, Curtis R. Cook
Venue: Communications of the ACM (1990)

There is disagreement about the role and importance of typographic style (source code formatting and commenting) in program comprehension. Results from experiments and opinions in programming style books are mixed. This article presents principles of typographic style consistent and compatible with the results of program comprehension studies. Four experiments demonstrate that the typographic style principles embodied in the book format significantly aid program comprehension and reduce maintenance effort. &mdash;Authors' Abstract
A tradeoff between space and efficiency for routing tables
Authors: David Peleg, Eli Upfal
Venue: Proceedings of the twentieth annual ACM symposium on Theory of computing (1988)

Two conflicting goals play a crucial role in the design of routing schemes for communication networks. A routing scheme should use as short as possible paths for routing messages in the network, while keeping the routing information stored in the processors' local memory as succinct as possible. The efficiency of a routing scheme is measured in terms of its stretch factor - the maximum ratio between the length of a route computed by the scheme and that of a shortest path connecting the same pair of vertices. Most previous work has concentrated on finding good routing schemes (with a small fixed stretch factor) for special classes of network topologies. In this work we study the problem for general networks, and look at the entire range of possible stretch factors. The results exhibit a tradeoff between the efficiency of a routing scheme and its space requirements. We present almost tight upper and lower bounds for this tradeoff. Specifically, we prove that any routing scheme for general n-vertex networks that achieves a stretch factor k &ge; 1 must use a total of &OHgr;(n1+1/2k+4) bits of routing information in the networks. This lower bound is complemented by a family H(k) of hierarchical routing schemes (for every fixed k &ge; 1), which guarantee a stretch factor of &Ogr;(k), require storing a total of &Ogr;(n1+1/k) bits of routing information in the network and name the vertices with &Ogr;(log2 n)-bit names.
A dynamic load balancer on the Intel hypercube
Authors: J. Koller
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

A class of commonly encountered problems requires dynamic load balancing for efficient use of concurrent processors. We are developing a test bed for dynamic load balancing studies, and have chosen the MOOSE operating system and the Intel iPSC as our environment. We discuss these choices, and how we are implementing a general purpose dynamic load balancer.
Inductive methods for reasoning about abstract data types
Authors: S.J. Garland, J. V. Guttag
Venue: Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1988)

Rewriting techniques have been used to reason about a variety of topics related to programming languages, e.g., abstract data types, Petri Nets, FP programs, and data bases. They have also been used in the implementation and definition of a variety of programming languages. At the 1980 POPL Conference, David Musser proposed a new method of proving inductive properties of abstract data types. Since that time, this method, which came to be called inductionless induction, has attracted considerable attention. Numerous applications and improvements have been proposed and several implementations described. However, little or no work has appeared that questions the basic utility of the idea. The thesis of this paper is that while induction using equational term-rewriting holds great promise, inductionless induction does not. More specifically, we argue that for reasoning about abstract data types traditional inductive methods are usually superior.
Stereo Correspondence Through Feature Grouping and Maximal Cliques
Authors: R. Horaud, T. Skordas
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

The authors propose a method for solving the stereo correspondence problem. The method consists of extracting local image structures and matching similar such structures between two images. Linear edge segments are extracted from both the left and right images. Each segment is characterized by its position and orientation in the image as well as its relationships with the nearby segments. A relational graph is thus built from each image. For each segment in one image as set of potential assignments is represented as a set of nodes in a correspondence graph. Arcs in the graph represent compatible assignments established on the basis of segment relationships. Stereo matching becomes equivalent to searching for sets of mutually compatible nodes in this graph. Sets are found by looking for maximal cliques. The maximal clique best suited to represent a stereo correspondence is selected using a benefit function. Numerous results obtained with this method are shown.
Asymptotic expansion for large closed queuing networks
Authors: Charles Knessl, Charles Tier
Venue: Journal of the ACM (JACM) (1990)

In this paper, a new asymptotic method is developed for analyzing closed BCMP queuing networks with a single class (chain) consisting of a large number of customers, a single infinite server queue, and a large number of single server queues with fixed (state-independent) service rates. Asymptotic approximations are computed for the normalization constant (partition function) starting directly from a recursion relation of Buzen. The approach of the authors employs the ray method of geometrical optics and the method of matched asymptotic expansions. The method is applicable when the servers have nearly equal relative utilizations or can be divided into classes with nearly equal relative utilizations. Numerical comparisons are given that illustrate the accuracy of the asymptotic approximations.
DOC: a practical approach to source-level debugging of globally optimized code
Authors: D. S. Coutant, S. Meloy, M. Ruscetta
Venue: Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation (1988)

As optimizing compilers become more sophisticated, the problem of debugging the source code of an application becomes more difficult. In order to investigate this problem, we implemented DOC, a prototype solution for Debugging Optimized Code. DOC is a modification of the existing C compiler and source-level symbolic debugger for the HP9000 Series 800. This paper describes our experiences in this effort. We show in an actual implementation that source-level debugging of globally optimized code is viable.
Graphical specification of user interfaces with behavior abstraction
Authors: J. F. DeSoi, W. M. Lively, S. V. Sheppard
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Wings for the mind (1989)

The Application Display Generator (ADG) is a graphical environment for the design and implementation of embedded system user interfaces. It is a major component of the Graphical Specification Subsystem (GSS) in Lockheed's Express knowledge-based software development environment. ADG gives non-programmers simple and flexible methods for graphically specifying the presentation and behavior of embedded system user interfaces. In the ADG methodology arbitrary presentations are attached to abstract object behaviors. This approach makes it possible to provide unconstrained presentations, intelligent user support, rapid prototyping, and flexible facilities for composing complex objects.
Optimal Matrix Multiplication on Fault-Tolerant VLSI Arrays
Authors: P. J. Varman, I. V. Ramakrishnan
Venue: IEEE Transactions on Computers (1989)

A fault-tolerant array for matrix multiplication that explicitly incorporates mechanisms for easy testability and reconfigurability is described. All signals in the array travel only a constant distance (independent of array size) in any clock cycle. An optimal-time algorithm, designed for multiplying matrices, is described. The algorithm is an efficient simulation of a 2-D systolic algorithm for multiplying matrices.