ppxscal/embedding_network huggingface dataset:
A concurrency control mechanism based on extendible hashing for main memory database systems
Authors: V. Kumar
Venue: Proceedings of the 17th conference on ACM Annual Computer Science Conference (1989)

A non-preemptive deadlock-free concurrency control mechanism based on extendible hashing has been presented for main memory database system. The algorithm makes use of the verification process of the optimistic concurrency control algorithm and two-phase locking policy to manage concurrent operations on sharable data. We also present a comparison of our algorithm with other two-phase locking mechanisms and show that our algorithm is more robust, easier to implement and provides a higher degree of concurrency than other algorithms on extendible hash file.
A set of level 3 basic linear algebra subprograms
Authors: J. J. Dongarra, Jeremy Du Croz, Sven Hammarling, I. S. Duff
Venue: ACM Transactions on Mathematical Software (TOMS) (1990)

This paper describes an extension to the set of Basic Linear Algebra Subprograms. The extensions are targeted at matrix-vector operations that should provide for efficient and portable implementations of algorithms for high-performance computers
Algorithm 675: Fortran subroutines for computing the square root covariance filter and square root information filter in dense or Hessenberg forms
Authors: M. Vanbegin, M. Verhaegen
Venue: ACM Transactions on Mathematical Software (TOMS) (1989)

In this paper, codes are provided for two of the most popular square root filters: the Square Root Covariance Filter and the Square Root Information Filter. We also give efficient implementations for the time invariant case based on so-called condensed forms. All routines make extensive use of BLAS routines.
The Design, Analysis and Simulation of a Fault-Tolerant Interconnection Network Supporting the Fetch-and-Add Primitive
Authors: P. Banerjee, A. Dugar
Venue: IEEE Transactions on Computers (1989)

The combining multistage interconnection network uses 4*4 switches as switching elements and introduces an extra stage of such switches and links to create four independent paths between any source-destination pair. Four copies of every message are sent through the network simultaneously. The scheduling discipline, the design of the switching elements to support the discipline, and the theoretical proof of correctness of the design constitute the key contributions of this study. Estimates are provided of various network parameters as a function of the workload, using analytical models and detailed network simulations. It is shown that the proposed design for fault tolerance is more cost-effective than the brute-force technique of having multiple copies of the network.
Design and Analysis of a Gracefully Degrading Interleaved Memory System
Authors: Kifung C. Cheung, Gurindar S. Sohi, Kewal K. Saluja, Dhiraj K. Pradhan
Venue: IEEE Transactions on Computers (1990)

The organization of interleaved memories in such a way that faults in the memory system degrade the performance in a graceful manner is studied. Attention is restricted to an interleaved memory system that starts out with 2/sup q/ memory banks and uses a low-order interleaving scheme. The motivation and design objectives of the memory system are described. A new reconfiguration scheme and the design of the hardware needed to implement it are presented. The reconfiguration scheme is evaluated using trace-driven simulation for a number of benchmarks. The ideas presented can easily be extended to other interleaved memory schemes.
Algorithms for Constructing Minimal Deduction Graphs
Authors: Chao-Chih Yang, Jennifer Janu-Yin Chen, H. Lewis Chau
Venue: IEEE Transactions on Software Engineering (1989)

Two algorithms for constructing minimal deduction graphs (MDG) for inferring rules and facts in an extended version of the Horn clause logic are described. A deduction graph (DG) is minimal if the number of arcs in the graph is minimized. Horn clauses (HC) are extended to Horn formulas (HF), such that the head or the body of an HF can be a conjunction of positive literals or a disjunction of the bodies of some rule instances, respectively. Each algorithm constructs an MDG from its source to its sink, whose arcs infer the HF 'if source then sink'. The construction of an MDG is based on a sound and complete set of inference rules of reflexivity, transitivity, and conjunction for HFs which proceeds by expanding a tree rooted at its sink until its source has a successful backtracking to the root. Then the MDG is extracted from the tree. The nodes being expanded in such a tree are classified into seven types, which are assigned by different priorities for their growing into subtrees or for their pruning to reduce the tree space.
A response to criticisms of a virus detection scheme
Authors: M. J. Joseph
Venue: ACM SIGSAC Review (1989)

In their recent paper Davida, Desmedt, and Matt [Davi89, p.313] state that there are many unanswered questions concerning the design of the virus detection scheme presented in [Jose88]. Included in their discussion are 3 specific criticisms of this virus detection scheme. However, 2 of these criticisms are completely unfounded, and can mislead the reader who is unfamiliar with the basic hardware design of the detection mechanism.
Automating comments
Authors: P.-N. Robillard
Venue: ACM SIGPLAN Notices (1989)

This paper addresses the problem of source code documentation. Source code documentation has two components: the description of the statement and the description of the steps required to go from the specifications in natural language to programming language statements. We propose a model that provides a different mechanism for each form of documentation. A tool is used to implement and automate this approach. Results show that this approach provides a systematic and coherent mechanism for source code documentation. Productivity is increased and maintenance effort is greatly reduced.
On the logic of unification
Authors: Philippe Le Chenadec
Venue: Journal of Symbolic Computation (1989)

Unification, or solving equations on finite trees, is a P-complete problem central to symbolic manipulation, especially in Resolution, Type Inference and Rewriting. We present a natural logic dedicated to unification, which includes a constructive version of equational logic. This logic enjoys the classical proof-theoretic properties: atomicity; strong normalization; Church-Rosserness; left right, introduction elimination and positive negative symmetries. Motivated by the Type Inference problem, we introduce, besides a model-theoretic semantics and its completeness, a geometrical interpretation of deductions describing their operational content. This allows the design of a normalization process. This unification logic provides significant tools in investigations of higher-order unification, especially for the Type Inference problem, via fixed-point equations deducible from the given equations in unification logic. We also present some results on the classification problem of these fixed-point equations. To this end, we introduce the notion of elementary cyclic sets, that essentially possess a single associated fixed-point equation. The finite set of elementary cyclic sets embedded in some unification problem is obtained by a linearization process of the input equations. Finally, up to permutation, there exists a minimum equational deduction associated to an elementary cyclic set. We give a deterministic algorithm computing this deduction.
Analysis of cache invalidation patterns in multiprocessors
Authors: W. Weber, A. Gupta
Venue: ACM SIGARCH Computer Architecture News (1989)

To make shared-memory multiprocessors scalable, researchers are now exploring cache coherence protocols that do not rely on broadcast, but instead send invalidation messages to individual caches that contain stale data. The feasibility of such directory-based protocols is highly sensitive to the cache invalidation patterns that parallel programs exhibit. In this paper, we analyze the cache invalidation patterns caused by several parallel applications and investigate the effect of these patterns on a directory-based protocol. Our results are based on multiprocessor traces with 4, 8 and 16 processors. To gain insight into what the invalidation patterns would look like beyond 16 processors, we propose a classification scheme for data objects found in parallel applications and link the invalidation traffic patterns observed in the traces back to these high-level objects. Our results show that synchronization objects have very different invalidation patterns from those of other data objects. A write reference to a synchronization object usually causes invalidations in many more caches. We point out situations where restructuring the application seems appropriate to reduce the invalidation traffic, and others where hardware support is more appropriate. Our results also show that it should be possible to scale &ldquo;well-written&rdquo; parallel programs to a large number of processors without an explosion in invalidation traffic.
Software Cost Reduction Methods in Practice
Authors: J. A. Hager
Venue: IEEE Transactions on Software Engineering (1989)

In 1978, a software cost reduction program was initiated with the goal of applying modern design and documentation principles to the development of large systems. The results of this effort have been documented in several research papers published by D. Parnas et al. (1983). The author extends that approach by updating the methodology based on lessons learned during the application of the concepts to the development of a computer-based training system. An engineering life-cycle which provides more visibility to maintenance concerns is described, and the lessons learned during its implementation are discussed. A summary provides the author's impressions of the methodology and its potential to reduce system maintenance costs.
A parallel object-oriented language with inheritance and subtyping
Authors: Pierre America, Frank van der Linden
Venue: Proceedings of the European conference on object-oriented programming on Object-oriented programming systems, languages, and applications (1990)

This paper shows that inheritance and subtyping can be introduced advantageously into a parallel object-oriented language, POOL-I. These concepts are clearly distinguished, because they deal with different aspects of programming. In this way several problems traditionally adhering to inheritance can be solved. The language POOL-I is a parallel object-oriented language with a strong typing scheme which includes genericity and dynamic binding. A novel and particularly powerful mechanism offers the possibility to manipulate and analyse types dynamically.
The Number of Intersections Between two Rectangular Paths
Authors: Y.-L. Wang, R. C. Lee, J. S. Chang
Venue: IEEE Transactions on Computers (1989)

The authors consider upper bounds on the number of intersections between two rectangular paths. Let these two paths be denoted as P and Q, and denote the number of Manhattan subpaths in P and Q by mod P mod and mod Q mod respectively. K. Kant (1985) gave an upper bound of 10 mod P mod mod Q mod /9+4( mod P mod + mod Q mod )/9. The authors have sharpened these upper bounds, using methods to break the rectangular paths into subpaths, to be mod P mod mod Q mod +( mod P mod /2)+( mod Q mod /3), where they assume without loss of generality that mod P mod >or= mod Q mod.
Traffic placement policies for multi-band network
Authors: K. J. Maly, E. C. Foudriat, D. Game, R. Mukkamala, C. M. Overstreet
Venue: ACM SIGCOMM Computer Communication Review (1989)

Recently protocols have been introduced that enable the integration of synchronous traffic (voice or video) and asynchronous traffic (data) and extend the size of local area networks without loss in speed or capacity. One of these is DRAMA, a multiband protocol based on broadband technology. It provides dynamic allocation of bandwidth among clusters of nodes in the total network. In this paper, we propose and evaluate a number of traffic placement policies for such networks. Metrics used for performance evaluation include average network access delay, degree of fairness of access among the nodes, and network throughput. The feasibility of the DRAMA protocol is established through simulation studies. DRAMA provides effective integration of synchronous and asynchronous traffic due to its ability to separate traffic types. Under the suggested traffic placement policies, the DRAMA protocol is shown to handle diverse loads, mixes of traffic types, and numbers of nodes, as well as modifications to the network structure and momentary traffic overloads.
Arnoldi-Tchebychev for large scale matrices and its vectorization
Authors: D. H. Ho, F. Chatelin
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

The initial results of the iterative Arnoldi-Tchebychev procedure for the eigensolutions of large scale nonsymmetric matrices are discussed. The procedure uses an accurate algorithm for the identification of the optimal Tchebychev ellipse relative to a complex reference eigenvalue in a complex eigenspectrum. The analysis of the procedure shows that the algorithm is vector intensive. Test run affirms that more than 80% of the sampling time involves matrix and vector operations. The procedure can be easily vectorized to take advantage of the storage hierarchy structure of the IBM 3090 System and its Vector Facility.
A Declarative Approach to Visualizing Concurrent Computations
Authors: G.-C. Roman, K. C. Cox
Venue: Computer (1989)

The authors explore the graphical representation of objects and processes as a means for understanding programs consisting of large numbers of concurrent processes. Their goal is to establish a technical foundation for research into the monitoring and debugging of large-scale concurrent programs. They explain declarative visualization and introduce some shared-data-space concepts and notation by means of a simple, nondeterministic, parallel algorithm. They discuss visual abstraction and their visualization methodology, which they illustrate by applying it to region labeling. Thy examine the relaxation of nonintervention that visualization makes possible.
Fast breakpoints: design and implementation
Authors: Peter B. Kessler
Venue: ACM SIGPLAN Notices (1990)

We have designed and implemented a fast breakpoint facility. Breakpoints are usually thought of as a feature of an interactive debugger, in which case the breakpoints need not be particularly fast. In our environment breakpoints are often used for non-interactive information gathering; for example, procedure call count and statement execution count profiling [Swinehart, et al.]. When used non-interactively, breakpoints should be as fast as possible, so as to perturb the execution of the program as little as possible. Even in interactive debuggers, a conditional breakpoint facility would benefit from breakpoints that could transfer to the evaluation of the condition rapidly, and continue expeditiously if the condition were not satisfied. Such conditional breakpoints could be used to check assertions, etc. Program advising could also make use of fast breakpoints [Teitelman]. Examples of advising include tracing, timing, and even animation, all of which should be part of an advanced programming environment. We have ported the Cedar environment from a machine with microcode support for breakpoints [Lampson and Pier] to commercial platforms running C code [Atkinson, et al.]. Most of our ports run under the Unix* operating system, so one choice for implementing breakpoints for Cedar was to use the breakpoint facility provided by that system. The breakpoints provided by the Unix operating system are several orders of magnitude too slow (and also several process switches too complicated) for the applications we have in mind. So we designed a breakpoint system that was fast enough for our purposes. Breakpoints for uni-processors running single threads of control used to be fast and simple to implement. This paper shows that breakpoints can still be fast, even with multiple threads of control on multi-processors. This paper describes problems in the design of a breakpoint package for modern computer architectures and programming styles, and our solutions to them for a particular architecture.
From mathematical specifications to parallel programs on a message-based system
Authors: Th. Ruppelt, G. Wirtz
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

SUSPENSE is a high-level specification language for partial differential equations (PDEs) and related areas in numerical analysis. The language offers facilities to describe and manipulate numerical objects such as vectors, matrices, domains, grids etc. at a high level of abstraction. Sequential algorithms can be formulated by means of general iterators which describe (in contrast to procedural programming languages) only partial orders on objects. Parallelism is obtained in a domain-specific way by splitting numerical objects such as grids, vectors etc. into segments which will be processed in parallel. The specification language is supported by a system which checks specifications and transforms them into parallel programs. Algorithms specified and transformed in SUSPENSE are tailored to the parallel SUPRENUM machine [BGM 86].
The TRY system -or- how to avoid testing student programs
Authors: Kenneth A. Reek
Venue: ACM SIGCSE Bulletin (1989)

This paper discusses TRY, a software package for the UNIX1 operating system that tests student programs. The motivation for developing the system is established by describing problems associated with traditional grading methods and electronic program submission. The design and use of the TRY system is discussed, along with the advantages it provides to both the student and the instructor.
On the problem of optimizing data transfers for complex memory systems
Authors: K. Gallivan, W. Jalby, D. Gannon
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

Parallel supercomputers architectures with complex memory hierarchies or distributed memory systems have become very common. Unfortunately, the problems associated with restructuring software to take advantage of these memory systems are not easily solved. This paper presents an overview of some of the mathematical issues behind several of these problems and attempts to give a brief look at some of the potential solutions.
Invariant Image Recognition by Zernike Moments
Authors: A. Khotanzad, Y. H. Hong
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

The problem of rotation-, scale-, and translation-invariant recognition of images is discussed. A set of rotation-invariant features are introduced. They are the magnitudes of a set of orthogonal complex moments of the image known as Zernike moments. Scale and translation invariance are obtained by first normalizing the image with respect to these parameters using its regular geometrical moments. A systematic reconstruction-based method for deciding the highest-order Zernike moments required in a classification problem is developed. The quality of the reconstructed image is examined through its comparison to the original one. The orthogonality property of the Zernike moments, which simplifies the process of image reconstruction, make the suggest feature selection approach practical. Features of each order can also be weighted according to their contribution to the reconstruction process. The superiority of Zernike moment features over regular moments and moment invariants was experimentally verified.
Replicated data management in distributed database systems
Authors: Sang Hyuk Son
Venue: ACM SIGMOD Record (1988)

Replication is the key factor in improving the availability of data in distributed systems. Replicated data is stored at multiple sites so that it can be accessed by the user even when some of the copies are not available due to site failures. A major restriction to using replication is that replicated copies must behave like a single copy, i.e., mutual consistency as well as internal consistency must be preserved. Synchronization techniques for replicated data in distributed database systems have been studied in order to increase the degree of concurrency and to reduce the possibility of transaction rollback. In this paper, we classify different synchronization methods by underlying mechanisms and the type of information they use in ordering the operations of transactions, and survey some of the replication management methods appeared in the literature.
Computing a Gröbner basis of a polynomial ideal over a Euclidean domain
Authors: Äbdelilah Kandri-Rody, Deepak Kapur
Venue: Journal of Symbolic Computation (1988)

An algorithm for computing a Grobner basis of a polynomial ideal over a Euclidean domain is presented. The algorithm takes an ideal specified by a finite set of polynomials as its input; it produces another finite basis of the same ideal with the properties that using this basis, every polynomial in the ideal reduces to 0 and every polynomial in the polynomial ring reduces to a unique normal form. The algorithm is an extension of Buchberger's algorithms for computing Grobner bases of polynomial ideals over an arbitrary field and over the integers as well as our algorithms for computing Grobner bases of polynomial ideals over the integers and the Gaussian integers. The algorithm is simpler than other algorithms for polynomial ideals over a Euclidean domain reported in the literature; it is based on a natural way of simplifying polynomials by another polynomial using Euclid's division algorithm on the coefficients in polynomials. The algorithm is illustrated by showing how to compute Grobner bases for polynomial ideals over the integers, the Gaussian integers as well as over algebraic integers in quadratic number fields admitting a division algorithm. A general theorem exhibiting the uniqueness of a reduced Grobner basis of an ideal, determined by an admissible ordering on terms (power products) and other conditions, is discussed.
The case for partial indexes
Authors: M. Stonebraker
Venue: ACM SIGMOD Record (1989)

Current data managers support secondary and/or primary indexes on columns of relations. In this paper we suggest the advantages that result from indexes which contain only some of the possible values in a column of a relation.
Partition Strategy for Distributed Query Processing in Fast Local Networks
Authors: Clement T. Yu, Keh-Chang Guh, David Brill, Arbee L. P. Chen
Venue: IEEE Transactions on Software Engineering (1989)

A partition-and-replicate strategy for processing distributed queries referencing no fragmented relation is sketched. An algorithm is given to determine which relation and which copy of the relation is to be partitioned into fragments, how the relation is to be partitioned, and where the fragments are to be sent for processing. Simulation results show that the partition strategy is useful for processing queries in fast local network environments. The results also show that the number of partitions does not need to be large. The use of semijoins in the partition strategy is discussed. A necessary and sufficient condition for a semijoin to yield an improvement is provided.