ppxscal/embedding_network huggingface dataset:
Data caching issues in an information retrieval system
Authors: Rafael Alonso, Daniel Barbara, Hector Garcia-Molina
Venue: ACM Transactions on Database Systems (TODS) (1990)

Currently, a variety of information retrieval systems are available to potential users.&hellip; While in many cases these systems are accessed from personal computers, typically no advantage is taken of the computing resources of those machines (such as local processing and storage). In this paper we explore the possibility of using the user's local storage capabilities to cache data at the user's site. This would improve the response time of user queries albeit at the cost of incurring the overhead required in maintaining multiple copies. In order to reduce this overhead it may be appropriate to allow copies to diverge in a controlled fashion.&hellip; Thus, we introduce the notion of quasi-copies, which embodies the ideas sketched above. We also define the types of deviations that seem useful, and discuss the available implementation strategies. &mdash;From the Authors' Abstract
On Subsequences of Arithmetic Sequences
Authors: D. L. Mandelbaum
Venue: IEEE Transactions on Computers (1988)

A property of subsequences in arithmetic or decimal sequences is proved. This property has a somewhat similar counterpart for linear-feedback shift register (LFSR) sequences discovered by J.L. Massey (1969). However, it is proved in a different manner, and the limit bound is two units away from the corresponding LFSR property. This property holds for any radix, but the conditions depend somewhat on the radix.
Multicast tree construction in bus-based networks
Authors: Philip K. McKinley, Jane W. S. Liu
Venue: Communications of the ACM (1990)

Because of the multiple-access property of the media, the problem of constructing multicast trees in bus-based networks differs fundamentally from that in point-to-point networks. This article investigates the multicast tree construction for both general and specific network topologies.
P-uniform circuit complexity
Authors: Eric W. Allender
Venue: Journal of the ACM (JACM) (1989)

Much complexity-theoretic work on parallelism has focused on the class NC, which is defined in terms of logspace-uniform circuits. Yet P-uniform circuit complexity is in some ways a more natural setting for studying feasible parallelism. In this paper, P-uniform NC (PUNC) is characterized in terms of space-bounded AuxPDAs and alternating Turing Machines with bounded access to the input. The notions of general-purpose and special-purpose computation are considered, and a general-purpose parallel computer for PUNC is presented. It is also shown that NC = PUNC if all tally languages in P are in NC; this implies that the NC = PUNC question and the NC = P question are both instances of the ASPACE(S(n)) = ASPACE,TIME(S(n), S(n)o(1)) question. As a corollary, it follows that NC = PUNC implies PSPACE = DTIME(2no(1)).
Timing verification by formal signal interaction modeling in a multi-level timing simulator
Authors: J. Benkoski, A. J. Strojwas
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

A new multi-level macromodeling technique for timing simulation has been developed. This technique is based upon the modeling of the behavior of subcircuits under single input changes. The possible interactions between multiple input changes determine the range of validity of the models. A formal method for developing the model validity conditions is presented. This work establishes a bridge between timing analysis by using single input change models, and timing simulation which correctly models signal interactions. The availability of a formal criterion for the validity of the models allows the dynamic identification of the parts of the circuit that require more accurate models. As a result, the cost advantage of high level models can be fully exploited while still allowing critical interactions to be simulated with high accuracy.
Interactive type analysis and extended message splitting; optimizing dynamically-typed object-oriented programs
Authors: Craig Chambers, David Ungar
Venue: Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation (1990)

Object-oriented languages have suffered from poor performance caused by frequent and slow dynamically-bound procedure calls. The best way to speed up a procedure call is to compile it out, but dynamic binding of object-oriented procedure calls without static receiver type information precludes inlining. Iterative type analysis and extended message splitting are new compilation techniques that extract much of the necessary type information and make it possible to hoist run-time type tests out of loops. Our system compiles code on-the-fly that is customized to the actual data types used by a running program. The compiler constructs a control flow graph annotated with type information by simultaneously performing type analysis and inlining. Extended message splitting preserves type information that would otherwise be lost by a control-flow merge by duplicating all the code between the merge and the place that uses the information. Iterative type analysis computes the types of variables used in a loop by repeatedly recompiling the loop until the computed types reach a fix-point. Together these two techniques enable our SELF compiler to split off a copy of an entire loop, optimized for the common-case types. By the time our SELF compiler generates code for the graph, it has eliminated many dynamically-dispatched procedure calls and type tests. The resulting machine code is twice as fast as that generated by the previous SELF compiler, four times faster than ParcPlace Systems Smalltalk-80,* the fastest commercially available dynamically-typed object-oriented language implementation, and nearly half the speed of optimized C. Iterative type analysis and extended message splitting have cut the performance penalty for dynamically-typed object-oriented languages in half.
Modeling the user in natural language systems
Authors: Robert Kass, Tim Finin
Venue: Computational Linguistics (1988)

For intelligent interactive systems to communicate with humans in a natural manner, they must have knowledge about the system users. This paper explores the role of user modeling in such systems. It begins with a characterization of what a user model is and how it can be used. The types of information that a user model may be required to keep about a user are then identified and discussed. User models themselves can vary greatly depending on the requirements of the situation and the implementation, so several dimensions along which they can be classified are presented. Since acquiring the knowledge for a user model is a fundamental problem in user modeling, a section is devoted to this topic. Next, the benefits and costs of implementing a user modeling component for a system are weighed in light of several aspects of the interaction requirements that may be imposed by the system. Finally, the current state of research in user modeling is summarized, and future research topics that must be addressed in order to achieve powerful, general user modeling systems are assessed.
Qualitative engineering at various levels of conception design and evaluation of structures
Authors: Bruno M. Franck
Venue: Proceedings of the 2nd international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1989)

A multiple layer semantic net is proposed as a cognitive science framework to represent knowledge at various levels of abstractness. The multiple layers are qualitative at higher levels and quantitative at lower levels, and contain at all levels concepts that can be described by declarative and/or procedural statements. The semantic nets describe hierarchical knowledge associated with facts and events, and the procedures that are followed to process the information contained in the factual semantic nets. A Typicality Function is used to qualify the relevance of a concept to a class, and an Abstraction Function is used to describe at what level of representational abstraction the concept is described; both functions will be developed by combination of a fuzzy set-theory and knowledge-based prototype theory. All concepts and semantic net are represented by semiotic paradigms and manipulated as such. The information is processed through the multiple layer semantic net by qualitative reasoning.
Task allocation onto a hypercube by recursive mincut bipartitioning
Authors: F. Ercal, J. Ramanujam, P. Sadayappan
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

An efficient recursive task allocation scheme, based on the Kernighan-Lin mincut bisection heuristic, is proposed for the effective mapping of tasks of a parallel program onto a hypercube parallel computer. It is evaluated by comparison with an adaptive, scaled simulated annealing method. The recursive allocation scheme is shown to be effective on a number of large test task graphs - its solution quality is nearly as good as that produced by simulated annealing, and its computation time is several orders of magnitude less.
EVA: an explicit vector language
Authors: J. Dekeyser, Ph. Marquet, Ph. Pruex
Venue: ACM SIGPLAN Notices (1990)

Fortran is the main language used on supercomputer today. Indeed, all supercomputers compilers have extensions, providing language features for explicit vector handling, to Fortran 77. These extensions are different on each machine and their functions are limited. Even with the next standard Fortran 8x, vector syntax is incomplete. EVA is an explicit vector language with powerful vector handling tools. Taking into account the billion of dollars invested in productive Fortran 77 programs, EVA has been designed keeping in mind Fortran and C interface facilities.
A collecting interpretation of expressions
Authors: P. Hudak, J. Young
Venue: Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1988)

A collecting interpretation of expressions is an interpretation of a program that allows one to answer questions of the sort: &ldquo;What are all possible values to which an expression might evaluate during program execution?&rdquo; Answering such questions in a denotational framework is akin to traditional data flow analysis, and when used in the context of abstract interpretation allows one to infer properties that approximate the run-time behavior of expression evaluation. In this paper collecting interpretations of expressions are developed for three abstract functional languages: (1) a first-order language with call-by-value semantics, (2) a first-order language with call-by-name semantics, and (3) a higher-order language with call-by-name semantics (i.e., the full untyped lambda calculus with constants). It is argued that the method is simple (in particular, no powerdomains are needed), natural (it captures the intuitive operational behavior of a cache), yet more expressive than existing methods (it is the first exact collecting interpretation for either lazy or higher-order programs).
Ray shooting and other applications of spanning trees with low stabbing number
Authors: P. K. Agarwal
Venue: Proceedings of the fifth annual symposium on Computational geometry (1989)

In this paper we consider the following problem: Given a set @@@@ of n (possibly intersecting) line segments in the plane, preprocess them so that, given a query ray &rgr; emanating from a point p, we can quickly compute the intersection point &PHgr;(@@@@, &rgr;) of &rgr; with a segment of @@@@ that lies nearest to p. We present an algorithm that preprocesses @@@@, in time &Ogr;(n3/2 log&ohgr; n), into a data structure of size &Ogr;(n&agr;(n) log4 n), so that for a query ray &rgr;, &PHgr;(@@@@, &rgr;) can be computed in &Ogr;(&radic;nlog3 n), where &ohgr; is a constant < 4.3 and &agr;(n) is a functional inverse of Ackermann's function. If the given segments are non-intersecting, the storage goes down to &Ogr;(nlog3 n) and the query time is only &Ogr;(&radic;n log2 n). The main tool that we use is spanning trees with low stabbing number, i.e. with the property that no line intersects more than &Ogr;(&radic;n) edges of the tree. Using such trees we obtain faster algorithms for several other problems, including implicit point location, polygon containment and implicit hidden surface removal.
Coding image sequences for interactive retrieval
Authors: Andrew Lippman, William Butera
Venue: Communications of the ACM (1989)

An image coding technique for digital storage of motion picture information is presented that is optimated for use in interactive systems where high quality still frames, random access, and database linkages are required.
A graphical representation of concurrent processes
Authors: Janice M. Stone
Venue: ACM SIGPLAN Notices (1989)

This paper describes a graphical representation called a concurrency map. It provides a succinct representation of the potentially large collection of possible correct event-orderings for a set of concurrent processes. The normal problems of monitoring, debugging and analyzing performance of single-process programs are compounded for programs with concurrent processes. Although we can observe the behavior of each separate process, we do not know what is occurring concurrently in the various processes during successive moments as execution progresses. Furthermore, unknown timing delays among the processes may cause different program behavior when we rerun the program. The relative time-ordering of events in different concurrent processes is not, in general, fixed, and events that occurred in one order on one occasion on which the program performed correctly might occur in another order on another occasion, with equal correctness. We need to know both how the program behaved during execution and how that behavior might have differed under normal variations of concurrent execution. The concurrency map aids in solving these problems.
Some Relations Among Stochastic Finite State Networks Used in Automatic Speech Recognition
Authors: F. Casacuberta
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

In the literature on automatic speech recognition, the popular hidden Markov models (HMMs), left-to-right hidden Markov models (LRHMMs), Markov source models (MSMs), and stochastic regular grammars (SRGs) are often proposed as equivalent models. However, no formal relations seem to have been established among these models to date. A study of these relations within the framework of formal language theory is presented. The main conclusion is that not all of these models are equivalent, except certain types of hidden Markov models with observation probability distribution in the transitions, and stochastic regular grammar.
NFQL: the natural forms query language
Authors: David W. Embley
Venue: ACM Transactions on Database Systems (TODS) (1989)

A means by which ordinary forms can be exploited to provide a basis for nonprocedural specification of information processing is discussed. The Natural Forms Query Language (NFQL) is defined. In NFQL data retrieval requests and computation specifications are formulated by sketching ordinary forms to show what data are desired and update operations are specified by altering data on filled-in forms. The meaning of a form depends on a store of knowledge that includes extended abstract data types for defining elementary data items, a database scheme defined by an entity-relationship model, and a conceptual model of an ordinary form. Based on this store of knowledge, several issues are addressed and resolved in the context of NFQL. These issues include automatic generation of query expressions from weak specifications, the view update problem, power and completeness, and a heuristic approach to resolving computational relationships. A brief status report of an implementation of NFQL is also given.
Two-Phase Deadlock Detection Algorithm
Authors: A. K. Elmagarmid, A. K. Datta
Venue: IEEE Transactions on Computers (1988)

A deadlock detection algorithm utilizing a transaction-wait-for (TWF) graph is presented. It is a fully distributed algorithm which allows multiple outstanding requests. The proposed algorithm can achieve improved overall performance, using multiple disjoint controllers coupled with the two-phase property, while maintaining the simplicity of centralized schemes. The detection step is divided into two phases. Phase 1 analyzes the conditions of the system of interacting transactions, involving phase 2 only if conditions are possible for deadlocks to occur. Phase 2 performs the actual cycle detection. The proposed algorithm can be used in transaction-based distributed processing systems. Some results on the complexity of the algorithm are given.
Automatic verification of database transaction safety
Authors: Tim Sheard, David Stemple
Venue: ACM Transactions on Database Systems (TODS) (1989)

Maintaining the integrity of databases is one of the promises of database management systems. This includes assuring that integrity constraints are invariants of database transactions. This is very difficult to accomplish efficiently in the presence of complex constraints and large amounts of data. One way to minimize the amount of processing required to maintain database integrity over transaction processing is to prove at compile-time that transactions cannot, if run atomically, disobey integrity constraints. We report on a system that performs such verification for a robust set of constraint and transaction classes. The system accepts database schemas written in a more or less traditional style and accepts programs in a high-level programming language. Automatic verification fast enough to be effective on current workstation hardware is performed.
Register window architecture for multitasking applications
Authors: D. Quammen, D. R. Miller, D. Tabak
Venue: ACM SIGARCH Computer Architecture News (1989)

The organization of large register banks into windows hasbeen shown to be effective in enhancing the performance of sequential programs. One drawback of such an organization, which is of of minor importance to sexsquential languages, is the overhead encountered when the register bank must be replaced during a task switch. With concurrent language paradigms, such as are found in Ada, Occam, and Modula-2, these switches will be more frequent. We introduce here a methodology, and an architecture, which greatly reduces this overhead while maintaining the inherent advantages of the register window approach. In addition, we present ways of implemnting traditional stacks and queues, as well as hierarchical storage structures using windows.
Analyzing Scheduled Maintenance Policies for Repairable Computer Systems
Authors: E. de Souza e Silva, H. Richard Gail
Venue: IEEE Transactions on Computers (1990)

A solution method is developed to analyze various scheduled maintenance policies for repairable computer systems. The analysis is applicable to systems with behavior (exclusive of the scheduled maintenance policy) that can be modeled by a continuous-time Markov process, and thus important characteristics can be included in the model. Furthermore, the assumption of perfect repair, which is unrealistic for most systems, is not used. Both transient and steady-state measures are obtained. The measures considered include expected availability, expected number of unscheduled repairs (repairs that are performed outside of the scheduled maintenance period), and the probability of an unscheduled repair. The solution approach is based on the randomization technique and possesses advantage such as numerical stability and ease of implementation.
Mathematical Principles for a First Course in Software Engineering
Authors: Harlan D. Mills, Victor R. Basili, John D. Gannon, Richard G. Hamlet
Venue: IEEE Transactions on Software Engineering (1989)

An introductory computer science course is developed, much as calculus is a basic course for mathematics and the physical sciences, concerned primarily with theoretical foundations and methodology rather than apprenticeship through applications. In this work, the principles taught in the course are described and an example illustrating them is given.
Speaker Adaptation in a Large-Vocabulary Gaussian HMM Recognizer
Authors: P. Kenny, M. Lennig, P. Mermelstein
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

The problem of using a small amount of speech data to adapt a set of Gaussian HMMs (hidden Markov models) that have been trained on one speaker to recognize the speech of another is considered. The authors experimented with a phoneme-dependent spectral mapping for adapting the mean vectors of the multivariate Gaussian distributions (a method analogous to the confusion matrix method that has been used to adapt discrete HMMs), and a heuristic for estimating covariance matrices from small amounts of data. The best results were obtained by training the mean vectors individually from the adaptation data and using the heuristic to estimate distinct covariance matrices for each phoneme.
The common Lisp object system metaobject kernel: a status report
Authors: Daniel G. Bobrow, Gregor Kiczales
Venue: Proceedings of the 1988 ACM conference on LISP and functional programming (1988)

The metaobject kernel of the Common Lisp Object System (CLOS) comprises the classes and methods that define and implement the behavior of the system. Since CLOS is an object-oriented program itself, exposing this kernel allows people to make useful integrated extensions to CLOS without changing the behavior of the system for ordinary programs, and without unwarranted loss of efficiency. This paper is organized around the classes used to implement CLOS, describing reasons for the class organization chosen, and how these classes participate in some protocols of the system.
Large deviations theory techniques in Monte Carlo simulation
Authors: J. S. Sadowsky, J. A. Bucklew
Venue: Proceedings of the 21st conference on Winter simulation (1989)

This paper considers the estimation via importance sampling simulation of large deviation probabilities. These are probabilities Pn which vanish with an exponential rate as n &infin;. Let Ln denote the number of simulations required to obtain a specified relative precision. Since Pn vanishes exponentially fast, it turns out that for most practical importance sampling simulation schemes Ln will grow exponentially as n &infin;. We say that a simulation scheme is asymptotically efficient if Ln grows less than exponentially fast. Identification of efficient importance sampling simulation schemes is the primary goal of this paper.There are several problems of interest which can be couched in the framework of large deviations theory. For the purpose of developing intuition and presenting of our results with minimal mathematical preliminaries we shall concentrate on the problem of i.i.d. sums crossing a threshold. In this setting we shall show that there is precisely one i.i.d. simulation scheme that is efficient. Generalization and related problems are also overviewed. We assume the reader has no previous knowledge of large deviations theory.
GENESIS: An Extensible Database Management System
Authors: D. S. Batory, J. R. Barnett, J. F. Garza, K. P. Smith, K. Tsukuda
Venue: IEEE Transactions on Software Engineering (1988)

A novel yet simple technology is presented that enables customized database management systems (DBMSs) to be developed rapidly. The authors are designing an extensible DBMS, called GENESIS, which is based on this theory. They give a detailed description of their first operational prototype. DBMS software components in GENESIS can be written in a few months. When all components for a target DBMS are present, writing the architecture specification of the DBMS and reconfiguring GENESIS takes a few hours and can be accomplished with negligible cost.