ppxscal/embedding_network huggingface dataset:
LH*&mdash;a scalable, distributed data structure
Authors: Witold Litwin, Marie-Anna Neimat, Donovan A. Schneider
Venue: ACM Transactions on Database Systems (TODS) (1996)

We present a scalable distributed data structure called LH*. LH* generalizes Linear Hashing (LH) to distributed RAM and disk files. An LH* file can be created from records with primary keys, or objects with OIDs, provided by any number of distributed and autonomous clients. It does not require a central directory, and grows gracefully, through splits of one bucket at a time, to virtually any number of servers. The number of messages per random insertion is one in general, and three in the worst case, regardless of the file size. The number of messages per key search is two in general, and four in the worst case. The file supports parallel operations, e.g., hash joins and scans. Performing a parallel operation on a file of M buckets costs at most 2M + 1 messages, and between 1 and O(log2 Mrounds of messages.We first describle the basic LH* scheme where a coordinator site manages abucket splits, and splits a bucket every time a collision occurs. We show that the average load factor of an LH* file is 65%&ndash;70% regardless of file size, and bucket capacity. We then enhance the scheme with load control, performed at no additional message cost. The average load factor then increases to 80&ndash;95%. These values are about that of LH, but the load factor for LH* varies more.We nest define LH* schemes without a coordinator. We show that insert and search costs are the same as for the basic scheme. The splitting cost decreases on the average, but becomes more variable, as cascading splits are needed to prevent file overload. Next, we briefly describe two variants of splitting policy, using parallel splits and presplitting that should enhance performance for high-performance applications.All together, we show that LH* files can efficiently scale to files that are orders of magnitude larger in size than single-site files. LH* files that reside in main memory may also be much faster than single-site disk files. Finally, LH* files can be more efficient than any distributed file with a centralized directory, or a static parallel or distributed hash file.
Performance-driven simultaneous place and route for island-style FPGAs
Authors: Sudip K. Nag, Rob A. Rutenbar
Venue: Proceedings of the 1995 IEEE/ACM international conference on Computer-aided design (1995)

Abstract: Sequential place and route tools for FPGAs are inherently weak at addressing both wirability and timing optimizations. This is primarily due to the difficulty of accurately predicting wirability and delay during placement. A new performance-driven simultaneous placement/routing technique has been developed for island-style FPGA designs. On a set of industrial designs for Xilinx 4000-series FPGAs, our scheme produces 100% routed designs with 8%-15% improvement in delay when compared to the Xilinx XACT5.0 place and route system.
A reflection on call-by-value
Authors: Amr Sabry, Philip Wadler
Venue: Proceedings of the first ACM SIGPLAN international conference on Functional programming (1996)

A number of compilers exploit the following strategy: translate a term to continuation-passing style (CPS) and optimize the resulting term using a sequence of reductions. Recent work suggests that an alternative strategy is superior: optimize directly in an extended source calculus. We suggest that the appropriate relation between the source and target calculi may be captured by a special case of a Galois connection known as a reflection. Previous work has focused on the weaker notion of an equational correspondence, which is based on equality rather than reduction. We show that Moggi's monad translation and Plotkin's CPS translation can both be regarded as reflections, and thereby strengthen a number of results in the literature.
C++ dynamic arrays vs. linked lists
Authors: Marsha Zaidman
Venue: ACM SIGCSE Bulletin (1996)

Dynamically allocated linked lists are generally portrayed as a more flexible structure than arrays. However, dynamically allocated arrays, as available in C++, can be just as flexible and easier to use. This paper compares the use of dynamically allocated linked lists to dynamically allocated arrays as available in C++.
Analysis of benchmark characteristics and benchmark performance prediction
Authors: Rafael H. Saavedra, Alan J. Smith
Venue: ACM Transactions on Computer Systems (TOCS) (1996)

Standard benchmarking provides to run-times for given programs on given machines, but fails to provide insight as to why those results were obtained (either in terms of machine or program characteristics) and fails to provide run-times for that program on some other machine, or some other programs on that machine. We have developed a machine-imdependent model of program execution to characterize both machine performance and program execution. By merging these machine and program characterizations, we can estimate execution time for arbitrary machine/program combinations. Our technique allows us to identify those operations, either on the machine or in the programs, which dominate the benchmark results. This information helps designers in improving the performance of future machines and users in tuning their applications to better utilize the performance of existing machines. Here we apply our methodology to characterize benchmarks and predict their execution times. We present extensive run-time statistics for a large set of benchmarks including the SPEC and Perfect Club suites. We show how these statistics can be used to identify important shortcoming in the programs. In addition, we give execution time estimates for a large sample of programs and machines and compare these against benchmark results. Finally, we develop a metric for program similarity that makes it possible to classify benchmarks with respect to a large set of characteristics.
Word sense disambiguation using a second language monolingual corpus
Authors: Ido Dagan, Alon Itai
Venue: Computational Linguistics (1994)

This paper presents a new approach for resolving lexical ambiguities in one language using statistical data from a monolingual corpus of another language. This approach exploits the differences between mappings of words to senses in different languages. The paper concentrates on the problem of target word selection in machine translation, for which the approach is directly applicable. The presented algorithm identifies syntactic relations between words, using a source language parser, and maps the alternative interpretations of these relations to the target language, using a bilingual lexicon. The preferred senses are then selected according to statistics on lexical relations in the target language. The selection is based on a statistical model and on a constraint propagation algorithm, which simultaneously handles all ambiguities in the sentence. The method was evaluated using three sets of Hebrew and German examples and was found to be very useful for disambiguation. The paper includes a detailed comparative analysis of statistical sense disambiguation methods.
Ultra-structure: a design theory for complex systems and processes
Authors: Jeffrey G. Long, Dorothy E. Denning
Venue: Communications of the ACM (1995)

The physicist and Nobel laureate Ilya Prigogine states that &ldquo;our understanding of nature is undergoing a radical change toward the multiple, the temporal, and the complex. Curiously, the unexpected complexity found in nature has not led to a slowdown in the progress of science, but on the contrary to the emergence of new conceptual structures that now appear as essential to our understanding of the physical world&rdquo; [11]. We believe the challenges posed by complex systems arise primarily from the use of conceptual structures that worked well for static systems but do not work as well for more dynamic systems. We therefore propose new conceptual structures based on a different metaphysical view of the nature of complex systems.
A N algorithm for mutual exclusion in decentralized systems
Authors: Mamoru Maekawa
Venue: ACM Transactions on Computer Systems (TOCS) (1985)

An algorithm is presented that uses only c&radic;N messages to create mutual exclusion in a computer network, where N is the number of nodes and c a constant between 3 and 5. The algorithm is symmetric and allows fully parallel operation.
On families of iterated derivatives
Authors: Wolfram Koepf
Venue: ACM SIGSAM Bulletin (1994)

We give an overview of an approach on special functions due to Truesdell, and show how it can be used to develop certain type of identities for special functions. Once obtained, these identities may be verified by an independent algorithmic method for which we give some examples.
On linear potential functions for approximating Bayesian computations
Authors: Eugene Santos,  Jr.
Venue: Journal of the ACM (JACM) (1996)

Probabilistic reasoning suffers from NP-hard implementations. In particular, the amount of probabilistic information necessary to the computations is often overwhelming. For example, the size of conditional probability tables in Bayesian networks has long been a limiting factor in the general use of these networks.We present a new approach for manipulating the probabilistic information given. This approach avoids being overwhelmed by essentially compressing the information using approximation functions called linear potential functions. We can potentially reduce the information from a combinatorial amount to roughly linear in the number of random variable assigments. Furthermore, we can compute these functions through closed form equations. As it turns out, our approximation method is quite general and may be applied to other data compression problems.
Dynamic Critical-Path Scheduling: An Effective Technique for Allocating Task Graphs to Multiprocessors
Authors: Yu-Kwong Kwok, Ishfaq Ahmad
Venue: IEEE Transactions on Parallel and Distributed Systems (1996)

In this paper, we propose a static scheduling algorithm for allocating task graphs to fully connected multiprocessors. We discuss six recently reported scheduling algorithms and show that they possess one drawback or the other which can lead to poor performance. The proposed algorithm, which is called the Dynamic Critical-Path (DCP) scheduling algorithm, is different from the previously proposed algorithms in a number of ways. First, it determines the critical path of the task graph and selects the next node to be scheduled in a dynamic fashion. Second, it rearranges the schedule on each processor dynamically in the sense that the positions of the nodes in the partial schedules are not fixed until all nodes have been considered. Third, it selects a suitable processor for a node by looking ahead the potential start times of the remaining nodes on that processor, and schedules relatively less important nodes to the processors already in use. A global as well as a pair-wise comparison is carried out for all seven algorithms under various scheduling conditions. The DCP algorithm outperforms the previous algorithms by a considerable margin. Despite having a number of new features, the DCP algorithm has admissible time complexity, is economical in terms of the number of processors used and is suitable for a wide range of graph structures.
LAPACK-style algorithms and software for solving the generalized Sylvester equation and estimating the separation between regular matrix pairs
Authors: Bo Kågström, Peter Poromaa
Venue: ACM Transactions on Mathematical Software (TOMS) (1996)

Robust and fast software to solve the generalized Sylvester equation (AR - LB = C, DR - LE = F) for unknowns R and L is presented. This special linear system of equations, and its transpose, arises in computing error bounds for computed eigenvalues and eigenspaces of the generalized eigenvalue problem S-&lgr;T, in computing deflating subspaces of the same problem, and in computing certain decompositions of transfer matrices arising in control theory. Our contributions are twofold. First, we reorganize the standard algorithm for this problem to use Level 3 BLAS operations, like matrix multiplication, in its inner loop. This speeds up the algorithm by a factor of 9 on an IBM RS6000. Second, we develop and compare several condition estimation algorithms, which inexpensively but accurately estimate the sensitivity of the solution of this linear system.
Organ transplantation policy evaluation
Authors: A. Alan B. Pritsker, David L. Martin, Janet S. Reust, Mary Ann Wagner, O. Patrick Daily, Ann M. Harper, Erick B. Edwards, Leah E. Bennett, James R. Wilson, Michael E. Kuhl, John P. Roberts, Margaret D. Allen, James F. Burdick
Venue: Proceedings of the 27th conference on Winter simulation (1995)

The paper on the UNOS Liver Allocation Model (ULAM) describes the building of a simulation model that supports policy evaluation for a national medical problem. The modeling and simulation techniques used in building ULAM include: fitting donor and patient arrival processes having trend and cyclic rate components using non-homogeneous Poisson processes (NHPPs) having exponential rate functions which may include both a polynomial and some trigonometric components, fitting distributions to data on transition times between states of medical urgency; application of variance reduction techniques using common random-number streams and prior information; organizing data structures for efficient file searching and ranking capabilities; the use of bootstrapping techniques for attribute sampling; the building of submodels employing biostatistical procedures such as Kaplan-Meier and logistic regression; and the characterization of performance measures within a complex political, economic and social environment. ULAM provides a means for producing quantitative information to support the selection of a liver allocation policy.
Chip-Firing Games on Mutating Graphs
Authors: Kimmo Eriksson
Venue: SIAM Journal on Discrete Mathematics (1996)

We investigate a generalization of a chip-firing game on a graph of Bjorner, Lovasz, and Shor [European J. Combin., 1 (1992), pp. 305--328]. In our version, the graph mutates during play. We show that some known results about the game length and period length of the earlier game hold for the mutating version as well, and some completely new bounds are also obtained. In a small detour, we treat an orientability concept for eulerian graphs.
Constructing deterministic finite-state automata in recurrent neural networks
Authors: Christian W. Omlin, C. Lee Giles
Venue: Journal of the ACM (JACM) (1996)

Recurrent neural networks that are trained to behave like deterministic finite-state automata (DFAs) can show deteriorating performance when tested on long strings. This deteriorating performance can be attributed to the instability of the internal representation of the learned DFA states. The use of a sigmoidel discriminant function together with the recurrent structure contribute to this instability. We prove that a simple algorithm can construct second-order recurrent neural networks with a sparse interconnection topology and sigmoidal discriminant function such that the internal DFA state representations are stable, that is, the constructed network correctly classifies strings of arbitrary length. The algorithm is based on encoding strengths of weights directly into the neural network. We derive a relationship between the weight strength and the number of DFA states for robust string classification. For a DFA with n state and minput alphabet symbols, the constructive algorithm generates a &ldquo;programmed&rdquo; neural network with O(n) neurons and O(mn) weights. We compare our algorithm to other methods proposed in the literature.
STiNG: a CC-NUMA computer system for the commercial marketplace
Authors: Tom Lovett, Russell Clapp
Venue: ACM SIGARCH Computer Architecture News (1996)

"STiNG" is a Cache Coherent Non-Uniform Memory Access (CC-NUMA) Multiprocessor designed and built by Sequent Computer Systems, Inc. It combines four processor Symmetric Multi-processor (SMP) nodes (called Quads), using a Scalable Coherent Interface (SCI) based coherent interconnect. The Quads are based on the Intel P6 processor and the external bus it defines. In addition to 4 P6 processors, each Quad may contain up to 4 GBytes of system memory, 2 Peripheral Component Interface (PCI) busses for I/O, and a Lynx board. The Lynx board provides the datapath to the SCI-based interconnect and ensures system-wide cache coherency. STiNG is one of the first commercial CC-NUMA systems to be built. This paper describes the motivation for building STiNG as well as its architecture and implementation. In addition, performance analysis is provided for On-Line Transaction Processing (OLTP) and Decision Support System (DSS) workloads. Finally, the status of the current implementation is reviewed.
Efficient fault-tolerant algorithms for distributed resource allocation
Authors: Manhoi Choy, Ambuj K. Singh
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1995)

Solutions to resource allocation problems and other related synchronization problems in distributed systems are examined with respect to the measures of response time, message complexity, and failure locality. Response time measures the time it takes for an algorithm to respond to the requests of a process; message complexity measures the number of messages sent and received by a process; and failure locality characterizes the size of the network that is affected by the failure of a single process. An algorithm for the resource allocation problem that achieves a constant failure locality of four along with a quadratic response time and a quadratic message complexity is presented. Applications of the algorithm to other process synchronization problems in distributed systems are also demonstrated.
An overview of DB2 parallel edition
Authors: Chaitanya Baru, Gilles Fecteau
Venue: Proceedings of the 1995 ACM SIGMOD international conference on Management of data (1995)

In this paper, we describe the architecture and features of DB2 Parallel Edition (PE). DB2 PE belongs to the IBM family of open DB2 client/server database products including DB2/6000, DB2/2, DB2 for HP-UX, and DB2 for the Solaris Operating Environment. DB2 PE employs a shared nothing architecture in which the database system consists of a set of independent logical database nodes. Each logical node represents a collection of system resources including, processes, main memory, disk storage, and communications, managed by an independent database manager. The logical nodes use message passing to exchange data with each other. Tables are partitioned across nodes using a hash partitioning strategy. The cost-based parallel query optimizer takes table partitioning information into account when generating parallel plans for execution by the runtime system. A DB2 PE system can be configured to contain one or more logical nodes per physical processor. For example, the system can be configured to implement one node per processor in a shared-nothing, MPP system or multiple nodes in a symmetric multiprocessor (SMP) system. This paper provides an overview of the storage model, query optimization, runtime system, utilities, and performance of DB2 Parallel Edition.
Bringing real-time scheduling theory and practice closer for multimedia computing
Authors: R. Gopalakrishnan, Gurudatta M. Parulkar
Venue: ACM SIGMETRICS Performance Evaluation Review (1996)

This paper seeks to bridge the gap between theory and practice of real-time scheduling in the domain of high speed multimedia networking. We show that the strict preemptive nature of real-time scheduling leads to more context switching, and requires system calls for concurrency control. We present our scheduling scheme called rate-monotonic with delayed preemption (rmdp) and show how it reduces both these overheads. We then develop the analytical framework to analyze rmdp and other scheduling schemes that lie in the region between strict (immediate) preemption and no preemption. Our idealized scheduler simulation methodology accounts for the blocking introduced by these schemes under the usual assumption that the time for context switching and preemption is zero. We derive simpler schedulability tests for non-preemptive scheduling, and prove a variant of rate-monotonic scheduling that has fewer preemptions. Our measurements on Sparc and Pentium platforms, show that for the workloads we considered, Rmdp increases useful utilization by as much as 8%. Thus our scheduling policies have the potential to improve performance over existing methods.
United States: computer graphics education in computer science undergoing a transformation
Authors: Jeffrey J. McConnell
Venue: ACM SIGGRAPH Computer Graphics (1996)

Computer graphics education in computer science is a very diverse world. This world is undergoing a transformation, albeit slowly, from traditional methods common in the days of limited computing power, screen resolution and available colors, to a modern approach where knowing how to draw lines pixel by pixel may not be as critical as it once was. This paper discusses some of the common trends and methodologies that are currently seen, and some of the resources that are currently available and used.The number of computer graphics courses varies, depending on the institution and whether they have a graduate program. For strictly undergraduate institutions, graphics is usually an upper-level elective, and is limited to one course. Students interested in further study either arrange for an independent study, or get a group together to have a special topics course offered. It is likely that only larger undergraduate institutions will be able to offer more than one course on a regular basis. Schools with graduate programs have greater flexibility, because it is typical for them to have an introductory course at the upper undergraduate level and one or more advanced courses as part of graduate study. Interested and capable undergraduate students are usually allowed to take these graduate level courses.The content of courses can also vary. Traditionally, schools with one course will usually have that course as an overview of 2D and 3D graphics, and those with two courses will sometimes have the first concentrate on 2D methods and the second on 3D. Many schools have a second undergraduate course concentrating on "advanced" rendering techniques like ray tracing and radiosity.
Sharing code through first-class environments
Authors: Christian Queinnec, David de Roure
Venue: ACM SIGPLAN Notices (1996)

Nowadays the Net is one of the most obvious driving forces. Yet, to consider it as one global store through which values and code may be shared is still immature. This paper suggests first-class environments as a means to achieve that goal in a multi-user Scheme framework. We propose two new special forms with a simple semantics. Our model allows precise control over environments (including extensible environments) and does not require (but does not prevent) reflective operations.
Excerpts from: An Information Systems Manifesto
Authors: James Martin, Leonard Kleinrock
Venue: Communications of the ACM (1985)

James Martin talks with Leonard Kleinrock about the state of the art in data processing&mdash;how corporate and MIS managers should manage the new technology, and how computer science education should relate to it.
Planar Strong Connectivity Helps in Parallel Depth-First Search
Authors: Ming-Yang Kao
Venue: SIAM Journal on Computing (1995)

This paper proves that for a strongly connected planar directed graph of size $n$, a depth-first search tree rooted at a specified vertex can be computed in $O(\log^{5}n)$ time with $n/\log{n}$ processors. Previously, for planar directed graphs that may not be strongly connected, the best depth-first search algorithm runs in $O(\log^{10}n)$ time with $n$ processors. Both algorithms run on a parallel random access machine that allows concurrent reads and concurrent writes in its shared memory, and in case of a write conflict, permits an arbitrary processor to succeed.