ppxscal/embedding_network huggingface dataset:
EARLY SYSTEM ANALYSIS OF CACHE PERFORMANCE FOR RISC SYSTEMS: MCM DESIGN TRADE-OFFS
Authors: James D. Roberts, Wayne W. M. Dai
Venue:  (1992)

This report presents a prototype early analysis tool for exploring trade-offs in cache architecture and packaging and inter- connection (P/I) technology for RISC microprocessor based systems. We define early analysis as the evaluation of system trade-offs, including implementation technology effects, at pre-netlist phases of development. Prior work in cache performance estimation and P/I modeling are combined and extended to be more specific to RISC systems. After describing the model, several case studies are presented. Although limited by the accuracy of the first-order model as well as by assumptions and estimations regarding input data, these studies indicate general trends and quantify several important trade-offs for multi-chip model systems. MCM characteristics favor larger off-chip caches, with improved performance as well as yield advantages. When combined with flip-chip mounting, MCM technology also permits cache system architectural changes which can significantly improve perfor- mance. The prototype is not intended as a design tool, but rather to demonstrate the utility and importance of an interactive early analysis tool, combining architecture and implementation technology issues. Suggestions for future tool development are made.
Eliminating Cycles in Composed Class Hierarchies
Authors: Robert J. Walker
Venue:  (2000)

Multiple class hierarchies can be used each to represent a separate requirement or design concern. To yield a working system, these disparate hierarchies must be composed in a semantically meaningful way. However, cycles can arise in the composed inheritance graph that restrict the space of composable hierarchies. This work presents an approach to eliminating these cycles by means of separating the type hierarchy from the implementation hierarchy; separate solutions are provided for languages permitting multiple inheritance, such as C++, and those permitting only interfaces, such as Java. The resulting acyclic class hierarchy will maintain the significant constraints imposed by the original, separate hierarchies, such as type-safety.
Fault-Tolerant High-Performance Matrix Multiplication
Authors: John A. Gunnels, Daniel S. Katz, Enrique S. Quintana-Orti, Robert A. van de Geijn
Venue:  (2000)

In this paper, we extend the theory of algorithmic fault-tolerant matrix-matrix multiplication, C = AB, in a number of ways. First, we propose low-overhead methods for detecting errors introduced not only in C but also in A and/or B. Second, we theoretically show that the methods will detect all errors as long as only one entry is corrupted. Third, we propose a low-overhead rollback approach to correct errors once detected. Finally, we give a high-performance implementation of matrix-matrix multiplication that incorporates these error detection and correction methods. Empirical results demonstrate that the methods work well in practice with an acceptable level of overhead relative to high-performance implementations without fault-tolerance.
Ensuring the Inspectability, Repeatability and Maintainability of the Safety Verification of a Critical System
Authors: Ken Wong, Jeff Joyce, Jim Ronback
Venue:  (1998)

This paper proposes an approach to the safety verification of the source code of a software-intensive system. This approach centers upon the production of a document intended to ensure the inspectability, maintainability and repeatability of the source code safety verification. This document, called a "safety verification case", is intended to be a part of the overall system safety case. Although the approach was designed for large software-intensive real-time information systems, it may also be useful for other kinds of large software systems with safety-related functionality. The approach involves the construction of a rigorous argument that the source code is safe. The steps of the argument include simplifying the safety verification case structure by isolating the relevant details of the source code, and reducing the "semantic gap" between the source code and the system level hazards through a series of hierarchical refinement steps. Some of the steps in a process based on this approach may be partially automated with tool-based support. Current research and industry practices are reviewed in this paper for supporting tools and techniques.
A Transformational Approach to Binary Translation of Delayed Branches
Authors: Norman Ramsey, Cristina Cifuentes
Venue:  (1999)

The fundamental steps in binary translation are distinguishing code from data, mapping data from source to target, and translating instructions. Translating instructions presents few problems, except when the source instruction set has features not present in typical compiler intermediate codes. The most common such feature is the delayed branch. Standard code-generation technology can handle delayed branches in the target language, but not in the source. Translating delayed branches can involve tricky case analyses to figure out what happens if there is a branch instruction in a delay slot. This paper presents a disciplined method for deriving such case analyses. The method identifies problematic cases, shows the translations for the non-problematic cases, and gives confidence that all cases are considered. The method also applies to other tools that analyze machine instructions. We begin by writing a very simple interpreter for the source machine. It specifies, at the register-transfer level, how the source machine executes instructions, including delayed branches. We then transform the interpreter into an interpreter for a target machine without delayed branches. To maintain the semantics of the program being interpreted, we simultaneously transform the sequence of source-machine instructions into a sequence of target-machine instructions. The transformation of the instructions becomes our algorithm for binary translation. We show the translation is correct by using a correspondence between source and target states, and showing if the source and target machines begin execution in corresponding states, they reach new corresponding states in a few instructions.
Stochastic Contention Resolution with Short Delays
Authors: P. Raghavan, E. Upfal
Venue:  (1995)

We study contention resolution protocols under a stochastic model of continuous request generation from a set of contenders. The performance of such a protocol is characterized by two parameters: the maximum arrival rate for which the protocol is stable and the expected delay of a request from arrival to service. Known solutions are either unstable for any constant injection rate, or have polynomial (in the number of contenders) expected delay. Our main contribution is a protocol that is stable for a constant injection rate, while achieving logarithmic expected delay. We extend our results to the case of multiple servers, with each request being targeted for a specific server. This is related to the optically connected parallel computer (or OCPC ) model. Finally, we prove a lower bound showing that long delays are inevitable in a class of protocols including backoff-style protocols, if the arrival rate is large enough (but still smaller than 1).
Efficient Non-parametric Estimation of Probability Density Functions
Authors: Omer Egecioglu
Venue:  (1995)

Accurate and fast estimation of probability density functions is crucial for satisfactory computational performance in many scientific problems. When the type of density is known a priori, then the problem becomes statistical estimation of parameters from the observed values. In the non-parametric case, usual estimators make use of kernel functions. If $X_j, ~ j=1,2, \ldots , n$ is a sequence of i.i.d. random variables with estimated probability density function $f_n$, in the kernel method the computation of the values $\, f_n(X_1), f_n(X_2), \ldots , f_n(X_n) \,$ requires $O(n^2)$ operations, since each kernel needs to be evaluated at every $X_j$. We propose a sequence of special weight functions for the non-parametric estimation of $f$ which requires almost linear time: if $m$ is a slowly growing function that increases without bound with $n$, our method requires only $O(m^2 \/ n)$ arithmetic operations. We derive conditions for convergence under a number of metrics, which turn out to be similar to those required for the convergence of kernel based methods. We also discuss experiments on different distributions and compare the efficiency and the accuracy of our computations with kernel based estimators for various values of $n$ and $m$.
Rigidity Checking of 3D Point Correspondences Under Perspective Projection
Authors: Daniel P. McReynolds, David G. Lowe
Venue:  (1995)

An algorithm is described which rapidly verifies the potential rigidity of three dimensional point correspondences from a pair of two dimensional views under perspective projection. The output of the algorithm is a simple yes or no answer to the question ``Could these corresponding points from two views be the projection of a rigid configuration?'''' Potential applications include 3D object recognition from a single previous view and correspondence matching for stereo or motion over widely separated views. Our analysis begins with the observation that it is often the case that two views cannot provide an accurate structure-from-motion estimate because of ambiguity and ill- conditioning. However, it is argued that an accurate yes/no answer to the rigidity question is possible and experimental results support this assertion with as few as six pairs of corresponding points over a wide range of scene structures and viewing geometries. Rigidity checking verifies point correspondences by using 3D recovery equations as a matching condition. The proposed algorithm improves upon other methods that fall under this approach because it works with as few as six corresponding points under full perspective projection, handles correspondences from widely separated views, makes full use of the disparity of the correspondences, and is integrated with a linear algorithm for 3D recovery due to Kontsevich. The rigidity decision is based on the residual error of an integrated pair of linear and nonlinear structure-from-motion estimators. Results are given for experiments with synthetic and real image data. A complete implementation of this algorithm is being made publicly available.
A Perspective on Multi-Agent Systems
Authors: I. D. Craig
Venue:  (1994)

People do not live in isolation from others; they live in societies. This paper is about Multi-Agent Systems and their relevance to cognitive science and to theories of social behaviour. We examine some of what we believe to be central issues in the theory of Multi-Agent Systems and relate them to issues in Cognitive Science. Our aims are to introduce Multi-Agent Systems and to show how they can be illuminating as modelling devices in the production of cognitive theories that relate the individual to social context.
Web Workloads Influencing Disconnected Service Access (Masters Thesis)
Authors: Bharat B Chandra
Venue:  (2001)

Disconnected operation, in which a client accesses a service without relying on network connectivity, is crucial for improving availability, supporting mobility, and providing responsive performance. Because many web services are not cachable, disconnected access to web services may require mobile service code to execute in client caches. Furthermore as web workloads access large amounts of data, disconnected access must require prefetching data that will later be used on demand. Unfortunately, this can significantly increase the total amount of data fetched by a service. In this thesis we present an argument thaat aggressive prefetching is feasible. A study of the web workload characteristics at typical clients suggests a need for a flexible, automated resource management system to prevent denial of service attacks by these potentially unreliable mobile service codes that prefetch at the clients. We therefore present and evaluate a Popularity based resource management policy for such an environment.
RAPID DECIMATION FOR DIRECT VOLUME RENDERING
Authors: Jonathan Gibbs, Allen VanGelder, Vivek Verma, Jane Wilhelms
Venue:  (1997)

An approach for eliminating unnecessary portions of a volume when producing a direct volume rendering is described. This reduction in volume size sacrifices some image quality in the interest of rendering speed. Since volume visualization is often used as an exploratory visualization technique, it is important to reduce rendering times, so the user can effectively explore the volume. The methods presented can speed up rendering by factors of 2 to 3 with minor image degradation. A family of decimation algorithms to reduce the number of primitives in the volume without altering the volume''s grid in any way is introduced. This allows the decimation to be computed rapidly, making it easier to change decimation levels on the fly. Further, because very little extra space is required, this method is suitable for the very large volumes that are becoming common. The method is also grid-independent, so it is suitable for multiple overlapping curvilinear and unstructured, as well as regular, grids. The decimation process can proceed automatically, or can be guided by the user so that important regions of the volume are decimated less than unimportant regions. A formal error measure is described based on a three-dimensional analog of the Radon transform. Decimation methods are evaluated based on this metric and on direct comparison with reference images.
A Methodology for Synthesis of Interface Design Requirements
Authors: Kevin A. Mayo, H. R Hartson
Venue:  (1993)

This report is no longer available - TR-93-20 replaces it.
Integrating Metrics into a Large-Scale Software Development Environment
Authors: Sallie M. Henry, John A. Lewis
Venue:  (1989)

Software metrics have been shown to be indicators of software complexity. These complexity indicators identify error-prone, unmaintainable software, which if identified early can be rewritten and/or thoroughly tested. However, the integration of metric use into commercial situations faces practical resistance from budget and deadline restrictions. This paper presents an experiment that introduces a nondisruptive method for integrating metrics into a large-scale commercial software development environment.
Syntactic Recognition of Common Cardiac Arrhythmias
Authors: Arkell
Venue:  (1993)

Abstract unavailable. The ACM Portal is published by the Association for Computing Machinery. Copyright © 2010 ACM, Inc. Terms of Usage Privacy Policy Code of Ethics Contact Us Useful downloads: Adobe Acrobat QuickTime Windows Media Player Real Player
Multi-process Structuring and the THOTH Operating System
Authors: David R. Cheriton
Venue:  (1979)

This report explores the idea of structuring programs as many concurrent processes. It is based on work done in designing, implementing, and using the Thoth operating system. Thoth implements an ahstraction that provides facilities to make this type of structuring attractive, namely inexpensive processes, efficient interprocess communication, dynamic process creation and destruction, and groups of processes sharing a common address space. .br The Thoth abstraction is described, including measurements of its performance and comments on its portability. This abstraction is motivated by considering various design and implementation tradeoffs. Then, the design of multi-process programs is discussed, both in terms of general principles and by giving specific uses and examples to demonstrate the adequacy of the abstraction. Examples are drawn from the operating system and the Thoth text editor. Finally, the feasibility of verifying the system is considered. This is motivated by the desire to exploit the multi-process structure of the system to aid in verification. .br We conclude that structuring programs as multiple processes can have significant benefits, especially for programs that respond to asynchronous events.
Tracking Structural Optima as a Function of Available Resources by a Homotopy Method
Authors: Yung S. Shin, Robert T. Haftka, Layne T. Watson, Raymond H. Plaut
Venue:  (1988)

Optimization problems are typically solved by starting with an initial estimate and proceeding iteratively to improve it until the optimum is found. The design points along the path from the initial estimate to the optimum are usually of no value. The present work proposes a strategy for tracing a path of optimum solutions parameterized by the amount of available resources. The paper specifically treats the optimum design of a structure to maximize its buckling load. Equations for the optimum path are obtained using Lagrange multipliers, and solved by a homotopy method. The solution path has several branches due to changes in the active constraint set and transitions from unimodal to bimodal solutions. The Lagrange multipliers and second-order optimality conditions are used to detect branching points and to switch to the optimum solution path. The procedure is applied to the design of a foundation which supports a column for maximum buckling load. Using the total available foundation stiffness as a homotopy parameter, a set of optimum foundation designs is obtained.
Managing Concurrent Activities in Collaborative Environments
Authors: D. Agrawal, J. L. Bruno, A. E Abbadi, V. Krishnaswamy
Venue:  (1994)

An approach to support activities in collaborative databases is proposed. This approach merges flexible transaction models from collaborative environments and semantics based correctness criteria. A model is first presented which incorporates the notion of collaboration in the context of transactions. A protocol is then developed based on this model for effcient management of collaborative activities. This is the first attempt to formally incorporate the notion of collaboration in the database management system. Most earlier approaches provide tools and mechanisms to circumvent the isolation requirement of transactions. The protocol is a generalization of strict two-phase locking since in the absence of collab oration, it reduces to strict two-phase locking.
Specifying and Inheriting Concurrent Behavior in an Actor-BasedObject-Oriented Language
Authors: Gregory R. Lavender, Dennis G. Kafura
Venue:  (1990)

Using CCS behavior equations to specify and reason about the observable behavior of concurrent objects, we demonstrate that a language mechanism called a behavior set can be used to capture the behavior of actor-like objects. Using behavior equations as a formal representation of concurrent object behavior results in the explication of a mapping from the domain of objects to a domain of behavior sets. We call this mapping the behavior function. By expressing relevant object states, behavior sets and the behavior function as first-class, inheritable, and mutable entities in a concurrent object-oriented language, we have defined the conditions which must be met in order to inherit concurrent behavior free of known anomalies.
A Prototype Assistance Manager For The Simulation Model Development Environment
Authors: Valerie L. Frankel, Osman Balci
Venue:  (1987)

The Assistance Manager, one of the tools of the Simulation Model Development Environment (SMDE), is required to provide effective and efficient transfer of assistance information to an SMDE user. This paper describes a prototype of the SMDE Assistance Manager. Objectives are set forth and a design is established and implemented on a SUN 3/160C workstation. The prototype is evaluated with respect to the design objectives and is shown to provide a highly flexible interface between the user and the database of assistance information. Results indicate that the prototype Assistance Manager incorporates the characteristics considered desirable in on-line assistance systems and serves as a basis for future enhancement and development.
Application-Specific Pipelines for Exploiting Instruction-Level Parallelism
Authors: Bruce R. Childers, Jack W. Davidson
Venue:  (1998)

Application-specific processor design is a promising approach for meeting the performance and cost goals of a system. Application-specific processors are especially promising for embedded systems (e.g., automobile control systems, avionics, cellular phones, etc.) where a small increase in performance and decrease in cost can have a large impact on a product''s viability. Sutherland, Sproull, and Molnar have proposed a new pipeline organization called the Counterflow Pipeline (CFP). This paper shows that the CFP is an ideal architecture for fast, low-cost design of high-performance processors customized for computation-intensive embedded applications. First, we describe why CFP''s are particularly well suited to realizing application-specific processors. Second, we describe how a CFP tailored to an application can be constructed automatically. Third, we present measurements that show CFP''s elegantly and simply provide speculative execution, out-of-order execution, and register renaming that is matched to the application. These measurements show that CFP''s speculative and out-of-order execution allow it to tolerate frequent control dependences and high-latency operation such as memory accesses. Finally, we show that asynchronous counterflow pipelines may achieve very high-performance by reducing the average execution latency of instructions over synchronous implementations. Application speedups of up to 7.8 are achieved using custom counterflow pipelines for several well-known kernel loops.
Proving Sequential Consistency by Model Checking
Authors: Tim Braun, Anne Condon, Alan J. Hu, Kai S. Juse, Marius Laza, Michael Leslie, Rita Sharma
Venue:  (2001)

Sequential consistency is a multiprocessor memory model of both practical and theoretical importance. The general problem of deciding whether a finite-state protocol implements sequential consistency is undecidable. In this paper, however, we show that for the protocols that arise in practice, proving sequential consistency can be done automatically in theory and can be reduced to regular language inclusion via a small amount of manual effort. In particular, we introduce an approach to construct finite-state ``observers'''' that guarantee that a protocol is sequentially consistent. We have developed possible observers for several cache coherence protocols and present our experimental model checking results on a substantial directory-based cache coherence protocol. From a theoretical perspective, our work characterizes a class of protocols, which we believe encompasses all real protocols, for which sequential consistency can be decided. From a practical perspective, we are presenting a methodology for designing memory protocols such that sequential consistency may be proven automatically via model~checking.
PSO: Shared Symbol Space for Multicomputer Architectures
Authors: Stefan Lupke, Jurgen W. Quittek, Torsten Wiese
Venue:  (1995)

The Public Shared Objects run-time system (PSO) is an attempt to offer advantages of Virtual Shared Memory for distributed memory parallel computers without a significant loss of performance. Shared data structures are distributed via the network to processing nodes and may exceed the capacity of local memory. Provided access objects hide access latency. The process of parallel program design is shortened and facilitated significantly. PSO is a portable software solution extending the C++ programming language. It has been implemented for the PARIX software environment and is available for parallel com puters based on Transputers or PowerPC processors. Reference applications in the fields of device simulation and image processing offer high efficiency for up to 128 processors.