Oblivious vs. Distribution-Based Sorting: An Experimental Evaluation

Abstract

We compare two algorithms for sorting out-of-core data on a distributed-memory cluster. One algorithm, Csort, is a 3-pass oblivious algorithm. The other, Dsort, makes three passes over the data and is based on the paradigm of distribution-based algorithms. In the context of out-of-core sorting, this study is the first comparison between the paradigms of distribution-based and oblivious algorithms. Dsort avoids two of the four steps of a typical distribution-based algorithm by making simplifying assumptions about the distribution of the input keys. Csort makes no assumptions about the keys. Despite the simplifying assumptions, the I/O and communication patterns of Dsort depend heavily on the exact sequence of input keys. Csort, on the other hand, takes advantage of predetermined I/O and communication patterns, governed entirely by the input size in order to overlap computation, communication, and I/O. Experimental evidence shows that, even on inputs that followed Dsort's simplifying assumptions, Csort fared well. The running time of Dsort showed great variation across five input cases, whereas Csort sorted all of them in approximately the same amount of time. In fact, Dsort ran significantly faster than Csort in just one out of the five input cases: the one that was the most unrealistically skewed in favor of Dsort. A more robust implementation of Dsort-one without the simplifying assumptions-would run even slower.

Out-of-core distribution sort in the FG programming environment

“…When we started this project, we expected results in line with the earlier results [7], in which csort prevailed due to the advantages that we listed in Section I. Much to our surprise, dsort ran faster.…”

“…Our implementation of out-of-core columnsort mirrors the earlier treatment [7], which we summarize here. Columnsort configures its records as a tall, thin matrix, and it sorts the records into column-major order.…”

“…Using only the features present in the original release of FG, we were able to implement an out-of-core sorting algorithm, described by Chaudhry and Cormen [7] and based on Leighton's columnsort algorithm [9].…”

“…These extensions to FG arose from the design requirements of an out-of-core, distribution-based sorting algorithm for a cluster. In a prior sorting algorithm for a cluster [7], which was based on out-of-core columnsort, all interprocessor communication was balanced, and so the single-pipeline model sufficed. In contrast, the distributionbased sort has unbalanced communication, and it merges sorted runs.…”

Slabpose Columnsort: A New Oblivious Algorithm for Out-of-Core Sorting on Distributed-Memory Clusters

“…Our first cut at such an algorithm takes advantage of simplifying assumptions about the input keys that are unlikely to hold in practice. Even with these simplifying assumptions, our oblivious sorting algorithm runs faster in many cases [10]. We are in the midst of developing a more robust partitioningbased algorithm, which makes no assumptions about the keys.…”