Showing papers on "Bitonic sorter published in 2004"

A Reconfigurable Recurrent Bitonic Sorting Network for Concurrently Accessible Data

Abstract: This paper presents the hardware realization of a recurrent scalable sorting network based on Batcher’s bitonic algorithm, which is very suitable for concurrently accessible data. Firstly, preserving the time complexity of the original bitonic sorter, the recurrent network yields a lower area complexity by reducing the communication within the network and minimizes the cost in terms of hardware resources. Secondly, an enhancement of the input registers allows the reuse of the same architecture for different input widths, where the role of each comparator level is redistributed over the network. Finally, the implementation of such a sorter has been realized in an FPGA (Field Programmable Gate Array) and shows how applications treating data block-wise can benefit from this architecture.

Parallel out-of-core sorting: the third way

Abstract: Sorting very large datasets is a key subroutine in almost any application that is built on top of a large database. Two ways to sort out-of-core data dominate the literature: merging-based algorithms and partitioning-based algorithms. Within these two paradigms, all the programs that sort out-of-core data on a cluster rely on assumptions about the input distribution. We propose a third way of out-of-core sorting: oblivious algorithms. In all, we have developed six programs that sort out-of-core data on a cluster. The first three programs, based completely on Leighton's columnsort algorithm, have a restriction on the maximum problem size that they can sort. The other three programs relax this restriction; two are based on our original algorithmic extensions to columnsort. We present experimental results to show that our algorithms perform well. To the best of our knowledge, the programs presented in this thesis are the first to sort out-of-core data on a cluster without making any simplifying assumptions about the distribution of the data to be sorted.

Formalising bitonic sort in type theory

Abstract: We discuss two complete formalisations of bitonic sort in constructive type theory. Bitonic sort is one of the fastest sorting algorithms where the sequence of comparisons is not data-dependent. In addition, it is a general recursive algorithm. In the formalisation we face two main problems: only structural recursion is allowed in type theory, and a formal proof of the correctness of the algorithm needs to consider quite a number of cases. In our first formalisation we define bitonic sort over dependently-typed binary trees with information in the leaves and we make use of the 0-1-principle to prove that the algorithm sorts inputs of arbitrary types. In our second formalisation we use notions from linear orders, lattice theory and monoids. The correctness proof is directly performed for any ordered set and not only for Boolean values.

Formalising Bitonic Sort using Dependent Types

Abstract: We present a complete formalisation of bitonic sort and its correctness proof in constructive type theory. Bitonic sort is one of the fastest sorting algorithms where the sequence of comparisons is not data-dependent. In addition, it is a general recursive algorithm that works on sequences of length 2^n. In the formalisation we face two main problems: only structural recursion is allowed in type theory, and a formal proof of the correctness of the algorithm needs to consider quite a number of cases. We define the bitonic sort algorithm over dependently-typed binary trees with information in the leaves. In proving that the algorithm sorts its input we make use of the 0-1-principle. To support the use of that principle we also prove a parametricity theorem derived from the type of our bitonic sort from which the 0-1-principle can be proved.

New High Efficient Sorting Algorithm by Grading to Character String Data

Abstract: In this paper, a new high efficient sorting algorithm by grading is proposed for sorting problem of character string Finally, the comparison of numerical experiments for several sorting algorithms are given ,it shows the new sorting algorithm has higher efficiency

SieveSort: yet another sorting algorithm

Abstract: Sorting is a well-known computational problem. Sorting means arranging a set of records (or a list of keys) in some (increasing or decreasing) order. In this paper, we propose a new comparison sorting algorithm SieveSort, based on the technique of divide-and-conquer, that takes time O(n/sup 2/) in the worst-case, where n is the number of records in the given list to be sorted. This sorting algorithm could be treated as a multiway Quicksort, which can be used to identify a desired key without sorting the entire sequence.