Search

This paper presents the design of a Special Function Unit for DataBase operations (SFU-DB), which is used as a backend database machine for performing sort and sort-based database operations. This machine implements a most-significant-digit-first radix sort algorithm by using a special hardware device called Automatic Retrieval Memory (ARM). The ARM performs an efficient content-to-address mapping to sort the data. Without performing any comparisons in the sorting process, the SFU-DB avoids the lower bound constraint on comparison-based sorting algorithms and achieves a complexity of O(n) for both execution time and main memory size. Based on the sorting algorithm, the SFU-DB also performs other primitive database operations such as relational join, elimination of duplicates, set union, set intersection, and set difference with a complexity of O(n). The capacity of the SFU-DB is limited by the size of its main memory rather than by the number of special processing elements as in most sorting machines. Hence, the SFU-DB has a better cost/performance and is more suitable for processing very large databases. Currently, a prototype SFU-DB system is under construction.

Two algorithms to perform sorting on parallel machines are presented. The first is a modified version of Batcher’s merge-exchange sort, but with an explicitly recursive structure involving fewer data passing operations between distant processors. The other is a version of the radix sort, which does not require the array elements to be moved between processors, but gradually computes the sequence number of each element using bit-serial counting.

This paper presents a performance study for many of today's popular parallel sorting algorithms. It is the first to present a comparative study on a large scale MIMD system. The machine, a Parsytec GCel, contains 1024 processors connected as a two-dimensional grid. To justify the experimental results, we develop a theoretical model to predict the performance in terms of communication and computation times. We get a very close relation between the experiments and the theoretical model as long as the edge congestion caused by the algorithms is predicted precisely. We compare: Bitonicsort, Shearsort, Gridsort, Samplesort, and Radixsort. Experiments were performed using random instances according to a well known benchmark problem. Results show that for the machine we used, Bitonicsort performs best for smaller numbers of keys per processor ( >

This paper considers integer sorting on a RAM. We show that adaptive sorting of a sequence with qn inversions is asymptotically equivalent to multisorting groups of at most q keys, and a total of n keys. Using the recent \(O(n\sqrt{\log\log n})\) expected time sorting of Han and Thorup on each set, we immediately get an adaptive expected sorting time of \(O(n\sqrt{\log\log q})\). Interestingly, for any positive constant e, we show that multisorting and adaptive inversion sorting can be performed in linear time if \(q\leq 2^{(\log n)^{1-\varepsilon}}\). We also show how to asymptotically improve the running time of any traditional sorting algorithm on a class of inputs much broader than those with few inversions.

Segmented sort, as a generalization of classical sort, orders a batch of independent segments in a whole array. Along with the wider adoption of manycore processors for HPC and big data applications, segmented sort plays an increasingly important role than sort. In this paper, we present an adaptive segmented sort mechanism on GPUs. Our mechanisms include two core techniques: (1) a differentiated method for different segment lengths to eliminate the irregularity caused by various workloads and thread divergence; and (2) a register-based sort method to support N-to-M data-thread binding and in-register data communication. We also implement a shared memory-based merge method to support non-uniform length chunk merge via multiple warps. Our segmented sort mechanism shows great improvements over the methods from CUB, CUSP and ModernGPU on NVIDIA K80-Kepler and TitanX-Pascal GPUs. Furthermore, we apply our mechanism on two applications, i.e., suffix array construction and sparse matrix-matrix multiplication, and obtain obvious gains over state-of-the-art implementations.

Integer sorting is a subclass of the sorting problem where the elements have integer values and the largest element is polynomially bounded in the number of elements to be sorted. It is useful for applications in which the size of the maximum value of element to be sorted is bounded. In this paper, we present a new distributed radix-sort algorithm for integer sorting. The structure of our algorithm is similar to radix sort except that it typically requires less number of communication phases. We present experimental results for our algorithm on two distributed memory multiprocessors, the Intel Paragon and the Thinking machine CM-5. These results are compared with two other well known practical parallel sorting algorithms based on radix sort and sample sort. The experimental results show that the distributed radix-sort is competitive with the other two algorithms.

When performing an external sort, an extra integer field added to the sort key can be used to count subsequences, and make the counts available at the beginning of each subsequence.