The Half Cleaner Lemma: Constructing Efficient Interconnection Networks from Sorting Networks

Transcription

1 Parallel Processing Letters c World Scientific Publishing Company The Half Cleaner Lemma: Constructing Efficient Interconnection Networks from Sorting Networks Tripti Jain and Klaus Schneider Department of Computer Science, TU Kaiserslautern, Germany Received (received date) Revised (revised date) Communicated by (Name of Editor) ABSTRACT In general, efficient non-blocking interconnection networks can be derived from sorting networks, and to this end, one may either follow the merge-based or the radix-based sorting paradigm. Both paradigms require special modifications to handle partial permutations. In this article, we present a general lemma about half cleaner modules that were introduced as building blocks in Batcher s bitonic sorting network. This lemma is the key to prove the correctness of many known optimizations of interconnection networks. In particular, we first show how to use any ternary sorter and a half cleaner for implementing an efficient split module as required for radix-based sorting networks for partial permutations. Second, our lemma formally proves the correctness of another known optimization of the Batcher-Banyan network. Keywords: interconnection networks, sorting networks, concentrators, half cleaners 1. Introduction Non-blocking interconnection networks were initially introduced for telecommunication networks and distributed multiprocessor systems [14, 17] and are nowadays also discussed as on-chip interconnection networks [1, 4]. A network with inputs x 0,..., x n 1 and outputs y 0,..., y n 1 is thereby called non-blocking if every possible permutation π : {0,..., n 1} {0,..., n 1} can be established in the sense that all inputs x i are routed in parallel to outputs y π(i) for i {0,..., n 1}. There is a plethora of non-blocking interconnection networks that cannot be discussed here (see e.g. [1, 4, 14, 17]), so we just consider two well-known examples of non-blocking networks: Crossbars have an optimal depth of O(log(n)), but a size of O(n 2 ) that becomes unacceptable for large n. Beneš networks improve the size of their switching network to O(n log(n)) while keeping the depth in O(log(n)), but require difficult algorithms to determine their configurations [24, 27] that have a depth larger than the network itself, i.e., O(log(n) 2 ). As an alternative, non-blocking interconnection networks can also be derived from sorting networks in that the input messages x i are sorted with respect to their 1

2 2 Parallel Processing Letters MBS(n) := Merge(n) RBS(n) := Split(n) RBS(n/2) RBS(n/2) Fig. 1. Merge-based (MBS) versus radix-based sorting (RBS) paradigms: MBS merges already sorted halves with Merge modules into a sorted output sequence while RBS splits input sequences by Split modules so that the inputs are already in the right halves where they are sorted recursively. target addresses. In general, there are merge-based and radix-based sorting networks as sketched in Figure 1: In the merge-based approach, a sorting network MBS(n) for n inputs is recursively constructed by splitting the given sequence into two halves, recursively sorting these by sorting networks MBS( n 2 ), and then merging the sorted halves by a merge module Merge(n) into a single sorted output sequence. Wellknown sorting networks following this paradigm are Batcher s famous bitonic and oddeven sorters [3] and related networks [28]. The second approach follows the (binary) radix sorting paradigm: The given input sequence is first split into two parts by a Split module according to the most significant bits of the target addresses. Thus, after the Split module, the entries have already been routed to the right halves, so that the remaining problems can be dealt with recursively in the same way (ignoring now the most significant bits of the target addresses to generate local addresses). Both paradigms have already been used for the construction of sorting and interconnection networks. For n = 2 p inputs, both paradigms lead to fat binary trees of depth O(log(n)). For example, Figure 2 shows Batcher s bitonic sorting network a for n = 8 inputs where the three levels of Merge modules (bitonic sorters) where highlighted with brown color. Moreover, each Merge module consists again of a binary tree of half cleaners (pink color; see Definition 2.1), and each half cleaner consists of one column of compare-and-swap modules (blue color, the arrows show where the smaller input is moved to). To be precise, a half cleaner with 2n inputs/outputs consists of n rows of 2 2 crossbar switches where the switch in row i is connected with inputs i and i + n and also with outputs i and i + n. In general, sorting networks can be used as non-blocking interconnection networks in that the routes are simply determined by sorting the messages according to their target addresses. This works well as long as all inputs shall be connected a It has been observed in [25, 30, 31] that the Merge modules can be arranged as reverse banyan butterfly networks [19] as shown in Figure 2 with an ingoing perfect shuffle permutation.

3 Instructions for Typesetting Camera-Ready Manuscripts 3 Fig. 2. Batcher s bitonic sorting network as an example of a merge-based sorting network: Its Merge modules (bitonic sorters) are again tree structures built by half cleaners (columns of compare-and-swap modules). to some output, i.e., as long as every input has a valid target address. However, if a partial permutation shall be established, i.e., if some inputs do not have to be connected to some outputs, the merge-based sorters do not work anymore, while the radix-based sorters still work correctly b. For that reason, one has to either generate the missing addresses to complete the partial permutation or one has to use an additional Banyan network as suggested in [18, 25]. In [25], Narasimha has proven the correctness of the Batcher-Banyan network by first observing that the Ω-network [23], the merge modules of Batcher s bitonic sorting network [3], and the generalized cube network [30] are all topologically isomorphic [19, 32]. It follows that the configurations of these networks can be mapped to each other. In addition to this observation that has been used in [25] to prove the correctness of the Batcher-Banyan network, two optimizations of interconnection networks have been suggested in the same paper. In this paper, we review these optimizations, and prove their correctness (which has not been done in [25]). To that end, we found a simple and general lemma about half cleaner modules that turned out to be the key to all of these optimizations. The outline of the rest of the article is as follows: In the next section, we define half cleaner modules, list Batcher s lemma about half cleaners, and prove then our new lemma. Even though our lemma can be derived from Batcher s original lemma, we give an independent proof, and show then that it is sufficient to prove all the optimizations mentioned above: Section 3 shows an optimization for the implementation of RBS networks using half cleaners, and Section 4 shows another optimization for the implementation of Batcher-Banyan networks using our half cleaner lemma. b The Split modules must become ternary sorters in that case: The inputs are again sorted by the most significant bits of their target addresses, where we use a third value for those inputs not having a target address with the ordering 0 1 (see Lemma 2.2).

4 4 Parallel Processing Letters 2. The Half Cleaner Lemma In this section, we first define half cleaners and then prove our technical lemma that is used in the following two sections to prove the correctness of two known optimizations of interconnection networks. Sorting networks are usually constructed by compare-and-swap switches which have two inputs x 0 and x 1 that are routed to the two outputs y 0 and y 1 such that y 0 := min{x 0, x 1 } and y 1 := max{x 0, x 1 } holds. Since the ordering of the inputs does not matter, we do not label them in the figures, and use an arrow to denote the minimum output y 0. Definition 2.1 (Half Cleaner) A half cleaner with 2n inputs x 0,..., x 2n 1 of some totally ordered set and outputs y 0,..., y 2n 1 consists of n compare-and-swap switches such that switch i has inputs x i and x i+n and outputs y i and y i+n that are computed as y i := min{x i, x n+i } and y n+i := max{x i, x n+i } for i = 0,..., n 1. x7 x6 x5 x4 x3 x2 x1 x0 y7 y6 y5 y4 y3 y2 y1 y0 Fig. 3. A half cleaner module with 8 inputs and 8 outputs consisting of four 2 2 compare-andswap switches (the arrows of compare-and-swap switches point towards the minimum output). Half cleaner modules were introduced in [3] as building blocks for the Merge modules used in Batcher s bitonic sorting network (Figure 2). To prove its correctness, Batcher proved the following Lemma in [3]: Lemma 2.1 (Half Cleaner Lemma (I)) Given a bitonic c sequence x 0,..., x 2n 1 with elements x i of some totally ordered set as input to a half cleaner, the following holds for its outputs y 0,..., y 2n 1 : y i y n+j for all i, j {0,..., n 1} and both halves y 0,..., y n 1 and y n,..., y 2n 1 are bitonic sequences. c The sequence x 0,..., x 2n 1 is (strongly) bitonic if there is some k such that x 0... x k... x 2n 1 holds, and it is bitonic if it is a rotation of a strongly bitonic sequence.

5 Instructions for Typesetting Camera-Ready Manuscripts 5 Batcher used the above lemma for the recursive construction of Merge modules as shown in Figure 9 so that the MBS paradigm shown in Figure 1 yields the sorting network shown in Figure 2: Note that every Merge module itself is recursively constructed by one half cleaner module and two Merge modules of half the size. We prove a simpler lemma about the half cleaner module which will be useful for optimizations of interconnection networks that we discuss in the next two sections. Our lemma is the following one: Lemma 2.2 (Half Cleaner Lemma (II)) Given sorted lists a 0... a n 1 and b 0... b n 1 with elements a i, b i {0,, 1} with the total order 0 1 such that the following holds (i.e., both the numbers of 0s and 1s contained are n): {i {0,..., n 1} a i = 0} + {i {0,..., n 1} b i = 0} n {i {0,..., n 1} a i = 1} + {i {0,..., n 1} b i = 1} n If the input sequence a 0,..., a n 1, b 0,..., b n 1 is given as input to a half cleaner, we obviously obtain the following outputs y 0,..., y 2n 1 for i = 0,..., n 1: y i := min{a i, b i } and y n+i := max{a i, b i } It then follows that we have y i {0, } and y n+i {, 1} for i = 0,..., n 1, so that the left half y 0,..., y n 1 contains all values 0 while the right half y n,..., y 2n 1 contains all values 1 of the input lists. Exchanging input sequences a 0... a n 1 and b 0... b n 1 with each other yields the same results. Proof: We first prove that the two values a i and b i that arrive at a switch of the half cleaner can be neither both 0 nor can they be both 1: Assuming that both a i and b i would be 0, it would follow that at least all a 0,..., a i and also all b i,..., b n 1 would have to be 0 since the input lists a and b are sorted. However, these are (i + 1) + (n i) = n + 1 values, which is in contradiction to the assumption that at most n values are 0. Assuming that both a i and b i would be 1, it would follow that at least all a i,..., a n 1 and also all b 0,..., b i would have to be 1 since the input lists a and b are sorted. However, these are (n i) + (i + 1) = n + 1 values, which is in contradiction to the assumption that at most n values are 1. Hence, it is impossible that two input values a i, b i of switch i in the half cleaner would be both 0 or both 1 (but both could be ). Therefore, y i := min{a i, b i } {0, } and y n+i := max{a i, b i } {, 1} for i = 0,..., n 1 as can be seen by the table in Figure 4. We will show in the next two sections how the above lemma can be used to implement a Split module for the construction of an RBS network, and how we can prove the correctness of Narasimha s optimization of the Batcher-Banyan network.

6 6 Parallel Processing Letters a i b i y i := min{a i, b i } y n+i := max{a i, b i } Fig. 4. Possible/impossible inputs and outputs of compare-and-swap switches of the half cleaner under the assumptions given in Lemma 2.2: The first and the last input/output rows cannot occur, and therefore y i 1 and y i+n 0 holds for i = 0,..., n From Sorters to Splitters As can be seen in Figure 1, MBS and RBS sorting networks are completely determined by their Merge and Split modules, respectively. For RBS networks, the construction of Split modules can be reduced to the construction of so-called concentrators [11, 29]. A (n, m)-concentrator is thereby a circuit with n inputs and m n outputs that can route any given subset of k m valid inputs to k of its m outputs. To construct a Split module by concentrators, we make use of two (n, n 2 )- concentrators: The first one routes inputs with most significant target address bit 0 to its n 2 outputs, while the other one routes the inputs with most significant target address bit 1 to its n 2 outputs, so that combining the outputs, we obtain a Split module. This construction of Split modules by concentrators can also be used for partial permutations, where a Split module has to consider ternary inputs {0,, 1}, so that RBS networks can also be used for partial permutations. However, the construction of efficient concentrators is a very difficult problem that has been considered in many previous research papers (see [19] for further references). While theoretical results indicate that O(log(n)) depth and O(n) size concentrators exist [11, 29], the practical concentrators have a depth of O(log(n) a ) and a size of O(n log(n) b ) for small constants a, b in terms of circuit gates [9, 20 22]. It is also possible to use sorting networks for binary sequences to implement Split modules. In fact, for total permutations, any binary sorter could be used to sort the inputs by the most significant bits of their target addresses. Hence, binary sorters as described in [9, 10, 21, 22, 26] could be used for that purpose, since exactly half of the inputs have a target address with most significant bit 0 (same for 1, of course). For partial permutations, we have to replace the binary sorters by ternary sorters, since we then find target addresses with most significant bits 0,, 1 where we use as most significant bit of those inputs that have no associated target address.

7 Instructions for Typesetting Camera-Ready Manuscripts 7 The size and depth of ternary sorters obviously grows with the number of inputs n. For example, the bitonic sorting network for n inputs has depth 1 2 log(n)(log(n)+ 1) and uses n 4 log(n)(log(n) + 1) compare-swap switches, while the Batcher oddeven sorting network for n inputs has the same depth 1 2 log(n)(log(n) + 1), but uses only log(n)(log(n) 1) + n 1 compare-swap switches. n 4 Split(n) := Sort(n/2) Sort(n/2) HC(n) Fig. 5. Implementing Split modules by two ternary sorting networks and a half cleaner module. Fortunately, Narasimha observed in [25] (Section V) that one can construct Split modules with n inputs/outputs using two sorting networks with n 2 inputs/outputs and a half cleaner with n inputs/outputs as shown in Figure 5. The same construction has been implicitly used in [22], but no correctness proofs were reported so far. Definition 3.1 (Half Cleaner Optimization of Split Modules) Given two sorting networks with n inputs/outputs and a half cleaner with 2n inputs/outputs, one can construct a Split module with 2n inputs/outputs as shown in Figure 5. Clearly, we assume that the constructed Split module should work as expected so that we can use it in RBS networks even for partial permutations. Narasimha did not prove the correctness of his construction, but it can be almost immediately derived from our half cleaner lemma: Theorem 1 (Half Cleaner Optimization of Split Modules) Given an input sequence x 0,..., x 2n 1 where x i {0,, 1} and where at most n of the inputs x i are 0 and also at most n of the inputs x i are 1, then the outputs y 0,..., y 2n 1 of the Split module shown in Figure 5 will satisfy the following: y i {0, } for i = 0,..., n 1 y n+i {, 1} for i = 0,..., n 1 Hence, all x i = 0 are routed to the lower half y 0,..., y n 1 and all x i = 1 are routed to the upper half y n,..., y 2n 1. Proof: Given a ternary input sequence x 0,..., x 2n 1, we can sort its lower half x 0,..., x n 1 and its upper half x n,..., x 2n 1 separately using the sorting networks shown in Figure 5. The outputs of the lower and upper sorting networks are the sequences b 0... b n 1 and a 0... a n 1 mentioned in Lemma 2.2, respectively. Thus, the above theorem follows now directly from Lemma 2.2.

8 8 Parallel Processing Letters According to the above theorem, the output sequence y 0,..., y 2n 1 is partitioned such that the 0s are in the lower half, the 1s are in the upper half, and inputs may occur in both halves. Hence, the half cleaner and the two sorting networks implement a Split module as required for the recursive construction of a RBS network even in case of partial permutations. Sort(4) HC(4) HC(8) Sort(4) HC(4) Fig. 6. A RBS network for 8 inputs constructed by Split modules according to Figure 5. Figure 6 shows a general RBS network for 8 inputs constructed by Split modules according to Figure 5. Size and depth of these Split modules are mainly determined by the used sorting networks, and while [25] used bitonic sorters, there are better ones in terms of the size like the Batcher oddeven network: Using oddeven sorters, we obtain RBS networks of depth 1 6 log(n)(log(n)2 + 5) and exactly n 12 log(n)(log(n)2 3 log(n)+20) 2n+2 compare-swap switches, while the use of bitonic sorters would require n 12 log(n)(log(n)2 + 5) switches (having the same depth). Fig. 7. A RBS network for 8 inputs constructed by Split modules according to Figure 5 where bitonic sorters were used as sorting networks.

9 Instructions for Typesetting Camera-Ready Manuscripts 9 Figure 7 expands the sorting networks in Figure 6 by bitonic sorting networks, and Figure 8 does the same using Batcher s oddeven sorters instead. Note that the networks are simply ternary comparators. Using these sorting networks, we finally obtain RBS networks of depth O(log(n) 3 ) and size O(n log(n) 3 ). Fig. 8. A RBS network for 8 inputs constructed by Split modules according to Figure 5 where oddeven sorters were used as sorting networks. While Batcher s sorting networks are still the best practical networks that can be recursively constructed for any power of 2, it is known that sorting networks of depth O(log(n)) and size O(n log(n)) exist [2]. While the latter are practically useless due to the large constants of their asympotic complexity, they still prove that there are Split modules of the mentioned complexities. We further remark that for particular numbers n, optimal-depth and optimal-size sorting networks are known: Currently, optimal-depth networks are known up to size n = 17 and optimal-size networks are known up to size n = 10 [5 8, 12, 12, 13, 15, 16]. They can obviously be used to construct efficient Split modules with the help of half cleaners. Note that in RBS networks, we only need ternary sorters to compare the most significant bits of the target addresses with each other. Above, we reduced Batcher s sorting networks to the ternary case, but we can also use special generalizations of binary sorters. This way, one can also implement RBS networks of depth O(log(n) 3 ) and size O(n log(n) 3 ) which are even better than those obtained with Batcher s sorters, since these binary sorters exploit the fact that their inputs are binary sequences. A ternary sorter can be easily implemented by two binary sorters that consider as 0 and 1, respectively, and then taking the 1s from the first, and the 0s from the second, declaring all remaining outputs as invalid ones. In [20], we have implemented different Split modules for the binary case according to the optimization described in this section. The added value of this section is to prove its correctness also for partial permutations which is required in practice.

10 10 Parallel Processing Letters 4. Optimizing Merge-Based Interconnection Networks Using sorting networks and half cleaners to implement Split modules according to Figure 5, we finally obtain RBS networks of depth O(log(n) 3 ) and size O(n log(n) 3 ). MBS networks have only a depth of O(log(n) 2 ) and size O(n log(n) 2 ) in terms of compare-and-swap switches. However, their comparators have to compare the full target addresses in each compare-and-swap switch. Since a network for n inputs has addresses with log(n) bits that can be compared with circuits of size O(log(n)) and depth O(log(log(n))) (in terms of circuit gates), these MBS networks yield interconnection networks of depth O(log(n) 2 log(log(n))) and size O(n log(n) 3 ) (in terms of circuit gates). Hence, we obtain the same circuit size, but a better depth. For this reason, MBS networks are also of interest, even though they alone cannot route partial permutations. To generalize them to partial permutations, a further Banyan network must be added to construct a Batcher-Banyan network [18, 25]. In [25], an optimization of the Batcher-Banyan has been suggested whose correctness can be again easily proved by our Lemma 2.2 as we will see in this section. Merge(n) := HC(n) Fig. 9. Recursive construction of Merge networks by means of half cleaner modules due to [3]. These Merge networks are actually bitonic sorters, i.e., able to sort all bitonic sequences [3]. According to Batcher [3], bitonic merge modules can be constructed by half cleaners as shown in Figure 9. Their correctness can be proved by induction using Lemma 2.1: If a given sequence is bitonic, then the half cleaner will generate two sequences according to Lemma 2.1 which are both bitonic and where all elements of one of the two sequences are less than or equal to all elements in the other sequence. For this reason, all elements are already in the right halves, and since the sequences are also bitonic, one can recursively sort them using bitonic sorters as shown in Figure 9 where in this case Merge modules are bitonic sorters. MBS(n) Merge(n) HC(n) := := Fig. 10. Expanding the construction of MBS networks by Figure 9.

11 Instructions for Typesetting Camera-Ready Manuscripts 11 For this reason, the recursive definition of the MBS network expands as shown in Figure 10 to Batcher s bitonic sorting network. Batcher s bitonic sorting network can sort all input sequences, and can therefore be used as a non-blocking interconnection network for total permutations. However, it cannot directly be used to route partial permutations which usually occur in practice. To that end, [18] extended the sorting network by an additional Banyan network which is then called the Batcher-Banyan network. The Batcher-Banyan network consists of a MBS sorting network like Batcher s bitonic sorting network, and a further Banyan network. As discussed in [25], the Banyan network can be any permutation network that must be able to route at least all bitonic sequences. In particular, we might directly use a Merge module as shown in Figure 9. Therefore, an instance of the Batcher-Banyan network can be implemented by instantiating the MBS sorting network on the left hand side of Figure 11 by Batcher s bitonic sorting network, and by instantiating the Banyan network (drawn as Merge module in Figure 11) using Batcher s bitonic sorter, i.e., the Merge modules given in Figure 9. If we expand both modules, we then obtain the structure shown on the right hand side of Figure 11 that can be improved as follows according to [25]: MBS(n) Merge(n) := HC(n) 1 : : 0 HC(n) sorting routing sorting routing Fig. 11. Optimization of the Batcher-Banyan network due to Narasimha [25] where Batcher s bitonic sorting network is used as MBS sorting network and Batcher s bitonic sorter is used as Banyan network. Theorem 2 (Half Cleaner Optimization of Batcher-Banyan Networks) The second half cleaner module of the Batcher-Banyan network shown in Figure 11 can be removed without changing the behavior of the network. Proof: Consider an input sequence x 0,..., x 2n 1 where each input x i consists of a message and a potential target address (in case there is no target address, we use again the symbol as target address). The MBS sorting networks shown on the right hand side in Figure 11 first sort the halves x 0,..., x n 1 and x n,..., x 2n 1 independently using the ordering 0... n 1 n... 2n 1. For this reason, the most significant bits of the outputs of the MBS sorting networks are of the form a 0... a n 1 and b 0... b n 1, respectively, with elements a i, b i {0,, 1} using the total order 0 1. By Lemma 2.2, it then follows that the first half cleaner routes the values already in their right

12 12 Parallel Processing Letters halves, however, not yet as sorted sequences. This is the important observation to understand that the second half cleaner is not required since the inputs are already in the right halves after the first half cleaner. By Lemma 2.1, the sequences after the first half cleaner are bitonic so that the two Merge modules in the next column will sort them with respect to the ordering 0... n 1 n... 2n 1. The combined output sequence of both Merge modules is therefore a sorted sequence and since the input sequence was a partial permutation, it follows that the sequences of most significant bits of these lower and upper halves are of the form 0 and 1, respectively (note that the number of inputs with most significant bits 0 and 1 can be at most half of the number of inputs). Now, consider the routing part where the switches are no longer configured by comparing the full target addresses of their inputs using the ordering. Instead, each one of the log(n) columns of switches in that part only considers one address bit of the target addresses as if it would be a RBS network, and to that end, the ordering 0 1 is used. By our half cleaner lemma, i.e., Lemma 2.2, it therefore follows that the values still remain in the halves where they came from. Since its inputs are already sorted sequences with respect to and since this is consistent with the ordering 0 1 of their most significant bits (but not of other bits), we can safely remove the second half cleaner. 5. Conclusions This paper proves a lemma about half cleaner modules that can also be derived from Batcher s original lemma about the half cleaner. However, our lemma focuses directly on ternary input sequences, i.e., sequences with elements taken from the set {0,, 1}. The proof of the lemma can therefore be done in a simpler way, and the lemma itself can be directly applied to interconnection networks for partial permutations that are constructed by means of half cleaners. In particular, this is the case for the construction of Split modules for interconnection networks based on radix-sorting: Using our lemma, we can construct a Split module for n inputs/outputs using two ternary sorters of size n 2 and a half cleaner with n inputs/outputs. Our lemma can be used to prove the correctness of RBS networks if these ternary Split modules are used. Second, our lemma has been applied to prove the correctness of an optimization of the Batcher-Banyan network [18] as suggested by Narasimha [25]. Even though Narasimha proved the correctness of the Batcher-Banyan network in [25], he did not prove the correctness of his optimization. Our lemma simplifies the correctness proof of his optimization and makes it more comprehensive.

13 REFERENCES 13 References [1] A. Agarwal, C. Iskander, and R. Shankar. Survey of network on chip (NoC) architectures and contributions. Journal of Engineering, Computing and Architecture, 3(1), [2] M. Ajtai, J. Komlos, and E. Szemeredi. An O(n log(n)) sorting network. In Symposium on Theory of Computing (STOC), pages 1 9. ACM, [3] K. Batcher. Sorting networks and their applications. In AFIPS Spring Joint Computer Conference, volume 32, pages , [4] T. Bjerregaard and S. Mahadevan. A survey of research and practices of network-on-chip. ACM Computing Surveys (CSUR), 38(1):1 51, March [5] D. Bundala, M. Codish, L. Cruz-Filipe, P. Schneider-Kamp, and J. Závodný. Optimal-depth sorting networks. arxiv Report arxiv: , Cornell University Library, [6] D. Bundala, M. Codish, L. Cruz-Filipe, P. Schneider-Kamp, and J. Závodný. Optimal-depth sorting networks. Journal of Computer and System Sciences, 84: , [7] D. Bundala and J. Zavodny. Optimal sorting networks. In A.-H. Dediu, C. Martin-Vide, J.-L. Sierra-Rodríguez, and B. Truthe, editors, Language and Automata Theory and Applications (LATA), volume 8370 of LNCS, pages , Madrid, Spain, Springer. [8] D. Bundala and J. Závodný. Optimal sorting networks. arxiv Report arxiv: , Cornell University Library, [9] W.-J. Cheng and W.-T. Chen. A new self-routing permutation network. IEEE Transactions on Computers, 45(5): , May [10] M. Chien and A. Oruç. High performance concentrators and superconcentrators using multiplexing schemes. IEEE Transactions on Communications, 42(11): , November [11] F. Chung. On concentrators, superconcentrators, generalizers, and nonblocking networks. The Bell Systems Technical Journal, 58(8): , October [12] M. Codish, L. Cruz-Filipe, T. Ehlers, M. Müller, and P. Schneider-Kamp. Sorting networks: to the end and back again. arxiv Report arxiv: v1, Cornell University Library, July [13] M. Codish, L. Cruz-Filipe, M. Frank, and P. Schneider-Kamp. Twenty-five comparators is optimal when sorting nine inputs (and twenty-nine for ten). arxiv.org Report arxiv: v3, Cornell University Library, [14] W. Dally and B. Towles. Principles and Practices of Interconnection Networks. Morgan Kaufmann, [15] T. Ehlers and M. Müller. Faster sorting networks for 17, 19 and 20 inputs. arxiv Report arxiv: , Cornell University Library, October [16] T. Ehlers and M. Müller. New bounds on optimal sorting networks. arxiv Report arxiv: v1, Cornell University Library, January 2015.

14 14 REFERENCES [17] T. Feng. A survey of interconnection networks. IEEE Computer, 14(12):12 27, December [18] A. Huang and S. Knauer. Starlite: A wideband digital switch. In Global Telecommunications Conference (GLOBECOM), pages , [19] T. Jain and K. Schneider. Verifying the concentration property of permutation networks by BDDs. In E. Leonard and K. Schneider, editors, Formal Methods and Models for Codesign (MEMOCODE), pages 43 53, Kanpur, India, IEEE Computer Society. [20] T. Jain, K. Schneider, and A. Jain. Deriving concentrators from binary sorters using half cleaners. In Reconfigurable Computing and FPGAs (ReConFig), Cancun, Mexico, IEEE Computer Society. [21] T. Jain, K. Schneider, and A. Jain. An efficient self-routing and non-blocking interconnection network on chip. In Network on Chip Architectures (NoCArc), pages 4:1 4:6, Boston, MA, USA, ACM. [22] D. Koppelman and A. Oruç. A self-routing permutation network. Journal of Parallel and Distributed Computing, 10(2): , [23] D. Lawrie. Access and alignment of data in an array processor. IEEE Transactions on Computers (T-C), 24: , [24] C.-Y. Lee and A. Oruç. A fast parallel algorithm for routing unicast assignments in Beneš networks. IEEE Transactions on Parallel and Distributed Systems, 6(3): , March [25] M. Narasimha. The Batcher-Banyan self-routing network: universality and simplification. IEEE Transactions on Communications, 36(10): , October [26] M. Narasimha. A recursive concentrator structure with applications to selfrouting switching networks. IEEE Transactions on Communications, 42(2-4): , February/March/April [27] D. Nassimi and S. Sahni. Parallel algorithms to set up the Beneš permutation network. IEEE Transactions on Computers (T-C), 31(2): , February [28] I. Parberry. The pairwise sorting network. Parallel Processing Letters (PPL), 2(2-3): , [29] M. Pinsker. On the complexity of a concentrator. In International Teletraffic Conference (ITC), pages 318:1 318:4, Stockholm, Sweden, [30] H. Siegel and S. Smith. Study of multistage SIMD interconnection networks. In International Symposium on Computer Architecture (ISCA), pages ACM, [31] H. Stone. Parallel processing with the perfect shuffle. IEEE Transactions on Computers (T-C), 20: , [32] C. Wu and T. Feng. On a class of multistage interconnection networks. IEEE Transactions on Computers (T-C), 29(8): , August 1980.