ppxscal/embedding_network huggingface dataset:
Microcomputer History and Prehistory - An Archaeological Beginning
Authors: Harold A. Layer
Venue: IEEE Annals of the History of Computing (1989)

Calculators, computers, and video games are all high-tech tools of the mind. Teachers find students fascinated by early examples and willing to engage in high-tech archaeological searches in their local community. The cost is usually low - sometimes nothing - since companies are willing often to give away or donate surplus equipment, and old video games are common garage sale items. These artifacts, combined with their disks and cartridges, may be disassembled and analyzed, restored and displayed or operated as functioning units-an archaeological challenge that motivates students and gives them a historical perspective about the computer revolution, both its software and hardware.
Task granularity analysis in logic programs
Authors: Saumya K. Debray, Nai-Wei Lin, Manuel Hermnegildo
Venue: Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation (1990)

While logic programming languages offer a great deal of scope for parallelism, there is usually some overhead associated with the execution of goals in parallel because of the work involved in task creation and scheduling. In practice, therefore, the &ldquo;granularity&rdquo; of a goal, i.e. an estimate of the work available under it, should be taken into account when deciding whether or not to execute a goal concurrently as a separate task. This paper describes a method for estimating the granularity of a goal at compile time. The runtime overhead associated with our approach is usually quite small, and the performance improvements resulting from the incorporation of grainsize control can be quite good. This is shown by means of experimental results.
On the Design of a Single-Key-Lock Mechanism Based on Newton's Interpolating Polynomial
Authors: C. S. Laih, L. Harn, J. Y. Lee
Venue: IEEE Transactions on Software Engineering (1989)

A single-key-lock (SKL) mechanism used for implementing the access matrix of a computer protection system is proposed. The key selection is very flexible. The lock values are generated recursively using the Newton interpolating polynomial. A new user/file can be inserted into the system without recomputing all locks/keys. Since the computational load of the key-lock operation depends on the key positions in the access matrix, a user-hierarchy structure can be constructed for the mechanism. Thus, the smallest key value is assigned to a user who accesses the information resources more frequently than others, in order to reduce the average computation time. An example is included to illustrate this idea.
Rapid, stable fluid dynamics for computer graphics
Authors: Michael Kass, Gavin Miller
Venue: Proceedings of the 17th annual conference on Computer graphics and interactive techniques (1990)

We present a new method for animating water based on a simple, rapid and stable solution of a set of partial differential equations resulting from an approximation to the shallow water equations. The approximation gives rise to a version of the wave equation on a height-field where the wave velocity is proportional to the square root of the depth of the water. The resulting wave equation is then solved with an alternating-direction implicit method on a uniform finite-difference grid. The computational work required for an iteration consists mainly of solving a simple tridiagonal linear system for each row and column of the height field. A single iteration per frame suffices in most cases for convincing animation.Like previous computer-graphics models of wave motion, the new method can generate the effects of wave refraction with depth. Unlike previous models, it also handles wave reflections, net transport of water and boundary conditions with changing topology. As a consequence, the model is suitable for animating phenomena such as flowing rivers, raindrops hitting surfaces and waves in a fish tank as well as the classic phenomenon of waves lapping on a beach. The height-field representation prevents it from easily simulating phenomena such as breaking waves, except perhaps in combination with particle-based fluid models. The water is rendered using a form of caustic shading which simulates the refraction of illuminating rays at the water surface. A wetness map is also used to compute the wetting and drying of sand as the water passes over it.
Making APL cheap-Saving time and money in APL
Authors: J. Lucas
Venue: Proceedings of the international conference on APL (1987)

There are many kinds of costs associated with the use of computers, e.g., hardware expense, programming time, and time spent waiting during execution. None of these are unique to APL. This paper identifies costs and potential savings and presents proven methods &mdash; both general and specific &mdash; for reducing each. Some techniques are specific to APL, but many are not. Examples are taken from the author's personal experience as a programmer.
2-D SIMD algorithms in the perfect shuffle networks
Authors: Y. Ben-Asher, D. Egozi, A. Schuster
Venue: ACM SIGARCH Computer Architecture News (1989)

This paper studies a set of basic algorithms for SIMD Perfect Shuffle networks. These algorithms where studied in several papers, but for the 1-D case, where the size of the problem N is the same as the number of processors P. For the 2-D case of N = L * P, studied by [GK-80] and [Kr-81], we improve several algorithms, achieving run time &Ogr;(L + log P) rather than &Ogr;(L * log P), as N exceeds P. We give non-trivial algorithms for the following 2-D operations: Row-Reduction, Parallel-Prefix, Transpose, Smoothing and Cartesian-Product.
A Survey of Cache Coherence Schemes for Multiprocessors
Authors: Per Stenström
Venue: Computer (1990)

Schemes for cache coherence that exhibit various degrees of hardware complexity, ranging from protocols that maintain coherence in hardware, to software policies that prevent the existence of copies of shared, writable data, are surveyed. Some examples of the use of shared data are examined. These examples help point out a number of performance issues. Hardware protocols are considered. It is seen that consistency can be maintained efficiently, although in some cases with considerable hardware complexity, especially for multiprocessors with many processors. Software schemes are investigated as an alternative capable of reducing the hardware cost.
Mapping Ada onto embedded systems: memory constraints
Authors: A. Tetewsky, A. Clough, R. Racine, R. Whittredge
Venue: ACM SIGAda Ada Letters (1988)

Running Ada programs on a self-targeting system with "virtually" unlimited memory (such as a mainframe), is quite different from running Ada on an embedded target. On self-targeting systems, the compiler and linker will automatically distribute the code, data, constants, and task-stacks onto available resources; the user need not worry about the details. On the other hand, the Ada developer in an embedded environment must understand how to explicitly instruct the development system to allocate resources. For example, to override default settings, (usually set to make the compiler look good on small benchmark programs), 'STORAGE_SIZE length representation settings must be given for task and access types, and linker directives must be given for size and location of code, data, heap, and stack areas. While embedded system technology has always required such settings, many of the parameters could be determined using the programmer's knowledge of implementation details. With Ada, the compiler and linker hide the implementation and the user is faced with setting these parameters with little or no guidance.Unfortunately, few, if any, Ada texts deal with how to set embedded system parameters. In addition, CASE tools usually do not help in these areas. To further complicate matters, even Ada compiler manuals do not adequately describe how to set embedded system parameters solely as a function of Ada constructs. Instead, compiler manuals provide guidelines based not only on Ada constructs but also on other parameters that only run-time system experts understand. Substantial time can be wasted trying to derive the setup values. Incorrect guesses may necessitate recompiling those portions of the program that are affected by representation clause changes.This article will develop formulas that will help estimate the minimum memory and CPU execution needs of an Ada program as a function of source code constructs. The formulas should, 1) help designers and programmers to better assess whether Ada programs will fit in a target environment, 2) reduce recompilation time when representation specifications are present in the specification portion of packages, and 3) remind programmers of the execution costs of various Ada language constructs.
A computer aided design automation system for developing microprogrammed processors: a design approach through HDLs
Authors: W. J. Chen, G. N. Reddy
Venue: ACM SIGMICRO Newsletter (1988)

This paper presents an approach that provides a total computer aided design environment for developing microprogrammed processors using hardware description languages. This includes the behavioral description, micro-coding, and testing of the integrated microprogrammed processors. To illustrate the design procedure a functionally equivalent micro-coded version of the Motorola's MC6809 processor was modeled, and tested. The results indicate that it is a valid design approach. The micro control unit described through the hardware description language AHPL not only replaces the required microprogram simulator but also emulates its exact hardware. Here the micro control unit and the microcode are emulated and tested as a unit: in such the same way a real processor's micro control unit functions with its stored microcode. The emulated micro-simulator here is used for verifying the MC6809 microcode. It can, however, be used as a general purpose testbed for testing any microcode. The design procedure presented here is for the MC6809 microprogrammed processor, however, the procedure can be used to design any processor with user defined instruction set.
Antialiased ray tracing by adaptive progressive refinement
Authors: J. Painter, K. Sloan
Venue: ACM SIGGRAPH Computer Graphics (1989)

We describe an antialiasing system for ray tracing based on adaptive progressive refinement. The goals of the system are to produce high quality antialiased images at a modest average sample rate, and to refine the image progressively so that the image is available in a usable form early and is refined gradually toward the final result.The method proceeds by adaptive stochastic sampling of the image plane, evaluation of the samples by ray tracing, and image reconstruction from the samples. Adaptive control of the sample generation process is driven by three basic goals: coverage of the image, location of features, and confidence in the values at a distinguished "pixel level" of resolution.A three-stage process of interpolation, filtering, and resampling is used to reconstruct a regular grid of display pixels. This reconstruction can be either batch or incremental.
Statistical Inference for General-Order-Statistics and Nonhomogeneous-Poisson-Process Software Reliability Models
Authors: H. Joe
Venue: IEEE Transactions on Software Engineering (1989)

There are many software reliability models that are based on the times of occurrences of errors in the debugging of software. It is shown that it is possible to do asymptotic likelihood inference for software reliability models based on order statistics or nonhomogeneous Poisson processes, with asymptotic confidence levels for interval estimates of parameters. In particular, interval estimates from these models are obtained for the conditional failure rate of the software, given the data from the debugging process. The data can be grouped or ungrouped. For someone making a decision about when to market software, the conditional failure rate is an important parameter. The use of interval estimates is demonstrated for two data sets that have appeared in the literature.
Object-oriented concurrent programming in CST
Authors: W. J. Dally, A. A. Chien
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

CST is a programming language based on Smalltalk-80 that supports concurrency using locks, asynchronous messages, and distributed objects. Distributed objects have their state distributed across many nodes of a machine, but are referred to by a single name. Distributed objects are capable of processing many messages simultaneously and can be used to efficiently connect together large collections of objects. They can be used to construct a number of useful abstractions for concurrency. This paper describes the CST language, gives examples of its use, and discusses an initial implementation.
Scalable, Secure, and Highly Available Distributed File Access
Authors: Mahadev Satyanarayanan
Venue: Computer (1990)

A summary of and historical perspective on work done to implement easy-to-share distributed file systems based on the Unix model are presented. Andrew and Coda are distributed Unix file systems that embody many of the recent advances in solving the problem of data sharing in large, physically dispersed workstation environments. The Andrew architecture is presented, the scalability and security of the system are discussed. The Coda system is examined, with emphasis on its high availability.
Grammar-like functional rules for representing query optimization alternatives
Authors: Guy M. Lohman
Venue: Proceedings of the 1988 ACM SIGMOD international conference on Management of data (1988)

Extensible query optimization requires that the &ldquo;repertoire&rdquo; of alternative strategies for executing queries be represented as data, not embedded in the optimizer code. Recognizing that query optimizers are essentially expert systems, several researchers have suggested using strategy rules to transform query execution plans into alternative or better plans. Though extremely flexible, these systems can be very inefficient at any step in the processing, many rules may be eligible for application and complicated conditions must be tested to determine that eligibility during unification. We present a constructive, &ldquo;building blocks&rdquo; approach to defining alternative plans, in which the rules defining alternatives are an extension of the productions of a grammar to resemble the definition of a function in mathematics. The extensions permit each token of the grammar to be parametrized and each of its alternative definitions to have a complex condition. The terminals of the grammar are base-level database operations on tables that are interpreted at run-time. The non-terminals are defined declaratively by production rules that combine those operations into meaningful plans for execution. Each production produces a set of alternative plans, each having a vector of properties, including the estimated cost of producing that plan. Productions can require certain properties of their inputs, such as tuple order and location, and we describe a &ldquo;glue&rdquo; mechanism for augmenting plans to achieve the required properties. We give detailed examples to illustrate the power and robustness of our rules and to contrast them with related ideas.
On the Number of Permutations Performable by Extra-Stage Multistage Interconnection Networks
Authors: I. Gazit, M. Malek
Venue: IEEE Transactions on Computers (1989)

The number of permutations performable by extra-stage multistage interconnection networks in a single pass is studied. A graph-theoretical approach is used to evaluate the multiplicity of the performable permutations. More specifically, the problem is reduced to a hypercube enumeration problem, and it is shown that there is a direct correspondence between the number of partial subgraphs of a hypercube with a given number of components, and the multiplicity of a corresponding class of permutations performable by the extra- stage network. The evaluation of these multiplicities leads to the calculation of the number of distinct permutations performable by the network.
Concurrent programming in an upper level operating systems course
Authors: J. L. Silver
Venue: ACM SIGCSE Bulletin (1989)

Since 1983, we have been covering concurrent programming as a central feature of a senior-level course in operating systems. This paper describes the content of that course, the mechanism used to implement concurrency, and the programming projects which provide students with practical experience in concurrency.
Adaptive mesh generation for global diffuse illumination
Authors: A. T. Campbell,  III, Donald S. Fussell
Venue: ACM SIGGRAPH Computer Graphics (1990)

Rapid developments in the design of algorithms for rendering globally illuminated scenes have taken place in the past five years. Net energy methods such as the hemicube and other radiosity algorithms have become very effective at computing the energy balance for scenes containing diffusely reflecting objects. Such methods first break up a scene description into a relatively large number of elements, or possibly several levels of elements. Energy transfers among these elements are then determined using a variety of means. While much progress has been made in the design of energy transfer algorithms, little or no attention has been paid to the proper generation of the mesh of surface elements. This paper presents a technique for adaptively creating a mesh of surface elements as the energy transfers are computed. The method allows large numbers of small elements to be placed at parts of the scene where the most active energy transfers occur without requiring that other parts of the scene be needlessly subdivided to the same degree. As a result, the computational effort in the energy transfer computations can be concentrated where it has the most effect.
Lower bounds for orthogonal range searching: I. The reporting case
Authors: Bernard Chazelle
Venue: Journal of the ACM (JACM) (1990)

We establish lower bounds on the complexity of orthogonal range reporting in the static case. Given a collection of n points in d-space and a box [a1, b1] X &hellip; X [ad, bd], report every point whose ith coordinate lies in [ai, bi], for each i = l, &hellip; , d. The collection of points is fixed once and for all and can be preprocessed. The box, on the other hand, constitutes a query that must be answered online. It is shown that on a pointer machine a query time of O(k + polylog(n)), where k is the number of points to be reported, can only be achieved at the expense of &OHgr;(n(log n/log log n)d-1) storage. Interestingly, these bounds are optimal in the pointer machine model, but they can be improved (ever so slightly) on a random access machine. In a companion paper, we address the related problem of adding up weights assigned to the points in the query box.
A Randomized Parallel Backtracking Algorithm
Authors: V. K. Janakiram, D. P. Agrawal, R. Mehrotra
Venue: IEEE Transactions on Computers (1988)

A technique for parallel backtracking using randomization is proposed. Its main advantage is that good speedups are possible with little or no interprocessor communication. The speedup obtainable is problem-dependent. In those cases where the problem size becomes very large, randomization is extremely successful achieving good speedups. The technique also ensures high reliability, flexibility, and fault tolerance.
X3J3 avoids deadlock
Authors: Loren P. Meissner
Venue: ACM SIGPLAN Fortran Forum (1989)

Plan generated by International Fortran Working Group wins broad X3J3 support at November 1988 meetingWhile you have been sitting at home, waiting for news about the agonies of birth of the revised Fortran standard, the obstetricians (X3J3, the ANSI accredited Fortran technical committee) have been busily working.
Experimental design issues for large scale simulation models
Authors: R. R. Barton
Venue: Proceedings of the 21st conference on Winter simulation (1989)

Experiment design issues are important at each stage in a simulation model's life- cycle, yet we have found that supercomputer users are poorly supported in this area. This panel will address experimental design techniques that can be used to make more efficient use of supercomputing resources and researcher resources. Problems associated specifically with large sale simulation models will be discussed by example.
Using tolerances to guarantee valid polyhedral modeling results
Authors: Mark Segal
Venue: Proceedings of the 17th annual conference on Computer graphics and interactive techniques (1990)

A polyhedral solid modeler that operates on boundary representations of objects must infer topological information from numerical data. Unavoidable errors (due to limited precision) affect these calculations so that their use may produce ambiguous or contradictory results. These effects cause existing polyhedral modelers to fail when presented with objects that nearly align or barely intersect[10][7].An object description associating a tolerance with each of its topological features (vertices, edges, and faces) is introduced. The use of tolerances leads to a definition of topological consistency that is readily applied to boundary representations. The implications of using tolerances to aid in making consistent topological determinations from imprecise geometric data are explored and applied to the calculations of a polyhedral solid modeler. The resulting modeler produces a consistent polyhedral boundary when given consistent boundaries as input.
Extending the operating system to support an object-oriented environment
Authors: J. A. Marques, P. Guedes
Venue: ACM SIGPLAN Notices (1989)

Comandos is a project within the European Strategic Programme for Research on Information Technology - ESPRIT and it stems from the identified need of providing simpler and more integrated environments for application development in large distributed systems. The fundamental goal of the project is the definition of an integrated platform providing support for distributed and concurrent processing in a LAN environment, extensible and distributed data management and tools for monitoring and administrating the distributed environment. An object oriented approach was used as the ground level for the integration of the multidisciplinary concepts addressed in the project. This paper starts by describing the basic model and architecture of Comandos, which results from a common effort by all the partners in the project. We focus then on the description of a first prototype of the system, which implements a subset of the architecture and is currently running on a set of personal computers and workstations at INESC. The prototype is a testbed for the architecture, providing dynamic linking, access to persistent objects and transparent distribution. Special attention is given to the performance aspects of object invocation in virtual memory.
On teaching operating systems
Authors: Su Yun-Lin
Venue: ACM SIGCSE Bulletin (1989)

This paper discusses teaching an Operating Systems Course. Different approaches to teaching the course are presented. An operating systems course is one of the kernel courses in computer curriculum of both China and other countries. This course is of critical importance for students to understand the working procedures and principles of modern computer systems, to understand the methodology and approach of the design of system software, and to gain an appreciation for the requirements of other large-scale software projects.
The PMC System Level Fault Model: Cardinality Properties of the Implied Faulty Sets
Authors: M. A. Kennedy, G. G. L. Meyer
Venue: IEEE Transactions on Computers (1989)

One aspect of the PMC system level fault model, the properties of the implied faulty sets, is considered. For tau -diagnosable systems that have at most tau faulty units, lower bounds on the cardinality of the maximal implied faulty sets are given. Then it is shown that these bounds are greatest lower bounds, and it is indicated how these results can be used in diagnosis algorithms.