ppxscal/embedding_network huggingface dataset:
Dynamic adaptation of real-time software
Authors: Thomas E. Bihari, Karsten Schwan
Venue: ACM Transactions on Computer Systems (TOCS) (1991)

In large, dynamic, real-time computer systems, it is frequently most cost effective to employ different software performance and reliability techniques at different levels of granularity, at different times, or within different subsystems. These techniques may include regulation of redundancy and resource allocation, multiversion and multipath execution, adjustments of program attributes such as time-out periods and others. The management of software in such systems is a difficult task. Software that may be adapted to meet varying performance and reliability requirements offers a solution. A REal-time Software Adaptation System (RESAS) includes a uniform model of adaptable software and provides the tool necessary for programmers to implement algorithms that choose and enact adaptations in real time. RESAS has been implemented on a testbed consisting of a multiprocessor and an attached workstation, and adaptation algorithms have been developed that address the problem of adapting software to achieve two goals: software execution within specified time constraints and software resiliency with respect to computer hardware failures.
Applying statistical physics to performance analysis of large-scale computing systems (abstract)
Authors: Eugene Pinsky
Venue: Proceedings of the 1990 ACM annual conference on Cooperation (1990)

We propose to use tools and methods of statistical mechanics to introduce a unified computational approach to analyze the performance of large-scale computing systems. Just as in statistical physics, we desire a small amount of &ldquo;macroscopic&rdquo; information about the system (&ldquo;thermo-dynamic&rdquo;) averages (e.g. average concurrency, through-put, blocking rates) despite the vast complexity of &ldquo;microscopic&rdquo; interactions. It seems natural, therefore, that the complexity existing in large-scale computing systems is the sort of complexity that ought to yield to some sort of treatment analogous to statistical mechanics. We model a computation (the allocation of tasks to processors) as analogous to a physical activity in some structured space and look for equilibrium statistics which are summarized in the corresponding partition function. This partition function, analogous to the partition function of a Gibbs canonical ensemble in statistical physics, reflects the topology of the system, load distribution, queueing and other relevant description of the system. We use analogies from physics to develop fast approximation methods to compute the system performance measures and use analogy to the thermodynamic limit to analyze critical phase transitions in computing systems. These transitions manifest themselves in a global change of state as a result of local interactions and are a direct result of scale.
Cooperative shared memory: software and hardware for scalable multiprocessor
Authors: Mark D. Hill, James R. Larus, Steven K. Reinhardt, David A. Wood
Venue: ACM SIGPLAN Notices (1992)

We believe the absence of massively-parallel, shared-memory machines follows from the lack of a shared-memory programming performance model that can inform programmers of the cost of operations (so they can avoid expensive ones) and can tell hardware designers which cases are common (so they can build simple hardware to optimize them). Cooperative shared memory, our approach to shared-memory design, addresses this problem. Our initial implementation of cooperative shared memory uses a simple programming model, called Check-In / Check-Out (CICO), in conjunction with even simpler hardware, called Dir1SW is a minimal director protocol that adds little complexity to message-passing hardware, but efficiently supports programs written within the CICO model.
Research at Altaïr
Authors: Philippe Richard
Venue: ACM SIGMOD Record (1991)

Alta&iuml;r is a five year project which began in September of 1986. Its goal is to design an implement a next generation database system. The five year project was divided in two phases: a three year prototyping phase and a two year phase devoted for one part to the development of a product from the prototype and for the other part to a new research effort. The three year phase ended by the demonstration of the V1 prototype of the O2 object-oriented database system which has been distributed for experimentation to more than 40 universities and about 13 industrial partners. The contribution of the Alta&iuml;r group to the database research community has been mainly in three areas: data model and database languages, object stores, and programming environments. Furthermore, all these efforts have been integrated in a consistent way into the V1 prototype. The results of this research and development effort are being summarized in a book [BDK91] which is a commented collection of papers, most of them already published in the proceedings of a number of internationally recognized conferences. We briefly survey in the following the O2 activities.
The ensemble system: concurrent programming on a personal computer
Authors: Michele Di Santo, Wilma Russo
Venue: ACM SIGPLAN Notices (1991)

ENSEMBLE is a programmming system for writing concurrent programs on a personal computer (PC).ENSEMBLE consists of a library of Turbo Pascal1 units to be used with applications written in the same language and executable on IBM PCs or compatibles under the MS-DOS2 operating system. ENSEMBLE provides the programmer with a set of facilities and predefined abstractions that simplify the construction of concurrent programs. The main abstractions are coroutines and tasks.ENSEMBLE's main goal is to provide an environment that can be easily used by students for gaining experience in a wide variety of concurrent programming models and techniques. However, ENSEMBLE was designed to be also a satisfactory production tool for writing concurrent and real-time software on a PC.
MediaMosaic&mdash;a multimedia editing environment
Authors: Jin-Kun Lin
Venue: Proceedings of the 5th annual ACM symposium on User interface software and technology (1992)

MediaMosaic is an editing environment developed to provide several features that are either unavailable or not adequately addressed in current editing systems. First, it is a multimedia editor of an open architecture. General media are inserted in documents by embedded virtual screens. Second, it allows users to do markup editing in context. The marked comments are overlapped and attached to the commented areas. Third, it provides a mechanism to allow users to bring data from more than one source to a single document. The views of the included data can be tailored. Fourth, users can work on an included medium through its embedded view or through another complete and duplicated view. It isolates and simplifies the interface design of individual media editors.
A framework for using formal methods in object-oriented software development
Authors: Richard Holt, Dennis deChampeaux
Venue: ACM SIGPLAN OOPS Messenger (1992)

Although formal methods (FMs) hold great promise for improving the process of software development, up to now these methods have had limited impact on the actual development of software. This note outlines why this is so and predicts how formal methods can be developed and evolved to become useful in practice.
Directions and implications of advanced computing: a report from Berkeley
Authors: Doug Schuler
Venue: ACM SIGCHI Bulletin (1992)

What relevance do computing and computer professionals have for the "real world?" This important question is infrequently addressed by computer professionals and the institutions --- academic, corporate, and governmental --- in which they're involved. The biannual "Directions and Implications of Advanced Computing" symposia, sponsored by Computer Professionals for Social Responsibility were established to address the wide ranging social implications of computing that often are given inadequate consideration. This report discusses some of the themes of the latest "Directions and Implications of Advanced Computing" (DIAC-92) Symposium that was held in Berkeley, California in May, 1992.
Semantic vs. structural resemblance of classes
Authors: Peter Fankhauser, Martin Kracker, Erich J. Neuhold
Venue: ACM SIGMOD Record (1991)

We present an approach to determine the similarity of classes which utilized fuzzy and incomplete terminological knowledge together with schema knowledge. We clearly distinguish between semantic similarity determining the degree of resemblance according to real world semantics, and structural correspondence explaining how classes can actually be interrelated. To compute the semantic similarity we introduce the notion of semantic relevance and apply fuzzy set theory to reason about both terminological knowledge and schema knowledge.
On better heuristic for euclidean Steiner minimum trees (extended abstract)
Authors: Ding-Zhu Du, Yanjun Zhang, Qing Feng
Venue: Proceedings of the 32nd annual symposium on Foundations of computer science (1991)

Finding a shortest network interconnecting a given set of points in the Euclidean plane (a Steiner minimum tree) is known to be NP-hard. It is shown that there exists a polynomial-time heuristic with a performance ratio bigger than square root 3/2.
The worst order in not always the lexicographic order
Authors: Alyson A. Reeves
Venue: ACM SIGSAM Bulletin (1991)

Consider I an homogeneous ideal in S = k[x0,..., xn], where k is a field of characteristic zero. For any multiplicative order gt; on S with x0 gt; x1 gt; ... gt; xn, denote by M gt; (I) the maximum degree of a generator of the Gr ouml;bner basis for I with respect to the order gt;. It is known [BaSt87] that if I is in generic coordinates, then Mrev. lex.(I) is minimal among all orders.
Lazy release consistency for software distributed shared memory
Authors: Pete Keleher, Alan L. Cox, Willy Zwaenepoel
Venue: Proceedings of the 19th annual international symposium on Computer architecture (1992)

Relaxed memory consistency models, such as release consistency, were introduced in order to reduce the impact of remote memory access latency in both software and hardware distributed shared memory (DSM). However, in a software DSM, it is also important to reduce the number of messages and the amount of data exchanged for remote memory access. Lazy release consistency is a new algorithm for implementing release consistency that lazily pulls modifications across the interconnect only when necessary. Trace-driven simulation using the SPLASH benchmarks indicates that lazy release consistency reduces both the number of messages and the amount of data transferred between processors. These reductions are especially significant for programs that exhibit false sharing and make extensive use of locks.
A review of recent work on multi-attribute access methods
Authors: David Lomet
Venue: ACM SIGMOD Record (1992)

Most database systems provide database designers with single attribute indexing capability via some form of B+tree. Multi-attribute search structures are rare, and are mostly found in systems specialized to some more narrow application area, e.g. geographic databases. The reason is that no multi-attirbute search structure has been demonstrated, with high confidence. Multi-attribute search is an active area of research. This paper reviews the state of this field and some of the difficult problems, and reviews some recent notable papers.
Three discussions on object-oriented typing
Authors: Jens Palsberg, Michael I. Schwartzbach
Venue: ACM SIGPLAN OOPS Messenger (1992)

This paper summarizes three discussions conducted at the ECOOP'91 W5 Workshop on "Types, Inheritance, and Assignments" Tuesday July 16, 1991 in Geneva, Switzerland, organized by the authors.
Lively linear Lisp: &ldquo;look ma, no garbage!&rdquo;
Authors: Henry G. Baker
Venue: ACM SIGPLAN Notices (1992)

Linear logic has been proposed as one solution to the problem of garbage collection and providing efficient "update-in-place" capabilities within a more functional language. Linear logic conserves accessibility, and hence provides a mechanical metaphor which is more appropriate for a distributed-memory parallel processor in which copying is explicit. However, linear logic's lack of sharing may introduce significant inefficiencies of its own.We show an efficient implementation of linear logic called Linear Lisp that runs within a constant factor of non-linear logic. This Linear Lisp allows RPLACX operations, and manages storage as safely as a non-linear Lisp, but does not need a garbage collector. Since it offers assignments but no sharing, it occupies a twilight zone between functional languages and imperative languages. Our Linear Lisp Machine offers many of the same capabilities as combinator/graph reduction machines, but without their copying and garbage collection problems.
The complexity of operations on a fragmented relation
Authors: C. Meghini, C. Thanos
Venue: ACM Transactions on Database Systems (TODS) (1991)

Data fragmentation is an important aspect of distributed database design, in which portions of relations, tailored to the specific needs of local applications, are defined to be further allocated to the sites of the computer network supporting the database system. In this paper we present a theory of fragmentation with overlapping fragments to study the complexity of the problems involved in checking the completeness of a fragmentation schema and in querying and updating a fragmented relation. We analyze these problems from the complexity viewpoint and present sound and complete algorithms for their solution.
An engineering graphics curriculum model with multidisciplinary implications
Authors: Michael B. McGrath, Gary R. Bertoline, Del Bowers, Michael H. Pleck, Mary Sadowski
Venue: ACM SIGGRAPH Computer Graphics (1991)

This paper reports on a funded project to develop a conceptual model for an engineering graphics curriculum. The analysis lead to a framework that defined the body of knowledge appropriate for engineering graphics and and a model useful for multidisciplinary applications. It is based on the premise that computer tools available for design and research in visualization and creativity play important but not controlling roles in many visually based disciplines.
Increased Throughput for the Testing and Repair of RAMs with Redundancy
Authors: Ramsey W. Haddad, Anton T. Dahbura, Anup B. Sharma
Venue: IEEE Transactions on Computers (1991)

The problem of determining whether a redundant random-access memory (RRAM) containing faulty memory cells can be repaired with spare rows and columns is discussed. The approach is to increase the number of working RRAMs manufactured per unit time, rather than per wafer, by presenting a computationally efficient algorithm for detecting unrepairability, a computationally efficient algorithm for optimal repair for special patterns of faulty memory cells and online algorithms that can find an optimal repair or else detect unrepairability during memory testing, aborting unnecessary testing. Experimental validation of the approach is given that is based on industrial device fabrication data.
ADA software for teaching modern computer arithmetic
Authors: M. C. Bartholomew-Biggs
Venue: ACM SIGNUM Newsletter (1991)

This paper describes three Ada packages which support the teaching of some recent and important ideas in numerical computation. The first is designed to enable students to write and use applications programs demonstrating the behaviour of floating point arithmetic with different precisions and roundings. It also underpins the other two packages which provide simple computational tools for interval arithmetic and for accurate arithmetic.
Randomized multidimensional search trees: lazy balancing and dynamic shuffling (extended abstract)
Authors: Ketan Mulmuley
Venue: Proceedings of the 32nd annual symposium on Foundations of computer science (1991)

A randomized technique, called dynamic shuffling, is given for multidimensional dynamic search. This technique, when specialized to the problem of searching in sorted lists, yields the previously known randomized binary trees (treaps). The crux of the technique is a multidimensional generalization of the rotation operation on binary search trees. Simultaneously, it is shown how to dynamize the randomized incremental algorithms so as to allow additions as well as deletions of objects. The techniques are based on remembering the history of the actual or imaginary sequence of updates. The techniques are applied to several problems in computational geometry.
Query by committee
Authors: H. S. Seung, M. Opper, H. Sompolinsky
Venue: Proceedings of the fifth annual workshop on Computational learning theory (1992)

We propose an algorithm called query by commitee, in which a committee of students is trained on the same data set. The next query is chosen according to the principle of maximal disagreement. The algorithm is studied for two toy models: the high-low game and perceptron learning of another perceptron. As the number of queries goes to infinity, the committee algorithm yields asymptotically finite information gain. This leads to generalization error that decreases exponentially with the number of examples. This in marked contrast to learning from randomly chosen inputs, for which the information gain approaches zero and the generalization error decreases with a relatively slow inverse power law. We suggest that asymptotically finite information gain may be an important characteristic of good query algorithms.
Psycho-biographical analysis with APL
Authors: Andrew V. Kondrashev, Alexander A. Kronik
Venue: Proceedings of the international conference on APL '91 (1991)

This paper deals with computer methods of psychological age measuring, psycho-biographical express-diagnostics of personality, and data analysis with APL.
Partitioning declarative programs into communicating processes
Authors: John M. A. Roy, Mark D. Nagel, Lubomir Bic
Venue: Proceedings of the 1990 ACM/IEEE conference on Supercomputing (1990)

The Process-Oriented Dataflow System (PODS) is an execution model that combines the von Neumann and dataflow models of computation to gain the benefits of each. Central to PODS is the concept of array distribution and its effects on partitioning and mapping processes. In this paper, we present and discuss the results of executing the classic matrix multiply algorithm (with 1024 data points) on a PODS simulator. The key result is that PODS can take advantage of the parallelism in matrix multiply using a simple automated partitioning scheme.
Synthesis and optimization procedures for robustly delay-fault testable combinational logic circuits
Authors: Srinivas Devadas, Kurt Keutzer
Venue: Proceedings of the 27th ACM/IEEE Design Automation Conference (1991)

In this paper we apply recently developed necessary and sufficient conditions for robust path-delay-fault testability to develop synthesis procedures which produce two-level and multilevel circuits with high degrees of robust path delay fault testability. For circuits which can be flattened to two levels, we give a covering procedure which optimizes for robust path delay fault testability. These two-level circuits can then be algebraically factored to produce robustly path-delay-fault testable multilevel circuits. For regular structures which cannot be flattened to two levels, we give a composition procedure which allows for the construction of robustly path-delay-fault testable regular structures. Finally, we show how these two techniques can be combined to produce cascaded combinational logic blocks that are robustly path-delay-fault testable. We demonstrate these techniques on a variety of examples. It is possible to produce entire chips that are fully path delay testable using these techniques.
Queuing delays for uniform and nonuniform traffic patterns in a MIN
Authors: Rajagopalan Sivaram
Venue: ACM SIGSIM Simulation Digest (1992)

In this paper we show that queuing delays or waiting times for messages impose a significant degradation in the performance of a buffered packet switching Multistage Interconnection Network subjected to heavy uniform traffic, and nonuniform traffic patterns. Hotspots and Nonuniform Traffic Spots were introduced to cause nonuniform traffic. The "average standard deviation queue time" is found to be a good measure of network congestion at each stage of a MIN, in a message passing environment. We also show that "tree saturation" effect is present even for MINs with infinite buffer queues.
Performance objectives&mdash;how to define them
Authors: Shyam Johari
Venue: ACM SIGMETRICS Performance Evaluation Review (1991)

The successful development of a product demands that product performance objectives be clearly defined and agreed to as early as possible during the product development cycle, typically during the product requirements phase. Unless clearly defined and uniformly understood, performance objectives can be subject to varied interpretation as product nears completion. Why? Because all parties (e.g., Product Marketing, Product Management, and Product Development) involved have their own performance perspective. How to clearly define the product performance objectives would be the thrust of this note.
Analogy or identity: brain and machine at the Macy conferences on cybernetics
Authors: James M. Nyce
Venue: ACM SIGBIO Newsletter (1992)

Of importance for cybernetics was its setting in the flesh...For me it proved that brains do not secrete thought as the liver secretes bile, but that they compute thoughts the way computing machines calculate numbers. Warren McCulloch 1974:10
Implementation of a non-deterministic loop
Authors: Hartmut Höft
Venue: ACM SIGCSE Bulletin (1991)

Dijkstra's calculus of guarded commands incorporates nondeterminism into the branch and the loop statements. I argue in this paper that the course CS8, Organization of Programming Languages, is an appropriate place to introduce this semantics for a language control structure into the undergraduate curriculum. In section IV I present a short implementation for the Dijkstra do... od command as a function in Mathematica. The paper concludes with the application of this function to random walks.
Algorithm-Based Fault Detection for Signal Processing Applications
Authors: A. L. N. Reddy, P. Banerjee
Venue: IEEE Transactions on Computers (1990)

The increasing demands for high-performance signal processing along with the availability of inexpensive high-performance processors have results in numerous proposals for special-purpose array processors for signal processing applications. A functional-level concurrent error-detection scheme is presented for such VLSI signal processing architectures as those proposed for the FFT and QR factorization. Some basic properties involved in such computations are used to check the correctness of the computed output values. This fault-detection scheme is shown to be applicable to a class of problems rather than a particular problem, unlike the earlier algorithm-based error-detection techniques. The effects of roundoff/truncation errors due to finite-precision arithmetic are evaluated. It is shown that the error coverage is high with large word sizes.
Extending the MERCURY system to support teams of Ada programmers
Authors: Josephine Micallef, Gail E. Kaiser
Venue: ACM SIGAda Ada Letters (1991)

The MERCURY system generates multi-user language-based environments from attribute grammars. The AG specifies the interface checking among modular units, to be applied by the environment to inform programmers of errors introduced by interface changes. Since AGs assume a monolithic program, we extended the formalism to support separate compilation units. Our previous work was based on an ideal language where programs consist of an unordered set of monolithic compilation units. We now augment our extensions to support Ada, to allow multiple kinds of compilation units and nested compilation units. We describe how these extensions are used to detect naming errors, determine compilation unit context, and check compilation order as mandated by Ada.