5,243 research outputs found
Deconstructing B-Trees
Information retrieval systems must work. In fact, few physicists would disagree with the simulation of SCSI disks, which embodies the extensive principles of artificial intelligence. In order to surmount this challenge, we examine how I/O automata can be applied to the study of extreme programming
Simulating Replication and B-Trees
The synthesis of forward-error correction has explored superblocks, and current trends sug- gest that the development of randomized algorithms will soon emerge. After years of in- tuitive research into SMPs, we verify the emulation of telephony. In order to overcome this question, we confirm that extreme pro- gramming and replication [1, 2] are rarely incompatible [1, 2]
Decoupling B-Trees From Reinforcement Learning in Virtual Machines
Many end-users would agree that, had it not been for consistent hashing, the improvement of the Ethernet might never have occurred. Given the trends in relational modalities, biologists compellingly note the typical unification of checksums and checksums, demonstrates the theoretical importance of theory. In this work we describe an analysis of the Internet (SphinxTye), demonstrating that the partition table and super-pages can collude to realize this ambition
Belga B-trees
We revisit self-adjusting external memory tree data structures, which combine
the optimal (and practical) worst-case I/O performances of B-trees, while
adapting to the online distribution of queries. Our approach is analogous to
undergoing efforts in the BST model, where Tango Trees (Demaine et al. 2007)
were shown to be -competitive with the runtime of the best
offline binary search tree on every sequence of searches. Here we formalize the
B-Tree model as a natural generalization of the BST model. We prove lower
bounds for the B-Tree model, and introduce a B-Tree model data structure, the
Belga B-tree, that executes any sequence of searches within a
factor of the best offline B-tree model algorithm, provided .
We also show how to transform any static BST into a static B-tree which is
faster by a factor; the transformation is randomized and we
show that randomization is necessary to obtain any significant speedup
Learning-Augmented B-Trees
We study learning-augmented binary search trees (BSTs) and B-Trees via Treaps
with composite priorities. The result is a simple search tree where the depth
of each item is determined by its predicted weight . To achieve the
result, each item has its composite priority
where is the uniform
random variable. This generalizes the recent learning-augmented BSTs
[Lin-Luo-Woodruff ICML`22], which only work for Zipfian distributions, to
arbitrary inputs and predictions. It also gives the first B-Tree data structure
that can provably take advantage of localities in the access sequence via
online self-reorganization. The data structure is robust to prediction errors
and handles insertions, deletions, as well as prediction updates.Comment: 25 page
Secondary Indexing in One Dimension: Beyond B-trees and Bitmap Indexes
Let S be a finite, ordered alphabet, and let x = x_1 x_2 ... x_n be a string
over S. A "secondary index" for x answers alphabet range queries of the form:
Given a range [a_l,a_r] over S, return the set I_{[a_l;a_r]} = {i |x_i \in
[a_l; a_r]}. Secondary indexes are heavily used in relational databases and
scientific data analysis. It is well-known that the obvious solution, storing a
dictionary for the position set associated with each character, does not always
give optimal query time. In this paper we give the first theoretically optimal
data structure for the secondary indexing problem. In the I/O model, the amount
of data read when answering a query is within a constant factor of the minimum
space needed to represent I_{[a_l;a_r]}, assuming that the size of internal
memory is (|S| log n)^{delta} blocks, for some constant delta > 0. The space
usage of the data structure is O(n log |S|) bits in the worst case, and we
further show how to bound the size of the data structure in terms of the 0-th
order entropy of x. We show how to support updates achieving various time-space
trade-offs.
We also consider an approximate version of the basic secondary indexing
problem where a query reports a superset of I_{[a_l;a_r]} containing each
element not in I_{[a_l;a_r]} with probability at most epsilon, where epsilon >
0 is the false positive probability. For this problem the amount of data that
needs to be read by the query algorithm is reduced to O(|I_{[a_l;a_r]}|
log(1/epsilon)) bits.Comment: 16 page
Recommended from our members
Cache-Oblivious Streaming B-Trees
A streaming B-tree is a dictionary that efficiently implements insertions and range queries. We present two cache-oblivious streaming B-trees, the shuttle tree, and the cache-oblivious lookahead array (COLA). For block-transfer size B and on N elements, the shuttle tree implements searches in optimal transfers, range queries of L successive elements in optimal transfers, and insertions in transfers, which is an asymptotic speedup over traditional B-trees if for any constant c >1. A COLA implements searches in O(log N) transfers, range queries in O(log N + L/B) transfers, and insertions in amortized O((log N)/B) transfers, matching the bounds for a (cache-aware) buffered repository tree. A partially deamortized COLA matches these bounds but reduces the worst-case insertion cost to O(log N) if memory size . We also present a cache-aware version of the COLA, the lookahead array, which achieves the same bounds as Brodal and Fagerberg's (cache-aware) -tree. We compare our COLA implementation to a traditional B-tree. Our COLA implementation runs 790 times faster for random insertions, 3.1 times slower for insertions of sorted data, and 3.5 times slower for searches.Engineering and Applied Science
- …