ppxscal/embedding_network huggingface dataset:
Algorithms for Multidimensional Partitioning of Static Files
Authors: D. Rotem, A. Segev
Venue: IEEE Transactions on Software Engineering (1988)

The problem of multidimensional file partitioning (MDFP) arises in large databases that are subject to frequent range queries on one or more attributes. In an MDFP scheme, the search attribute space is partitioned into cells, which are mapped to physical disk locations. This mapping preserves the order of the search attribute values so that range queries can be answered most efficiently, while maintaining good performance for other types of queries. Recently, MDFP schemes have been suggested to include both dynamic and static file organizations. Optimal and heuristic MDFP algorithms are developed for the static case. The results of extensive computational experiments show that the proposed heuristics perform better than known static ones. It is also shown that incorporating a static algorithm into a dynamic MDFP such as a grid file at conversion and/or periodical reorganization points significantly improves the resulting storage utilization of the data file and decreases the size of the directory file.
Fast computation using faulty hypercubes
Authors: J. Hastad, T. Leighton
Venue: Proceedings of the twenty-first annual ACM symposium on Theory of computing (1989)

We consider the computational power of a hypercube containing a potentially large number of randomly located faulty components. We describe a randomized algorithm which embeds an N-node hypercube in an N-node hypercube with faulty processors. Provided that the processors of the N-node hypercube are faulty with probability p < 1, and that the faults are independently distributed, we show that with high probability, the faulty hypercube can emulate the fault-free hypercube with only constant slowdown. In other words, an N-node hypercube with faults can simulate T steps of an N-node fault-free hypercube in O(T) steps. The embedding is easy to construct in polylogarithmic time using only local control. We also describe O(log N)-step routing algorithms which ensure the delivery of messages with high probability even when a constant fraction of the nodes and edges have failed. The routing results represent the first adaptive routing algorithms for which an effective theoretical analysis has been achieved.
Generalized predictive TCQ of speech
Authors: Michael W. Marcellin, Thomas R. Fischer
Venue: Communications of the ACM (1990)

Trellis coded quantization (TCQ) is incorporated into a noise feedback coding structure for encoding sampled speech. The effects of varying the encoding delay and the number of symbols released per trace-back on system performance and complexity are investigated.
The SeaView Security Model
Authors: T. F. Lunt, D. E. Denning, R. R. Schell, M. Heckman, W. R. Shockley
Venue: IEEE Transactions on Software Engineering (1990)

A multilevel database is intended to provide the security needed for database systems that contain data at a variety of classifications and serve a set of users having differentclearances. A formal security model for such a system is described. The model is formulated in two layers, one corresponding to a reference monitor that enforces mandatory security, and the second an extension of the standard relational model defining multilevel relations and formalizing policies for labeling new and derived data, data consistency, and discretionary security. The model also defines application-independent properties for entity integrity, referential integrity, and polyinstantiation integrity.
Computing trends in small liberal arts colleges
Authors: Peter D. Smith
Venue: ACM SIGCSE Bulletin (1988)

This paper summarizes the information gathered by the author during visits to 40 small liberal arts colleges in the east and Midwest during the winter of 1987. It focuses on the following questions: What is happening with computer science programs as colleges are coping with declining computer science enrollments? What trends are noticeable in staffing levels of computing faculty and of administrative and academic computing center support staff? How should colleges balance mainframe and micro computing and how many public access microcomputers are enough? Should students be required or strongly urged to buy a microcomputer? Should colleges provide faculty and administrators with microcomputers? What about networking? The paper provides tables and graphs to help small colleges answer these questions.
An expert advising system with acoustic output
Authors: Harald Trost, E. Buchberger, G. Dorffner
Venue: Issue 109 (July 1989) (1989)

In this paper we describe the application of natural language processing and speech techniques to improve the user-interface of expert systems. The particular goal of our project was to develop a German language interface for expert systems using speech input and output. The interface design was chosen in a way to provide for portability and flexibility. Possible application areas are domains where the user's vision is occupied by some task and where the dialogue is mostly system-driven, i.e., the user's answers can be restricted to a small set of utterances.
Fast Surface Interpolation Using Hierarchical Basis Functions
Authors: R. Szeliski
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

An alternative to multigrid relaxation that is much easier to implement and more generally applicable is presented. Conjugate gradient descent is used in conjunction with a hierarchical (multiresolution) set of basis functions. The resultant algorithm uses a pyramid to smooth the residual vector before the direction is computed. Simulation results showing the speed of convergence and its dependence on the choice of interpolator, the number of smoothing levels, and other factors are presented. The relationship of this approach to other multiresolution relaxation and representation schemes is also discussed.
Factoring polynomials using fewer random bits
Authors: Eric Bach, Victor Shoup
Venue: Journal of Symbolic Computation (1990)

Let F be a field of q=p^n elements, where p is prime. We present two new probabilisticalgorithms for factoring polynomials in F[X] that make particularly efficient use of random bits. They are easy to implement, and require no randomness beyond an initial seed whose length is proportional to the input size. The first algorithm is based on a procedure of Berlekamp; on input f in F[X] of degree d, it uses d log"2p random bits and produces in polynomial time a complete factorisation of f with a failure probability of no more than 1/p^(^1^-^e^)^d^/^2. (Here @e denotes a fixed parameter between 0 and 1 that can be chosen by the implementer.) The second algorithm is based on a method of Cantor and Zassenhaus; it uses d log"2q random bits and fails to find a complete factorisation with probability no more than 1/q^(^1^-^e^)^d^/^4. For both of these algorithms, the failure probability is exponentially small in the number of random bits used.
On aspects of university and performance for closed hashing
Authors: J. P. Schmidt, A. Siegel
Venue: Proceedings of the twenty-first annual ACM symposium on Theory of computing (1989)

We consider two hashing models for storing a set S &sub; {0, 1, 2, &hellip;, m - 1} in a table T of size n. The first model uses universal hashing for a partially loaded table. A set of hash functions is universal if, for any the input set, a randomly selected function has an efficient expected performance. Universal hash functions originate in [CW79], where they were used for open hashing using chaining. [CW79] poses as an open question whether comparable results can be achieved for any closed hashing schemes. The second model is perfect hashing for a full table. In preprocessing the input set is used to determine a hash function that achieves some desired performance criteria. This model was used among others in [ME82] and [FKS84]. In both models a key problem is to construct a &ldquo;small&rdquo; set of functions, which will permit a short description (program) for each function in the set. We show, for the first time, that universal hashing can be successfully used for closed hashing and in particular for double hashing. Specifically, the set of congruential polynomials of &Ogr;(log n) degree is universal for double hashing if the table load is below .75; the program size (or number of random bits generated by the algorithm) is &Ogr;(log log m + log2 n). For perfect hashing, we obtain nearly tight results on the size of oblivious &Ogr;(1)-probe hash functions: Oblivious k-probe hash functions require &OHgr;(n/k2e-k + log log m) bits of description. A probabilistic construction is presented, which shows that oblivious k-probe hash functions, can be specified in &Ogr;(ne-k + log log m) bits, which nearly matches the above lower bound. We give a variation of an &Ogr;(1) time 1-probe (perfect) hash function that can be specified in &Ogr;(n + log log m) bits, which is tight to within a constant factor of the lower bound. In view of the adaptive schemes presented in [FNSS88], these bounds establish a significant gap between oblivious and non-oblivious &Ogr;(1)-probe search.
An improved replacement strategy for function caching
Authors: William Pugh
Venue: Proceedings of the 1988 ACM conference on LISP and functional programming (1988)

Function caching is the technique of remembering previous function calls and avoiding the cost of recomputing them. Function caching provides a simple way of implementing dynamic programming algorithms and can provide a facility for incremental computation. Previous discussions of function caching have generally relied on the user to purge items from the function cache or have proposed a strategy such as least-recently-used without any analysis of the appropriateness of that strategy. We describe a formal model that allows us to describe the potential of a function cache and use that model to develop a practical cache replacement strategy that performs substantially better than currently used strategies. Benchmarks show that in use in an incremental theorem prover, our caching strategy produces almost a factor of four improvement in running time over a system running without function caching and almost a factor of two improvement in running time over a system using a standard cache replacement strategy.
The de Bruijn Multiprocessor Network: A Versatile Parallel Processing and Sorting Network for VLSI
Authors: M. R. Samatham, D. K. Pradhan
Venue: IEEE Transactions on Computers (1989)

It is shown that the binary de Bruijn multiprocessor network (BDM) can solve a wide variety of classes of problems. The BDM admits an N-node linear array, an N-node ring, (N-1)-node complete binary trees, ((3N/4)-2)-node tree machines, and an N-node one-step shuffle-exchange network, where N (=2/sup k/, k an integer) is the total number of nodes. The de Bruijn multiprocessor networks are proved to be fault-tolerant as well as extensible. A tight lower bound of the VLSI layout area of the BDM is derived; a procedure for an area-optimal VLSI layout is also described. It is demonstrated that the BDM is more versatile than the shuffle-exchange and the cube-connected cycles. Recent work has classified sorting architectures into (1) sequential input/sequential output, (2) parallel input/sequential output, (3) parallel input/parallel output, (4) sequential input/parallel output, and (5) hybrid input/hybrid output. It is demonstrated that the de Bruijn multiprocessor networks can sort data items in all of the abovementioned categories. No other network which can sort data items in all the categories is known.
Improving Quicksort Performance with a Codeword Data Structure
Authors: Jean-Loup Baer, Yi-Bing Lin
Venue: IEEE Transactions on Software Engineering (1989)

The problem is discussed of how the use of a new data structure, the codeword structure, can help improve the performance of quicksort when the records to be sorted are long and the keys are alphanumeric sequences of bytes. The codeword is a compact representation of a key with respect to some codeword generator. It consists of a byte for a character count of equal bytes, a byte for the first nonequal byte, and a pointer to the record. It is shown how the ordering of keys is preserved by an adequate choice of the code generator and how this can be applied to the quicksort algorithm. An analysis of the potential saving son various architectures and actual measurements shows the improvements that can be attained by using codewords rather than pointers. Architecturally independent parameters, such as the number of bytes to be compared, the number of swaps, architecture-dependent parameters such as caches and their write policies, and compiler optimizations such as in-line expansion and register allocation are considered.
The joint research councils' supercomputing unit
Authors: B. W. Davies, R. G. Evans, T. Daniels, D. J. Rigby
Venue: Proceedings of the 1988 ACM/IEEE conference on Supercomputing (1988)

A brief description is given of the Joint Research Councils Supercomputer Unit, a Cray X-MP/48 installation for the use of academic researchers in the UK. Operational experience and scientific use of the machine is discussed.
KCM: a knowledge crunching machine
Authors: H. Benker, J. M. Beacco, M. Dorochevsky, Th. Jeffré, A. Pöhlmann, J. Noyé, B. Poterie, J. C. Syre, O. Thibault, G. Watzlawik
Venue: ACM SIGARCH Computer Architecture News (1989)

KCM (Knowledge Crunching Machine) is a high-performance back-end processor which, coupled to a UNIX* desk-top workstation, provides a powerful and user-friendly Prolog environment catering for both development and execution of significant Prolog applications. This paper gives a general overview of the architecture of KCM stressing some new features like a 64-bit tagged architecture, shallow backtracking and an original memory management unit. Some early benchmark results obtained on prototype machines are presented. They show that KCM, which runs at a peak speed of 833 Klips on list concatenation, compares favorably with other dedicated Prolog machines and available commercial systems running on fast general purpose processors.
A parallel QR factorization algorithm using local pivoting
Authors: C. H. Bischof
Venue: Proceedings of the 1988 ACM/IEEE conference on Supercomputing (1988)

This paper presents a new parallel version of the Householder algorithm with column pivoting for computing the QR factorization of a matrix. In contrast to the standard algorithm we employ a local pivoting scheme that allows for efficient implementation of the algorithm on a parallel machine, in particular one with a distributed architecture. An inexpensive but reliable incremental condition estimator is used to control the selection of pivot columns by obtaining cheap estimates for the smallest singular value of the currently created upper triangular matrix R. Numerical experiments show that the local pivoting strategy behaves about as well as the traditional global pivoting strategy. They also show the advantages of incorporating the controlled pivoting strategy into the traditional QR algorithm to guard against the known pathological cases.
Compiling programs for a linear systolic array
Authors: Ping-Sheng Tseng
Venue: Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation (1990)

This paper describes an AL compiler for the Warp systolic array. AL is a programming language in which the user programs a systolic array as if it were a sequential computer and relies on the compiler to generate parallel code. This paper introduces the notion of data relations in compiling programs for systolic arrays. Unlike dependence relations among statements of a program, data relations define compatibility relations among data objects of a program. The AL compiler uses data relations to compute data compatibility classes, determine data distribution, and distribute loop iterations. The AL compiler can generate efficient parallel code almost identical to what the user would have written by hand. For example, the AL compiler generates parallel code for the LINPACK LU decomposition (SGEFA) and QR decomposition (SQRDC) routines with a nearly 8-fold speedup on the 10-cell Warp array for matrices of size 180 &times; 180.
Tradeoffs in the Design of Efficient Algorithm-Based Error Detection Schemes for Hypercube Multiprocessors
Authors: Vijay Balasubramanian, Prithviraj Banerjee
Venue: IEEE Transactions on Software Engineering (1990)

The authors provide an in-depth study of the various issues and tradeoffs available in algorithm-based error detection, as well as a general methodology for evaluating the schemes. They illustrate the approach on an extremely useful computation in the field of numerical linear algebra: QR factorization. They have implemented and investigated numerous ways of applying algorithm-based error detection using different system-level encoding strategies for QR factorization. Specifically, schemes based on the checksum and sum-of-squares (SOS) encoding techniques have been developed. The results of studies performed on a 16-processor Intel iPSC-2/D4/MX hypercube multiprocessor are reported. It is shown that, in general, the SOS approach gives much better coverage (85-100%) for QR factorization while maintaining low overheads (below 10%).
Displacement Estimates Through Adaptive Affinities
Authors: P. Werhoven, A. Toet, J. J. Koenderink
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

A technique that is functionally equivalent to the oriented smoothing concept and reduces numerical complexity and computational costs by eliminating the smoothness requirement from the iteration process is introduced. Local affine transformations are applied to propagate uniquely computed flow vectors into homogeneous regions and along edges in a single step. The window within which the local affine transformation is performed can adapt to the local structure of the intensity pattern in accordance with the oriented smoothness concept as formulated by H. Nagel (1987).
The limited performance benefits of migrating active processes for load sharing
Authors: D. L. Eager, E. D. Lazowska, J. Zahorjan
Venue: Proceedings of the 1988 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1988)

Load sharing in a distributed system is the process of transparently sharing workload among the nodes in the system to achieve improved performance. In non-migratory load sharing, jobs may not be transferred once they have commenced execution. In load sharing with migration, on the other hand, jobs in execution may be interrupted, moved to other nodes, and then resumed. In this paper we examine the performance benefits offered by migratory load sharing beyond those offered by non-migratory load sharing. We show that while migratory load sharing can offer modest performance benefits under some fairly extreme conditions, there are no conditions under which migration yields major performance benefits.
Using PAGE-AHEAD for large FORTRAN programs
Authors: R. Di Antonio, J. Eilert, M. Vitaletti
Venue: Proceedings of the 1989 ACM/IEEE conference on Supercomputing (1989)

Virtual storage management allows an efficient use of computer memory through the cooperative actions of the computer hardware and the operating system which are completely transparent to application programs. However, when program data exceed the available memory space, the program elapsed time may be dominated by the time spent in paging I/O operations. The data transfer rate, as determined by the operating system implementation of demand paging, may be small when compared with the maximum I/O bandwidth that the I/O hardware could support. Page-ahead is a technique which complements the operating system support of demand paging on virtual storage systems in order to exploit the regularity and predictability which is typical of the data access pattern of large engineering and scientific (E/S) application programs. Application programs may exploit this regularity by using page-ahead to request paging operations from the operating system in anticipation of future needs and take full advantage of the operating systems I/O bandwidth to auxiliary paging store.
Active Tracking Strategy for Monocular Depth Inference over Multiple Frames
Authors: G. Sandini, M. Tistarelli
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

The extraction of depth information from a sequence of images is investigated. An algorithm that exploits the constraint imposed by active motion of the camera is described. Within this framework, in order to facilitate measurement of the navigation parameters, a constrained egomotion strategy was adopted in which the position of the fixation point is stabilized during the navigation (in an anthropomorphic fashion). This constraint reduces the dimensionality of the parameter space without increasing the complexity of the equations. A further distinctive point is the use of two sampling rates: the faster (related to the computation of the instantaneous optical flow) is fast enough to allow the local operator to sense the passing edge (or, in other words, to allow the tracking of moving contour points), while the slower (used to perform the triangulation procedure necessary to derive depth) is slow enough to provide a sufficiently large baseline for triangulation. Experimental results on real image sequences are presented.
Two infinite sets of primes with fast primality tests
Authors: János Pintz, William Steiger, Endre Szemerédi
Venue: Proceedings of the twentieth annual ACM symposium on Theory of computing (1988)

Infinite sets P and Q of primes are described, P &sub; Q. For any natural number n it can be decided if n &isin; P in (deterministic) time &Ogr;((log n)9). This answers affirmatively the question of whether there exists an infinite set of primes whose membership can be tested in polynomial time, and is the main result of the paper. Also, for every n &isin; Q, we show how to produce at random, in expected time &Ogr;((log n)3), a certificate of length &Ogr;(log n) which can be verified in (deterministic) time &Ogr;((log n)3); this is less than the time needed for two exponentiations and is much faster than existing methods. Finally it is important that P is relatively dense (at least cn2/3/log n elements less than n). Elements of Q in a given range may be generated quickly, but it would be costly for an adversary to search Q in this range; this could be useful in cryptography.
The effect of unstaffing
Authors: A. H. Jarvis, D. Pratt, K. E. Gatling
Venue: Proceedings of the 17th annual ACM SIGUCCS conference on User Services (1989)

In 1984 the first microcomputer cluster was opened on the Syracuse University campus, joining established mainframe terminal clusters. One mainframe cluster was staffed with a full-time manager and student consultants keeping the cluster open approximately ninety hours a week. The microcomputer cluster was staffed in the same manner. Within the next five years Academic Computing Services (ACS) responded to the need for more microcomputers on campus and built six more clusters. Each cluster was staffed with student consultants, and the mainframe cluster joined the microcomputer clusters resulting in two full-time managers for eight clusters. These clusters are known as Remote Sites. During the academic year 1987-88 discussions were held to decide whether to unstaff some of the clusters. It was decided to unstaff all the DOS clusters starting in September 1988 and work toward unstaffing the Macintosh clusters for the following year. DOS clusters at this time were networked; consultants were still needed in the Macintosh sites to signout software disks. Macintosh sites would be unstaffed when the Macintosh network was in place. In September 1988 five of eight clusters were unstaffed.