US 20030088600 A1 Abstract Improved transposition of a matrix in a computer system may be accomplished while utilizing at most a single permutation vector. This greatly improves the speed and parallelability of the transpose operation. For a standard rectangular matrix having M rows and N columns and a size M×N, first n and q are determined, wherein N=n*q, and wherein M×q represents a block size and wherein N is evenly divisible by p. Then, the matrix is partitioned into n columns of size M×q. Then for each column n, elements are sequentially read within the column row-wise and sequentially written into a cache, then sequentially read from the cache and sequentially written row-wise back into the matrix in a memory in a column of size q×M. A permutation vector may then be applied to the matrix to arrive at the transpose. This method may be modified for special cases, such as square matrices, to further improve efficiency.
Claims(39) 1. A method for transposing a matrix of numbers using a computer system, said computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and N columns and a size M×N, the method including:
determining n and q, wherein N=n*q, and wherein M×q represents a block size and wherein N is evenly divisible by q;
partitioning said matrix into n columns of size M×q;
for each column n:
sequentially reading elements within said column n row-wise and sequentially writing said elements into the cache; and
sequentially reading elements from the cache and sequentially writing them row-wise back into the matrix in the memory in a column of size q×M; and
applying a permutation vector to said matrix.
2. The method of 3. The method of 4. The method of 5. The method of 6. The method of 7. A method for transposing a square matrix of numbers using a computer system, said computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and M columns and a size M×M, the method including:
determining m and p, wherein M=m*p, and wherein M×p represents a block size and wherein M is evenly divisible by p;
setting a partitioning position at the upper-left corner element of the matrix, said partitioning position having a horizontal position and a vertical position;
for each column of size p:
sequentially reading elements row-wise from said partitioning position for p rows, without reading any elements to the left of said horizontal position of said partitioning position, and sequentially writing said elements into the cache;
sequentially reading elements column-wise from said partitioning position for p columns, without reading any elements above said vertical position of said partitioning position, and sequentially writing said elements row-wise from said partitioning position for p rows, without writing any elements to the left of said horizontal position of said partitioning position;
sequentially reading elements from the cache and sequentially writing them row-wise back into the matrix column-wise for p columns, without writing any elements above said vertical position of said partitioning position; and
moving said partitioning position p elements down and p elements to the right.
8. The method of 9. A method for transposing a matrix of numbers using a computer system, said computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and k*M columns and a size M×kM, the method including:
partitioning said matrix into k square matrices of size M×M;
determining m and p, wherein M=m*p, and wherein M×p represents a block size and wherein M is evenly divisible by p;
for each of said k square matrices:
setting a partitioning position at the upper-left corner element of the matrix, said partitioning position having a horizontal position and a vertical position;
for each column of size m:
sequentially reading elements row-wise from said partitioning position for p rows, without reading any elements to the left of said horizontal position of said partitioning position, and sequentially writing said elements into the cache;
sequentially reading elements column-wise from said partitioning position for p columns, without reading any elements above said vertical position of said partitioning position, and sequentially writing said elements row-wise from said partitioning position for p rows, without writing any elements to the left of said horizontal position of said partitioning position;
sequentially reading elements from the cache and sequentially writing them row-wise back into the matrix column-wise for p columns, without writing any elements above said vertical position of said partitioning position; and
moving said partitioning position p elements down and p elements to the right;
converting the matrix into an M×k matrix of vectors of length M; and
applying a permutation vector to said converted matrix.
10. The method of 11. The method of 12. The method of 13. The method of 14. The method of 15. A method for transposing a matrix of numbers using a computer system, said computer system having a processor, a memory, and a cache, the matrix stored in the memory and having k*N rows and N columns and a size kN×N, the method including:
treating the matrix as a k×n matrix of vectors of length N;
applying a permutation vector to said k×n matrix of vectors of length N, achieving a result matrix;
treating said result matrix of said applying as an N×kN matrix;
partitioning said N×kN matrix into k contiguous square matrices;
partitioning said matrix into k square matrices of size M×M, wherein M=N;
determining m and p, wherein M=m*p, and wherein M×p represents a block size and wherein M is evenly divisible by p;
for each of said k contiguous square matrices:
setting a partitioning position at the upper-left corner element of the matrix, said partitioning position having a horizontal position and a vertical position;
for each column of size m:
sequentially reading elements row-wise from said partitioning position for p rows, without reading any elements to the left of said horizontal position of said partitioning position, and sequentially writing said elements into the cache;
sequentially reading elements column-wise from said partitioning position for p columns, without reading any elements above said vertical position of said partitioning position, and sequentially writing said elements row-wise from said partitioning position for p rows, without writing any elements to the left of said horizontal position of said partitioning position;
sequentially reading elements from the cache and sequentially writing them row-wise back into the matrix column-wise for p columns, without writing any elements above said vertical position of said partitioning position; and
moving said partitioning position p elements down and p elements to the right.
16. The method of 17. A method for transposing a matrix of numbers using a computer system, said computer system having a processor, a memory, and a cache, the matrix stored in the memory and having k*m rows and k*n columns and a size km×kn, the method including:
partitioning the matrix into a k×k square matrix of blocks of size m×n;
for each of said k×k blocks:
sequentially reading elements within said blocks row-wise and sequentially writing said elements into the cache;
sequentially reading elements from the cache and sequentially writing them row-wise back into the matrix in the memory in a block of size n×m; and
swapping all of said k×k blocks about the main diagonal.
18. A computer system for transposing a matrix of numbers, the matrix having M rows and N columns and a size M×N, the system including:
a processor;
a memory coupled to the processor, the matrix stored in the memory;
a cache coupled to the processor;
a block size determiner coupled to the processor, the memory, and the cache;
a matrix partitioner coupled to the processor and to the memory;
a sequential reader/writer coupled to the cache and to the processor; and
a permutation vector applier coupled to the processor and to the memory.
19. A computer system for transposing a matrix of numbers, the matrix having M rows and M columns and a size M×M, the system including:
a processor;
a memory coupled to the processor;
a cache coupled to the processor;
a block size determiner coupled to the processor, the memory, and the cache;
a partitioning position setter coupled to the memory;
a sequential reader/writer coupled to the cache and the processor; and
a partitioning position mover coupled to the sequential reader/writer and to the cache.
20. A computer system for transposing a matrix of numbers, the matrix having M rows and k*M columns and a size M×kM, the system including:
a processor;
a memory coupled to the processor;
a cache coupled to the processor;
a matrix partitioner coupled to the processor and to the memory;
a block size determiner coupled to the processor, the memory, and the cache;
a partitioning position setter coupled to the memory;
a sequential reader/writer coupled to the cache and the processor; and
a partitioning position mover coupled to the sequential reader/writer.
21. A computer system for transposing a matrix of numbers, the matrix having k*N rows and N columns and a size kN×N, the system including:
a processor;
a memory coupled to the processor;
a cache coupled to the processor;
a matrix treater coupled to the memory;
a permutation vector applier coupled to the processor;
a result matrix treater coupled to the memory;
a matrix partitioner coupled to the memory;
a block size determiner coupled to the processor, the memory, and the cache;
a partition position setter coupled to the memory;
a sequential reader/writer coupled to the cache and to the processor; and
a partition position mover coupled to the sequential reader/writer and to the cache.
22. A computer system for transposing a matrix of numbers, the matrix having M rows and M columns and a size M×M, the system including:
a processor;
a memory coupled to the processor;
a cache coupled to the processor;
a matrix partitioner coupled to the processor;
a sequential reader/writer coupled to the cache and to the processor; and
a block swapper coupled to the memory.
23. An apparatus for transposing a matrix of numbers using a computer system, said computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and N columns and a size M×N, the apparatus including:
means for determining n and q, wherein N=n*q, and wherein M×q represents a block size and wherein N is evenly divisible by q;
means for partitioning said matrix into n columns of size M×q;
for each column n:
means for sequentially reading elements within said column n row-wise and sequentially writing said elements into the cache; and
means for sequentially reading elements from the cache and sequentially writing them row-wise back into the matrix in the memory in a column of size q×M; and
means for applying a permutation vector to said matrix.
24. The apparatus of 25. The apparatus of 26. The apparatus of 27. The apparatus of 28. The apparatus of 29. An apparatus for transposing a square matrix of numbers using a computer system, said computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and M columns and a size M×M, the apparatus including:
means for determining m and p, wherein M=m*p, and wherein M×p represents a block size and wherein M is evenly divisible by p;
means for setting a partitioning position at the upper-left corner element of the matrix, said partitioning position having a horizontal position and a vertical position;
for each column of size p:
means for sequentially reading elements row-wise from said partitioning position for p rows, without reading any elements to the left of said horizontal position of said partitioning position, and sequentially writing said elements into the cache;
means for sequentially reading elements column-wise from said partitioning position for p columns, without reading any elements above said vertical position of said partitioning position, and sequentially writing said elements row-wise from said partitioning position for p rows, without writing any elements to the left of said horizontal position of said partitioning position;
means for sequentially reading elements from the cache and sequentially writing them row-wise back into the matrix column-wise for p columns, without writing any elements above said vertical position of said partitioning position; and
means for moving said partitioning position p elements down and p elements to the right.
30. The apparatus of 31. An apparatus for transposing a matrix of numbers using a computer system, said computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and k*M columns and a size M×kM, the apparatus including:
means for partitioning said matrix into k square matrices of size M×M;
means for determining m and p, wherein M=m*p, and wherein M×p represents a block size and wherein M is evenly divisible by p;
for each of said k square matrices:
means for setting a partitioning position at the upper-left corner element of the matrix, said partitioning position having a horizontal position and a vertical position;
for each column of size m:
means for sequentially reading elements row-wise from said partitioning position for p rows, without reading any elements to the left of said horizontal position of said partitioning position, and sequentially writing said elements into the cache;
means for sequentially reading elements column-wise from said partitioning position for p columns, without reading any elements above said vertical position of said partitioning position, and sequentially writing said elements row-wise from said partitioning position for p rows, without writing any elements to the left of said horizontal position of said partitioning position;
means for sequentially reading elements from the cache and sequentially writing them row-wise back into the matrix column-wise for p columns, without writing any elements above said vertical position of said partitioning position; and
means for moving said partitioning position p elements down and p elements to the right;
means for converting the matrix into an M×k matrix of vectors of length M; and
means for applying a permutation vector to said converted matrix.
32. The apparatus of 33. The apparatus of 34. The apparatus of 35. The apparatus of 36. The method of 37. An apparatus for transposing a matrix of numbers using a computer system, said computer system having a processor, a memory, and a cache, the matrix stored in the memory and having k*N rows and N columns and a size kN×N, the apparatus including:
means for treating the matrix as a k×n matrix of vectors of length N;
means for applying a permutation vector to said k×n matrix of vectors of length N, achieving a result matrix;
means for treating said result matrix of said applying as an N×kN matrix;
means for partitioning said N×kN matrix into k contiguous square matrices;
means for partitioning said matrix into k square matrices of size M×M, wherein M=N;
means for determining m and p, wherein M=m*p, and wherein M×p represents a block size and wherein M is evenly divisible by p;
for each of said k contiguous square matrices:
means for setting a partitioning position at the upper-left corner element of the matrix, said partitioning position having a horizontal position and a vertical position;
for each column of size m:
means for sequentially reading elements row-wise from said partitioning position for p rows, without reading any elements to the left of said horizontal position of said partitioning position, and sequentially writing said elements into the cache;
means for sequentially reading elements column-wise from said partitioning position for p columns, without reading any elements above said vertical position of said partitioning position, and sequentially writing said elements row-wise from said partitioning position for p rows, without writing any elements to the left of said horizontal position of said partitioning position;
means for sequentially reading elements from the cache and sequentially writing them row-wise back into the matrix column-wise for p columns, without writing any elements above said vertical position of said partitioning position; and
means for moving said partitioning position p elements down and p elements to the right.
38. The apparatus of 39. A apparatus for transposing a matrix of numbers using a computer system, said computer system having a processor, a memory, and a cache, the matrix stored in the memory and having k*m rows and k*n columns and a size km×kn, the apparatus including:
means for partitioning the matrix into a k×k square matrix of blocks of size m×n;
for each of said k×k blocks:
means for sequentially reading elements within said blocks row-wise and sequentially writing said elements into the cache;
means for sequentially reading elements from the cache and sequentially writing them row-wise back into the matrix in the memory in a block of size n×m; and
means for swapping all of said k×k blocks about the main diagonal.
Description [0001] This application claims the benefit of provisional patent application Serial No. ______, filed Aug. 13, 2001 in the name of inventors Shandong Lao, Brad R. Lewis, and Michael Boucher and entitled “Matrix Transposition”, Attorney Docket No. SUN-P5618PSP. [0002] The present invention relates to the field of computer science. More particularly, the present invention relates to a software program for transposing a matrix in a computer system. [0003] Matrices are utilized in many different computing processes. There are a number of different operations that may be applied to a matrix. One of the most important operations is the transpose operation. In the transpose operation, the rows and columns of an input matrix are reversed. In formal terms, if A is any matrix whose (i,j)-entry is a [0004] For example:
[0005] The transpose operation is used frequently in remote-sensing data processing, seismic data processing, signal processing, and image processing, as well as for data rearrangement for more efficient computation in other transformations and applications such as Fast Fourier Transform (FFT). If the application requires large data matrices, in-place transpose must be used as there is often not enough memory to hold both a large matrix and its transpose. [0006] The transpose operation may be performed out-of-place and in-place in computers. In out-of-place transpose, the input and output matrices reside in two distinct memory locations. The input matrix is not changed and the result of the operation is placed in the output matrix. The output matrix has at least the size of the input matrix. This can be done by simply copying every element in input matrix to its reversed position in output matrix. The processing is trivial but inefficient. In-place transpose is much more complicated. In in-place transpose, the input and output matrices occupy the same memory location. A workspace, normally much smaller than the input matrix, may be required to be used as a cache to improve performance. While out-of-place transpose is faster than in-place transpose, it required more available memory. Thus, the determination of whether to use out-of-place or in-place transpose in a particular system is largely dependent upon which is more valuable in that system, time or space. [0007] The in-place transpose operation for a square matrix, a matrix in which the number of rows equals the number of columns, may be accomplished by swapping the elements about the main diagonal. It should be pointed out that is a very inefficient approach. For a rectangular matrix, a method known as cyclic permutation may be utilized to do the in-place transpose. [0008] Consider a 3×4 matrix:
[0009] and its transpose:
[0010] When stored in computer memory, the elements reside sequentially as: [0011] A [0012] and [0013] A [0014] where m indicates the memory layout of the matrix. The value of each element also serves as the index of the element in the computer memory. [0015] If one compares A [0016] (3←9←5←4←1←3←) [0017] and [0018] (8←2←6←7←10←8←) [0019] where the arrows indicate the direction of the element movement in order to achieve the transformation. These permutation cycles are independent from each other. The first and last elements are not moved. The permutation cycles may be kept in a vector called the permutation vector. The permutation vector for the example above would be: [0020] (3 9 5 4 1 0 8 2 6 7 10 0 0) [0021] where a single 0 represents the termination of the permutation cycle and a double 0 indicates the termination of the permutation vector. This implementation, however, requires the checking of both the cycle terminator and the vector terminator for every element to be moved when the permutation is actually performed. [0022] Representing the permutations as matrices is helpful in understanding the processing, even though at the computer level the matrices are represented as vectors.
[0023] where underlined elements are those moved during the permutations. The notation V [0024] However, applying a permutation vector in the computing realm is not a trivial matter. Simply applying a permutation vector on a large matrix is very expensive. A much better method, a four-step method, can be used. This method is best described using the following example. [0025] Consider a 6×4 matrix:
[0026] This matrix can be partitioned into a 3×2 matrix of submatrices of size 2×2
[0027] In step [0028] Then each of the two submatrices is transposed by permutation using the termination vector (the terminators are omitted in this example to improve readability): [0029] V [0030] to get:
[0031] In step [0032] Permutations using the permutation vector: [0033] V [0034] may then performed on each of the submatrices to get:
[0035] A [0036] V [0037] may then be performed on the matrix to get:
[0038] In step [0039] Each of the three submatrices is transposed by permutation using the permutation vector: [0040] V [0041] to finish the transpose processing:
[0042] In this four step method, at least two permutation vectors have to be computed and four times of permutation processing using these two permutation vectors have to be perform on the matrix. A special case also exists where a simplified transposed method may be applied if the matrix is a square matrix. A square matrix A [0043] then simply:
[0044] The transpose is accomplished by transposing each A [0045] Computing the permutation vector is a task accomplished via serial processing, and may take a significant amount of time depending on the size and shape of the matrix and the block size used to partition the matrix. As parallel computing grows in popularity, this delay becomes even more significant. The time spent in computing the permutation vectors may be longer than that spent on moving the elements. Thus, reducing the number of permutation vectors required to perform the transpose would make the operation much more efficient. [0046] What is needed is a solution which reduces the number of permutation vectors required to perform a transpose of a matrix to allow for better parallel processing of transpose operations. [0047] Improved transposition of a matrix in a computer system may be accomplished while utilizing at most a single permutation vector. This greatly improves the speed and parallelability of the transpose operation. For a standard rectangular matrix having M rows and N columns and a size M×N, first n and q are determined, wherein N=n*q, and wherein M×q represents a block size and wherein N is evenly divisible by q. Then, the matrix is partitioned into n columns of size M×q. Then for each column n, elements are sequentially read within the column row-wise and sequentially written into a cache, then sequentially read from the cache and sequentially written row-wise back into the matrix in a memory in a column of size q×M. A permutation vector may then be applied to the matrix to arrive at the transpose. This method may be modified for special cases, such as square matrices, to further improve efficiency. [0048] The accompanying drawings, which are incorporated into and constitute a part of this specification, illustrate one or more embodiments of the present invention and, together with the detailed description, serve to explain the principles and implementations of the invention. [0049] In the drawings: [0050]FIG. 1 is a flow diagram illustrating a method for transposing a matrix of numbers using a computer system, the computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and N columns and a size M×N in accordance with a specific embodiment of the present invention. [0051]FIG. 2 is a block diagram illustrating a computer system for transposing a matrix of numbers, the matrix having M rows and N columns and a size M×N in accordance with a specific embodiment of the present invention. [0052]FIG. 3 is a flow diagram illustrating a method for transposing a square matrix of numbers using a computer system, the computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and M columns and a size M×M in accordance with a specific embodiment of the present invention. [0053]FIG. 4 is a block diagram illustrating a computer system for transposing a square matrix of numbers, the matrix having M rows and M columns and a size M×M in accordance with a specific embodiment of the present invention. [0054]FIG. 5 is a flow diagram illustrating a method for transposing a matrix of numbers using a computer system, the computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and k*M columns and a size M×kM in accordance with a specific embodiment of the present invention. [0055]FIG. 6 is a block diagram illustrating a computer system for transposing a matrix of numbers, the matrix having M rows and k*M columns and a size M×kM in accordance with a specific embodiment of the present invention. [0056]FIG. 7 is a flow diagram illustrating a method for transposing a matrix of numbers using a computer system, the computer system having a processor, a memory, and a cache, the matrix stored in the memory and having k*N rows and N columns and a size kN×N in accordance with a specific embodiment of the present invention. [0057]FIG. 8 is a block diagram illustrating a computer system for transposing a matrix of numbers, the matrix having k*N rows and N columns and a size kN×N in accordance with a specific embodiment of the present invention. [0058]FIG. 9 is a flow diagram illustrating a method for transposing a matrix of numbers using a computer system, the computer system having a processor, a memory, and a cache, the matrix stored in the memory and having k*m rows and k*n columns and a size km×kn in accordance with a specific embodiment of the present invention. [0059]FIG. 10 is a block diagram illustrating a computer system for transposing a matrix of numbers, the matrix having k*m rows and k*n columns and a size km×kn in accordance with a specific embodiment of the present invention. [0060] Embodiments of the present invention are described herein in the context of a system of computers, servers, and software. Those of ordinary skill in the art will realize that the following detailed description of the present invention is illustrative only and is not intended to be in any way limiting. Other embodiments of the present invention will readily suggest themselves to such skilled persons having the benefit of this disclosure. Reference will now be made in detail to implementations of the present invention as illustrated in the accompanying drawings. The same reference indicators will be used throughout the drawings and the following detailed description to refer to the same or like parts. [0061] In the interest of clarity, not all of the routine features of the implementations described herein are shown and described. It will, of course, be appreciated that in the development of any such actual implementation, numerous implementation-specific decisions must be made in order to achieve the developer's specific goals, such as compliance with application- and business-related constraints, and that these specific goals will vary from one implementation to another and from one developer to another. Moreover, it will be appreciated that such a development effort might be complex and time-consuming, but would nevertheless be a routine undertaking of engineering for those of ordinary skill in the art having the benefit of this disclosure. [0062] In accordance with the present invention, the components, process steps, and/or data structures may be implemented using various types of operating systems, computing platforms, computer programs, and/or general purpose machines. In addition, those of ordinary skill in the art will recognize that devices of a less general purpose nature, such as hardwired devices, field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), or the like, may also be used without departing from the scope and spirit of the inventive concepts disclosed herein. [0063] The present invention permits a transpose operation to be performed while computing at most a single permutation vector. This allows for much faster processing during the transpose operation, and permits parallel computing to be accomplished much more efficiently. [0064] The permutation in the prior art uses terminators included in the permutation vector to separate permutation cycles and stop the permutation processing. This implementation incurs a performance cost because it must check both the cycle terminator and the vector terminator for each element to be moved. The prior art also makes parallelizing the permutations inefficient and/or difficult. [0065] In a specific embodiment of the present invention, an index vector is utilized to indicate the beginning and end of each permutation cycle. Using the example outlined in the background, the index vector and permutation vector are: [0066] I [0067] V [0068] The numbers in the index vector are index pointers to the beginning of the permutation cycles. The ends of the permutation cycles may also be calculated from the indexes. The last element of the index vector is only used to determine the end of the last cycle. In a specific embodiment of the present invention, the permutation vector generator may be modified to generate both the index vector and the permutation vector without any performance penalty. This implementation greatly improves the permutation processing and makes it easier to parallelize the permutations. [0069] Saving the generated permutation vector for reuse will also improve performance, as often the transpose operation is repeatedly called for the same matrix and/or its transpose. In accordance with a specific embodiment of the present invention, a linked list data structure may be utilized to keep the used permutation vectors. A newly generated permutation vector is added to the list at the most recent node. Whenever a new permutation vector is needed, the total space utilized by the linked list may be checked before the permutation vector is generated. If it exceeds a maximum size amount, the least recent node may be removed from the list (unless it is identical to the newly generated permutation vector). The checking and deletion may be repeated until enough space is released for the new vector. [0070] The same permutation vector may be utilized in the transpose operation of both an M×N matrix and an N×M matrix by carrying out the permutation in the opposite direction for each cycle. Therefore, when a permutation is required to transpose an M×N matrix, a search is performed through the linked list for not only the vector generated for the M×N matrix but also for the N×M matrix. [0071] An optimal block size is the largest block size that keeps cache misses at a minimum. Therefore, the guide for partitioning a matrix is to use large contiguous blocks but make them small enough to fit in the cache. Blocks selected under this guide will take maximum advantage of the cache. In a specific embodiment of the present invention, the block size chosen will be the largest block size that fits into the cache. Thus, an M×N matrix may be partitioned into n blocks (columns) of size M×q instead of m*n blocks of size p×q, where M=m*p and N=n*q. For example:
[0072] For the same block size, this column block implementation incurs fewer cache misses. Partition along a single dimension is also easier and less restrictive than along two dimensions. This partition implementation also allows a two-step process for in-place transpose. Additionally, a more efficient out-of-place transpose may be based from this partition implementation. [0073] Combining the two-step in-place transpose with dataflow techniques allows significant improvement in parallelability, and thus significant improvement in load balancing and scalability, as well as a reduction in the number of data moves. Additionally, the reduction in steps from four to two allows only one permutation vector to be required. [0074] In a specific embodiment of the present invention, dataflow techniques may be implemented using a dataflow application program interface (API), which may aid in the manipulation of data dependencies. The parallelism may be well controlled using this tool. A problem may be divided into pieces of tasks and the tasks placed in priority queues. Thus, in a specific embodiment of the present invention, the two steps are partitioned into many tasks and placed into priority queues. The first step's tasks have higher priority than the second. The permutation vector search and computation may be given the highest priority. This allows the parallel transpose to run with excellent load balancing and scalability. [0075] For efficient out-of-place transposing of a matrix A [0076] The two-step transpose may be accomplished as follows. In step [0077] In step [0078] The permutation vector used is V [0079]FIG. 1 is a flow diagram illustrating a method for transposing a matrix of numbers using a computer system, the computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and N columns and a size M×N in accordance with a specific embodiment of the present invention. At [0080] Once this is done for each of the columns, at [0081] The first partition (band) is then copied into workspace W:
[0082] Then the first column is transposed into its mirror position about the main diagonal. The operation is equivalent to a copy of a column to a band in out-of-place transpose discussed above. Its result is:
[0083] where the underlined elements are those changed. Then the elements stored in the workspace are copied back to get:
[0084] This is exactly the copy transpose in the first step in general in-place transpose discussed above. [0085] This process is repeated for the second column to get:
[0086] The left block is copied to the workspace:
[0087] then copied back in transpose to get the final result:
[0088]FIG. 3 is a flow diagram illustrating a method for transposing a square matrix of numbers using a computer system, the computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and M columns and a size M×M in accordance with a specific embodiment of the present invention. At [0089] Then, for each column of size p, [0090]FIG. 4 is a block diagram illustrating a computer system for transposing a square matrix of numbers, the matrix having M rows and M columns and a size M×M in accordance with a specific embodiment of the present invention. A processor [0091] Then, for each column of size p, elements [0092] If a rectangular matrix can be divided into square matrices in a way that the elements in each square matrix are stored in memory contiguously, the efficient square matrix transpose can be used to improve performance of the rectangular transpose. This may not get rid of permutation. However, it will reduce the number of permutation nodes significantly by increasing the length of the vectors to be moved. [0093] A matrix with M rows and k*M columns, A [0094] where the permutation vector used in step [0095] V [0096]FIG. 5 is a flow diagram illustrating a method for transposing a matrix of numbers using a computer system, the computer system having a processor, a memory, and a cache, the matrix stored in the memory and having M rows and k*M columns and a size M×kM in accordance with a specific embodiment of the present invention. At [0097] Then, for each of the k square matrices, [0098] At [0099]FIG. 6 is a block diagram illustrating a computer system for transposing a matrix of numbers, the matrix having M rows and k*M columns and a size M×kM in accordance with a specific embodiment of the present invention. A processor [0100] Then, for each of the k square matrices, elements [0101] A matrix converter [0102] Though a kN×N rectangular matrix cannot be divided into contiguous square matrices, it can still take the benefit of square transpose and long length vector permutation transpose by swapping the two steps executed on the M×kM matrix above. [0103] A matrix with kN rows and N columns, A [0104] where the permutation vector used in step [0105] V [0106]FIG. 7 is a flow diagram illustrating a method for transposing a matrix of numbers using a computer system, the computer system having a processor, a memory, and a cache, the matrix stored in the memory and having k*N rows and N columns and a size kN×N in accordance with a specific embodiment of the present invention. At [0107] At [0108] Then, for each of the k square matrices, [0109]FIG. 8 is a block diagram illustrating a computer system for transposing a matrix of numbers, the matrix having k*N rows and N columns and a size kn×N in accordance with a specific embodiment of the present invention. A processor [0110] A result matrix treater [0111] Then, for each of the k square matrices, elements [0112] If a rectangular matrix A [0113] In step [0114] In step [0115] For step [0116] then copied back from W to A in the same spot in a transpose manner (the two blocks are transposed respectively):
[0117] Repeat the copy transpose to the second column:
[0118] For step [0119]FIG. 9 is a flow diagram illustrating a method for transposing a matrix of numbers using a computer system, the computer system having a processor, a memory, and a cache, the matrix stored in the memory and having k*m rows and k*n columns and a size km×kn in accordance with a specific embodiment of the present invention. At [0120]FIG. 10 is a block diagram illustrating a computer system for transposing a matrix of numbers, the matrix having k*m rows and k*n columns and a size km×kn in accordance with a specific embodiment of the present invention. A processor [0121] While embodiments and applications of this invention have been shown and described, it would be apparent to those skilled in the art having the benefit of this disclosure that many more modifications than mentioned above are possible without departing from the inventive concepts herein. The invention, therefore, is not to be restricted except in the spirit of the appended claims. Referenced by
Classifications
Legal Events
Rotate |