ppxscal/embedding_network huggingface dataset:
Translation lookaside buffer consistency: a software approach
Authors: D. L. Black, R. F. Rashid, D. B. Golub, C. R. Hill
Venue: ACM SIGARCH Computer Architecture News (1989)

We discuss the translation lookaside buffer (TLB) consistency problem for multiprocessors, and introduce the Mach shootdown algorithm for maintaining TLB consistency in software. This algorithm has been implemented on several multiprocessors, and is in regular production use. Performance evaluations establish the basic costs of the algorithm and show that it has minimal impact on application performance. As a result, TLB consistency does not pose an insurmountable obstacle to multiprocessors with several hundred processors. We also discuss hardware support options for TLB consistency ranging from a minor interrupt structure modification to complete hardware implementations. Features are identified in current hardware that compound the TLB consistency problem; removal or correction of these features can simplify and/or reduce the overhead of maintaining TLB consistency in software.
Stability in a sea of change
Authors: Danald Soule
Venue: ACM SIGAPL APL Quote Quad (1990)

As a developer, how do you continue to productively develop business applications when the hardware/software environment changes twice each year?
A campus and off-campus computing strategy
Authors: P. Brady, R. Startup
Venue: Proceedings of the 17th annual ACM SIGUCCS conference on User Services (1989)

During the 1980s great stress has been laid on the rapid increase of workstations for student use and their ready accessibility. An experimental project funded by the &ldquo;Computers in Teaching&rdquo; initiative [6,7] of the UK Computer Board and University Grants Committee and conducted at the University of Wales, Swansea, U.K. advances understanding of a cost effective solution. The aims were to examine the managerial and operational problems of installing clusters of terminals in local and remote student residences and to determine the resulting advantages. On the educational side the primary gains were greater, more economical and more widespread use of computers and a better working relationship between users and staff of the Computer Centre. Approximately two fifths of those in the residences had used the facilities regularly and, significantly, one fifth of these indicated that their pattern of work had altered to include more computing in the evening, late at night and at weekends. More course administrative tasks are now being performed electronically and extensive use is being made of electronic mail to seek advice both about computing and academic problems. On the operational side key factors in running a successful remote service have been the ability to monitor the state of communications equipment, and to place news and service messages in X25 PADs. The success of the monitor has led to a more ambitious tool to archive the configuration of a PAD to disk, and restore it should the PAD subsequently fail. The archive/restore suite has an extra utility in the form of an archive editor enabling new PADs to be configured readily. A further stage of project development is envisaged whereby a set of microcomputers will be installed to meet the increasing demands of computer literacy courses. In line with the policy of dispersed facilities these will comprise networked systems in the Computer Centre and stand-alone micros in the residences.
Comparative analysis of LISP and APL2
Authors: A. Kaneko
Venue: ACM SIGAPL APL Quote Quad (1987)

LISP and APL2 were both born in 1960's and they have the similar syntax which is called function type. The main users of LISP were in the universities and the applications were linguistics or formula processing in mathematics. On the other hand APL was used in the companies and many of their applications were in the business environment such as business planning or reporting. Traditional APL provided user intuitive expressions, but it was rather weak in handling character string of variable length or combination of numerics and characters. APL2 and its general array resolved these weak points and it has a great capability to develop AI applications. This paper introduces the similarities between LISP and APL2 and shows how APL2 solves the problem which LISP is good at handling.
Validating programs without specifications
Authors: W. Howden
Venue: Proceedings of the ACM SIGSOFT '89 third symposium on Software testing, analysis, and verification (1989)

This work was supported by the Office of Naval Research and the Naval Weapons Center
Acquiring Recursive and Iterative Concepts with Explanation-Based Learning
Authors: Jude W. Shavlik
Venue: Machine Learning (1990)

In explanation-based learning, a specific problem's solution is generalized into a form that can be later used to solve conceptually similar problems. Most research in explanation-based learning involves relaxing constraints on the variables in the explanation of a specific example, rather than generalizing the graphical structure of the explanation itself. However, this precludes the acquisition of concepts where an iterative or recursive process is implicitly represented in the explanation by a fixed number of applications. This paper presents an algorithm that generalizes explanation structures and reports empirical results that demonstrate the value of acquiring recursive and iterative concepts. The BAGGER2 algorithm learns recursive and iterative concepts, integrates results from multiple examples, and extracts useful subconcepts during generalization. On problems where learning a recursive rule is not appropriate, the system produces the same result as standard explanation-based methods. Applying the learned recursive rules only requires a minor extension to a PROLOG-like problem solver, namely, the ability to explicitly call a specific rule. Empirical studies demonstrate that generalizing the structure of explanations helps avoid the recently reported negative effects of learning.
Linear Feedback Shift Register Design Using Cyclic Codes
Authors: L.-T. Wang, E. J. McClusky
Venue: IEEE Transactions on Computers (1988)

A design technique is given for linear-feedback shift registers (LFSR) that generate test patterns for pseudoexhaustive testing of networks with restricted output dependency. This technique is based on cyclic code theory. Examples indicate that LFSRs based on cyclic codes are easier to implement and have lower hardware overhead than LFSRs that use other linear codes.
Artificial reality with force-feedback: development of desktop virtual space with compact master manipulator
Authors: Hiroo Iwata
Venue: Proceedings of the 17th annual conference on Computer graphics and interactive techniques (1990)

A new configuration of Human Interface for "artificial reality" is discussed. This paper describes a method of implementing force-feedback in a virtual space manipulation system. The system is composed of two subsystems, a real-time graphic display system and a tactile input device with reaction force generator. A specialized graphics computer (Stardent TITAN) provides a realtime image of the virtual space. A 9 degree-of-freedom manipulator has been developed as a tactile input device. The manipulator applies reaction forces to the fingers and palm of the operator. The generated forces are calculated from a solid model of the virtual space. The performance of the system is exemplified in manipulation of virtual solid objects such as a mockup for industrial design and a 3D animated character.
Resource requirements of dataflow programs
Authors: D. E. Culler, Arvind
Venue: ACM SIGARCH Computer Architecture News (1988)

Parallel execution of programs requires more resources and more complex resource management than sequential execution. If concurrent tasks can be spawned dynamically, programs may require an inordinate amount of resources when the potential parallelism in the program is much greater than the amount of parallelism the machine can exploit. We describe loop bounding, a technique for dynamically controlling the amount of parallelism exposed in dataflow programs. The effectiveness of the technique in reducing token storage requirements is supported by experimental data in the form of parallelism profiles and waiting-token profiles. Comparisons are made throughout with more conventional approaches to parallel computing.
The analytic approach to recursion relations
Authors: S. A. Fulling
Venue: Journal of Symbolic Computation (1990)

Solution of algebraic recursion relations in the most obvious fashion may produce unwieldy expressions. If the structure of the recursion is well understood, a better method may be to calculate the coefficient of each term in the answer by analysis of all ways in which that tern can be generated by the recursion relation. This technique has been applied with great success to the WKB (phase-integral) approximation for ordinary differential equations and systems. In progress is a more difficult application, to differential geometry and relativity (Synge-DeWitt tensors).
Problem reporting and development tracking using VM/SP
Authors: J. Murray
Venue: ACM SIGSOFT Software Engineering Notes (1988)

This paper discusses some aspects of handling software error information in an environment where development is also in progress. A tool called RPT is described, combining the twin tasks of problem reporting and enhancement tracking in a medium-sized operating system project. RPT runs under IBM VM/ISP and uses CMS and XEDIT.
The 1986-1987 Taulbee survey
Authors: D. Gries, D. Marsh
Venue: Communications of the ACM (1988)

The Computing Research Board's 1986-87 Taulbee Survey includes the latest statistics on production and employment of Ph.D.'s and faculty in computer science and engineering. For the first time, departments offering Ph.D.'s in computer engineering are also included.
Inverse-transformation algorithms for some common stochastic processes
Authors: B. Schmiser, W.-M. Tina Song
Venue: Proceedings of the 21st conference on Winter simulation (1989)

Realizations from common stochastic processes are often used by simulation-methodology researchers in Monte Carlo performance evaluation of new and existing methods for output analysis, variance reduction, and optimization. Typically realizations can be obtained easily from either the definition or simple properties of the process. We discuss using the inverse of the distribution function for generating realizations from some of these processes. The inverse transformation always possesses the advantage of correlation induction, useful for variance reduction. We consider the discrete-time processes ARMA, EAR, M/M/1-QT (time in queue), and M/M/1-ST (time in system, the sojourn time), and Markov chains. The inverse-transformation algorithms are sometimes slower (e.g., ARMA, M/M/1-ST), sometimes faster (e.g., M/M/1-QT), and often about the same speed as the usual algorithm. Some Fortran implementations are provided.
Mirage: a coherent distributed shared memory design
Authors: B. Fleisch, G. Popek
Venue: Proceedings of the twelfth ACM symposium on Operating systems principles (1989)

Shared memory is an effective and efficient paradigm for interprocess communication. We are concerned with software that makes use of shared memory in a single site system and its extension to a multimachine environment. Here we describe the design of a distributed shared memory (DSM) system called Mirage developed at UCLA. Mirage provides a form of network transparency to make network boundaries invisible for shared memory and is upward compatible with an existing interface to shared memory. We present the rationale behind our design decisions and important details of the implementation. Mirage's basic performance is examined by component timings, a worst case application, and a &ldquo;representative&rdquo; application. In some instances of page contention, the tuning parameter in our design improves application throughput. In other cases, thrashing is reduced and overall system performance improved using our tuning parameter.
MPX-PC: an operating system project for the PC
Authors: M. G. Lane, A. k. Ghosal
Venue: ACM SIGCSE Bulletin (1989)

This paper describes a student operating system project, MPX-PC, that can be implemented on an IBM PC-compatible computer. Seven modules make up the project, with the seventh module being the completion of a &ldquo;stand-alone&rdquo; student multiprogramming operating system. The project is implemented in Turbo C.
A multiprocessor configuration in accordance with the aspects of physical and systems design
Authors: Y.-J. Oyang
Venue: ACM SIGARCH Computer Architecture News (1989)

A new multiprocessor configuration that exploits process-level parallelism is proposed. The objective is to define a configuration for next generation multiprocessor systems. The new configuration is a direct result of careful examination of the aspects of physical and system design and the development of integrated circuit technology. The new configuration eliminates the major problems that limit the expansion capability of the conventional configurations and thus paves the path toward higher performance systems.
A new way to access a supercomputer
Authors: L. M. Andrade
Venue: Proceedings of the 17th annual ACM SIGUCCS conference on User Services (1989)

One of the frustrations of being a user in the computing world is that there are so many different types of systems to learn. This is especially true for users of NCAR's computing facilities, most of whom are at various universities around the country. Typically, the university users do most of their computing on their local systems. When they need extra computing power, they are able to easily access the NCAR computing facilities without logging on to another machine. This is due to the Internet Remote Job Entry (IRJE); a facility that provides a method for NCAR supercomputer users at remote sites to submit jobs easily and directly from their local hosts, and get the results delivered back to their local hosts.
Profiling an Incremental Data Flow Analysis Algorithm
Authors: Barbara G. Ryder, William Landi, Hemant D. Pande
Venue: IEEE Transactions on Software Engineering (1990)

Incremental data flow analysis algorithms have been designed to deal efficiently with change in evolving software systems. These algorithms document the current state of a software system by incorporating change effects into previously derived information describing the definition and use of data in the system. Unfortunately, the performance of these algorithms cannot, in general, be characterized by analytic predictions of their expected behavior. It is possible, however, to observe their performance empirically and predict their average behavior. The authors report on experiments on the empirical profiling of a general-purpose, incremental data flow analysis algorithm. The algorithm, dominator based and coded in C, was applied to statistically significant numbers of feasible, random software systems of moderate size. The experimental results, with quantifiable confidence limits, substantiate the claim that incremental analyses are viable and grow more valuable as a software system grows in size.
Searching for empty convex polygons
Authors: D. P. Dobkin, H. Edelsbrunner, M. H. Overmars
Venue: Proceedings of the fourth annual symposium on Computational geometry (1988)

A key problem in computational geometry is the identification of subsets of a point set having particular properties. We study this problem for the properties of convexity and emptiness. We show that finding empty triangles is related to the problem of determining pairs of vertices that see each other in a star-shaped polygon. A linear time algorithm for this problem which is of independent interest yields an optimal algorithm for finding all empty triangles. This result is then extended to an algorithm for finding empty convex r-gons (r > 3) and for determining a largest empty convex subset. Finally, extensions to higher dimensions are mentioned.
Integration of elementary functions
Authors: Manuel Bronstein
Venue: Journal of Symbolic Computation (1990)

We extend a recent algorithm of Trager to a decision procedure for the indefinite integration of elementary functions. We can express the integral as an elementary function or prove that it is not elementary. We show that if the problem of integration in finite terms is solvable on a given elementary function field k, then it is solvable in any algebraic extension of k(@d), where @d is a logarithm or exponential of an element of k. Our proof considers an element of such an extension field to be an algebraic function of one variable over k. In his algorithm for the integration of algebraic functions, Trager describes a Hermitetypereduction to reduce the problem to an integrand with only simple finite poles on the associated Riemann surface. We generalize that technique to curves over liouvillian ground fields, and use it to simplify our integrands. Once the multiple finite poles have been removed, we use the Puiseux expansions of the integrand at infinity and n generalization of the residues to compute the integral. We also generalize a result of Rothstein that gives us a necessary condition for elementary integrability, and provide examples of its use.
The Clipper processor: instruction set architecture and implementation
Authors: W. Hollingsworth, H. Sachs, A. J. Smith
Venue: Communications of the ACM (1989)

Intergraph's CLIPPER microprocessor is a high performance, three chip module that implements a new instruction set architecture designed for convenient programmability, broad functionality, and easy future expansion.
A linear-time probabilistic counting algorithm for database applications
Authors: Kyu-Young Whang, Brad T. Vander-Zanden, Howard M. Taylor
Venue: ACM Transactions on Database Systems (TODS) (1990)

We present a probabilistic algorithm for counting the number of unique values in the presence of duplicates. This algorithm has O(q) time complexity, where q is the number of values including duplicates, and produces an estimation with an arbitrary accuracy prespecified by the user using only a small amount of space. Traditionally, accurate counts of unique values were obtained by sorting, which has O(q log q) time complexity. Our technique, called linear counting, is based on hashing. We present a comprehensive theoretical and experimental analysis of linear counting. The analysis reveals an interesting result: A load factor (number of unique values/hash table size) much larger than 1.0 (e.g., 12) can be used for accurate estimation (e.g., 1% of error). We present this technique with two important applications to database problems: namely, (1) obtaining the column cardinality (the number of unique values in a column of a relation) and (2) obtaining the join selectivity (the number of unique values in the join column resulting from an unconditional join divided by the number of unique join column values in the relation to he joined). These two parameters are important statistics that are used in relational query optimization and physical database design.
The Consistent Comparison Problem in N-Version Software
Authors: S. S. Brilliant, J. C. Knight, N. G. Leveson
Venue: IEEE Transactions on Software Engineering (1989)

The authors have identified a difficulty in the implementation of N-version programming. The problem, called the consistent comparison problem, arises for applications in which decisions are based on the results of comparing finite-precision numbers. It is shown that when versions make comparisons involving the results of finite-precision calculations, it is impossible to guarantee the consistency of their results. It is therefore possible that correct versions may arrive at completely different outputs for an application that does not apparently have multiple correct solutions. If this problem is not dealt with explicitly, an N-version system may be unable to reach consensus even when none of its component versions falls.
Prototyping a real-time embedded system in Smalltalk
Authors: B. M. Barry
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1989)

This paper presents a case study of AMEP, a prototype ESM signal processor which has been implemented in Smalltalk using an actor-based design methodology, Arguments for choosing an OOPS for implementing such applications are reviewed. AMEP is a large system which includes both hard real-time and knowledge-based subsystems. Extensive software metrics are presented for each subsystem and used to compare the characteristics of code designed for different purposes. For example, analysis of this data suggests that knowledge-based applications may be more difficult to port to an object-based language such as Ada than hard real-time systems. Team programming, productivity, documentation standards and other software engineering issues are also addressed.
Using generics modules to enhance the CS2 course
Authors: Ashok Kumar, John Beidler
Venue: ACM SIGCSE Bulletin (1989)

We normally expect features in a programming language to support the concepts and methodologies in the course. This article describes another role for features within a programming language, support of sound educational methodology. Specifically, this paper describes how the library module capability in Modula-2 may be used to formally separate the concept from the implementation of abstract data types. That is, by having generic support for various structures, the structures can be taught at a conceptual level and students are given assignments to use these structures long before the implementations of the structures are taught. The result is a clear separation of concept and implementation and a better understanding of the structures as ADTs.
Graph attribution as a specification paradigm
Authors: Bowen Alpern, Alan Carle, Barry Rosen, Peter Sweeney, Kenneth Zadeck
Venue: Proceedings of the third ACM SIGSOFT/SIGPLAN software engineering symposium on Practical software development environments (1989)

An interactive software development environment can be viewed as a structure-based editor, provided that structure is broadly interpreted. The user sees and manipulates complex objects at various levels of detail. Many of the implications of changes are analyzed and made available to the user as frequently as the user wishes, without a mode change from editing to compiling or linking. To help provide these services in a uniform way that can readily respond to changes in the programming language(s) supported or in the preferences of individual users, some programming environments use attribute grammars. The attributed graph specifications (AGS's) defined here are inspired by attribute grammars but are free of their restriction to structures expressible by parse trees generated by context-free grammars. An AGS deals with whatever structure is appropriate in a given application. The graph concept here is not tied to any decision about pictorial representation. Indeed, we do not care whether the user sees pictures or text or a combination of the two. The AGS formalism is a uniform paradigm for specifying the desired relations among many and varied chunks of information, some of which are changed by the user. The benefits of the original attribute grammar formalism were confined to parse trees and severely restricted manipulations of parse trees. The AGS paradigm extends those benefits to software development on a larger scale.