ppxscal/embedding_network huggingface dataset:
Predicting Nearly As Well As the Best Pruning of a Decision Tree
Authors: David P. Helmbold, Robert E. Schapire
Venue: Machine Learning (1997)

Many algorithms for inferring a decision tree from data involve a two-phase process: First, a very large decision tree is grown which typically ends up &ldquo;over-fitting&rdquo; the data. To reduce over-fitting, in the second phase, the tree is pruned using one of a number of available methods. The final tree is then output and used for classification on test data.In this paper, we suggest an alternative approach to the pruning phase. Using a given unpruned decision tree, we present a new method of making predictions on test data, and we prove that our algorithm&lsquo;s performance will not be &ldquo;much worse&rdquo; (in a precise technical sense) than the predictions made by the best reasonably small pruning of the given decision tree. Thus, our procedure is guaranteed to be competitive (in terms of the quality of its predictions) with {\it any} pruning algorithm. We prove that our procedure is very efficient and highly robust.Our method can be viewed as a synthesis of two previously studied techniques. First, we apply Cesa-Bianchi et al.&lsquo;s (1993) results on predicting using &ldquo;expert advice&rdquo; (where we view each pruning as an &ldquo;expert&rdquo;) to obtain an algorithm that has provably low prediction loss, but that is computationally infeasible. Next, we generalize and apply a method developed by Buntine (1990, 1992) and Willems, Shtarkov and Tjalkens (1993, 1995) to derive a very efficient implementation of this procedure.
Representation Inheritance: A Safe Form of "White Box" Code Inheritance
Authors: Stephen H. Edwards
Venue: IEEE Transactions on Software Engineering (1997)

There are two approaches to using code inheritance for defining new component implementations in terms of existing implementations. Black box code inheritance allows subclasses to reuse superclass implementations as-is, without direct access to their internals. Alternatively, white box code inheritance allows subclasses to have direct access to superclass implementation details, which may be necessary for the efficiency of some subclass operations and to prevent unnecessary duplication of code.Unfortunately, white box code inheritance violates the protection that encapsulation affords superclasses, opening up the possibility of a subclass interfering with the correct operation of its superclass' methods. Representation inheritance is proposed as a restricted form of white box code inheritance where subclasses have direct access to superclass implementation details, but are required to respect the representation invariant(s) and abstraction relation(s) of their ancestor(s). This preserves the protection that encapsulation provides, while allowing the freedom of access that component implementers sometimes desire.
SPAM: a microcode based tool for tracing operating system events
Authors: Stephen W. Melvin, Yale N. Patt
Venue: Proceedings of the 20th annual workshop on Microprogramming (1987)

We have developed a tool called SPAM (for System Performance Analysis using Microcode), based on microcode modifications to a VAX 8600, that traces operating system events as a side-effect to normal execution. This trace of interrupts, exceptions, system calls and context switches can then be processed to analyze operating system behavior for the purpose of debugging, tuning or development. SPAM allows measurements to be made on a fully operating UNIX system with little perturbation (typically less than 10%) and without the need for modifying the kernel.
High-level area and power estimation for VLSI circuits
Authors: Mahadevamurty Nemani, Farid N. Najm
Venue: Proceedings of the 1997 IEEE/ACM international conference on Computer-aided design (1997)

This paper addresses the problem of computing the area complexity of a multi-output combinational logic circuit, given only its functional description, i.e., Boolean equations, where area complexity is measured in terms of the number of gates required for an optimal multi-level implementation of the combinational logic. The proposed area model is based on transforming the given multi-output Boolean function description into an equivalent single-output function. The model is empirical, and results demonstrating its feasibility and utility are presented. Also, a methodology for converting the gate count estimates, obtained from the area model, into capacitance estimates is presented. High-level power estimates based on the total capacitance estimates and average activity estimates are also presented.
Quantum cryptanalysis of hash and claw-free functions
Authors: Gilles Brassard, Peter Høyer, Alain Tapp
Venue: ACM SIGACT News (1997)

In this note, we give a quantum algorithm that finds collisions in arbitrary tau;-to-one functions after only O(3 radic;N/ tau;) expected evaluations of the function. Assuming the function is given by a black box, this is more efficient than the best possible classical algorithm, even allowing probabilism. We also give a similar algorithm for finding claws in pairs of functions. Furthermore, we exhibit a space-time tradeoff for our technique. Our approach uses Grover's quantum searching algorithm in a novel way.
Partial evaluation of call-by-value &lgr;-calculus with side-effects
Authors: Kenichi Asai, Hidehiko Masuhara, Akinori Yonezawa
Venue: Proceedings of the 1997 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation (1997)

We present a framework of an online partial evaluator for a call-by-value lambda;-calculus with destructive updates of data structures. It properly and correctly specializes expressions that contain side-effects, while preserving pointer equality, which is an important property for programs using updates. Our partial evaluator uses a side-effect analysis to extract immutable data structures and then performs an online specialization using preactions. Once mutable and immutable data structures are separated, partial evaluation is done in such a way that accesses to immutable ones are performed at specialization time, while accesses to mutable ones are residualized. For the correct residualization of side-effecting operations, preactions are used to solve various issues, including code elimination, code duplication, and execution order preservation. The preaction mechanism also enables us to reduce expressions that were residualized when the conventional let-expression approach of Similix was used. The resulting partial evaluator is simple enough to prove its correctness. Based on the framework, we have constructed a partial evaluator for Scheme, which is powerful enough to specialize fairly complicated programs with side-effects, such as an interpreter.
Cellular-Automata-Array-Based Diagnosis of Board Level Faults
Authors: Santanu Chattopadhyay, Dipanwita Roy Chowdhury, Subarna Bhattacharjee, Parimal Pal Chaudhuri
Venue: IEEE Transactions on Computers (1998)

A novel scheme for board level fault diagnosis based on Cellular Automata Array (CAA) is presented. In the proposed diagnosis scheme, the output responses of the chips are encoded by applying the strategy of CA-based byte error correcting code [1], [2]. The encoded response symbols for different test vectors are compressed to a signature. The decoding scheme of byte error correcting code is subsequently employed to detect the faulty chips on the board. The CAA-based design for the fault diagnosis strategy results in a simple and modular test structure that is well suited for VLSI implementation. The scheme can be applied for testing and diagnosis of multichip modules (MCMs) as well.
An Automatic Program Generator for Multi-Level Specialization
Authors: Robert Glück, Jesper Jørgensen
Venue: Lisp and Symbolic Computation (1997)

Program specialization can divide a computation into several computation stages. This paper investigates the theoretical limitations and practical problems of standard specialization tools, presents multi-level specialization, and demonstrates that, in combination with the cogen approach, it is far more practical than previously supposed. The program generator which we designed and implemented for a higher-order functional language converts programs into very compact multi-level generating extensions that guarantee fast successive specialization. Experimental results show a remarkable reduction of generation time and generator size compared to previous attempts of multi-level specialization by self-application. Our approach to multi-level specialization seems well-suited for applications where generation time and program size are critical.
Automatic modeling of file system workloads using two-level arrival processes
Authors: Peter P. Ware, Thomas W. Page,  Jr., Barry L. Nelson
Venue: ACM Transactions on Modeling and Computer Simulation (TOMACS) (1998)

This article describes a method for analyzing, modeling, and simulating a two-level arrival-counting process. This method is particlarly appropriate when the number of independent processes is large, as is the case in our motivating application which requires analyzing and representing computer file system trace data for activity on nearly 8,000 files. The method is also applicable to network trace data characterizing communication patterns between pairs of computers. We apply cluster analysis to separate the arrival process into groups or bursts of activity on a file. We then characterize the arrival procss in terms of the time between bursts of activity on file, the time between file events within bursts, and the number of events in a burst. Finally, we model these three components individually, then reassemble the results to produce a synthetic trace generator. In order to gauge the effectiveness of this method, we use synthetically generated (simulated) trace data produced in this way to drive a discrete-event simulation of a distributed replicated file system. We compare the results of the simulation driven by the synthetic trace with the same simulation driven by the original trace data, and conclude that the synthetic data capture the essential characteristics of the empirical trace.
How to declare an imperative
Authors: Philip Wadler
Venue: ACM Computing Surveys (CSUR) (1997)

How can we integrate interaction into a purely declarative language? This tutorial describes a solution to this problem based on a monad. The solution has been implemented in the functional language Haskell and the declarative language Escher. Comparisons are given with other approaches to interaction based on synchronous streams, continuations, linear logic, and side effects.
Test generation for comprehensive testing of linear analog circuits using transient response sampling
Authors: Pramodchandran N. Variyam, Abhijit Chatterjee
Venue: Proceedings of the 1997 IEEE/ACM international conference on Computer-aided design (1997)

The problem of testing analog components continues to be the bottleneck in reducing the time-to-market of mixed-signal ICs. In this paper, we present a test generation algorithm for implicit functional testing of linear analog circuits using transient response sampling. Each specification of the circuit under test (CUT) imposes bounds on individual parametric deviations under the single fault assumption. These bounds are mapped on to "acceptable" ranges of measurements of the transient response of the CUT at various sample points using time domain sensitivity calculations. Any circuit that "passes" the applied test is also guaranteed to meet its specifications. The simplicity of the test waveform, reduced test generation time and test time show that this testing method is a good alternative to existing testing schemes.
The STRIP rule system for efficiently maintaining derived data
Authors: Brad Adelberg, Hector Garcia-Molina, Jennifer Widom
Venue: ACM SIGMOD Record (1997)

Derived data is maintained in a database system to correlate and summarize base data which records real world facts. As base data changes, derived data needs to be recomputed. This is often implemented by writing active rules that are triggered by changes to base data. In a system with rapidly changing base data, a database with a standard rule system may consume most of its resources running rules to recompute data. This paper presents the rule system implemented as part of the STandard Real-time Information Processor (STRIP). The STRIP rule system is an extension of SQL3-type rules that allows groups of rule actions to be batched together to reduce the total recomputation load on the system. In this paper we describe the syntax and semantics of the STRIP rule system, present an example set of rules to maintain stock index and theoretical option prices in a program trading application, and report the results of experiments performed on the running system. The experiments verify that STRIP's rules allow much more efficient derived data maintenance than conventional rules without batching.
A study of large object spaces
Authors: Michael Hicks, Luke Hornof, Jonathan T. Moore, Scott M. Nettles
Venue: ACM SIGPLAN Notices (1999)

This paper examines the design space for copying garbage collectors (GCs) in which "large objects" are managed in a separate, non-copy-collected space. We focus on two main issues:1. how to set the policy for classifying objects as "large"2. how to manage the large object spaceWe explore these issues experimentally using the Oscar GC testbed. In particular, we vary the threshold size of large objects and also whether the objects may contain pointers. Furthermore, we compare the performance of treadmill collection to that of mark-and-sweep collection for managing the large object space.We find that for some heaps there is a minimum cutoff size below which adding objects to the large object space does not result in a performance improvement, while for others no such cutoff exists. In general, including pointer-containing objects in the large object space seems beneficial. Finally, the exact method used to collect the large object space does not significantly influence overall performance.
Least-Squares Finite Element Method for the Stokes Problem with Zero Residual of Mass Conservation
Authors: C. L. Chang, John J. Nelson
Venue: SIAM Journal on Numerical Analysis (1997)

In this paper the simulation of incompressible flow in two dimensions by the least-squares finite element method (LSFEM) in the vorticity-velocity-pressure version is studied. In the LSFEM, the equations for continuity of mass and momentum and a vorticity equation are minimized on a discretization of the domain of interest. A problem is these equations are minimized in a global sense. Thus this method may not enforce that div$\underline{u} = 0$ at every point of the discretization. In this paper a modified LSFEM is developed which enforces near zero residual of mass conservation, i.e., div$\underline{u}$ is nearly zero at every point of the discretization. This is accomplished by adding an extra restriction in the divergence-free equation through the Lagrange multiplier strategy. In this numerical method the inf-sup or say LBB condition is not necessary, and the matrix resulting from applying the method on a discretization is symmetric; the uniqueness of the solution and the application of the conjugate gradient method are also valid. Numerical experience is given in simulating the flow of a cylinder with diameter 1 moving in a narrow channel of width 1.5. Results obtained by the LSFEM show that mass is created or destroyed at different points in the interior of discretization. The results obtained by the modified LSFEM show the mass is nearly conserved everywhere.
The Performance of Two Phase Commit Protocols in the Presence of Site Failures
Authors: M. L. Liu, D. Agrawal, A. El Abbadi
Venue: Distributed and Parallel Databases (1998)

The two phase commit is an important protocol in distributed database systems. Much of the existing literature on the protocol is restricted to discussing and analyzing the protocol (and its variants) in the absence of failures. Very little, especially in quantitative terms, has been written about its performance in the presence of site failures. In this study, we use a simulation testbed of a distributed database system to quantify the differences in the performances of four widely known variants of the 2PC protocols (the generic 2PC, presumed commit, presumed abort, and early prepare). Our study covers both the no-failure case and the case of site failures. We present a number of interesting results based on our experiments. One is that the performance of these protocols is highly dependent on the message-processing latency at the transaction coordinator site. Another is that the presumed abort protocol does not necessarily yield better performance in the presence of site failures.
Equivalent Unconstrained Minimization and Global Error Bounds for Variational Inequality Problems
Authors: Nobuo Yamashita, Masao Fukushima
Venue: SIAM Journal on Control and Optimization (1997)

New merit functions for variational inequality problems are constructed through the Moreau--Yosida regularization of some gap functions. The proposed merit functions constitute unconstrained optimization problems equivalent to the original variational inequality problem under suitable assumptions. Conditions are studied for those merit functions to be differentiable and for any stationary point of those functions to be a solution of the original variational inequality problem. Moreover, those functions are shown to provide global error bounds for general variational inequality problems under the strong monotonicity assumption only.
Approximation Algorithms for the Feedback Vertex Set Problem with Applications to Constraint Satisfaction and Bayesian Inference
Authors: Reuven Bar-Yehuda, Dan Geiger
Venue: SIAM Journal on Computing (1998)

A feedback vertex set of an undirected graph is a subset of vertices that intersects with the vertex set of each cycle in the graph. Given an undirected graph G with n vertices and weights on its vertices, polynomial-time algorithms are provided for approximating the problem of finding a feedback vertex set of G with smallest weight. When the weights of all vertices in G are equal, the performance ratio attained by these algorithms is 4-(2/n). This improves a previous algorithm which achieved an approximation factor of $O(\sqrt{\log n})$ for this case. For general vertex weights, the performance ratio becomes $\min\{2\Delta^2, 4 \log_2 n\}$ where $\Delta$ denotes the maximum degree in G. For the special case of planar graphs this ratio is reduced to 10. An interesting special case of weighted graphs where a performance ratio of 4-(2/n) is achieved is the one where a prescribed subset of the vertices, so-called blackout vertices, is not allowed to participate in any feedback vertex set.It is shown how these algorithms can improve the search performance for constraint satisfaction problems. An application in the area of Bayesian inference of graphs with blackout vertices is also presented.
Scheduling Algorithms for Parallel Gaussian Elimination With Communication Costs
Authors: Abdel Krim Amoura, Evripidis Bampis, Jean-Claude König
Venue: IEEE Transactions on Parallel and Distributed Systems (1998)

We consider a graph theoretical model and study a parallel implementation of the well-known Gaussian elimination method on parallel distributed memory architectures, where the communication delay for the transmission of an elementary data is higher than the computation time of an elementary instruction. We propose and analyze two low-complexity algorithms for scheduling the tasks of the parallel Gaussian elimination on an unbounded number of completely connected processors. We compare these two algorithms with a higher-complexity general-purpose scheduling algorithm, the DSC heuristic, proposed by Gerasoulis and Yang.
GOLDENGATE: a fast and accurate bridging fault simulator under a hybrid logic/IDDQ testing environment
Authors: Tzuhao Chen, Ibrahim N. Hajj
Venue: Proceedings of the 1997 IEEE/ACM international conference on Computer-aided design (1997)

In this paper we describe GOLDENGATE-a bridging fault simulator for cell-based digital VLSI circuits with the following features: 1. It targets both combinational and sequential circuits. 2. It simulates general (routing, adjacency, and intra-cell) realistic bridging faults efficiently through a table-based scheme. The pre-computed table contains accurate cell output voltage and I/sub DDQ/ values obtained through electrical-level simulations. 3. It simulates both feedback and nonfeedback bridging faults (BFs) efficiently through a cycling event-driven technique. 4. It allows mixed voltage and I/sub DDQ/ simulation to support a fully hybrid test scheme where mixed logic and I/sub DDQ/ sensings are allowed. The experimental results show that GOLDENGATE is both accurate and fast.
Data-centric multi-level blocking
Authors: Induprakas Kodukula, Nawaaz Ahmed, Keshav Pingali
Venue: Proceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation (1997)

We present a simple and novel framework for generating blocked codes for high-performance machines with a memory hierarchy. Unlike traditional compiler techniques like tiling, which are based on reasoning about the control flow of programs, our techniques are based on reasoning directly about the flow of data through the memory hierarchy. Our data-centric transformations permit a more direct solution to the problem of enhancing data locality than current control-centric techniques do, and generalize easily to multiple levels of memory hierarchy. We buttress these claims with performance numbers for standard benchmarks from the problem domain of dense numerical linear algebra. The simplicity and intuitive appeal of our approach should make it attractive to compiler writers as well as to library writers.
Getting Ada into the mainstream
Authors: Chris Anderson
Venue: Proceedings of the conference on TRI-ADA '90 (1990)

To me, Ada will have achieved mainstream status when it can be written about without saying &ldquo;Ada, the DOD mandated language,&rdquo; when it is the language of choice at educational institutions, and when we stop debating whether our grandchildren will remember it. Now, how do we achieve this status? I believe there are at least two major aspects to this question. The first is making Ada even more usable to the software engineering community. Secondly and perhaps more important, is to continue to strengthen the software engineering discipline world-wide since, after all, Ada was designed to support software engineering rather than &ldquo;hacking.&rdquo; The Ada 9X Project is focusing on the first area: the fine tuning of Ada to make it more usable. This is quite challenging since the Ada users of today are quite a diverse group. However, I believe the current approach to the language revision will achieve this goal while maintaining stability in the market. The second area is even more challenging. In many regards Ada was ahead of its time. It is a language that supports software engineering principles. Unfortunately, software engineering is just emerging as an engineering discipline. There are few curricula at educational institutions, no formal certification procedures, and little upper management recognition of the importance of applying software engineering techniques by qualified practitioners to solve complex problems. Lip service&mdash;yes; true recognition and action&mdash;no. It is incumbent upon each member of the software engineering community to improve this situation. Not for Ada's sake, but for the sake of the world's future automated systems. It can be done through lectures and awareness briefings to upper level management, through the development and teaching of software engineering curricula at our universities, and via cross-training programs for engineers trained in other disciplines. We can all play an important role; we can all make a difference. The ACM Portal is published by the Association for Computing Machinery. Copyright © 2010 ACM, Inc. Terms of Usage Privacy Policy Code of Ethics Contact Us Useful downloads: Adobe Acrobat QuickTime Windows Media Player Real Player