ppxscal/embedding_network huggingface dataset:
Two-Dimensional Convolution on a Pyramid Computer
Authors: Jik H. Chang, Oscar H. Ibarra, Ting-Chuen Pong, Stephen M. Sohn
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

An algorithm for convolving a k*k window of weighting coefficients with an n*n image matrix on a pyramid computer of O(n/sup 2/) processors in time O(logn+k/sup 2/), excluding the time to load the image matrix, is presented. If k= Omega ( square root log n), which is typical in practice, the algorithm has a processor-time product O(n/sup 2/ k/sup 2/) which is optimal with respect to the usual sequential algorithm. A feature of the algorithm is that the mechanism for controlling the transmission and distribution of data in each processor is finite state, independent of the values of n and k. Thus, for convolving two (0, 1)-valued matrices using Boolean operations rather than the typical sum and product operations, the processors of the pyramid computer are finite-state.
On accuracy of switch-level modeling of bridging faults in complex gates
Authors: R. Rajsuman, Y. K. Malaiya, A. P. Jayasumana
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

Bridging faults have been shown to be a major failure mode in VLSI devices. This study examines nMOS and CMOS complex gates in detail for bridging faults. Analysis is carried out using both switch and circuit level models for comparison. It is shown that in most cases, the switch level analysis predicts the correct behavior. A set of conditions are presented, under which the switch level analysis may fail to predict the correct behavior. These conditions can be used for accurate switch level test generation and simulation.
Architecture and Applications of the Connection Machine
Authors: Lewis W. Tucker, George G. Robertson
Venue: Computer (1988)

The concept of data-parallel computers is explained, and their architecture of the Connection Machine (CM), which implements this approach, is described. It provides 64 K physical processing elements, millions of virtual processing elements with its virtual processor mechanism, and general-purpose, reconfigurable communications networks. The evolution of the CM architecture is examined, and the software environment, engineering and physical characteristics, and performance of the current embodiment (the CM-2) are discussed. Applications of the CM to molecular dynamics, VLSI design and circuit simulation, and computer vision are described.
Object-oriented database support for software environments
Authors: Scott E. Hudson, Roger King
Venue: ACM SIGMOD Record (1987)

Cactis is an object-oriented, multi-user DBMS developed at the University of Colorado. The implementation is self-adaptive and concurrent, and runs in the Unix/C Sun workstation environment. A central, unique focus of Cactis is the support of functionally-defined data in a manner which provides good performance. Cactis is intended for use in applications which are conducive to an object-oriented approach and involve derived data. Such applications include software environments. Cactis supports the construction of objects and type/subtype hierarchies, which are useful for managing the complex and highly-interrelated data found in software environments. Such data types include programs, requirement specifications, milestone reports, configurations, documentation, and many others. Cactis uses techniques based on attributed graphs to ensure that functionally-defined attributes of objects, such as compilation dependencies, cost calculations, and milestone dependencies can be maintained efficiently. Since it is necessary to dynamically add new tools (such as debuggers and compilers) to a software environment, the DBMS allows the user to extend the type structure. The system also supports an efficient rollback and recovery mechanism, which provides the framework for a software version facility.
Conform: a conformal mapping system
Authors: Harlan R. Seymour
Venue: Proceedings of the fifth ACM symposium on Symbolic and algebraic computation (1986)

Conform consists of a collection of LISP routines that permit the real time manipulation and display of conformal mappings of one complex plane onto another.
A system for compiling fonts
Authors: John E. Howland
Venue: ACM SIGAPL APL Quote Quad (1987)

An interactive system for specifying fonts using an object oriented approach, based on cubic splines, is given. An interactive Bezier curve editor is described as well as systems for compiling bit image fonts from their geometric descriptions and a system for compiling PostScript programs which can be used to render fonts on a PostScript printer or typesetter.
An APL system for experimentation with spectral methods in fault detection
Authors: Eric Gullichsen
Venue: ACM SIGAPL APL Quote Quad (1986)

An ability to detect faults in digital circuitry is of increasing importance as a result of the current trend towards ever-greater levels of circuit complexity in VLSI design. This paper describes a system of APL routines that permits the interactive specification of combinational circuits and the discovery of spectra for lines of the (fault-free) circuits. The system can also simulate the spectral behavior of a specified circuit under the condition of "stuck-at" faults on any combination of circuit lines, or under the condition of some internal line considered as if it were another circuit input.
Interfacing Ada and relational databases
Authors: L S McCoy
Venue: ACM SIGAda Ada Letters (1987)

With the advent of the Ada* language, relational database manufacturers are faced with the task of interfacing their databases to a language based on the object-oriented model. This paper discusses the benefits gained from interfacing Ada to a relational DBMS, with ORACLE* Pro*Ada used as a concrete example. Two approaches to interfacing Ada and a DBMS are discussed: one which was based on the alpha testing the author performed on Pro*Ada, and one based on retrieving rows in a record format. The paper concludes with a discussion of the Government request for an SQL to Ada interface, as well as general issues for DBMS interfaces.
A pragmatic view of the system architect
Authors: John A. Mills
Venue: Communications of the ACM (1985)

A whole-system designer, fire fighter, mediator, and jack-of-all-trades, the system architect brings unity and continuity to a development project&mdash;offsetting the inevitable compartmentalization of modern modular designs.
On the Reliability of the IBM MVS/XA Operating System
Authors: Samiha Mourad, Dorothy Andrews
Venue: IEEE Transactions on Software Engineering (1987)

This paper describes an analysis of system-detected errors on the MVS operating system under the eXtended Architecture (XA) for two IBM 3081 systems. The analysis classifies the errors in categories and examines the effectiveness of the recovery system of the MVS/XA. Comparison of the results for the two IBM 3081's confirm the dependence of the error distribution on the type of system utilization. The results for one of the machines are compared to those obtained for the same system when operating under MVS/SP. The comparison of the MVS/XA to the MVS/SP reveals the following: more addressing errors, a better error recording system and improved reliability and fault tolerance.
Skinny and fleshy failures of relative completeness
Authors: D. Leivant, T. Fernando
Venue: Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages (1987)

The notion of relative completeness of logics of programs was delineated almost ten years ago, in particular by Wand, Cook and Clarke. More recently, it has been felt that Cook's notion hinges on a fragile balance between the semantics of a programming language and first-order expressiveness in structures. This fragility underlies the negative results about relative completeness. The main negative result in this area, Clarke's Theorem, states that for a programming language with a sufficiently rich control structure there is no effective formalism for partial-correctness that is both sound and relatively complete (in the sense of Cook). A conclusion often drawn from this result is that the non-existence of an adequate Cook-complete formalization of the partial-correctness theory of a programming language is an indicator of the complexity of that language. Our most novel result is that this is not always the case. We exhibit a programming language whose control structure is trivial, and yet for which no Cook-complete Hoare logic exists. The poverty of the language is precisely what permits certain structures to be expressive, structures which would not be expressive had the program constructs been used more freely. We also discuss the failure of relative completeness for &ldquo;fleshy&rdquo; programming languages, of the kind of Clarke's. We point out the relevance of the Lambda Calculus here, from which we derive the failure of Cook-completeness for a programming language orthogonal (i.e. incomparable) to Clarke's, whose control-structure complexity resides to a great extent in a modest use of generic procedures. A variant of the same idea also provides an alternative proof of non-relative-completeness for (a variant of) Clarke's language. Finally, we note in passing a simple proof of Wand's Theorem, which states the failure of local completeness (without Cook's expressiveness condition) for while programs. Our proof uses rudimentary facts from Mathematical Logic. Its interest, compared with previous proofs [Wan78, BT82, Apt81] is that it refers to a structure whose first-order theory is not decidable. Moreover, our proof shows that the failure of local completeness for while programs is not necessarily due to a tension between first-order definability and definability by program looping, as one might have been tempted to conclude from previous proofs.
A New Bit-Serial Systolic Multiplier Over GF(2/sup m/)
Authors: B. B. Zhou
Venue: IEEE Transactions on Computers (1988)

A bit-serial systolic array has been developed to computer multiplications over GF(2/sup m/). In contrast to a previously designed systolic multiplier, this algorithm allows the input elements to center a linear systolic array in the same order, and the system only requires one control signal.
Superoptimizer: a look at the smallest program
Authors: Henry Massalin
Venue: ACM SIGPLAN Notices (1987)

Given an instruction set, the superoptimizer finds the shortest program to compute a function. Startling programs have been generated, many of them engaging in convoluted bit-fiddling bearing little resemblance to the source programs which defined the functions. The key idea in the superoptimizer is a probabilistic test that makes exhaustive searches practical for programs of useful size. The search space is defined by the processor's instruction set, which may include the whole set, but it is typically restricted to a subset. By constraining the instructions and observing the effect on the output program, one can gain insight into the design of instruction sets. In addition, superoptimized programs may be used by peephole optimizers to improve the quality of generated code, or by assembly language programmers to improve manually written code.
On the relationship between permission and obligation
Authors: A. J. I. Jones
Venue: Proceedings of the 1st international conference on Artificial intelligence and law (1987)

In two interesting papers ((1983), (1986)) Thorne McCarty has presented a semantics for the central deontic concepts, permission and obligation, based upon a semantics for an action language. The latter, in turn, was constructed along lines deriving from Pratt-Harel dynamic logic. I shall here offer some critical comments on McCarty's analysis of the relationship between obligation and permission, and of his account of so-called &ldquo;free-choice&rdquo; permissions; these come in section II, below. In section I an outline sketch is given of the main features of McCarty's semantics with which the criticism will be concerned.
Branch folding in the CRISP microprocessor: reducing branch delay to zero
Authors: D. R. Ditzel, H. R. McLellan
Venue: Proceedings of the 14th annual international symposium on Computer architecture (1987)

A new method of implementing branch instructions is presented. This technique has been implemented in the CRISP Microprocessor. With a combination of hardware and software techniques the execution time cost for many branches can be effectively reduced to zero. Branches are folded into other instructions, making their execution as separate instructions unnecessary. Branch Folding can reduce the apparent number of instructions needed to execute a program by the number of branches in that program, as well as reducing or eliminating pipeline breakage. Statistics are presented demonstrating the effectiveness of Branch Folding and associated techniques used in the CRISP Microprocessor.
A mathematically focused curriculum for computer science
Authors: Alfs Berztiss
Venue: Communications of the ACM (1987)

A curriculum that is flexible enough to suit all students studying computer science, and that reintegrates the theoretical aspects of the field along with more practical or vocational aspects, is proposed.
Dataflow machine architecture
Authors: Arthur H. Veen
Venue: ACM Computing Surveys (CSUR) (1986)

Dataflow machines are programmable computers of which the hardware is optimized for fine-grain data-driven parallel computation. The principles and complications of data-driven execution are explained, as well as the advantages and costs of fine-grain parallelism. A general model for a dataflow machine is presented and the major design options are discussed. Most dataflow machines described in the literature are surveyed on the basis of this model and its associated technology. For general-purpose computing the most promising dataflow machines are those that employ packet-switching communication and support general recursion. Such a recursion mechanism requires an extremely fast mechanism to map a sparsely occupied virtual space to a physical space of realistic size. No solution has yet proved fully satisfactory. A working prototype of one processing element is described in detail. On the basis of experience with this prototype, some of the objections raised against the dataflow approach are discussed. It appears that the overhead due to fine-grain parallelism can be made acceptable by sophisticated compiling and employing special hardware for the storage of data structures. Many computing-intensive programs show sufficient parallelism. In fact, a major problem is to restrain parallelism when machine resources tend to get overloaded. Another issue that requires further investigation is the distribution of computation and data structures over the processing elements.
Solving minimum-cost flow problems by successive approximation
Authors: A. Goldberg, R. Tarjan
Venue: Proceedings of the nineteenth annual ACM symposium on Theory of computing (1987)

We introduce a framework for solving minimum-cost flow problems. Our approach measures the quality of a solution by the amount that the complementary slackness conditions are violated. We show how to extend techniques developed for the maximum flow problem to improve the quality of a solution. This framework allows us to achieve &Ogr;(min(n3, n5/3 m2/3, nm log n) log (nC)) running time.
The design of POSTGRES
Authors: Michael Stonebraker, Lawrence A. Rowe
Venue: ACM SIGMOD Record (1986)

This paper presents the preliminary design of a new database management system, called POSTGRES, that is the successor to the INGRES relational database system. The main design goals of the new system are to provide better support for complex objects, provide user extendibility for data types, operators and access methods, provide facilities for active databases (i.e., alerters and triggers) and inferencing including forward- and backward-chaining, simplify the DBMS code for crash recovery, produce a design that can take advantage of optical disks, workstations composed of multiple tightly-coupled processors, and custom designed VLSI chips, and make as few changes as possible (preferably none) to the relational model. The paper describes the query language, programming language interface, system architecture, query processing strategy, and storage system for the new system.
Display of Surfaces from Volume Data
Authors: Marc Levoy
Venue: IEEE Computer Graphics and Applications (1988)

The application of volume-rendering techniques to the display of surfaces from sampled scalar functions of three spatial dimensions is discussed. It is not necessary to fit geometric primitives to the sampled data; images are formed by directly shading each sample and projecting it onto the picture plane. Surface-shading calculations are performed at every voxel with local gradient vectors serving as surface normals. In a separate step, surface classification operators are applied to compute a partial opacity of every voxel. Operators that detect isovalue contour surfaces and region boundary surfaces are examined. The technique is simple and fast, yet displays surfaces exhibiting smooth silhouettes and few other aliasing artifacts. The use of selective blurring and supersampling to further improve image quality is described. Examples from molecular graphics and medical imaging are given.
Encapsulators: a new software paradigm in Smalltalk-80
Authors: Geoffrey A. Pascoe
Venue: ACM SIGPLAN Notices (1986)

Certain situations arise in programming that lead to multiply polymorphic expressions, that is, expressions in which several terms may each be of variable type. In such situations, conventional object-oriented programming practice breaks down, leading to code which is not properly modular. This paper describes a simple approach to such problems which preserves all the benefits of good object-oriented programming style in the face of any degree of polymorphism. An example is given in Smalltalk-80 syntax, but the technique is relevant to all object-oriented languages.
Are LR parsers too powerful?
Authors: P Machanick
Venue: ACM SIGPLAN Notices (1986)

The general trend in the development of parser theory is in the direction of exploring implementing methods of increasing power. In particular, ways of improving the efficiency of LR parsers and the generation of LR tables have been receiving a lot of attention. The value of increasingly powerful tools is questioned from the point-of-view of the need to keep definitions of languages understandable to the programmer. Consideration is given to Wirth's contention that recursive descent is the method of choice and alternatives are suggested.
Computing on an anonymous ring
Authors: Hagit Attiya, Marc Snir, Manfred K. Warmuth
Venue: Journal of the ACM (JACM) (1988)

The computational capabilities of a system of n indistinguishable (anonymous) processors arranged on a ring in the synchronous and asynchronous models of distributed computation are analyzed. A precise characterization of the functions that can be computed in this setting is given. It is shown that any of these functions can be computed in O(n2) messages in the asynchronous model. This is also proved to be a lower bound for such elementary functions as AND, SUM, and Orientation. In the synchronous model any computable function can be computed in O(n log n) messages. A ring can be oriented and start synchronized within the same bounds. The main contribution of this paper is a new technique for proving lower bounds in the synchronous model. With this technique tight lower bounds of &thgr;(n log n) (for particular n) are proved for XOR, SUM, Orientation, and Start Synchronization. The technique is based on a string-producing mechanism from formal language theory, first introduced by Thue to study square-free words. Two methods for generalizing the synchronous lower bounds to arbitrary ring sizes are presented.
APL: A prototyping language
Authors: Robert Bernecky
Venue: ACM SIGAPL APL Quote Quad (1986)

The use of APL as a language for system design and prototyping is discussed. Benefits of APL over traditional design techniques are shown to include higher productivity, improved code reliability, superior maintainability and performance, and executable documentation. Hierarchical and hybrid approaches to modelling systems of various degrees of complexity are presented, with examples chosen from the author's experience.
Eliminating Redundant Primitives from Set-Theoretic Solid Models by a Consideration of Constituents
Authors: John R. Woodwark
Venue: IEEE Computer Graphics and Applications (1988)

Set-theoretic solid models often contain redundant primitives, which slow down rendering and other processes. They are not simple to remove, especially as there can be alternative eliminations that may not be equally desirable. Existing techniques for eliminating such redundant primitives do not fully consider the possibilities and rely on repeated evaluation of parts of the object's boundary, a process that is likely to be very slow. A technique that allows alternative eliminations to be examined is proposed and a potentially efficient, but geometrically approximate, method of implementation is outlined.
OSI service specification: SAP and CEP modelling
Authors: JG Tomas, J Pavon, O Pereda
Venue: ACM SIGCOMM Computer Communication Review (1987)

Within the effort of ISO standarization, service specifications have been thought to be an important tool for formal verification of protocols. The paper discusses the modelling of some concepts quite related with the service: service access points and abstract service primitives. Firstly, ISO concepts are explained. Then, a service architectural model is developed as a refinament of the service access point idea using the connection end point concept. A finite state machine approach is shown to specify the behavior of the modules of such architecture. This lead us to consider the service access point represented as a single state automaton that consists of several connection end point automata. Thus, service access points allow the specification of services, and provide an abstraction of interfaces between adjacent layers of the Open System Interconnection model of ISO.
Checkpoint Faults are not Sufficient Target Faults for Test Generation
Authors: M. Abramovici, P. R. Menon
Venue: IEEE Transactions on Computers (1986)

Stuck-at faults on primary inputs and fan-out branches are commonly used as target faults in test generation algorithms for combinational circuits. This correspondence shows that these faults may not constitute an adequate set of target faults. A procedure is presented for selecting a set of target faults with the property that the detection of all detectable faults from this set guarantees the detection of all detectable faults in the circuit.
Mapping office work to office technology
Authors: William C. Sasso, Sung K. Kim
Venue: Proceedings of the third ACM-SIGOIS conference on Office information systems (1986)

While several procedures designed to facilitate office analysis have achieved success with respect to describing what happens in the office, they have contributed far less with respect to prescribing how computer-based technologies can support the office. Here we present TEMO (TEchnological Mapping of Office-work), a procedure which aids the analyst in determining the feasibility of supporting a given office task and suggests which specific software packages might improve performance of that task. In order to illustrate the procedure's application, we present a case in which TEMO is applied, in step-by-step fashion, in order to assess the feasibility of automating a simple set of tasks and to assist in the selection of an appropriate software package. Directions of continuing work in the procedure's extension, enhancement, and evaluation are also described.