ppxscal/embedding_network huggingface dataset:
Adaptive Join Algorithms in Dynamic Distributed Databases
Authors: Min J. Yu, P. C.-Y. Sheu
Venue: Distributed and Parallel Databases (1997)

This paper addresses the problem of query optimization for dynamic databases in distributed environments where data frequently change their values. An adaptive query optimization algorithm is proposed to evaluate queries. Rather than constructing a full plan for an access path and executing it, the algorithm constructs a partial plan, executes it, updates the statistics, and constructs a new partial plan. Since a partial plan is constructed based on the latest statistics, the algorithm is adaptive to data modifications and errors from the statistics. The algorithm extends the SDD-1 algorithm by considering local processing cost as well as communication cost. Whereas the SDD-1 algorithm only uses semi-joins to reduce communication cost, the algorithm reduces it with joins as well. It is proved that the adaptive algorithm is more efficient than the SDD-1 algorithm.
Student development of multimedia CBE (poster)
Authors: Jane Meyerowitz, Maurice Mars, Steve Knight
Venue: ACM SIGCSE Bulletin (1998)

Experiences with a large scale CAL project development by Computer Science Honours students are discussed.
On the Practical Need for Abstraction Relations to Verify Abstract Data Type Representations
Authors: Murali Sitaraman, Bruce W. Weide, William F. Ogden
Venue: IEEE Transactions on Software Engineering (1997)

The typical correspondence between a concrete representation and an abstract conceptual value of an abstract data type (ADT) variable (object) is a many-to-one function. For example, many different pointer aggregates give rise to exactly the same binary tree. The theoretical possibility that this correspondence generally should be relational has long been recognized. By using a nontrivial ADT for handling an optimization problem, we show why the need for generalizing from functions to relations arises naturally in practice. Making this generalization is among the steps essential for enhancing the practical applicability of formal reasoning methods to industrial-strength software systems.
A Class of Interconnection Networks for Multicasting
Authors: Yuanyuan Yang
Venue: IEEE Transactions on Computers (1998)

Multicast, or one-to-many, communication arises frequently in parallel computing and telecommunication applications. Multicast networks can simultaneously support multiple multicast connections between the network inputs and network outputs. However, due to the complex communication patterns and routing control in multicast networks, there is still a considerably large gap in network cost between the currently best known multicast networks and permutation networks. In this paper, we will present a class of interconnection networks which can support a substantial amount of well-defined multicast patterns in a nonblocking fashion and yet have a comparable cost to permutation networks. We will also provide an efficient routing algorithm for satisfying multicast connection requests in such networks. Moreover, the multicast capability of the networks will be represented as a function of fundamental network structural parameters so that the trade-off between the network multicast capability and the network cost can be determined.
Nesting of reducible and irreducible loops
Authors: Paul Havlak
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1997)

Recognizing and transforming loops are essential steps in any attempt to improve the running time of a program. Aggressive restructuring techniques have been developed for single-entry (reducible) loops, but restructurers and the dataflow and dependence analysis they rely on often give up in the presence of multientry (irreducible) loops. Thus one irreducible loop can prevent the improvement of all loops in a procedure. This article give an algorithm to build a loop nesting tree for a procedure with arbitrary control flow. The algorithm uses definitions of reducible and irreducible loops which allow either kind of loop to be nested in the other. The tree construction algorithm, an extension of Tarjan's algorithm for testing reducibility, runs in almost linear time. In the presence of irreducible loops, the loop nesting tree can depend on the depth-first spanning tree used to build it. In particular, the header node representing a reducible loop in one version of the loop nesting tree can be the representative of an irreducible loop in another. We give a normalization method that maximizes the set of reducible loops discovered, independent of the depth-first spanning tree used. The normalization require the insertion of at most one node and one edge per reducible loop.
VLIW-in-the-large: a model for fine grain parallelism exploitation on distributed memory multiprocessors
Authors: Marco Danelutto, Marco Vanneschi
Venue: Proceedings of the 23rd annual workshop and symposium on Microprogramming and microarchitecture (1990)

VLIW architectures have been shown to be able to exploit large amounts of fine grain parallelism in the execution of sequential imperative programs. In this paper, a new computing model is presented, which allows the VLIW techniques to be adopted to operate a distributed memory, multiprocessor machine. The model, called VLIW-in-the-large, can be adopted in conjunction with a suitable hardware framework to obtain consistent speedups in the execution of both sequential and parallel-natured software. In this paper, we will show that the advantages of the VLIW-in-the-large computing model with respect to the classical VLIW approach are: i) better utilization of hardware resources, ii) extension of the applicability of the VLIW techniques to multiprocessor architectures, in such a way that they can be used for multi-style, multi-grain parallelism exploitation, iii) compact realization of processing elements, suitable for VLSI massively parallel architectures.
The Joint Training System: a pillar of joint readiness and an automation challenge
Authors: Joseph C. Barto,  III, Patrick D. Clark
Venue: Proceedings of the 28th conference on Winter simulation (1996)

The Joint Training System (JTS) (Figure 1) defines a multi-step approach to identify training requirements, plan, execute, and assess joint training events. First, and foremost, the JTS is focused on warfighting. "The specific objective is to develop a joint training program that bolsters the combatant commanders' ability to execute the National Military Strategy while simultaneously maintaining high readiness of our forces as a pro-requisite to deterring aggression and responding to crisis. The desired end state is the improved readiness of joint forces, a training and exercise strategy better aligned with the National Military Strategy, improved interoperability, and a more stable process for optimizing the application of scarce resources (dollars, forces, time)." Successful implementation of the JTS depends upon automating the system's processes so that the development, sharing, and reporting of training information and products is conducted as efficiently and effectively as possible.
The development of Erlang
Authors: Joe Armstrong
Venue: Proceedings of the second ACM SIGPLAN international conference on Functional programming (1997)

This paper describes the development of the programming language Erlang during the period 1985--1997.Erlang is a concurrent programming language designed for programming large-scale distributed soft real-time control applications.The design of Erlang was heavily influenced by ideas from the logic and functional programming communities. Other sources of inspiration came from languages such as Chill and Ada which are used in industry for programming control systems.
A Consistent Causality-Based View on a Timed Process AlgebraIncluding Urgent Interactions
Authors: Joost-Pieter Katoen, Rom Langerak, Ed Brinksma, Diego Latella, Tommaso Bolognesi
Venue: Formal Methods in System Design (1998)

This paper discusses a timed variant of a process algebra akin to LOTOS, baptized UPA, in a causality-based setting. Two timed features are incorporated&mdash;a delay function which constrains the occurrence time of atomic actions and an urgency operator that forces (local or synchronized) actions to happen urgently. Timeouts are typical urgent phenomena. A novel timed extension of event structures is introduced and used as a vehicle to provide a denotational causality-based semantics for UPA. Recursion is dealt with by using standard fixpoint theory. In addition, an operational semantics is presented based on separate time- and action-transitions that is shown to be consistent with the event structure semantics. An interleaving semantics for UPA is immediately obtained from the operational semantics. By adopting this dual approach the well-developed timed interleaving view is extended with a consistent timed partial order view and a comparison is facilitated of the partial order model and the variety of existing (interleaved) timed process algebras.
Synchronous up/down binary counter for LUT FPGAs with counting frequency independent of counter size
Authors: Alexandre F. Tenca, Miloš D. Ercegovac
Venue: Proceedings of the 1997 ACM fifth international symposium on Field-programmable gate arrays (1997)

This paper presents the design of a fast binary counter for LUT FPGAs. The counter has a cycle time independent of the counter size. The key aspects of the design are described and applied to a 64-bit synchronous binary counter implemented in a XC4010 FPGA chip. Experimental results show that the counter can scale up to hundreds of bits while keeping a short cycle time.
A tool for the collection of industrial software metrics data
Authors: K. K. Aggarwal
Venue: ACM SIGSOFT Software Engineering Notes (1997)

A tool has been designed under Windows 3.1, which converts a 'C' software to its abridged version that lists program characteristics of interest to the metric researchers. These characteristics may be operators, operands lists, their frequency of occurrences, number of terminators, different types of control structures, internal and external variables, etc. This information may be useful for the researchers but prevents the reconstruction of the original source code.
Problems, puzzles, challenges
Authors: G. J. Fee, M. B. Managan
Venue: ACM SIGSAM Bulletin (1997)

This new section is for the submission of problems, puzzles and challenges for our computer algebra systems to solve, and for publishing the computer solutions to the above. We start the problem section by presenting some problems that appear at first glance to be purely numerical, that is they look like they should be solvable by using a purely numerical package. However, you may find that this just leads to an error message when you try to solve them using a purely numerical package. Can our computer algebra systems come to the rescue and solve the following problems?
Componential set-based analysis
Authors: Cormac Flanagan, Matthias Felleisen
Venue: Proceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation (1997)

Set based analysis is a constraint-based whole program analysis that is applicable to functional and object-oriented programming language. Unfortunately, the analysis is useless for large programs, since it generates descriptions of data flow relationships that grow quadratically in the size of the program.This paper presents componential set-based analysis, which is faster and handles larger programs without any loss of accuracy over set-based analysis. The design of the analysis exploits a number of theoretical results concerning constraint systems, including a completeness result and a decision algorithm concerning the observable equivalance of constraint systems. Experimental results validate the practically of the analysis.
Euclidean Norm Minimization of the SOR Operators
Authors: Apostolos Hadjidimos, Michael Neumann
Venue: SIAM Journal on Matrix Analysis and Applications (1998)

Because the spectral radius is only an asymptotic measure of the rate of convergence of a linear iterative method, Golub and dePillis [ Toward an effective two-parameter method, in Iterative Methods for Large Linear Systems, Academic Press, New York, 1990] have raised in a recent paper the question of determining, for each $k\geq 1$, a relaxation parameter $\omega\in (0,2)$ and a pair of relaxation parameters $\omega_1$ and $\omega_2$ which minimize the Euclidean norm of the kth power of the SOR and MSOR iteration matrices, respectively, associated with a real symmetric positive definite matrix with "Property A." Here we use a reduction of these operators which they derived from the SVD of the associated block Jacobi matrix to obtain the minimizing relaxation parameters for the case k = 1 for both operators. We conclude the paper with two brief sections in which we assess what our results imply.
Symmetry and nonconvergence in iterative polynomial zero-finding
Authors: Tien Chi Chen
Venue: ACM SIGNUM Newsletter (1997)

It is well known that, in Newton's method, a real guess cannot converge to a complex zero of a real polynomial. Actually for the class of RR-weighted methods including those of Newton and Halley, a guess lying on a reflective symmetry axis of the zeros produces only iterates on the same axis; multiple symmetry axes intersect at the centroid C; a nearby guess gives approximations to either C or infin;. Irrational Newton-like method fare much better, but local symmetry can still lead to rebounding, calling for special detection and recovery algorithms.
Iterative development and commercial tools in an undergraduate software engineering course
Authors: Mark J. Sebern
Venue: ACM SIGCSE Bulletin (1997)

Many undergraduate software engineering courses combine team projects with discussion of development cycle concepts. It can be difficult to connect these elements in a coherent way, especially when the lecture is a broad survey and the project is sharply focused on meeting the needs of a client.This paper describes one attempt to bridge this gap, by incorporating the iterative development of a classroom example and an object-oriented process based on two commercial software tools. Although the course time frame (an academic quarter) is too short for significant iteration on the team project, students can participate in an accelerated version of the process by making a small increment to the non-trivial example.This approach retains the benefits of a realistic, client-centered team development project, while providing experience in a contemporary software development process based on commercial CASE tools.
Joint Minimization of Code and Data for Synchronous DataflowPrograms
Authors: Praveen K. Murthy, Shuvra S. Bhattacharyya, Edward A. Lee
Venue: Formal Methods in System Design (1997)

In this paper, we formally develop techniques that minimize the memory requirements of a target program when synthesizing software from dataflow descriptions of multirate signal processing algorithms. The dataflow programming model that we consider is the synchronous dataflow (SDF) model [21], which has been used heavily in DSP design environments over the past several years. We first focus on the restricted class of well-ordered SDF graphs. We show that while extremely efficient techniques exist for constructing minimum code size schedules for well-ordered graphs, the number of distinct minimum code size schedules increases combinatorially with the number of vertices in the input SDF graph, and these different schedules can have vastly different data memory requirements. We develop a dynamic programming algorithm that computes the schedule that minimizes the data memory requirement from among the schedules that minimize code size, and we show that the time complexity of this algorithm is cubic in the number of vertices in the given well-ordered SDF graph. We present several extensions to this dynamic programming technique to more general scheduling problems, and we present a heuristic that often computes near-optimal schedules with quadratic time complexity. We then show that finding optimal solutions for arbitrary acyclic graphs is NP-complete, and present heuristic techniques that jointly minimize code and data size requirements. We present a practical example and simulation data that demonstrate the effectiveness of these techniques.
Triangularly Implicit Iteration Methods for ODE-IVP Solvers
Authors: P. J. van der
Venue: SIAM Journal on Scientific Computing (1997)

It often happens that iteration processes used for solving the implicit relations arising in ODE-IVP methods only start to converge rapidly after a certain number of iterations. Fast convergence right from the beginning is particularly important if we want to use so-called step-parallel iteration in which the iteration method is concurrently applied at a number of step points. In this paper, we construct highly parallel iteration methods that do converge fast from the first iteration on. Our starting point is the PDIRK method (parallel, diagonally implicit, iterated Runge--Kutta method), designed for solving implicit Runge--Kutta equations on parallel computers. The PDIRK method may be considered as a Newton-type iteration in which the Newton Jacobian is "simplified" to block-diagonal form. However, when applied in a step-parallel mode, it turns out that its relatively slow convergence, or even divergent behavior, reduces the effectiveness of the step-parallel scheme. By replacing the block-diagonal Newton Jacobian approximation in PDIRK by a block-triangular approximation, we do achieve convergence right from the beginning at a modest increase of the computational costs. Our convergence analysis of the block-triangular approach will be given for the wide class of general linear methods, but the derivation of iteration schemes is limited to Runge--Kutta-based methods. A number of experiments show that the new parallel, triangularly implicit, iterated Runge--Kutta method (PTIRK method) is a considerable improvement over the PDIRK method.
Research Demonstration of a Hardware Reference-Counting Heap
Authors: David S. Wise, Brian Heck, Caleb Hess, Willie Hunt, Eric Ost
Venue: Lisp and Symbolic Computation (1997)

A hardware self-managing heap memory (RCM) for languages like Lisp, Smalltalk, and Java has been designed, built, tested and benchmarked. On every pointer write from the processor, reference-counting transactions are performed in real time within this memory, and garbage cells are reused without processor cycles. A processor allocates new nodes simply by reading from a distinguished location in its address space. The memory hardware also incorporates support for off-line, multiprocessing, mark-sweep garbage collection.Performance statistics are presented from a partial implementation of Scheme over five different memory models and two garbage collection strategies, from main memory (no access to RCM) to a fully operational RCM installed on an external bus. The performance of the RCM memory is more than competitive with main memory.
Analysis methodology for simulation of distributed adaptive routing systems
Authors: Arthur S. Olsen
Venue: ACM SIGCOMM Computer Communication Review (1997)

In network simulations, complex dynamical behavior is Previous analysis has identified limitations associated with Markov Chain Models and has established a need for the analysis of network dynamics through bound-queue/minimum-interarrival-time simulation models. In network simulations, complex dynamical behavior is observed even for simplistic stationary offered loads. An important contributor to the complexity of the network dynamics is the routing system. When a network consists of a large number of nodes, a routing system is applied in order to route traffic in an efficient manner between the nodes. The routing system has an important effect on the resulting network dynamics. This paper will discuss the complex dynamical behavior observed in networks controlled by distributed adaptive routing systems. This methodology can be applied during stability analyses of routing systems and is useful in system-level simulation verification.
Large Sets of Mutually Almost Disjoint Steiner Triple SystemsNot From Steiner Quadruple Systems
Authors: F. Franek, A. Rosa, T. S. Griggs
Venue: Designs, Codes and Cryptography (1997)

We construct what we believe to be the first examples of large sets of v MAD STS( v) which are not obtained from Steiner quadruple systems
Long term in vitro precision of single slice peripheral quantitative computed tomography (pQCT): multicenter comparison
Authors: G. Guglielmi, M. Cammisa, A. De Serio, G. M. Giannatempo, G. Orlandi, C. R. Russo
Venue: Technology and Health Care (1997)

In a multicenter evaluation the precision and stability of single slice peripheral Quantitative Computed Tomography (pQCT) systems were assessed. Compared to central Europe the peripheral QCT device is also widely used in the Italian health care system. Phantoms were measured frequently on each machine in four pQCT scanners over a two-year period using an identical automated software program. Intrasite and intersite phantom mineral densities, expressed in units of mg/cm^3, were analyzed and examined. The short and long term precision were estimated from the consistency of these measurements using the root mean square error and expressed as coefficient of variation in percent (% CV). Short term precision was good (mean intrasite coefficient of variation (CV) 0.21\pm 0.056 standard deviation (SD)). Intersite measurements of a single phantom revealed differences between machines of the same type of not more than 2.9 mg/cm^3. At four sites frequent phantom measurements revealed a mean CV of 0.18% (range 0.12-0.28). No significant changes in the regression slopes (drift of the machine versus time) were observed. We conclude that the in vitro precision and stability of the single slice pQCT systems are sufficiently high and unlikely to negatively affect the in vivo precision.
Stochastic Integration Rules for Infinite Regions
Authors: Alan Genz, John Monahan
Venue: SIAM Journal on Scientific Computing (1998)

Stochastic integration rules are derived for infinite integration intervals, generalizing rules developed by Siegel and O'Brien [ SIAM J. Sci. Statist. Comput., 6 (1985), pp. 169--181] for finite intervals. Then random orthogonal transformations of rules for integrals over the surface of the unit m-sphere are used to produce stochastic rules for these integrals. The two types of rules are combined to produce stochastic rules for multidimensional integrals over infinite regions with Normal or Student-t weights. Example results are presented to illustrate the effectiveness of the new rules.
Algorithm 779: Fermi-Dirac functions of order -1/2, 1/2, 3/2, 5/2
Authors: Allan J. MacLeod
Venue: ACM Transactions on Mathematical Software (TOMS) (1998)

The computation of Fermi-Dirac integrals *** is discussed for the values *** = -1, 1/2, 3/2, 5/2. We derive Chebyshev polynomial expansions which allow the computation of these functions to double precision IEEE accuracy.