Results 1  10
of
42
Selfadjusting binary search trees
, 1985
"... The splay tree, a selfadjusting form of binary search tree, is developed and analyzed. The binary search tree is a data structure for representing tables and lists so that accessing, inserting, and deleting items is easy. On an nnode splay tree, all the standard search tree operations have an am ..."
Abstract

Cited by 428 (16 self)
 Add to MetaCart
The splay tree, a selfadjusting form of binary search tree, is developed and analyzed. The binary search tree is a data structure for representing tables and lists so that accessing, inserting, and deleting items is easy. On an nnode splay tree, all the standard search tree operations have an amortized time bound of O(log n) per operation, where by “amortized time ” is meant the time per operation averaged over a worstcase sequence of operations. Thus splay trees are as efficient as balanced trees when total running time is the measure of interest. In addition, for sufficiently long access sequences, splay trees are as efficient, to within a constant factor, as static optimum search trees. The efftciency of splay trees comes not from an explicit structural constraint, as with balanced trees, but from applying a simple restructuring heuristic, called splaying, whenever the tree is accessed. Extensions of splaying give simplified forms of two other data structures: lexicographic or multidimensional search trees and link/ cut trees.
A Methodology for Implementing Highly Concurrent Data Objects
, 1993
"... A concurrent object is a data structure shared by concurrent processes. Conventional techniques for implementing concurrent objects typically rely on critical sections: ensuring that only one process at a time can operate on the object. Nevertheless, critical sections are poorly suited for asynchro ..."
Abstract

Cited by 350 (11 self)
 Add to MetaCart
(Show Context)
A concurrent object is a data structure shared by concurrent processes. Conventional techniques for implementing concurrent objects typically rely on critical sections: ensuring that only one process at a time can operate on the object. Nevertheless, critical sections are poorly suited for asynchronous systems: if one process is halted or delayed in a critical section, other, nonfaulty processes will be unable to progress. By contrast, a concurrent object implementation is lock free if it always guarantees that some process will complete an operation in a finite number of steps, and it is wait free if it guarantees that each process will complete an operation in a finite number of steps. This paper proposes a new methodology for constructing lockfree and waitfree implementations of concurrent objects. The object’s representation and operations are written as stylized sequential programs, with no explicit synchronization. Each sequential operation is automatically transformed into a lockfree or waitfree operation using novel synchronization and memory management algorithms. These algorithms are presented for a multiple instruction/multiple data (MIMD) architecture in which n processes communicate by applying atomic read, wrzte, load_linked, and store_conditional operations to a shared memory.
A Data Structure for Dynamic Trees
, 1983
"... A data structure is proposed to maintain a collection of vertexdisjoint trees under a sequence of two kinds of operations: a link operation that combines two trees into one by adding an edge, and a cut operation that divides one tree into two by deleting an edge. Each operation requires O(log n) ti ..."
Abstract

Cited by 345 (19 self)
 Add to MetaCart
A data structure is proposed to maintain a collection of vertexdisjoint trees under a sequence of two kinds of operations: a link operation that combines two trees into one by adding an edge, and a cut operation that divides one tree into two by deleting an edge. Each operation requires O(log n) time. Using this data structure, new fast algorithms are obtained for the following problems: (1) Computing nearest common ancestors. (2) Solving various network flow problems including finding maximum flows, blocking flows, and acyclic flows. (3) Computing certain kinds of constrained minimum spanning trees. (4) Implementing the network simplex algorithm for minimumcost flows. The most significant application is (2); an O(mn log n)time algorithm is obtained to find a maximum flow in a network of n vertices and m edges, beating by a factor of log n the fastest algorithm previously known for sparse graphs.
A Locally Adaptive Data Compression Scheme
, 1986
"... A data compression scheme that exploits locality of reference, such as occurs when words are used frequently over short intervals and then fall into long periods of disuse, is described. The scheme is based on a simple heuristic for selforganizing sequential search and on variablelength encoding ..."
Abstract

Cited by 169 (2 self)
 Add to MetaCart
A data compression scheme that exploits locality of reference, such as occurs when words are used frequently over short intervals and then fall into long periods of disuse, is described. The scheme is based on a simple heuristic for selforganizing sequential search and on variablelength encodings of integers. We prove that it never performs much worse than Huffman coding and can perform substantially better; experiments on real files show that its performance is usually quite close to that of Huffman coding. Our scheme has many implementation advantages: it is simple, allows fast encoding and decoding, and requires only one pass over the data to be compressed (static Huffman coding takes two passes).
Simulation of networks of spiking neurons: A review of tools and strategies
 Journal of Computational Neuroscience
, 2007
"... We review different aspects of the simulation of spiking neural networks. We start by reviewing the different types of simulation strategies and algorithms that are currently implemented. We next review the precision of those simulation strategies, in particular in cases where plasticity depends on ..."
Abstract

Cited by 100 (29 self)
 Add to MetaCart
We review different aspects of the simulation of spiking neural networks. We start by reviewing the different types of simulation strategies and algorithms that are currently implemented. We next review the precision of those simulation strategies, in particular in cases where plasticity depends on the exact timing of the spikes. We overview different simulators and simulation environments presently available (restricted to those freely available, open source and documented). For each simulation tool, its advantages and pitfalls are reviewed, with an aim to allow the reader to identify which simulator is appropriate for a given task. Finally, we provide a series of benchmark simulations of different types of networks of spiking neurons, including HodgkinHuxley type, integrateandfire models, interacting with currentbased or conductancebased synapses, using clockdriven or eventdriven integration strategies. The same set of models are implemented on the different simulators, and the codes are made available. The ultimate goal of this review is to provide a resource to facilitate identifying the appropriate integration strategy and simulation tool to use for a given
New upper bounds for pairing heaps
 In Scandinavian Workshop on Algorithm Theory (LNCS 1851
, 2000
"... Pairing heaps are shown to have constant amortized time Insert and Meld, thus showing that pairing heaps have the same amortized runtimes as Fibonacci heaps for all operations but Decreasekey. 1 ..."
Abstract

Cited by 26 (9 self)
 Add to MetaCart
(Show Context)
Pairing heaps are shown to have constant amortized time Insert and Meld, thus showing that pairing heaps have the same amortized runtimes as Fibonacci heaps for all operations but Decreasekey. 1
An Empirical Analysis of Algorithms for Constructing a Minimum Spanning Tree
 DIMACS Series in Discrete Mathematics and Theoretical Computer Science
, 1991
"... We compare algorithms for the construction of a minimum spanning tree through largescale experimentation on randomly generated graphs of different structures and different densities. In order to extrapolate with confidence, we use graphs with up to 130,000 nodes (sparse) or 750,000 edges (dense). A ..."
Abstract

Cited by 26 (1 self)
 Add to MetaCart
(Show Context)
We compare algorithms for the construction of a minimum spanning tree through largescale experimentation on randomly generated graphs of different structures and different densities. In order to extrapolate with confidence, we use graphs with up to 130,000 nodes (sparse) or 750,000 edges (dense). Algorithms included in our experiments are Prim's algorithm (implemented with a variety of priority queues), Kruskal's algorithm (using presorting or demand sorting), Cheriton and Tarjan's algorithm, and Fredman and Tarjan 's algorithm. We also ran a large variety of tests to investigate lowlevel implementation decisions for the data structures, as well as to enable us to eliminate the effect of compilers and architectures. Within the range of sizes used, Prim's algorithm, using pairing heaps or sometimes binary heaps, is clearly preferable. While versions of Prim's algorithm using efficient implementations of Fibonacci heaps or rankrelaxed heaps often approach and (on the densest graphs) so...
A LockFree Approach to Object Sharing in RealTime Systems
, 1997
"... This work aims to establish the viability of lockfree object sharing in uniprocessor realtime systems. Naive usage of conventional lockbased objectsharing schemes in realtime systems leads to unbounded priority inversion. A priority inversion occurs when a task is blocked by a lowerpriority ta ..."
Abstract

Cited by 17 (0 self)
 Add to MetaCart
This work aims to establish the viability of lockfree object sharing in uniprocessor realtime systems. Naive usage of conventional lockbased objectsharing schemes in realtime systems leads to unbounded priority inversion. A priority inversion occurs when a task is blocked by a lowerpriority task that is inside a critical section. Mechanisms that bound priority inversion usually entail kernel overhead that is sometimes excessive. We propose that lockfree objects offer an attractive alternative to lockbased schemes because they eliminate priority inversion and its associated problems. On the surface, lockfree objects may seem to be unsuitable for hard realtime systems because accesses to such objects are not guaranteed to complete in bounded time. Nonetheless, we present scheduling conditions that demonstrate the applicability of lockfree objects in hard realtime systems. Our scheduling conditions are applicable to schemes such as ratemonotonic scheduling and earliestdeadline...
Fishspear: A Priority Queue Algorithm (Extended Abstract)
"... The Fishspear priority queue algorithm is presented and analyzed. Fishspear makes fewer than 80 % as many comparisons as heaps in the worst case, and its relative performance is even better in many common situations. The code itself embodies an unusual recursive structure which permits highly dynami ..."
Abstract

Cited by 15 (1 self)
 Add to MetaCart
The Fishspear priority queue algorithm is presented and analyzed. Fishspear makes fewer than 80 % as many comparisons as heaps in the worst case, and its relative performance is even better in many common situations. The code itself embodies an unusual recursive structure which permits highly dynamic and datadependent execution. Fishspear also differs from heaps in that it can be implemented efficiently using sequential storage such as stacks or tapes, making it possibly attractive for implementation of very large queues on paged memory systems. (Details of the implementation are deferred to the full paper.)