ppxscal/embedding_network huggingface dataset:
Efficient debugging primitives for multiprocessors
Authors: Z. Aral, I. Gerther, G. Schaffer
Venue: ACM SIGARCH Computer Architecture News (1989)

Existing kernel-level debugging primitives are inappropriate for instrumenting complex sequential or parallel programs. These functions incur a heavy overhead in their use of system calls and process switches. Context switches are used to alternately invoke the debugger and the target programs. System calls are used to communicate data between the target and debugger. None of this is necessary in shared-memory multiprocessors. Multiple processors concurrently run both the debugger and the target. Shared-memory is used to implement efficient communication. The target's state is accessed by running both the target and the debugger in the same address space. Finally, instrumentation points, which have largely been implemented as traps to the system, are reimplemented as simple branches to routines of arbitrary complexity maintained by the debugger. Not only are primitives such as conditional breakpoints thus generalized, but their efficiency is improved by several orders of magnitude. In the process, much of the traditional system's kernel support for debugging is reimplemented at user-level. This paper describes the implementation of debugging primitives in Parasight, a parallel programming environment. Parasight has been used to implement conditional breakpoints, an important primitive for both high-level and parallel debugging. Preliminary measurements indicate that Parasight breakpoints are 1000 times faster than the breakpoints in parallel &ldquo;cdb&rdquo;, a conventional UNIX debugger. Light-weight conditional breakpoints open up new opportunities for debugging and profiling both parallel and sequential programs.
A formalism for the definition of graphical formulas
Authors: Robert Gabriel
Venue: Proceedings of the 1988 ACM SIGSMALL/PC symposium on ACTES (1988)

This paper describes a new formalism (the typed holistic formula definition) which enables to define two dimensional formula grammars very easily by just drawing a prototype of the desired formula. The formalism is used in a tool called G2F (An Editor Generator for Two Dimensional Graphical Formulas) the properties of which are also sketched (its main advantage is the possibility to use the editors as interfaces for symbol manipulating systems).
Rule-based VLSI verification system constrained by layout parasitics
Authors: J. Wenin, J. Verhasselt, M. Van Camp, J. Leonard, P. Guebels
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

This paper addresses a rule-based method for VLSI design review, constrained by parasitics. Using the new ideas discussed in this paper, extraction from layout is not limited anymore to conventional electrical data, but additionally allows modelling of functional and timing behaviour. An extendable rule based validation algorithm operates on extracted models, decorated with parasitic effects, to formally prove most aspects of design correctness.
Codatatypes in ML
Authors: Tatsuya Hagino
Venue: Journal of Symbolic Computation (1989)

A new data type declaration mechanism of defining codatatypes is introduced to a functional programming language ML. Codatatypes are dual to datatypes for which ML already has a mechanism of defining. Sums and finite lists are defined as datatypes, but their duals, products and infinite lists, could not be defined in ML. This new facility gives ML the missing half of data types and makes ML symmetric. Categorical and domain-theoretic characterization of codatatypes are also given.
An interactive simulation modeling system: DYNAGRAPH for multi-period planning on an APL spreadsheet
Authors: T. Aonuma
Venue: ACM SIGAPL APL Quote Quad (1987)

A Modeling System named DYNAGRAPH has been developed on the IBM 5550 Personal Computer with NEXUS 5500 Graphics to interactively build dynamic simulation models using APL functions. A model for the simulation is represented by APL expressions in the rows of an APL Spreadsheet. The modeling of dynamic systems is achieved by a state-variable method. The paper introduces DYNAGRAPH and the underlying modeling method. Some of the modeling functions for dynamic simulations are presented. We claim that the method is suitable and convenient for modeling problems of moderate size, especially when using APL in teaching or business environments: DYNAGRAPH is useful as a training tool and an APL program generator to enhance APL applications in management science.
A proof of H. K. Hodge's induction formula and the number of zeros in which N] ends
Authors: C. Rosselló
Venue: ACM SIGSMALL/PC Notes (1989)

I have read the paper of H. K. Hodge on integer arithmetic and I find it very interesting. However two questions arised when I was reading the paper. First, is there an algorithm to compute the exact number of zeros in which N! ends?, and second, can we easily prove the induction formula?
Hierarchy in Picture Segmentation: A Stepwise Optimization Approach
Authors: Jean-Marie Beaulieu, Morris Goldberg
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

A segmentation algorithm based on sequential optimization which produces a hierarchical decomposition of the picture is presented. The decomposition is data driven with no restriction on segment shapes. It can be viewed as a tree, where the nodes correspond to picture segments and where links between nodes indicate set inclusions. Picture segmentation is first regarded as a problem of piecewise picture approximation, which consists of finding the partition with the minimum approximation error. Then, picture segmentation is presented as an hypothesis-testing process which merges only segments that belong to the same region. A hierarchical decomposition constraint is used in both cases, which results in the same stepwise optimization algorithm. At each iteration, the two most similar segments are merged by optimizing a stepwise criterion. The algorithm is used to segment a remote-sensing picture, and illustrate the hierarchical structure of the picture.
Environment for enhancing iPSC/2 programmer productivity
Authors: D. Ertel
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

Experience with the first generation iPSC system indicated that several programmer productivity issues needed to be addressed. This paper describes major features of the iPSC/2 environment which were intended to address some of those issues, The features include: extending the programming model across the network. the ability to support multiple users simultaneously executing on independent partitions of the iPSC/2. direct file access from the iPSC/2 nodes to the host file system. Concurrent Workbench tools accessible from certain workstations, such as the Sun*/3.
Some APL2 programming examples using nested arrays
Authors: J. P. Benkard
Venue: Proceedings of the international conference on APL (1987)

Three extracts from a program currently in use are shown and discussed. The program reads seven files, formats the data as nested arrays, and prepares several reports and files. The examples are taken, respectively, from the input, process, and output sections of the program. In each section nested arrays are useful. N-WISE REDUCTION is used as the inverse of SCAN to simplify a backward scheduling algorithm. The flexible formatting of nested array output makes optimum use of print columns. An experimental depth operator described in the references is very useful.
ICE: information center expert: a consultation system for resource allocation
Authors: Mari M. Heltne, Ajay S. Vinze, Benn R. Konsynski, Jay F. Nunamaker,  Jr.
Venue: ACM SIGMIS Database (1988)

This paper demonstrates the viability of a rule-based consultation system as a mechanism for effective resource management through integration of knowledge about users, business problems, and resources. The specific domain within which the expert system will be tested is the Information Center (IC), which deals with end-user computing resources. In the last decade, the information center concept has been proposed repeatedly as an organizational solution to resource management problems related to end user computing. The research hypothesis is that the knowledge and methodologies of IC consultants, as well as institutional policies, can be represented in a knowledge base. The system will then draw conclusions about appropriate software or training solutions based on the interaction of user and resource profiles with the problem definition. The output of the model should be identical to the situation which it is modeling.Currently, a rule-based ES is being developed at the University of Arizona Department of Management Information Systems. This paper will present methodologies for design and implementation of the system. The development approach for the IC environment is unique as compared to expert system development as discussed in the literature. First, the use of prototyping has been stressed for expert system development with the view of using it as a throw-away system. The prototyping of an ES for the IC environment, however, has to take into account the difference between two aspects of a prototype: user interface (dialogue) and system structures (knowledge representation, inferencing techniques). There needs to be iteration of the prototype until the user if comfortable with the dialogue. The prototype will be used to extract more knowledge form the experts as well as for enhancing user dialogue. The system structures will be changed only when the user dialogue has been settled.Second, because of changes in tool availability, resulting in a need for new descriptions of the tools available, the design of an expert system for ICs has to respond dynamically to unique flexibility, portability, and maintenance issues. The ability to transport such a system to similar, but not identical, ICs should be addressed in the design as well.An IC has been described as an organization specifically designed to produce guided services to help end users help themselves. A consultation expert system might be useful in reaching that goal.
A generalization of Dijkstra's calculus
Authors: Greg Nelson
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1989)

Dijsktra's calculus of guarded commands can be generalized and simplified by dropping the law of the excluded miracle. This paper gives a self-contained account of the generalized calculus from first principles through the semantics of recursion. The treatment of recursion uses the fixpoint method from denotational semantics. The paper relies only on the algebraic properties of predicates; individual states are not mentioned (except for motivation). To achieve this, we apply the correspondence between programs and predicates that underlies predicative programming. The paper is written from the axiomatic semantic point of view, but its contents can be described from the denotational semantic point of view roughly as follows: The Plotkin-Apt correspondence between wp semantics and the Smyth powerdomain is extended to a correspondence between the full wp/wlp semantics and the Plotkin powerdomain extended with the empty set.
On the risch-norman integration method and its implementation in MAPLE
Authors: K. O. Geddes, L. Y. Stefanus
Venue: Proceedings of the ACM-SIGSAM 1989 international symposium on Symbolic and algebraic computation (1989)

Unlike the Recursive Risch Algorithm for the integration of transcendental elementary functions, the Risch-Norman Method processes the tower of field extensions directly in one step. In addition to logarithmic and exponential field extensions, this method can handle extensions in terms of tangents. Consequently, it allows trigonometric functions to be treated without converting them to complex exponential form. We review this method and describe its implementation in MAPLE. A heuristic enhancement to this method is also presented.
Multiple instruction issue and single-chip processors
Authors: A. R. Pleszkun, G. S. Sohi
Venue: Proceedings of the 21st annual workshop on Microprogramming and microarchitecture (1988)

In this paper we evaluate the performance of single-chip processors with multiple functional units. As a basis for our studies we use a processor model that is very similar to many of today's single-chip processors. Using this basic machine model, we investigate the performance that can be achieved if some limited form of multiple instruction issue is supported. For these investigations, we use 4 variants of the basic machine that represented different memory access times and branch execution times. In particular, we evaluate issuing 2 instructions per cycle and find that by restricting multiple instruction issue to load or branch instructions much of the same performance gains can be achieved as in the unrestricted form.
Color APL beautiful!
Authors: Ralph L. Fox
Venue: ACM SIGAPL APL Quote Quad (1990)

This paper presents many ways you can use color display attributes to make your interaction with the APL*PLUS PC and APL*PLUS II Systems more productive and enjoyable. An extensive suite of utility functions will be illustrated. These functions enable you to establish color schemes for the editing, maintenance, and display of functions and many types of data arrays. The workspace of utilities, many of which are also applicable to monochrome monitors, is publicly available in several formats.
Multicast routing in internetworks and extended LANs
Authors: S. E. Deering
Venue: Symposium proceedings on Communications architectures and protocols (1988)

Multicasting is used within local-area networks to make distributed applications more robust and more efficient. The growing need to distribute applications across multiple, interconnected networks, and the increasing availability of high-performance, high-capacity switching nodes and networks, lead us to consider providing LAN-style multicasting across an internetwork. In this paper, we propose extensions to two common internetwork routing algorithms&mdash;distance-vector routing and link-state routing&mdash;to support low-delay datagram multicasting. We also suggest modifications to the single-spanning-tree routing algorithm, commonly used by link-layer bridges, to reduce the costs of multicasting in large extended LANs. Finally, we show how different link-layer and network-layer multicast routing algorithms can be combined hierarchically to support multicasting across large, heterogeneous internetworks.
Practical selectivity estimation through adaptive sampling
Authors: Richard J. Lipton, Jeffrey F. Naughton, Donovan A. Schneider
Venue: ACM SIGMOD Record (1990)

Recently we have proposed an adaptive, random sampling algorithm for general query size estimation. In earlier work we analyzed the asymptotic efficiency and accuracy of the algorithm, in this paper we investigate its practicality as applied to selects and joins. First, we extend our previous analysis to provide significantly improved bounds on the amount of sampling necessary for a given level of accuracy. Next, we provide &ldquo;sanity bounds&rdquo; to deal with queries for which the underlying data is extremely skewed or the query result is very small. Finally, we report on the performance of the estimation algorithm as implemented in a host language on a commercial relational system. The results are encouraging, even with this loose coupling between the estimation algorithm and the DBMS.
Managing a diamond jewelry manufacturing business using APL
Authors: Steven I. Promisel, James V. Merrill
Venue: ACM SIGAPL APL Quote Quad (1990)

We discuss the development of several interconnected computer systems designed and built for a manufacturer of finished jewelry. Our approach will be two-fold. We describe how the company uses APL-based computer systems to analyze pricing issues and handle the manufacturing process. We show how the system has been developed by describing what techniques have been employed and what tools have been created and used. The purpose of this paper is to show how an APL application development system can be used to build continually evolving interactive computer systems in a combined sales and manufacturing environment.
Improving performance of an electrical power expert system with genetic algorithms
Authors: Mike Goodloe, Sara Graves
Venue: Proceedings of the 1st international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1988)

Nickel cadmium batteries are an important source of power for aerospace applications. One such application is being developed at the Marshall Space Flight Center (MSFC) for use with the Hubble Space Telescope. A battery testbed has been built at MSFC to aid in that development. In addition, the Nickel Cadmium Battery Expert System (NICBES) was developed by Martin Marietta Corporation to assist NASA engineers in battery management. This paper describes an extension to NICBES which will make it more effective as a battery management tool. The extension involves the incorporation of classifier system machine learning techniques into a subsystem of NICBES. The principal reason for suggesting this extension is the nature of battery management itself. There is still much which is unknown about these batteries and the factors affecting their performance [2]. Hence, battery management might be said to be as much an art as a science and relies heavily on the expertise of the battery manager. NICBES is an attempt to incorporate that battery expertise into an expert system. One difficulty, however, is that battery behavior is likely to change over time in unforseen ways. This detracts from the usefulness of the expert system. Consequently, the battery manager who is using NICBES as a tool would be required to make changes to the expert system in order to accomodate the changed parameters of battery behavior. This should be the function of the knowledge engineer, however, not the battery expert. This is an example of the familiar problem of knowledge acquisition in knowledge engineering. The solution presented here is to use machine learning techniques to help overcome the knowledge acquisition problem. The expert system then interacts at a high level with the battery manager and undertakes adaptation on itself in order to determine new rules conforming to the changed parameters of the power system. The basic principles of learning classifier systems based on genetic algorithms will be presented first. Next, a brief description of NICBES will be given, particularly the advice subsystem to which the learning component will be added. A discussion of specific techniques by which machine learning can be incorporated into this particular rule-based expert system will follow. This discussion will come under the headings of the bit-string representation of rules, the initial rule population, an evaluation function for this system, and the genetic operators. Finally, some comments will be made concerning the implementation of a user interface for a system such as this.
Control and Definition Modularization: an Improved Software Design Technique for Organizing Programs
Authors: Surya B. Yadav
Venue: IEEE Transactions on Software Engineering (1990)

The author proposes a technique called control and definition modularization (CDM), which derives a systematic program layout from a given structure chart using the concepts of 'control' and 'definition' modules. A control module includes processes for handling a conceptual data object not directly implementable. A definition module defines operations associated with a concrete data object implementable using a primitive or derived data type of a programming language. Grouping the operations available for each concrete data object, and keeping them separated from execution flow, improves programs maintainability. This technique extends the structured design methodology and provides designers with a systematic way of deriving informational strength modules as well as a structured physical layout from the structure chart. A program based on the CDM technique is easier to understand and maintain. This research makes a significant contribution toward bridging the gap between structured design and object-oriented concepts.
The design of a lockup-free cache for high-performance multiprocessors
Authors: C. Scheurich, M. Dubois
Venue: Proceedings of the 1988 ACM/IEEE conference on Supercomputing (1988)

High-performance multiprocessors must incorporate a high-bandwidth, short-latency memory aggregate to support maximal processor utilization. Cache memories are often used to meet this requirement. The performance of cache-based, shared-memory multiprocessors can suffer greatly from moderate cache miss rates because of the usually high ratio between memory-access and cache-access times. In this paper we propose a lockup-free cache design in which the handling of one or several cache misses is overlapped with processor activity. In multiprocessors, lockup-free caches aggravate the memory coherence problem. Three different cache architectures relying on different compiler interventions are introduced. A performance model demonstrates the usefulness of lockup-free caches for high-performance processors. The merits and disadvantages of the three schemes are discussed and compiler techniques, to take advantage of the proposed designs, are illustrated at the end of the paper.
The design of the C++ Booch Components
Authors: Grady Booch, Michael Vilot
Venue: ACM SIGPLAN Notices (1990)

This paper describes design issues encountered developing a reusable component library. The design applied encapsulation, inheritance, composition and type parameterization. The implementation uses various C++ mechanisms, including: virtual and static member functions, templates, and exceptions. The resulting library contains about 500 components (mostly template classes and functions) and an optional utility for instantiating templates. The components provide variations of basic collection/container abstractions with various time and space complexities. A key insight gained from this project: the design process centered on developing a &ldquo;template for the templates&rdquo; &mdash; designing a component framework and orderly process for generating the template classes.
A process model for data bases
Authors: Jacques Guyot
Venue: ACM SIGMOD Record (1988)

we present a process model for data bases, which integrates concepts of relation, process, integrity constraint, event and period. The model allows one to specify the synchronization of processes and the constraints due to consumption and production of data. In particular we present the formalization which is carried out with the Petri Nets. These are obtained by using refining primitives which keep the interpretation simple for designers. The aspects of verification and validation of the specification are also examined.
Multiprocessor cache analysis using ATUM
Authors: R. L. Sites, A. Agarwal
Venue: ACM SIGARCH Computer Architecture News (1988)

The design of high-performance multiprocessor systems necessitates a careful analysis of the memory system performance of parallel programs. Lacking multiprocessor address traces, previous multiprocessor performance studies using analytical models had to make an inordinate number of assumptions about the underlying memory reference patterns. We previously developed a scheme called ATUM - Address Tracing Using Microcode - to get reliable operating system and multiprogramming traces on single processors. This paper briefly describes the multiprocessor extension of ATUM and its implementation on a VAX 8350 multiprocessor. We also report on our use of the resulting traces to analyze physical versus virtual addressing of large caches, process-identifier hashing in virtual caches, cache interference between multiple processes, cache interference between multiple CPUs, process affinity, and semaphore usage in writeback caches.