Results 11  20
of
115
On Labeling Schemes for the Semantic Web
, 2003
"... This paper focuses on the optimization of the navigation through voluminous subsumption hierarchies of topics employed by Portal Catalogs like Netscape Open Directory (ODP). We advocate for the use of labeling schemes for modeling these hierarchies in order to efficiently answer queries such as subs ..."
Abstract

Cited by 38 (6 self)
 Add to MetaCart
This paper focuses on the optimization of the navigation through voluminous subsumption hierarchies of topics employed by Portal Catalogs like Netscape Open Directory (ODP). We advocate for the use of labeling schemes for modeling these hierarchies in order to efficiently answer queries such as subsumption check, descendants, ancestors or nearest common ancestor, which usually require costly transitive closure computations. We rst give a qualitative comparison of three main families of schemes, namely bit vector, prefix and interval based schemes. We then show that two labeling schemes are good candidates for an efficient implementation of label querying using standard relational DBMS, namely, the Dewey Prefix scheme [6] and an Interval scheme by Agrawal, Borgida and Jagadish [1]. We compare their storage and query evaluation performance for the 16 ODP hierarchies using the PostgreSQL engine.
A Survey of Adaptive Optimization in Virtual Machines
 PROCEEDINGS OF THE IEEE, 93(2), 2005. SPECIAL ISSUE ON PROGRAM GENERATION, OPTIMIZATION, AND ADAPTATION
, 2004
"... Virtual machines face significant performance challenges beyond those confronted by traditional static optimizers. First, portable program representations and dynamic language features, such as dynamic class loading, force the deferral of most optimizations until runtime, inducing runtime optimiza ..."
Abstract

Cited by 35 (5 self)
 Add to MetaCart
Virtual machines face significant performance challenges beyond those confronted by traditional static optimizers. First, portable program representations and dynamic language features, such as dynamic class loading, force the deferral of most optimizations until runtime, inducing runtime optimization overhead. Second, modular
Efficient Implementation of Java Interfaces: Invokeinterface Considered Harmless
 In Proc. 2001 ACM SIGPLAN Conference on ObjectOriented Programming Systems, Languages and Applications
, 2001
"... Single superclass inheritance enables simple and ecient tabledriven virtual method dispatch. However, virtual method table dispatch does not handle multiple inheritance and interfaces. This complication has led to a widespread misimpression that interface method dispatch is inherently inecient. Thi ..."
Abstract

Cited by 34 (1 self)
 Add to MetaCart
Single superclass inheritance enables simple and ecient tabledriven virtual method dispatch. However, virtual method table dispatch does not handle multiple inheritance and interfaces. This complication has led to a widespread misimpression that interface method dispatch is inherently inecient. This paper argues that with proper implementation techniques, Java interfaces need not be a source of significant performance degradation. We present an efficient interface method dispatch mechanism, associating a fixedsized interface method table (IMT) with each class that implements an interface. Interface method signatures hash to an IMT slot, with any hashing collisions handled by customgenerated conflict resolution stubs. The dispatch mechanism is efficient in both time and space. Furthermore, with static analysis and online profile data, an optimizing compiler can inline the dominant target(s) of any frequently executed interface call. Microbenchmark results demonstrate that the expected cost of an interface method call dispatched via an IMT is comparable to the cost of a virtual method call. Experimental evaluation of a number of interface dispatch mechanisms on a suite of larger applications demonstrates that, even for applications that make only moderate use of interface methods, the choice of interface dispatching mechanism can significantly impact overall performance. Fortunately, several mechanisms provide good performance at a modest space cost.
An experimental analysis of selfadjusting computation
 In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI
, 2006
"... Selfadjusting computation uses a combination of dynamic dependence graphs and memoization to efficiently update the output of a program as the input changes incrementally or dynamically over time. Related work showed various theoretical results, indicating that the approach can be effective for a r ..."
Abstract

Cited by 34 (18 self)
 Add to MetaCart
Selfadjusting computation uses a combination of dynamic dependence graphs and memoization to efficiently update the output of a program as the input changes incrementally or dynamically over time. Related work showed various theoretical results, indicating that the approach can be effective for a reasonably broad range of applications. In this article, we describe algorithms and implementation techniques to realize selfadjusting computation and present an experimental evaluation of the proposed approach on a variety of applications, ranging from simple list primitives to more sophisticated computational geometry algorithms. The results of the experiments show that the approach is effective in practice, often offering orders of magnitude speedup from recomputing the output from scratch. We believe this is the first experimental evidence that incremental computation of any type is effective in practice for a reasonably broad set of applications.
Scanning and traversing: maintaining data for traversals in a memory hierarchy
 In Proceedings of the 10th Annual European Symposium on Algorithms
, 2002
"... Abstract. We study the problem of maintaining a dynamic ordered set subject to insertions, deletions, and traversals of k consecutive elements. This problem is trivially solved on a RAM and on a simple twolevel memory hierarchy. We explore this traversal problem on more realistic memory models: the ..."
Abstract

Cited by 31 (11 self)
 Add to MetaCart
Abstract. We study the problem of maintaining a dynamic ordered set subject to insertions, deletions, and traversals of k consecutive elements. This problem is trivially solved on a RAM and on a simple twolevel memory hierarchy. We explore this traversal problem on more realistic memory models: the cacheoblivious model, which applies to unknown and multilevel memory hierarchies, and sequentialaccess models, where sequential block transfers are less expensive than random block transfers. 1
Integrating pointer variables into oneway constraint models
 ACM Trans. Comput. Hum. Interaction
, 1994
"... Pointer variables have long been considered useful for constructing and manipulating data structures in traditional programming languages. This article discusses how pointer variables can be integrated into oneway constraint models and indicates how these constraints can be usefully employed in use ..."
Abstract

Cited by 30 (4 self)
 Add to MetaCart
Pointer variables have long been considered useful for constructing and manipulating data structures in traditional programming languages. This article discusses how pointer variables can be integrated into oneway constraint models and indicates how these constraints can be usefully employed in user interfaces. Pointer variables allow constraints to model a wide array of dynamic application behavior, simplify the implementation of structured objects and demonstrational systems, and improve the storage and effkiency of constraintbased applications. This article presents two incremental algorithms—one lazy and one eager—for solving constraints with pointer variables. Both algorithms arecapable ofhandling (l)arbitrary systems ofoneway constraints, including constraints that involve cycles, and(2) editing models that allow multiple changes between calls to the constraint solver. These algorithms are fault tolerant in that they can handle and recover gracefully from formulas that crash due to programmer error. Constraints that use pointer variables have been implemented in a comprehensive user interface toolkit, Garnet, and our experience with applications written in Garnet have proven the usefulness of pointer variable constraints. Many largescale applications have been implemented
Imperative selfadjusting computation
 In POPL ’08: Proceedings of the 35th annual ACM SIGPLANSIGACT symposium on Principles of programming languages
, 2008
"... Recent work on selfadjusting computation showed how to systematically write programs that respond efficiently to incremental changes in their inputs. The idea is to represent changeable data using modifiable references, i.e., a special data structure that keeps track of dependencies between read an ..."
Abstract

Cited by 28 (16 self)
 Add to MetaCart
Recent work on selfadjusting computation showed how to systematically write programs that respond efficiently to incremental changes in their inputs. The idea is to represent changeable data using modifiable references, i.e., a special data structure that keeps track of dependencies between read and writeoperations, and to let computations construct traces that later, after changes have occurred, can drive a change propagation algorithm. The approach has been shown to be effective for a variety of algorithmic problems, including some for which adhoc solutions had previously remained elusive. All previous work on selfadjusting computation, however, relied on a purely functional programming model. In this paper, we show that it is possible to remove this limitation and support modifiable references that can be written multiple times. We formalize this using a language AIL for which we define evaluation and changepropagation semantics. AIL closely resembles a traditional higherorder imperative programming language. For AIL we state and prove consistency, i.e., the property that although the semantics is inherently nondeterministic, different evaluation paths will still give observationally equivalent results. In the imperative setting where pointer graphs in the store can form cycles, our previous proof techniques do not apply. Instead, we make use of a novel form of a stepindexed logical relation that handles modifiable references. We show that AIL can be realized efficiently by describing implementation strategies whose overhead is provably constanttime per primitive. When the number of reads and writes per modifiable is bounded by a constant, we can show that change propagation becomes as efficient as it was in the pure case. The general case incurs a slowdown that is logarithmic in the maximum number of such operations. We use DFS and related algorithms on graphs as our running examples and prove that they respond to insertions and deletions of edges efficiently. 1.
ThreeDimensional Orthogonal Graph Drawing
, 2000
"... vi Declaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . vii Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . viii List of Figures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix List of Tables . . . . . . . . . . . . ..."
Abstract

Cited by 27 (10 self)
 Add to MetaCart
vi Declaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . vii Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . viii List of Figures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix List of Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xiii List of Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xiv I Orthogonal Graph Drawing 1 1
AreaEfficient Static and Incremental Graph Drawings
, 1997
"... In this paper, we present algorithms to produce orthogonal drawings of arbitrary graphs. As opposed to most known algorithms, we do not restrict ourselves to graphs with maximum degree 4. The best previous result gave an (m \Gamma 1) \Theta ( m 2 + 1)grid for graphs with n nodes and m edges. We p ..."
Abstract

Cited by 26 (6 self)
 Add to MetaCart
In this paper, we present algorithms to produce orthogonal drawings of arbitrary graphs. As opposed to most known algorithms, we do not restrict ourselves to graphs with maximum degree 4. The best previous result gave an (m \Gamma 1) \Theta ( m 2 + 1)grid for graphs with n nodes and m edges. We present algorithms for two scenarios. In the static scenario, the graph is given completely in advance. We produce a drawing on a grid of size at most m+n 2 \Theta m+n 2 , or on a larger grid where the aspect ratio of the nodes is bounded. Furthermore, we give upper and lower bounds for drawings of the complete graph Kn in the underlying model. In the incremental scenario, the graph is given one node at a time, and the placement of previous nodes can not be changed for later nodes. We then come close to the bounds achieved in the static case and get at most an ( m 2 + n) \Theta ( 2 3 m+ n)grid. In both algorithms, every edge gets at most one bend, thus, the total number of bends ...
CacheOblivious String Btrees
 IN: PROC. OF PRINCIPLES OF DATABASE SYSTEMS
, 2006
"... Btrees are the data structure of choice for maintaining searchable data on disk. However, Btrees perform suboptimally • when keys are long or of variable length, • when keys are compressed, even when using front compression, the standard Btree compression scheme, • for range queries, and • with r ..."
Abstract

Cited by 26 (5 self)
 Add to MetaCart
Btrees are the data structure of choice for maintaining searchable data on disk. However, Btrees perform suboptimally • when keys are long or of variable length, • when keys are compressed, even when using front compression, the standard Btree compression scheme, • for range queries, and • with respect to memory effects such as disk prefetching. This paper presents a cacheoblivious string Btree (COSBtree) data structure that is efficient in all these ways: • The COSBtree searches asymptotically optimally and inserts and deletes nearly optimally. • It maintains an index whose size is proportional to the frontcompressed size of the dictionary. Furthermore, unlike standard frontcompressed strings, keys can be decompressed in a memoryefficient manner. • It performs range queries with no extra disk seeks; in contrast, Btrees incur disk seeks when skipping from leaf block to leaf block. • It utilizes all levels of a memory hierarchy efficiently and makes good use of disk locality by using cacheoblivious layout strategies.