ppxscal/embedding_network huggingface dataset:
Solving narrow banded systems on ensemble architectures
Authors: S. Lennart Johnsson
Venue: ACM Transactions on Mathematical Software (TOMS) (1985)

We present concurrent algorithms for the solution of narrow banded systems on ensemble architectures, and analyze the communication and arithmetic complexities of the algorithms. The algorithms consist of three phases. In phase 1, a block tridiagonal system of reduced size is produced through largely local operations. Diagonal dominance is preserved. If the original system is positive, definite, and symmetric, so is the reduced system. It is solved in a second phase, and the remaining variables obtained through local back substitution in a third phase. With a sufficient number of processing elements, there is no first and third phase. We investigate the arithmetic and communicationcomplexity of Gaussian elimination and block cyclic reduction for the solution of the reduced system on boolean cubes, perfect shuffle and shuffle-exchange networks, binary trees, and linear arrays. With an optimum number of processors, the minimum solution time on a linear array is of an order that ranges from Om2Nm to O(m3 + m3log2(N/m)) depending on the bandwidth, the dimension of the problem, and the times for communication and arithmetic. For boolean cubes, cube-connected cycles, prefect shuffle and shuffle-exchange networks, and binary trees, the minimum time is Om3+m3log 2N/m including the communication complexity
Teaching formal programming to first year computer science students
Authors: Henry McLoughlin, Kevin Hely
Venue: ACM SIGCSE Bulletin (1996)

The integration of formal methods into the undergraduate curriculum has been slow considering the benefits they offer. One reason for this is that the limited number of relevant textbooks, although excellent, are rather terse. As a result, we have developed various techniques for teaching formal programming in which each step is fully justified by appealing to a design rule or heuristic. Another technique we have developed is 'programming by rule' using generic templates to solve problems of similar structure---rather like differentiation by rule. Our experience to date has been encouraging. We outline some of these techniques and give examples of them in practice.
Optimal Reconfiguration Algorithms for Real-Time Fault-Tolerant Processor Arrays
Authors: Ran Libeskind-Hadas, Nimish Shrivastava, Rami G. Melhem, C. L. Liu
Venue: IEEE Transactions on Parallel and Distributed Systems (1995)

In this paper we consider the problem of reconfiguring processor arrays subject to computational loads that alternate between two modes. A strict mode is characterized by a heavy computational load and severe constraints on response time while a relaxed mode is characterized by a relatively light computational load and relaxed constraints on response time. In the strict mode, reconfiguration is performed by a distributed local algorithm in order to achieve fast recovery from faults. In the relaxed mode, a global reconfiguration algorithm is used to restore the system to a state that maximizes the probability that future faults occurring in subsequent strict modes will be repairable.Several new results are given for this problem. Efficient reconfiguration algorithms are described for a number of general classes of architectures. These general algorithms obviate the need for architecture-specific algorithms for architectures in these classes. We show that it is unlikely that similar algorithms can be obtained for related classes of architectures since the reconfiguration problem for these classes is NP-complete. Finally, a general approximation algorithm is described that can be used for any architecture. Experimental results are given, suggesting that our algorithms are very effective.
Informix online XPS
Authors: Bob Gerber
Venue: Proceedings of the 1995 ACM SIGMOD international conference on Management of data (1995)

Parallel database systems have delivered on the promise of providing excellent, linear performance speedups for both decision support and transaction processing workloads across a variety of parallel system platforms. The challenge is now to extend those results across the entire open systems spectrum of loosely coupled environments while realizing the inherent high availability of such systems. The Informix eXtended Parallel Server (XPS) will accomplish that goal.XPS is the third and latest in the series of Online database servers that are based upon the Informix Dynamic Scalable Architecture (DSA). Earlier Online DSA servers have proven the effectiveness of the SMP-based high performance parallel data query (PDQ) technology that is the foundation of XPS: multi-threaded process groups, table partitioning, pipelined hash-partitioned operators, light access methods, and parallel resource management. XPS extends that PDQ technology across the continuum from small clusters of large SMP systems to massively parallel clusters of SMP or uniprocessor systems.
Fitting a Second Degree Curve in the Presence of Error
Authors: Michael Werman, Z. Geyzel
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1995)

This correspondence presents a statistically sound, simple and, fast method to estimate the parameters of a second degree curve from a set of noisy points that originated from the curve.
Helping programmers understand computer programs: the use of metacognition
Authors: Teresa M. Shaft
Venue: ACM SIGMIS Database (1995)

A large portion of computer programmers' efforts to maintain, test, and debug computer programs is spent understanding, or comprehending, the existing program. Current theories of program comprehension have not considered the circumstances that cause programmers to use different approaches to understanding programs. Metacognition may provide some insight into the comprehension process. Metacognition is a psychological terms that refers to "one's knowledge concerning one's own cognitive processes" (Flavell, 1976) and influences the execution of cognitive tasks. Through metacognition, a person confronting a cognitive task can select a strategy, and then monitor and regulate their progress on a task.This study investigates the use of metacognition by programmers to purposefully (deliberately) choose a comprehension strategy. The results of this study support the view that programmers use metacognition when studying computer programs. Specifically, two-thirds of the programmers indicated that, in general, they purposefully choose a comprehension strategy. When studying a computer program from an unfamiliar application domain, however, programmers who generally use metacognition had lower levels of comprehension than when working in a familiar domain or when compared to those programmers who do not use metacognition.These results suggest that programmers use metacognition during computer program comprehension and that the use of metacognition influences how well they understand a program. That metacognition reduces comprehension, but only in certain circumstances, leads to the speculation that programmers' metacognitive heuristics may be too general and that programmers need to develop more specific metacognitive heuristics to aid comprehension in a wider range of circumstances.
Matrices with Sign Consistency of a Given Order
Authors: J. M. Pena
Venue: SIAM Journal on Matrix Analysis and Applications (1995)

In this paper, the matrices whose minors of a given order have the same sign are characterized in several ways. In particular, given an $n\times d$ matrix $A$ (with $n>d$), a criterion involving $(n-d)d+1$ minors to determine if all $d\times d$ minors of $A$ have the same strict sign is obtained. A test of $O(m^3)$ elementary operations (with $m=\max \{n-d,d\}$) to check if a given matrix satisfies these properties is also provided. Finally, these results are applied to improve the characterizations of alternating polytopes.
A taxonomy of model abstraction techniques
Authors: Frederick K. Frantz
Venue: Proceedings of the 27th conference on Winter simulation (1995)

Model abstraction is a method for reducing the complexity of a simulation model while maintaining the validity of the simulation results with respect to the question that the simulation is being used to address. Model developers have traditionally used a number of abstraction techniques, and simulation researchers have conducted formal research to build a theoretical foundation for model manipulation. More recently, researchers in the artificial intelligence (AI) subfield of qualitative simulation have also been developing techniques for simplifying models, determining whether models results are valid, and developing tools for automatic model selection and manipulation. Metamodeling can also be considered as an abstraction technique. The purpose of the paper is to provide a taxonomy of abstraction techniques drawn from these fields. This taxonomy provides a framework for comparing and contrasting various abstraction techniques.
Stochastic optimization applied to a manufacturing system operation problem
Authors: Robert W. Brennan, Paul Rogers
Venue: Proceedings of the 27th conference on Winter simulation (1995)

This paper deals with stochastic optimization of a discrete-event simulation model for the solution of a manufacturing system operation problem. Gradient estimates are obtained by the application of the infinitesimal perturbation analysis (IPA) technique. We begin with background material on stochastic approximation (SA) and the IPA technique, their potential value in finding optimal solutions to manufacturing system operation problems, and limitations concerning their applicability. Next we present our attempt to solve a real problem (the design of a partially-automated assembly line in an electronics manufacturing facility) using this approach. A sequence of models is described moving from one which embodies some restrictive assumptions through to models which more closely approximate the real system. All of the models are implemented in the SIMAN IV simulation language incorporating user-written code (written in C++) implementing the SA and IPA algorithms. We report and interpret the results obtained with the different models and close with concluding remarks on the current value of this technique in solving this kind of system design problem.
A gentle introduction to algorithm complexity for CS1 with nine variations on a theme by Fibonacci
Authors: Óscar Martín-Sánchez, Cristóbal Pareja-Flores
Venue: ACM SIGCSE Bulletin (1995)

In this paper, we propose our ideas about didactic methods and a few examples appropriate to motivate in students the comprehension of the basic principles related to algorithm complexity. Emphasis is put on avoiding formalisms and presenting gradually every new concepts. This paper as well provides for both: an organisation of these ideas and a collection of, we hope, useful examples and experiences that show these concepts in a natural way.
Parallel skeletons for structured composition
Authors: John Darlington, Yi-ke Guo, Hing Wing To, Jin Yang
Venue: ACM SIGPLAN Notices (1995)

In this paper, we propose a straightforward solution to the problems of compositional parallel programming by using skeletons as the uniform mechanism for structured composition. In our approach parallel programs are constructed by composing procedures in a conventional base language using a set of high-level, pre-defined, functional, parallel computational forms known as skeletons. The ability to compose skeletons provides us with the essential tools for building further and more complex application-oriented skeletons specifying important aspects of parallel computation. Compared with the process network based composition approach, such as PCN, the skeleton approach abstracts away the fine details of connecting communication ports to the higher level mechanism of making data distributions conform, thus avoiding the complexity of using lower level ports as the means of interaction. Thus, the framework provides a natural integration of the compositional programming approach with the data parallel programming paradigm.
A distributed simulation model of air traffic in the national airspace system
Authors: Eric L. Blair, Frederick P. Wieland, Anthony E. Zukas
Venue: Proceedings of the 27th conference on Winter simulation (1995)

The study of air transportation systems is a prime opportunity for the application of simulation modeling. The complexity and highly interdependent nature of the national air transportation system makes it difficult to study, even through simulation. As a result, models of this system are typically large and require long run times. This paper reports on a model designed to apply the emerging technology of parallel/distributed computing to facilitate the rapid analysis of national-scope air transportation systems. The model makes extensive use of the SPEEDES distributed simulation support software developed at the Jet Propulsion Laboratory by Dr. Jeff Steinman.
A Modified TRAM Architecture
Authors: S. Rai, V. P. Kirpalani
Venue: IEEE Transactions on Computers (1996)

This paper modifies the tree RAM (TRAM) architecture[1] of multimegabit dynamic random access memories using a tree-star (TS) interconnection topology. The modified TS-RAM design offers a reduced access time and an improved yeild for the proposed TS-RAM architecture. We also propose an improved built-in self test (BIST) approach for the architecture.
Labelled domains and automata with concurrency
Authors: Felipe Bracho, Manfred Droste
Venue: Theoretical Computer Science (1994)

We investigate an operational model of concurrent systems, called automata with concurrency relations. These are labelled transition systems A in which the event set is endowed with a collection of binary concurrency relations which indicate when two events, in a particular state of the automaton, commute. This model generalizes asynchronous transition systems, and as in trace theory we obtain, through a permutation equivalence for computation sequences of A , an induced domain DA, &le; . Here, we construct a categorical equivalence between a large category of (&ldquo;cancellative&rdquo;) automata with concurrency relations and the associated domains. We show that each cancellative automaton can be reduced to a minimal cancellative automaton generating, up to isomorphism, the same domain. Furthermore, when fixing the event set, this minimal automaton is unique. &mdash;Authors' Abstract
Accurate Eigensystem Computations by Jacobi Methods
Authors: Roy Mathias
Venue: SIAM Journal on Matrix Analysis and Applications (1995)

Demmel and Veselic showed that, subject to a minor proviso, Jacobi's method computes the eigenvalues and eigenvectors of a positive definite matrix more accurately than methods that first tridiagonalize the matrix. We extend their analysis and thereby: \begin{remunerate} \item We remove the minor proviso in their results and thus guarantee the accuracy of Jacobi's method. \item We show how to cheaply check, a posteriori, whether tridiagonalizing a particular matrix has caused a large relative perturbation in the eigenvalues on the matrix. This can be useful when dealing with graded matrices. \item We derive hybrid Jacobi algorithms that have the same accuracy of Jacobi's method but are faster, at least on a serial computer. \item We show that if $G$ is an $m \times n$ matrix and $m >>n$ then Jacobi's method computes the singular values almost as quickly as standard methods, but potentially much more accurately.
Teaching algorithms
Authors: Ricardo A. Baeza-Yates
Venue: ACM SIGACT News (1995)

In this paper we propose and discuss how to teach algorithms, including contents, methodologies, textbooks, and computer labs. We use the ACM/IEEE curricula as a starting point and compare our proposal to theirs. We raise several issues, but we do not provide definite answers. Our main proposal is a paradigm driven methodology for the main algorithmic course, as well as some paradigms and problems not usually covered. An ultimate teaching algorithm is still an open problem.
A tutorial on design and analysis of simulation experiments
Authors: W. David Kelton
Venue: Proceedings of the 27th conference on Winter simulation (1995)

This paper describes, in general terms, methods to help design the runs for simulation models and interpret their output. Statistical methods are described for several different purposes, and related problems like comparison, variance reduction, sensitivity estimation, metamodeling and optimization are mentioned. The main point is to call attention to the challenges and opportunities in using simulation models carefully and effectively.
Recovery protocols for shared memory database systems
Authors: Lory D. Molesky, Krithi Ramamritham
Venue: Proceedings of the 1995 ACM SIGMOD international conference on Management of data (1995)

Significant performance advantages can be gained by implementing a database system on a cache-coherent shared memory multiprocessor. However, problems arise when failures occur. A single node (where a node refers to a processor/memory pair) crash may require a reboot of the entire shared memory system. Fortunately, shared memory multiprocessors that isolate individual node failures are currently being developed. Even with these, because of the side effects of the cache coherency protocol, a transaction executing strictly on a single node may become dependent on the validity of the memory of many nodes thereby inducing unnecessary transaction aborts. This happens when database objects, such as records, and database support structures, such as index structures and shared lock tables, are stored in shared memory.In this paper, we propose crash recovery protocols for shared memory database systems which avoid the unnecessary transaction aborts induced by the effects of using shared physical memory. Our recovery protocols guarantee that if one or more nodes crash, all the effects of active transactions running on the crashed nodes will be undone, and no effects of transactions running on nodes which did not crash will be undone. In order to show the practicality of our protocols, we discuss how existing features of cache-coherent multiprocessors can be utilized to implement these recovery protocols. Specifically, we demonstrate that (1) for many types of database objects and support structures, volatile (in-memory) logging is sufficient to avoid unnecessary transaction aborts, and (2) a very low overhead implementation of this strategy can be achieved with existing multiprocessor features.
Two techniques for on-line index modification in shared nothing parallel databases
Authors: Kiran J. Achyutuni, Edward Omiecinski, Shamkant B. Navathe
Venue: Proceedings of the 1996 ACM SIGMOD international conference on Management of data (1996)

Whenever data is moved across nodes in the parallel database system, the indexes need to be modified too. Index modification overhead can be quite severe because there can be a large number of indexes on a relation. In this paper, we study two alternatives to index modification, namely OAT (One-At-a-Time page movement) and BULK (bulk page movement). OAT and BULK are two extremes on the spectrum of the granularity of data movement. OAT and BULK differ in two respects: first, OAT uses very little additional disk space (at most one extra page), whereas BULK uses a large amount of disk space. Second, BULK uses sequential prefetch I/O to optimize on the number of I/Os during index modification, while OAT does not. Using an experimental testbed, we show that BULK is an order of magnitude faster than OAT. In terms of the impact on transaction performance during reorganization, BULK and OAT perform differently: when the number of indexes to be modified is either one or two, OAT has a lesser impact on the transaction performance degradation. However, when the number of indexes is greater than two, both techniques have the same impact on transaction performance.
A Life's Work in Geometry: An Homage to Hanfried Lenz
Authors: Dieter Jungnickel, Günter Pickert
Venue: Designs, Codes and Cryptography (1996)

We give a brief review of the mathematical work of Hanfried Lenz, at the occasion of his 80th birthday on April 22, 1996.
Sensor Modeling, Probabilistic Hypothesis Generation, and Robust Localization for Object Recognition
Authors: Mark D. Wheeler, Katsushi Ikeuchi
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1995)

In an effort to make object recognition efficient and accurate enough for real applications, we have developed three probabilistic techniques¿sensor modeling, probabilistic hypothesis generation, and robust localization¿which form the basis of a promising paradigm for object recognition. Our techniques effectively exploit prior knowledge to reduce the number of hypotheses that must be tested during recognition. Our recognition approach utilizes statistical constraints on the matches between image and model features. These statistical constraints are computed using a model of the entire sensing process¿resulting in more realistic and tighter constraints on matches. The candidate hypotheses are pruned by probabilistic constraint satisfaction to select likely matches based on the image evidence and prior statistical constraints. The resulting hypotheses are ordered most-likely first for verification, thus minimizing unnecessary verifications. The reliability of the verification decision is significantly increased by the use of a robust localization algorithm. Our localization algorithm reliably locates objects despite partial occlusion and significant errors in initial location estimates. We have implemented these techniques in a system that recognizes polyhedral objects in range images. Our results demonstrate accurate recognition while greatly limiting the number of verifications.
A router architecture for real-time point-to-point networks
Authors: Jennifer Rexford, John Hall, Kang G. Shin
Venue: Proceedings of the 23rd annual international symposium on Computer architecture (1996)

Parallel machines have the potential to satisfy the large computational demands of emerging real-time applications. These applications require a predictable communication network, where time-constrained traffic requires bounds on latency or throughput while good average performance suffices for best-effort packets. This paper presents a router architecture that tailors low-level routing, switching, arbitration and flow-control policies to the conflicting demands of each traffic class. The router implements deadline-based scheduling, with packet switching and table-driven multicast routing, to bound end-to-end delay for time-constrained traffic, while allowing best-effort traffic to capitalize on the low-latency routing and switching schemes common in modern parallel machines. To limit the cost of servicing time-constrained traffic, the router shares packet buffers and link-scheduling logic between the multiple output ports. Verilog simulations demonstrate that the design meets the performance goals of both traffic classes in a single-chip solution.
Variance reduction for discrete event systems driven by Poisson processes
Authors: Pirooz Vakili
Venue: Proceedings of the 27th conference on Winter simulation (1995)

In studies on conditions guaranteeing variance reduction for common random numbers (CRN), there is often the implicit assumption that the timing inputs, i.e., the random variables of clock samples, are generated via the inverse transform method. Some recommend using only inverse transform method when using CRN, suggesting that this strategy yields the best result, i.e., the highest degree of variance reduction. In this paper, we derive conditions guaranteeing variance reduction for a special class of systems-generalized semi-Markov processes (GSMP) with exponential clock samples-when using CRN and when the clock samples are generated via a version of the acceptance-rejection method. Our preliminary experimental results show that the variance reduction under this construction may be higher, sometimes significantly, than when inverse transform method is used.