ppxscal/embedding_network huggingface dataset:
The Performance of Two-phase Commit Protocols in the Presence of Site Failures
Authors: M. L. Liu, D. Agrawal, A. E Abbadi
Venue:  (1994)

Although the two-phase commit (2PC) protocol has been studied extensively for a long time, the topic is of sufficient significance that several refinements of the protocol have continued to emerge. However, much of the existing literature on 2PC is restricted to discussing and analyzing the protocol (and its variants) in the absence of failure. Very little, especially in quantitative terms, has been written about its performance in the presence of site failures. In this study, we use a simulation testbed of a distributed database system to quantify the differences in the performances of four 2PC protocols. Our study covers both the no-failure case and the case of site failures. We present a number of interesting experiment results. One is that the performance of these protocols is highly dependent on the message-processing latency at the transaction coordinator site. Another is that the presumed abort protocol does not necessarily yield better performance in the presence of site failures.
Situational Analysis with the Task Mapping Model (TMM): A Tutorial
Authors: Kevin A. Mayo
Venue:  (1994)

The Task Mapping Model (TMM) is a user-centered analysis technique providing methods and notations for use in human-computer interaction (HCI) task analysis (Mayo & Hartson, 1993). The primary function of the TMM is to synthesize new design requirements based on usability problems, user task descriptions, user class profiles, user knowledge requirements, and current user interface designs. The TMM does not, however, derive new design specifications or high/low level interface designs.
Using Reflection for Implementing ICOM, An Interoperable Common Object Model
Authors: Siva Challa, Dennis G. Kafura
Venue:  (1995)

Reuse of already developed object-oriented software components is reduced when software is written in different object-oriented languages, or when it is not easy to relocate the software components from one machine to another machine. Software development in a distributed and heterogeous environment is a solution to this problem. Several common object models have been defined for software development in a distributed and heterogeous environment. Most of the existing common object models do not agree upon a common set of object-oriented features. These models are weak (i.e., they have only a modest subset of object-oriented features) because they support both object-oriented and non object-oriented languages and mapping of the model into non object-oriented languages is a complex problem. In this paper an interoperable common object model (ICOM) that supports statically typed object-oriented languages is presented. The ICOM model has an extensive set of object-oriented features that uses reflection techniques to support the model. The architecture of ICOM framework is described and a detailed account on how reflection is used is given. A prototype involving dynamic method binding feature is explained in detail.
Speaker-Independent Isolated Word Recognition Using Multi-Hidden Markov Models
Authors: Yaxin Zhang, Christopher J.S. deSilva, Roberto Togneri, Mike Alder, Yianni Attikiouzel
Venue:  (1994)

A multi-HMM speaker-independent isolated word recognition system is described. In this system, three vector quantization methods, the LBG algorithm, the EM algorithm, and a new MGC algorithm, are used for the classification of the speech space. These quantizations of the speech space are then used to produce three HMMs for each word in the vocabulary. In the recognition step, the Viterbi algorithm is used in the three sub-recognizers. The log probabilities of the observation sequences matching the models are multiplied by the weights determined by the recognition accuracies of individual sub-recognizers and summed to give the log probability that the utterance is of a particular word in the vocabulary. This multi-HMM system results in a reduction of about 50 per cent in the error rate in comparison with the single model system.
Experiments with Conjugate Gradient Algorithms for Homotopy CurveTracking
Authors: Kashmira M. Irani, Manohar P. Kamat, Calvin J. Ribbens, Homer F. Walker, Layne T. Watson
Venue:  (1990)

There are algorithms for finding zeros or fixed points of nonlinear systems of equations that are globally convergent for almost all starting points, i.e., with probability one. The essence of all such algorithms is the construction of an appropriate homotopy map and then tracking some smooth curve in the zero set of this homotopy map. HOMPACK is a mathematical software package implementing globally convergent homotopy algorithms with three different techniques for tracking a homotopy zero curve, and has separate routines for dense and sparse Jacobian matrices. The HOMPACK algorithms for sparse Jacobian matrices use a preconditioned conjugate gradient algorithm for the computation of the kernal of the homotopy Jacobian matrix, a required linear algebra step for homotopy curve tracking. Here variants of the conjugate gradient algorithm are implemented in the context of homotopy curve tracking and compared with Craig''s preconditioned conjugate gradient method used in HOMPACK. The test problems used include actual large scale, sparse structural mechanics problems.
Improved Approximation Algorithms for Multimessage Multicasting
Authors: Teofilo F. Gonzalez
Venue:  (1996)

We consider Multimessage Multicasting over the $n$ processor complete (or fully connected) static network ($MM_{C}$). We present several fast approximation algorithms with improved approximation bounds for problem instances with small fan-out (maximum number of processors receiving any given message), but arbitrary degree $d$, where $d$ is the maximum number of messages that each processor may send (receive). These problem instances are the ones that arise in practice, since the fan-out restriction is imposed by the applications and the number of processors available in commercial systems. Our algorithms are centralized and require all the communication information ahead of time. Applications where this information is available include iterative algorithms for solving linear equations and most dynamic programming procedures. The Meiko CS-2 machine and in general computer systems with processors communicating via dynamic permutation networks whose basic switches can act as data replicators (e.g., $n$ by $n$ Benes network with 2 by 2 switches that can also act as data replicators) will also benefit from our results at the expense of doubling the number of communication phases.
Machine-independent support for garbage collection, debugging, exception handling, and concurrency (draft)
Authors: Simon L Peyton Jones, Norman Ramsey
Venue:  (1998)

For a compiler writer, generating good machine code for a variety of platforms is hard work. One might try to reuse a retargetable code generator from another compiler, but code generators are complex and difficult to use, and they limit one''s choice of implementation language. One might try to use&#x00A0;C as a portable assembly language, but C&#x00A0;limits the compiler writer''s flexibility and the performance of the resulting code. The wide use of&#x00A0;C, despite these drawbacks, argues for a portable assembly language. C--&#x00A0;is a new language designed expressly as a portable assembly language. C--&#x00A0;eliminates some of the performance problems associated with&#x00A0;C, but in its originally-proposed form it does not provide adequate support for garbage collection, exception handling, and debugging. The problem is that neither the high-level compiler nor the C-- compiler has all of the information needed to support these run-time features. This paper proposes a three-part solution: new language constructs for&#x00A0;C--, run-time support for C--, and restrictions on optimization of C--&#x00A0;programs. The new C-- language constructs enable a high-level compiler to associate initialized data with spans of C-- source ranges and to specify ``alternate continuations'''' for calls to procedures that might raise exceptions. The run-time support is an interface (specified in&#x00A0;C) that the garbage collector, exception mechanism, and debugger can use to get access to both high-level and low-level information, provided that the C-- program is suspended at a safe point. High- and low-level information is coordinated by means of the C--&#x00A0;spans and a common numbering for variables. Finally, the C-- optimizer operates under the constraints that the debugger or garbage collector can change the values of local variables while execution is suspended, and that a procedure call with alternate continuations can return to more than one location. This three-part solution also provides adequate support for concurrency, so the paper illustrates the problem and the proposed solution with examples from garbage collection, exception handling, debugging, and threads. The paper also includes a model of the dataflow behavior of C--&#x00A0;calls. A number of open problems remain. The most serious have to do with apparent redundancies among spans and safe points, and with the interaction of debugging support with optimization. This paper is very much work in progress. We are not yet satisfied with the solutions we''ve come up with. Perhaps you can help improve it.
Process Introspection: A Checkpoint Mechanism for High Performance Heterogeneous Distributed Systems
Authors: Adam Ferrari
Venue:  (1996)

The Process Introspection project is a design and implementation effort, the main goal of which is to construct a general purpose, flexible, efficient checkpoint/restart mechanism appropriate for use in high performance heterogeneous distributed systems. This checkpoint/restart mechanism has the primary constraint that it must be platform independent; that is, checkpoints produced on one architecture or operating system platform must be restartable on a different architecture or operating system platform. The Process Introspection mechanism is based on a design pattern for constructing interoperable checkpointable modules. Application of the design pattern is automated by two levels of software tools: a library of support routines that facilitate the use of the design pattern, and a source code translator that automatically applies the pattern to platform independent modules. A prototype implementation of library has been constructed and used to demonstrate that the design pattern can be applied effectively to construct platform independent checkpointable programs that operate efficiently.
Graph Immunity Against Local Influence
Authors: D. Peleg
Venue:  (1996)

This paper considers the question of the influence of a coalition of vertices, seeking to gain control (or majority) in local neighborhoods in a general graph. A vertex v is said to be controlled by the coalition M if the majority of its neighbors are from M. Let Ruled(G,M) denote the set of vertices controlled by M in G. Previous studies focused on constructions allowing small coalitions to control many vertices, and provided tight bounds for the maximum possible |Ruled(G,M)| (as a function of |M|). This paper introduces the dual problem, concerning the existence of graphs immune to the influence of small coalitions, i.e., graphs G for which Ruled(G,M) is small (relative to |M| again) for every coalition M. Upper and lower bounds are derived on the extent to which such immunity can be achieved.
Runge-Kutta Research at Toronto
Authors: T. E. Hull, Wayne H. Enright, K. R. Jackson
Venue:  (1996)

The main purpose of this paper is to summarize the work on Runge-Kutta methods at the University of Toronto during the period 1963 to the present. To provide some background, brief mention is also made of related work on the numerical solution of ordinary differential equations, but, with just a few exceptions, specific references are given only if the referenced material has a direct bearing on Runge-Kutta methods and their application to a variety of problem areas. There are several main themes. New Runge-Kutta formulas and new error control strategies are developed, leading for example to continuous methods and to new application areas such as delay, differential- algebraic and boundary value problems. Software design and implementation are also emphasized. And so is the importance of careful testing and comparing. Other topics, such as the notion of effectiveness, taking advantage of parallelism, and handling discontinuities are also discussed.
The Cogency Monitor: An External Interface Architecture for a Distributed Object-Oriented Real-Time Database System
Authors: John A. Stankovic, Sang H. Son, Chi D. Nguyen
Venue:  (1998)

We are developing a distributed database, called BeeHive, which could offer features along different types of requirements: real-time, fault-tolerance, security, and quality-of service for audio and video. Support of these features and potential trade-offs between them could provide a significant improvement in performance and functionality over current distributed database and object management systems. The BeeHive system however, must be able to interact with existing databases and import such data. In this paper, we present a high level design for this external interface and introduce the concept of a cogency monitor which acts as a gateway between BeeHive and the external world. The cogency monitor filters, shapes, and controls the flow of information to guarantee specified properties along the real-time, fault tolerance, quality of service, and security dimensions. We also describe three implementations of the cogency monitor and present some preliminary performance results that demonstrate the value of the cogency monitor.
Decentralized Incremental Maintenance of Multi-View Data Warehouses
Authors: Ioana Stanoi, Divyakanth Agrawal, Amr El Abbadi
Venue:  (1999)

As data warehouses are presently designed mostly as centralized system, the majority of the research in this area has concentrated on developing updating algorithms for this specific model. Aproaches have been proposed either under the assumption of a single view data warehouse, a multi-view centralized system, or a multi-view distributed system with strict synchronization restrictions. However, we project that a distributed, decentralized system will soon prove to be a good model for the generalization of the data warehouse system. To our knowledge, there is no proposal for algorithms in this context, to incorporate individually and asynchronously updates to different views. Existing protocols either solve the synchronicity problem by grouping out of order updates in batches or by creating multiple versions of the data. In this paper we propose a different method for updating views in a distributed data warehouse, and address issues related to a decentralized system were the sytes are autonomous. Although the procedure of updating views becomes more comples, it does not involve any additional messages with respect to a method that synchronizes communication through the system, and some additional storage is needed only for the control structures.
Chebyshev Polynomials for Boxing and Intersections of Parametric Curves and Surfaces
Authors: Alain Fournier, John Buchanan
Venue:  (1994)

Parametric curves and surfaces are powerful and popular modeling tools in Computer Graphics and Computer Aided Design. Ray-tracing is a versatile and popular rendering technique. There is therefore a strong incentive in developing fast, accurate and reliable algorithms to intersect rays and parametric curves and surfaces. We propose and demonstrate the use of Chebyshev basis functions to speed up the computation of the intersections between rays and parametric curves or surfaces. The properties of Chebyshev polynomials result in the computation of better and tighter enclosing boxes. For surfaces they provide a better termination criterion to decide on the limits of subdivision, and allow the use of bilinear surfaces for the computation of the intersection when needed. The efficiency of the techniques used depends on the relative magnitude of the coefficients of the Chebyshev basis functions. We show from a statistical analysis of the characteristics of several thousands surfaces of different origin that these techniques will result most of the time in significant improvement in speed and accuracy over other boxing and subdivision technqiues.
A Tutorial Introduction to Distributed Memory Models of Parallel Computation
Authors: A. M. Gibbons
Venue:  (1992)

This is an introduction to distributed memory models of parallel computation. Communication networks that have been advocated for general purposes are described and the problem of parallel routing within these networks is addressed through the permutation routing paradigm. A number of basic techniques are briefly introduced for efficient implementation of P-RAM algorithms on distributed memory models of parallel computation. These include techniques which are dependent on network topology or algorithmic structure, such as graph embedding and the method of compress and iterate as well as techniques with less specific application such as the employment of hashing and the use of parallel slackness to hide network latency.
Foderierung heterogener Datenbanksysteme und lokalerDatenhaltungskomponenten zur systemubergreifendenIntegritatssicherung- Grundlagen und Ziele des Projektes SIGMA_FDB
Authors: G. Saake, S. Conrad, Hö, M. ding, S. Janssen, I. Schmitt, T&uuml, C. rker
Venue:  (1996)

Ziel des Vorhabens ist die Entwicklung einer Basis-Informationsinfrastruktur als Grundlage integrierter und einheitlicher Datenhaltung fur alle Phasen der Fabrikplanung. Dazu soll ein foderiertes heterogenes Informationssystem entstehen, das als Rahmensystem zur Integration aller an der Fabrikplanung beteiligten Software-Werkzeuge einschliesslich deren lokaler Datenbestande dient. Damit sollen bislang separate Werkzeuge, die fur Produktentwurf, Produktionsplanung und Fabriksimulation eingesetzt werden oder dafur noch entwickelt werden, synergetisch zusammengefugt werden. Zentrale Aufgabe eines solchen foderierten Informationssystem ist die systemubergreifende Gewahrleistung der Datenkonsistenz. Um diese zu gewahrleisten, sollen aktive Mechanismen auf einer ubergeordneten Ebene realisiert werden, um die Einzelsysteme mit ihren unterschiedlichen Moglichkeiten der Integritatssicherung zu verbinden.
SCATTERED DATA TECHNIQUES FOR SURFACES
Authors: Suresh K. Lodha
Venue:  (1996)

This chapter presents several techniques for solving variants of the following scattered data interpolation problem: given a finite set of $N$ points in $R^3$, find a surface that interpolates the given set of points. Problems of this variety arise in numerous areas of applications such as geometric modeling and scientific visualization. A large class of solutions exists for these problems and many excellent surveys exist as well. The focus of this survey is on presenting techniques that are relatively recent. sSolutions are classified into one of the five categories: piecewise polynomial or rational parametric solutions, algebraic solutions, radial basis function methods, Shepard''s methods and subdivision surfaces. Discussion on parametric solutions includes global interpolation by a single polynomial, interpolants based on data dependent triangulations, piecewise linear solutions such as alpha-shapes, and interpolants on irregular mesh. Algebraic interpolants based on cubic A-patches are described. Interpolants based on radial basis functions include Hardy''s multiquadrics, inverse multiquadrics and thin plate splines. Techniques for blending local solutions and natural neighbor interpolants are described as variations of Shepard''s methods. Subdivision techniques include Catmull-Clark subdivision technique and its variants and extensions. A brief discussion on surface interrogation techniques and visualization techniques is also included.
Semantic Foundations of Commutativity Analysis
Authors: Martin Rinard, Pedro Diniz
Venue:  (1996)

This paper presents the semantic foundations of commutativity analysis, an analysis technique for automatically parallelizing programs written in a sequential, imperative programming language. Commutativity analysis views the computation as composed of operations on objects. It then analyzes the program at this granularity to discover when operations commute (i.e. generate the same result regardless of the order in which they execute). If all of the operations required to perform a given computation commute, the compiler can automatically generate parallel code. This paper shows that the basic analysis and tranformations that form the foundation of the parallelization technique are sound. It also presents performance results from two automatically parallelized programs.
Transformation of Programs for Fault-tolerance
Authors: Zhiming Liu, M. Joseph
Venue:  (1990)

It has been usual to consider that the steps of program refinement start with a program specification and end with the production of the text of an executable program. But for fault-tolerance, the program must be capable of taking account of the failure modes of the particular architecture on which it is to be executed. In this paper we shall describe how a program constructed for a fault-free system can be transformed into a fault-tolerant program for execution on a system which is susceptible to failures. We assume that the interference by a faulty environment F on the execution of a program P can be described as a fault-transformation F which transforms P into a program F(P) = P + F. A recovery transformation R transforms P into a program R(P) = P[]R by adding a set of recovery actions R, called a recovery program. If the system is fail stop and faults do not affect recovery actions, we have F(R(P)) = F(P)[]R = (P + F)[]R We illustrate this approach to fault-tolerant programming by considering the problem of designing a protocol that guarantees reliable communication from a sender to a receiver in spite of faults in the communication channel between them.
Parallel Depth First Search on the Ring Architecture
Authors: Vipin Kumar, V. N Rao, K. Ramesh
Venue:  (1988)

This paper presents the implementation and analysis of parallel depth-first search on the ring architecture. At the heart of the parallel formulation of depth-first search is a dynamic work distribution scheme that divides the work between different processors. The effectiveness of the parallel formulation is strongly influenced by the choice of the work distribution scheme. In particular, a commonly used work distribution scheme is found to give very poor performance on large rings( < 32 processors). We present a new work distribution scheme that is better than the work distribution scheme used by other researchers, and gives good performance even on large rings (128 processors). We introduce the concept of iso-efficiency function to characterize the effectiveness of different work distribution schemes.
A New Interpretation of the Blackboard Architecture
Authors: I. D. Alexander-Craig
Venue:  (1993)

This paper describes a new interpretation of Newell''s blackboard metaphor of group problem-solving activity. The new interpretation considers the experts of the metaphor to be independent, concurrently active, agents that communicate by posting information on a shared memory (the blackboard). The blackboard in our new interpretation is expanded in functionality and is implemented as a concurrently executing process. The blackboard is able to perform tasks such as agent creation message direction and forwarding, and message censorship. We outline all of these functions and compare them with the conventional (HEARSAY-II derived) interpretation of the metaphor. We end by indicating some of the various ways in which the new interpretation can be used to construct systems that are distributed as well as parallel; as part of this, we show how the blackboard structures of the new interpretation can be recursively composed (embedded) to produce complex systems built from simple components.