12 research outputs found
Fast Parallel Operations on Search Trees
Using (a,b)-trees as an example, we show how to perform a parallel split with
logarithmic latency and parallel join, bulk updates, intersection, union (or
merge), and (symmetric) set difference with logarithmic latency and with
information theoretically optimal work. We present both asymptotically optimal
solutions and simplified versions that perform well in practice - they are
several times faster than previous implementations
Efficient abstractions for visualization and interaction
Abstractions, such as functions and methods, are an essential tool for any programmer. Abstractions encapsulate the details of a computation: the programmer only needs to know what the abstraction achieves, not how it achieves it. However, using abstractions can come at a cost: the resulting program may be inefficient. This can lead to programmers not using some abstractions, instead writing the entire functionality from the ground up. In this thesis, we present several results that make this situation less likely when programming interactive visualizations. We present results that make abstractions more efficient in the areas of graphics, layout and events
The Log-Interleave Bound: Towards the Unification of Sorting and the BST Model
We study the connections between sorting and the binary search tree model,
with an aim towards showing that the fields are connected more deeply than is
currently known. The main vehicle of our study is the log-interleave bound, a
measure of the information-theoretic complexity of a permutation . When
viewed through the lens of adaptive sorting -- the study of lists which are
nearly sorted according to some measure of disorder -- the log-interleave bound
is comparable to the most powerful known measure of disorder. Many of these
measures of disorder are themselves virtually identical to well-known upper
bounds in the BST model, such as the working set bound or the dynamic finger
bound, suggesting a connection between BSTs and sorting. We present three
results about the log-interleave bound which solidify the aforementioned
connections. The first is a proof that the log-interleave bound is always
within a multiplicative factor of a known lower bound in the BST
model, meaning that an online BST algorithm matching the log-interleave bound
would perform within the same bounds as the state-of-the-art -competitive BST. The second result is an offline algorithm in the BST model
which uses accesses to search for any permutation .
The technique used to design this algorithm also serves as a general way to
show whether a sorting algorithm can be transformed into an offline BST
algorithm. The final result is a mergesort algorithm which performs work within
the log-interleave bound of a permutation . This mergesort also happens to
be highly parallel, adding to a line of work in parallel BST operations
Multiversion Concurrency with Bounded Delay and Precise Garbage Collection
In this paper we are interested in bounding the number of instructions taken
to process transactions. The main result is a multiversion transactional system
that supports constant delay (extra instructions beyond running in isolation)
for all read-only transactions, delay equal to the number of processes for
writing transactions that are not concurrent with other writers, and
lock-freedom for concurrent writers. The system supports precise garbage
collection in that versions are identified for collection as soon as the last
transaction releases them. As far as we know these are first results that bound
delays for multiple readers and even a single writer. The approach is
particularly useful in situations where read-transactions dominate write
transactions, or where write transactions come in as streams or batches and can
be processed by a single writer (possibly in parallel).
The approach is based on using functional data structures to support multiple
versions, and an efficient solution to the Version Maintenance (VM) problem for
acquiring, updating and releasing versions. Our solution to the VM problem is
precise, safe and wait-free (PSWF).
We experimentally validate our approach by applying it to balanced tree data
structures for maintaining ordered maps. We test the transactional system using
multiple algorithms for the VM problem, including our PSWF VM algorithm, and
implementations with weaker guarantees based on epochs, hazard pointers, and
read-copy-update. To evaluate the functional data structure for concurrency and
multi-versioning, we implement batched updates for functional tree structures
and compare the performance with state-of-the-art concurrent data structures
for balanced trees. The experiments indicate our approach works well in
practice over a broad set of criteria
Recommended from our members
Proceedings of the Workshop on Algorithmic Aspects of Advanced Programming Languages: WAAAPL'99: Paris, France, September 30, 1999
The first Workshop on Algorithmic Aspects of Advanced Programming Languages was held on September 30, 1999, in Paris, France, in conjunction with the PLI'99 conferences and workshops. The choice of programming languages has a huge effect on the algorithms and data structures that are to be implemented in that language. Traditionally, algorithms and data structures have been studied in the context of imperative languages. This workshop considers the algorithmic implications of choosing an advanced functional or logic programming language instead. A total of eight papers were selected for presentation at the workshop, together with an invited lecture by Robert Harper. We would like to thank Dider Remv, general chair of PLI'99, for his assistance in organizing this workshop
RUN, Xtatic, RUN: EFFICIENT IMPLEMENTATION OF AN OBJECT-ORIENTED LANGUAGE WITH REGULAR PATTERN MATCHING
Schema languages such as DTD, XML Schema, and Relax NG have been steadily growing in importance in the XML community. A schema language provides a mechanism for defining the type of XML documents; i.e., the set of constraints that specify the structure of XML documents that are acceptable as data for a certain programming task. A number of recent language designsâmany of them descended from the XDuce language of Hosoya, Pierce, and Vouillonâhave showed how such schemas can be used statically for type-checking XML processing code and dynamically for evaluation of XML structures. The technical foundation of such languages is the notion of regular types, a mild generalization of nondeterministic top-down tree automata, which correspond to a core of most popular schema notations, and the no-tion of regular patternsâregular types decorated with variable bindersâa powerful and convenient primitive for dynamic inspection of XML values. This dissertation is concerned with one of XDuceâs descendants, Xtatic. The goal of the Xtatic project is to bring the regular type and regular pattern technologies to a wide audience by integrating them with a mainstream object-oriented language. My research focuses on an efficient implementation of Xtatic including a compiler that generates fast and compact target program
Tracing the Compositional Process. Sound art that rewrites its own past: formation, praxis and a computer framework
The domain of this thesis is electroacoustic computer-based music and sound art. It investigates
a facet of composition which is often neglected or ill-defined: the process of composing itself
and its embedding in time. Previous research mostly focused on instrumental composition or,
when electronic music was included, the computer was treated as a tool which would eventually
be subtracted from the equation. The aim was either to explain a resultant piece of music by
reconstructing the intention of the composer, or to explain human creativity by building a model
of the mind.
Our aim instead is to understand composition as an irreducible unfolding of material traces which
takes place in its own temporality. This understanding is formalised as a software framework
that traces creation time as a version graph of transactions. The instantiation and manipulation
of any musical structure implemented within this framework is thereby automatically stored
in a database. Not only can it be queried ex post by an external researcherâproviding a new
quality for the empirical analysis of the activity of composingâbut it is an integral part of
the composition environment. Therefore it can recursively become a source for the ongoing
composition and introduce new ways of aesthetic expression. The framework aims to unify
creation and performance time, fixed and generative composition, human and algorithmic
âwritingâ, a writing that includes indeterminate elements which condense as concurrent vertices
in the version graph.
The second major contribution is a critical epistemological discourse on the question of ob-
servability and the function of observation. Our goal is to explore a new direction of artistic
research which is characterised by a mixed methodology of theoretical writing, technological
development and artistic practice. The form of the thesis is an exercise in becoming process-like
itself, wherein the epistemic thing is generated by translating the gaps between these three levels.
This is my idea of the new aesthetics: That through the operation of a re-entry one may establish
a sort of process âformâ, yielding works which go beyond a categorical either âsound-in-itselfâ
or âconceptualismâ.
Exemplary processes are revealed by deconstructing a series of existing pieces, as well as
through the successful application of the new framework in the creation of new pieces
Purely Functional Representations of Catenable Sorted Lists.
The power of purely functional programming in the construction of data structures has received much attention, not only because functional languages have many desirable properties, but because structures built purely functionally are automatically fully persistent: any and all versions of a structure can coexist indefinitely. Recent results illustrate the surprising power of pure functionality. One such result was the development of a representation of double-ended queues with catenation that supports all operations, including catenation, in worst-case constant time [19]