Optimal Batcher Odd-Even Merge Networks for Non-Power-of-Two Sizes

Batcher's odd-even merge sort, introduced by Kenneth E. Batcher, is an essential sorting network in parallel computing. While it is traditionally associated with input sizes that are powers of two, efficient extensions for sizes not equal to $2^n$ have important applications. This article delves into the mechanics, design, and implications of using these networks for non-$2^n$ sizes.

Understanding Odd-Even Merge Sort

Batcher’s network employs a comparative network structure, sorting input by dividing data into smaller sublists, sorting them separately, and merging. The unique aspect of Batcher's method is its use of odd-even merging.

Basics of Odd-Even Merging

Given two sorted sequences, the odd-even merge algorithm arranges elements by comparing and swapping odd-indexed and then even-indexed pairs. This is done recursively until the entire sequence is sorted.

Challenges with Non-Power-of-Two Sizes

Sorting networks often assume that input sizes are powers of two, yielding symmetrical patterns. When input sizes do not follow this pattern, additional design considerations are necessary.

Recursive Structure Adaptation

The recursive nature of sorting networks allows adaptation by introducing padding or segmented merging:

1. Padding with Dummy Elements: Adding extra elements to round up to the next power of two, which are ignored after sorting.
2. Segmented Decomposition: Dividing inputs into segments that are powers of two (e.g., $N = 12$ split into $8$ and $4$).

Techniques for Non-$2^n$ Sizes

To efficiently handle various sizes, several techniques and practices can be applied:

• Circuit Decomposition: Break down the input size into a combination of smaller, power-of-two sizes.
• Custom Comparator Networks: Design specific comparator paths for leftover elements after decomposition.
• Recursive Merging: Repeat the odd-even merge across each segment iteratively until all are merged.

Examples and Design

Example: Consider $N=6$.

• Decompose into segments: $N_1 = 4$, $N_2 = 2$.
• Apply a sorting network to $N_1$ and $N_2$ separately.
• Use segmented odd-even merge, integrating a padding technique for $N_1$.

Advantages and Limitations

Advantages:

• Scalability: Sorting networks are inherently parallel, allowing simultaneous operations.
• Deterministic Performance: Following a fixed number of steps ensures predictable execution time.

Limitations:

• Complexity for Larger N: As inputs deviate from $2^n$, design becomes intricate.
• Resource Utilization: More comparators may be needed, increasing the computational load.

Key Points and Data

Below is a table summarizing the key points for using Batcher’s odd-even networks in non-$2^n$ scenarios:

Additional Considerations

When designing these networks:

• Consider the trade-off between design simplicity and execution efficiency.
• Optimize for the specific hardware constraints, such as the number of available comparators.
• Explore software simulations to test network configurations before hardware implementation.

Conclusion

Expanding Batcher's odd-even merge network for non-power-of-two sizes combines algorithmic finesse with practical needs. This flexibility widens the application spectrum of sorting networks across diverse computational paradigms, paving the way for innovations in parallel processing systems.