ppxscal/embedding_network huggingface dataset:
A Minimax Theorem and a Dulmage--Mendelsohn Type Decomposition for a Class of Generic Partitioned Matrices
Authors: Satoru Iwata, Kazuo Murota
Venue: SIAM Journal on Matrix Analysis and Applications (1995)

This paper discusses an extension of the Dulmage--Mendelsohn decomposition for a certain class of matrices whose row-set and column-set are divided into couples or singletons. A genericity assumption is imposed and an admissible transformation is defined in respect of this partition structure. Extensions of the Konig--Egervary theorem and the Hall--Ore theorem are established. The latter states that the rank of such a matrix is characterized by the minimum value of a submodular function, of which the set of minimizers yields a canonical block-triangularization under the admissible transformations.
Songs and the analysis of algorithms
Authors: Darrah Chavey
Venue: Proceedings of the twenty-seventh SIGCSE technical symposium on Computer science education (1996)

In teaching a course that includes the analysis of algorithms, songs can be used as teaching examples. Multiple examples can be done at one time, or in one homework set, without the background explanation required to analyze real algorithms. Many components of algorithm analysis can be introduced using an analysis of songs. This is particularly useful at gaining experience extracting summations from "word problems."
An approach to the classification of domain models in support of analogical reuse
Authors: Chung-Horng Lung, Joseph E. Urban
Venue: ACM SIGSOFT Software Engineering Notes (1995)

This paper presents an approach to classify domain models in order to facilitate reuse through analogy. Domain analysis plays a critical role for systematic reuse, but domain analysis is difficult to perform, especially for new application areas. Analogical approach to reuse can support the domain analysis process by providing software products in a different but analogous domain. In order to achieve this goal, domain models need to be classified. This paper proposes a classification method for domain models. The method is an integration of the enumerative hierarchy and faceted scheme. The classification approach can help the domain analyst to locate an analogous domain to perform the modeling and analysis process. Moreover, the approach is more flexible and more descriptive than conventional classification methods.
Sporadic tasks in hard real-time systems
Authors: R. K. Allen, A. Burns, A. J. Wellings
Venue: ACM SIGAda Ada Letters (1995)

In this paper, we illustrate how systems containing hard real-time sporadic tasks can be analysed for their worst case behaviour. In order to undertake this schedulability analysis, it is necessary to define the minimum inter-arrival time and/or maximum arrival frequency of sporadic tasks. Furthermore, at run-time it is essential to ensure that sporadic tasks are not invoked more often than has been guaranteed by the analysis. We assume that sporadics are invoked by interrupts and that interrupts can be masked under software control.
Inferring Finite Automata with Stochastic Output Functions and an Application to Map Learning
Authors: Thomas Dean, Dana Angluin, Kenneth Basye, Sean Engelson, Leslie Kaelbling, Evangelos Kokkevis, Oded Maron
Venue: Machine Learning (1995)

It is often useful for a robot to construct a spatial representation of its environment from experiments and observations, in other words, to learn a map of its environment by exploration. In addition, robots, like people, make occasional errors in perceiving the spatial features of their environments. We formulate map learning as the problem of inferring from noisy observations the structure of a reduced deterministic finite automaton. We assume that the automaton to be learned has a distinguishing sequence. Observation noise is modeled by treating the observed output at each state as a random variable, where each visit to the state is an independent trial and the correct output is observed with probability exceeding 1/2. We assume no errors in the state transition function.Using this framework, we provide an exploration algorithm to learn the correct structure of such an automaton with probability 1 &minus; &delta;, given as inputs &delta;, an upper bound m on the number of states, a distinguishing sequence s, and a lower bound &alpha; > 1/2 on the probability of observing the correct output at any state. The running time and the number of basic actions executed by the learning algorithm are bounded by a polynomial in &delta;&minus;l, m, &verbar;s&verbar;, and (1/2-&alpha;)&minus;1.We discuss the assumption that a distinguishing sequence is given, and present a method of using a weaker assumption. We also present and discuss simulation results for the algorithm learning several automata derived from office environments.
Rank and uniformity
Authors: Roger K. W. Hui
Venue: ACM SIGAPL APL Quote Quad (1995)

Rank is elucidated through an executable model. Integrated rank support for specific functions can be vastly more efficient than the general algorithm in computing v"r, and uniform verbs provide a way to extend the more efficient implementation to a large class of verbs.
Debugging heterogeneous distributed systems using event-based models of behavior
Authors: Peter C. Bates
Venue: ACM Transactions on Computer Systems (TOCS) (1995)

We describe a high-level debugging approach, Event-Based Behavioral Abstraction (EBBA), in which debugging is treated as a process of creating models of expected program behaviors and comparing these to the actual behaviors exhibited by the program. The use of EBBA techniques can enhance debugging-tool transparency, reduce latency and uncertainty for fundamental debugging activities, and accommodate diverse, heterogeneous architectures. Using events and behavior models as a basic mechanism provides a uniform view of heterogeneous systems and enables analysis to be performed in well-defined ways. Their use also enables EBBA users to extend and reuse knowledge gained in solving previous problems to new situations. We describe our behavior-modeling algorithm that matches actual behavior to models and automates many behavior analysis steps. The algorithm matches behavior in as many ways as possible and resolves these to return the best match to the user. It deals readily with partial behavior matches and incomplete information. In particular, we describe a tool set we have built. The tool set has been used to investigate the behavior of a wide range of programs. The tools are modular and can be distributed readily throughout a system.
Explaining recursion to the unsophisticated
Authors: S. M. Haynes
Venue: ACM SIGCSE Bulletin (1995)

This paper addresses the topic of explaining recursion to Beginning programmers. It briefly presents the common approaches, then describes an extension to those methods called the activation tree.
Combination of multiplicative congruential random-number generators with safe prime modulus
Authors: Munetaka Sakamoto, Susumu Morito
Venue: Proceedings of the 27th conference on Winter simulation (1995)

Two or more multiplicative congruential random-number generators with prime modulus combined by means of a method proposed by Wichmann and Hill (1982) yield a random-number generator equivalent to a multiplicative congruential random-number generator with modulus equal to the product of the moduli of the component multiplicative congruential generators. The period of a random-number sequence obtained by the Wichmann-Hill method is equal to the least common multiple of the periods of the combined sequences. One of the two purposes of this paper is to present a necessary and sufficient set of efficiently verifiable conditions for the period to be equal to its maximum, which is the maximum of the least common multiple. Each of the conditions is always satisfied or is more easily verifiable when the modulus of each of the component generators is a safe prime. The other purpose of this paper is to derive an efficiently evaluatable formula for serial correlations of the maximum-period sequences by the Wichmann-Hill method. The authors recommend (i) to make the modulus of each of the component generators a safe prime, and (ii) to chose the multipliers of the components so as to (a) maximize the period and (b) make the serial correlations small in absolute value.
Efficient optimistic concurrency control using loosely synchronized clocks
Authors: Atul Adya, Robert Gruber, Barbara Liskov, Umesh Maheshwari
Venue: Proceedings of the 1995 ACM SIGMOD international conference on Management of data (1995)

This paper describes an efficient optimistic concurrency control scheme for use in distributed database systems in which objects are cached and manipulated at client machines while persistent storage and transactional support are provided by servers. The scheme provides both serializability and external consistency for committed transactions; it uses loosely synchronized clocks to achieve global serialization. It stores only a single version of each object, and avoids maintaining any concurrency control information on a per-object basis; instead, it tracks recent invalidations on a per-client basis, an approach that has low in-memory space overhead and no per-object disk overhead. In addition to its low space overheads, the scheme also performs well. The paper presents a simulation study that compares the scheme to adaptive callback locking, the best concurrency control scheme for client-server object-oriented database systems studied to date. The study shows that our scheme outperforms adaptive callback locking for low to moderate contention workloads, and scales better with the number of clients. For high contention workloads, optimism can result in a high abort rate; the scheme presented here is a first step toward a hybrid scheme that we expect to perform well across the full range of workloads.
A comparative analysis of schemes for correlated branch prediction
Authors: Cliff Young, Nicolas Gloy, Michael D. Smith
Venue: Proceedings of the 22nd annual international symposium on Computer architecture (1995)

Modern high-performance architectures require extremely accurate branch prediction to overcome the performance limitations of conditional branches. We present a framework that categorizes branch prediction schemes by the way in which they partition dynamic branches and by the kind of predictor that they use. The framework allows us to compare and contrast branch prediction schemes, and to analyze why they work. We use the framework to show how a static correlated branch prediction scheme increases branch bias and thus improves overall branch prediction accuracy. We also use the framework to identify the fundamental differences between static and dynamic correlated branch prediction schemes. This study shows that there is room to improve the prediction accuracy of existing branch prediction schemes.
Tight Bounds for Dynamic Storage Allocation
Authors: Michael G. Luby
Venue: SIAM Journal on Discrete Mathematics (1996)

This paper is concerned with on-line storage allocation to processes in a dynamic environment. This problem has been extensively studied in the past. We provide a new, tighter bound for the competitive ratio of the well-known First Fit algorithm. This bound is obtained by considering a new parameter, namely the maximum number of concurrent active processes. We observe that this bound is also a lower bound on the competitive ratio of any deterministic on-line algorithm. Our second contribution is an on-line allocation algorithm that uses coloring techniques. We show that the competitive ratio of this algorithm is the same as that of First Fit. Furthermore, we indicate that this algorithm may be advantageous in certain applications. Our third contribution is to analyze the performance of randomized algorithms for this problem. We obtain lower bounds on the competitive ratio that are close to the best deterministic upper bounds.
Organizing Large Structural Modelbases
Authors: Kuntal Sengupta, Kim L. Boyer
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1995)

We present a hierarchically structured approach to organizing large structural modelbases using an information theoretic criterion. Objects (patterns) are modeled in the form of random parametric structural descriptions (RPSDs), an extension of the parametric structural description graph-theoretic formalism [1]. Objects in scenes are modeled as parametric structural descriptions (PSDs). The organization process is driven by pairwise dissimilarity values between RPSDs. We also introduce the node pointer lists, which are computed offline during modelbase organization. During recognition, the only exponential matching process involved is between the scene PSD and the RPSD at the root of the organized tree. Using the organized hierarchy along with the node pointer lists, the remaining work simplifies to a series of inexpensive linear tests at the subsequent levels of the tree search. We develop the theory and present three modelbases: 50 objects built from real image data, 100 CAD models, and 1000 synthetic abstract models.
The Potential of Compile-Time Analysis to Adapt the Cache Coherence Enforcement Strategy to the Data Sharing Characteristics
Authors: Farnaz Mounes-Toussi, David J. Lilja
Venue: IEEE Transactions on Parallel and Distributed Systems (1995)

Cache coherence schemes that dynamically adapt to memory referencing patterns have been proposed to improve coherence enforcement in shared-memory multiprocessors. By using only run-time information, however, these existing schemes are incapable of looking ahead in the memory referencing stream. We present a combined hardware-software strategy that uses the predictive capability of the compiler to select updating or invalidating for each write reference. To determine the potential performance improvement that can be achieved with this optimization, three different levels of compiler capabilities are examined. Simulations using memory traces show that with an ideal compiler, this optimization can potentially reduce the miss ratio by 0.4% to 15% compared to an invalidating-only scheme, while reducing the generated network traffic by 13% to 94 % compared to an updating-only scheme. In addition, this optimization can potentially reduce the miss ratio by up to 13%, while reducing the generated network traffic by up to 92%, compared to a dynamic adaptive scheme. Furthermore, performance can be potentially improved even with a compiler capable of performing only imprecise array subscript analysis and no interprocedural analysis.Index Terms¿Compiler optimization, update, invalidate, directory, cache coherence, shared-memory, multiprocessor.
A Methodology for the Rapid Injection of Transient Hardware Errors
Authors: Charles R. Yount, Daniel P. Siewiorek
Venue: IEEE Transactions on Computers (1996)

Ultra-dependable computing demands verification of fault-tolerant mechanisms in the hardware. The most popular class of verification methodologies, fault-injection, is fraught with a host of limitations. Methods which are rapid enough to be feasible are not based on actual hardware faults. On the other hand, methods which are based on gate-level faults require enormous time resources. This research tries to bridge that gap by developing a new fault-injection methodology for processors based on a register-transfer-language (RTL) fault model. The fault model is developed by abstracting the effects of low-level faults to the RTL level. This process attempts to be independent of implementation details without sacrificing coverage, the proportion of errors generated by gate-level faults that are successfully reproduced by the RTL fault model. A prototype tool, ASPHALT, is described which automates the process of generating the error patterns. The IBM RISC-Oriented Micro-Processor (ROMP) is used as a basis for experimentation. Over 1.5 million transient faults are injected using a gate-level model. Over 97% of these are reproduced with the RTL model at a speedup factor of over 500:1. These results show that the RTL fault model may be used to greatly accelerate fault-injection experiments without sacrificing accuracy.
A workflow analysis and design environment (WADE)
Authors: Perakath C. Benjamin, Charles Marshall, Richard J. Mayer
Venue: Proceedings of the 27th conference on Winter simulation (1995)

This paper presents the architecture of a workflow analysis and design environment (WADE) that will provide robust support for simulation-based design of next-generation workflow systems. The architecture's utility is illustrated by showing its use to design and analyze material ordering and control system workflow.
Fringe analysis revisited
Authors: Ricardo A. Baeza-Yates
Venue: ACM Computing Surveys (CSUR) (1995)

Fringe analysis is a technique used to study the average behavior of search trees. In this paper we survey the main results regarding this technique, and we improve a previous asymptotic theorem. At the same time, we present new developments and applications of the theory that allow improvements in several bounds on the behavior of search trees. Our examples cover binary search trees, AVL-trees, 2&ndash;3 trees, and B-trees.
A Generalization of the Suffix Tree to Square Matrices, with Applications
Authors: Raffaele Giancarlo
Venue: SIAM Journal on Computing (1995)

We describe a new data structure, the Lsuffix tree, which generalizes McCreight's suffix tree for a string [J. Assoc. Comput. Mach., 23 (1976), pp. 262--272] to a square matrix. All matrices have entries from a totally ordered alphabet $\Sigma$. Based on the Lsuffix tree, we give efficient algorithms for the static versions of the following dual problems that arise in low-level image processing and visual databases. Two-dimensional pattern retrieval. We have a library of texts $S=\{TEXT^1,\cdots, TEXT^r\}$, where $TEXT^i$ is an $n_i\times n_i$ matrix, $ 1 \leq i \leq r$. We may preprocess the library. Then, given an $m \times m$, $m \leq n_i$, $ 1 \leq i \leq r$, pattern matrix $PAT$, we want to find all occurrences of $PAT$ in $TEXT$, for all $TEXT \in S$. Let $t(S)=\Sigma_{i=1}^r n_i^2$ be the size of the library. The preprocessing step builds the Lsuffix tree for the matrices in $S$ and then transforms it into an index (a trie defined over $\Sigma$). It takes $O(t(S)( \log |\Sigma| +\log t(S)))$ time and $O(t(S))$ space. The index can be queried directly in $O(m^2\log |\Sigma|+totocc)$ time, where $totocc$ is the total number of occurrences of $PAT$ in $TEXT$, for all $TEXT \in S$. Two-dimensional dictionary matching. We have a dictionary of patterns $DC=\{PAT_1, \cdots, PAT_s\}$, where $PAT_i$ is of dimension $m_i\times m_i$, $ 1 \leq i \leq s$. We may preprocess the dictionary. Then, given an $n \times n$ text matrix $TEXT$, we want to search for all occurrences of patterns in the dictionary in the text. Let $t(DC)=\Sigma_{i=1}^s m^2_i$ be the size of the dictionary and let $\overline{t}(DC)$ be the sum of the $m_i$'s. The preprocessing consists of building the Lsuffix tree for the matrices in $DC$. It takes $O(t(DC)\log |\Sigma| +\overline{t}(DC)\log \overline{t}(DC)))$ time and $O(t(DC))$ space. The search step takes $O(n^2(\log |\Sigma|+\log \overline{t}(DC))+totocc)$ time, where $totocc$ is the total number of occurrences of patterns in the text. Both problems have a dynamic version in which the library and the dictionary, respectively, can be updated by insertion or deletion of square matrices in them. In a companion paper, we will provide algorithms for the dynamic version.
Maintaining database consistency in presence of value dependencies in multidatabase systems
Authors: Claire Morpain, Michéle Cart, Jean Ferrié, Jean-François Pons
Venue: Proceedings of the 1996 ACM SIGMOD international conference on Management of data (1996)

The emergence of new criteria specifically adapted to multidatabase systems, in response to constraints imposed by global serializability, leads to restrictive hypotheses in order to ensure correctness of executions. This is the case with the two level serializability presented in [6], that ensures strongly correct executions if transaction programs are Local Database Preserving (LDP). The main drawback of the LDP hypothesis is that it relies on rigorous programming. The principal objective of this paper has been to suppress this drawback while conserving the strong correctness of 2LSR executions We propose defining precisely the notion of value dependencies, and managing them so as not to impose the LDP property.
Undetectable on-line password guessing attacks
Authors: Yun Ding, Patrick Horster
Venue: ACM SIGOPS Operating Systems Review (1995)

Several 3-party-based authentication protocols have been proposed, which are resistant to off-line password guessing attacks. We show that they are not resistant to a new type of attack called "undetectable on-line password guessing attack". The authentication server is not able to notice this kind of attack from the clients' (attacker's) requests, because they don't include enough information about the clients (or attacker). Either freshness or authenticity of these requests is not guaranteed. Thus the authentication server responses and leaks verifiable information for an attacker to verify his guess.
Memory system performance of programs with intensive heap allocation
Authors: Amer Diwan, David Tarditi, Eliot Moss
Venue: ACM Transactions on Computer Systems (TOCS) (1995)

Heap allocation with copying garbage collection is a general storage management technique for programming languages. It is believed to have poor memory system performance. To investigate this, we conducted an in-depth study of the memory system performance of heap allocation for memory systems found on many machines. We studied the performance of mostly functional Standard ML programs which made heavy use of heap allocation. We found that most machines support heap allocation poorly. However, with the appropriate memory system organization, heap allocation can have good performance. The memory system property crucial for achieving good performance was the ability to allocate and initialize a new object into the cache without a penalty. This can be achieved by having subblock by placement with a subblock size of one word with a write-allocate policy, along with fast page-mode writes or a write buffer. For caches with subblock placement, the data cache overhead was under 9% for a 64K or larger data cache; without subblock placement the overhead was often higher than 50%.
Unified Mixed Radix 2-4 Redundant CORDIC Processor
Authors: Eilsardo Antelo, Javier D. Bruguera, Emilio L. Zapata
Venue: IEEE Transactions on Computers (1996)

We present a unified mixed radix CORDIC algorithm with carry-save arithmetic with a constant scale factor. The pipelined architecture of the processor is determined by a unique sequence of microrotations for the two modes of operation (rotation and vectoring) in circular and hyperbolic coordinates. The combination of radix-2 and radix-4 microrotations allows us to reduce the latency and size of the pipeline significantly. The unified algorithm is based on the correcting microrotation method, which we have extended to the vectoring mode in hyperbolic coordinates. We have also generalized the use of radix-4 microrotations to the two operation modes and coordinate systems.