A Parallel Framework with Block Matrices of a Discrete Fourier Transform for Vector-Valued Discrete-Time Signals

Abstract

This paper presents a parallel implementation of a kind of discrete Fourier transform (DFT): the vector-valued DFT. The vector-valued DFT is a novel tool to analyze the spectra of vector-valued discrete-time signals. This parallel implementation is developed in terms of a mathematical framework with a set of block matrix operations. These block matrix operations contribute to analysis, design, and implementation of parallel algorithms in multicore processors. In this work, an implementation and experimental investigation of the mathematical framework are performed using MATLAB with the Parallel Computing Toolbox. We found that there is advantage to use multicore processors and a parallel computing environment to minimize the high execution time. Additionally, speedup increases when the number of logical processors and length of the signal increase.

1. Introduction

Let l ²(ℤ _n, ℂ ^d) be the space of vector-valued discrete-time signals with n samples, where each sample is a complex vector of length d. The vector-valued discrete-time signals are used very often in several applications in signal processing and electrical engineer, for example, vector quantization of images [1], time-frequency localization with wavelets [2], image coding [3], vector filter bank theory [4], linear time-dependent MISO [5], and analysis of MMSE estimation for compressive sensing of block sparse signals [6].

Now, to analyze the spectra of vector-valued discrete-time signals, a novel tool was developed, and it is called vector-valued DFT [7, 8]. This transform has applications in vector analysis in complex, quaternion, biquaternion, and Clifford algebras [8]. Additionally, the vector-valued DFT is used in digital signal processing, for example, the study of new complex valued constant amplitude zero autocorrelation (CAZAC) signals [9], which serve as coefficients for phase coded waveforms with prescribed vector-valued ambiguity function behavior, which is relevant in light of time-frequency analysis, vector sensor, and MIMO technologies [7].

The following paper presents a parallel framework of the vector-valued DFT. The major contributions of this paper are summarized as follows:

1. The construction of a new mathematical structure for the vector-valued DFT using block matrix theory such that it allows a parallel implementation in multicore processors.

2. Reducing the elapsed time to compute the vector-valued DFT of a vector-valued discrete-time signal using parallel computing through aforementioned new mathematical framework.

This new framework is developed with a set of block matrix operations, for example, Kronecker product, direct sum, stride permutation, vec operator, and vec inverse operator (see Section 2.1 for details). These block matrix operations contribute to analysis, design, and implementation of parallel algorithms in multicore processors [10–12]. This mathematical framework is inspired in the matrix representation of the Cooley-Tukey fast Fourier transform (FFT) algorithm for complex discrete-time signals, corresponding to the decomposition of the transform size n into the product of two factors r and s, which is developed in [10, 12, 13].

The present paper is organized as follows. Section 2 explains a mathematical background about block matrix operations and discrete Fourier transform. Section 3 defines the concept of vector-valued DFT for vector-valued discrete-time signals. Section 4 develops a mathematical framework of vector-valued DFT in terms of block matrix operations for vector-valued discrete-time signals with length n = rs. This mathematical framework contributes to implementation of parallel algorithms. Section 5 explains an implementation and experimental investigation of this mathematical framework using parallel computing in multicore processors with MATLAB. Finally, some conclusions are presented in Section 6.

Throughout the paper, the following notations are used. ℤ _n = {0,1,…, n − 1} is the additive group ℤ of integers modulo n, ℂ ^m×n is the matrix space of m rows and n columns with complex numbers entries and ℂ ⁿ = ℂ ^n×1. The rows and columns of A ∈ ℂ ^m×n are indexed by elements of ℤ _m and ℤ _n, respectively. A(j, k), A(j, :), A(:, k), and A ^T represent entry (j, k), row j, column k, and transpose matrix of A, respectively. I _n ∈ ℂ ^n×n is identity matrix.

2. Background

2.1. Block Matrix Operations

A block matrix A ∈ ℂ ^mp×nq with m row partitions and n column partitions and a block vector x ∈ ℂ ^mp with m row blocks are defined as

$$\begin{array}{c}\mathbf{A}=\left(\begin{array}{ccc}{\mathbf{A}}_{\mathrm{0,0}}& \cdots & {\mathbf{A}}_{\mathrm{0},n-\mathrm{1}}\\ ⋮& \ddots & ⋮\\ {\mathbf{A}}_{m-\mathrm{1,0}}& \cdots & {\mathbf{A}}_{m-\mathrm{1},n-\mathrm{1}}\end{array}\right),\\ \\ \mathbf{x}=\left(\begin{array}{c}{\mathbf{x}}_{\mathrm{0}}\\ ⋮\\ {\mathbf{x}}_{m-\mathrm{1}}\end{array}\right),\\ \end{array}$$ (1)

respectively, where A _j,k ∈ ℂ ^p×q designates (j, k) block and x _j ∈ ℂ ^p designates j block. In this paper, the following block matrix operations are used: Kronecker product, direct sum, stride permutation, vec operator, and vec inverse operator.

The Kronecker product of two matrices A ∈ ℂ ^m×n and B ∈ ℂ ^p×q is defined as A ⊗ B ∈ ℂ ^mp×nq and it replaces every entry (j, k) of A by the matrix A(j, k)B. In the special case A = I _n, it is called parallel operation [12].

The direct sum of n matrices constructs a block diagonal matrix from a set of matrices, that is, for {C _k}_k∈ℤn, such that C _k ∈ ℂ ^p_k×q_n:

$$\begin{array}{c}\mathbf{C}=\underset{k\in {\mathbb{Z}}_n}{{\displaystyle ⨁}}{\mathbf{C}}_k=\mathrm{diag}\left({\mathbf{C}}_{\mathrm{0}},{\mathbf{C}}_{\mathrm{1}},\dots ,{\mathbf{C}}_{n-\mathrm{1}}\right),\end{array}$$ (2)

where C ∈ ℂ ^p×q, p = ∑_j∈ℤn p _j, and q = ∑_j∈ℤn q _j.

Let n = rs. The stride permutation matrix is defined as L _s ⁿ ∈ ℂ ^n×n such that it permutes the elements of the input signal x ∈ ℂ ⁿ as jr + k → ks + j, j ∈ ℤ _s, and k ∈ ℤ _r [12, 14]. This matrix permutation governs the data flow required to parallelize a Kronecker product computation [12]. We clarify that the superscript n is an index, not power.

The vec operator, 𝒱 : ℂ ^m×n → ℂ ^mn, transforms a matrix into a vector by stacking all the columns of this matrix one underneath the other. On the other hand, the vec inverse operator, ℛ _m,n : ℂ ^mn → ℂ ^m×n, transforms a vector of dimension mn into a matrix of size m × n.

2.2. Discrete Fourier Transform

Let l ²(ℤ _n) be the set of ℂ-valued signals on ℤ _n; that is, x ∈ l ²(ℤ _n) if and only if x ∈ ℂ ⁿ [9]. Additionally, for each k ₁ ∈ ℤ, x(k ₁) = x(k ₂), where k ₂ ∈ ℤ _n and k ₁ ≡ k ₂mod⁡n. The discrete Fourier transform (DFT) of x ∈ l ²(ℤ _n) is represented as ℱ _x : ℤ _n → ℂ such that ℱ _x(k) = ∑_m∈ℤn x(m)ω _N ^−mk, where ω _n = exp⁡(2πi/n) and $i=\sqrt{-\mathrm{1}}$.

As mentioned in [14], there are two different approaches of representing the DFT: as matrix-vector products or using summations. Consequently, fast algorithms using parallel computing are represented with either a matrix formalism as in [10, 12–14] or summations as in most signal processing books. Below, the matrix formalism is introduced and used to express the Cooley-Tukey FFT algorithm, corresponding to the decomposition of the transform size n into the product of two factors r and s; that is, n = rs.

The matrix representation of DFT of x is ℱ _x = F _n x, where F _n ∈ ℂ ^n×n such that F _n(j, k) = ω _N ^−jk. If n = rs, then the matrix formalism can be used to express F _n as factorizations of matrices using block matrices operations [10, 12, 13]:

$$\begin{array}{c}{\mathbf{F}}_n={\mathbf{L}}_s^n\left({\mathbf{I}}_r\otimes {\mathbf{F}}_s\right){\mathbf{L}}_r^n{\mathbf{T}}_r^n\left({\mathbf{I}}_s\otimes {\mathbf{F}}_r\right){\mathbf{L}}_s^n.\end{array}$$ (3)

Here, T _r ⁿ is a diagonal matrix containing the twiddle factors. We clarify that the superscript n is an index, not power. This factorization of F _n is the matrix representation of the Cooley-Tukey FFT for n = rs. In addition, this representation of F _n allows the implementation using parallel computing [14].

3. DFT for Vector-Valued Signals

Based on [2, 6–9, 15, 16], the space of vector-valued discrete-time signals with n samples is defined as

$$\begin{array}{c}{l}^{\mathrm{2}}\left({\mathbb{Z}}_n,{\mathbb{C}}^d\right)=\left\{{\left({\mathbf{x}}_{\mathrm{0}},{\mathbf{x}}_{\mathrm{1}},\dots ,{\mathbf{x}}_{n-\mathrm{1}}\right)}^T:{\mathbf{x}}_j\in {\mathbb{C}}^d,j\in {\mathbb{Z}}_n\right\}.\end{array}$$ (4)

The space l ²(ℤ _n, ℂ ^d) is the set of ℂ ^d-valued signals on ℤ _n; that is, x ∈ l ²(ℤ _n, ℂ ^d) if and only if x ∈ ℂ ^nd. Additionally, for each k ₁ ∈ ℤ, x _k1 = x _k2, where k ₂ ∈ ℤ _n and k ₁ ≡ k ₂mod⁡n. Furthermore, if d = 1, then l ²(ℤ _n, ℂ ^d) = l ²(ℤ _n). Now, for x ∈ l ²(ℤ _n, ℂ ^d), there is a kind of DFT for vector-valued signals called vector-valued DFT. This transform is defined as ℱ _x ^d : ℤ _n → ℂ ^d such that

$$\begin{array}{c}{\mathcal{F}}_{\mathbf{x}}^d\left(k\right)={\displaystyle \sum }_{m\in {\mathbb{Z}}_n}{\mathbf{W}}_n^{-mk}{\mathbf{x}}_m,\end{array}$$ (5)

where W _n ∈ ℂ ^d×d is the matrix kernel. Algorithm 1 shows the implementation of (5). This implementation is a sequential algorithm.

Algorithm 1.

Vector-valued DFT (sequential algorithm).

From the reviewed literature, there are two kinds of kernels for this transform: the first one is hypercomplex DFT kernel [8]:

$$\begin{array}{c}{\mathbf{W}}_n=\exp \left(\frac{\mathrm{2}\pi }{n}·\mathbf{J}\right)=\cos \left(\frac{\mathrm{2}\pi }{n}\right)·{\mathbf{I}}_d+\sin \left(\frac{\mathrm{2}\pi }{n}\right)·\mathbf{J},\end{array}$$ (6)

where J ∈ ℂ ^d×d such that J ² = −I _d, and the second one is DFT frame kernel [7]:

$$\begin{array}{c}{\mathbf{W}}_n=\frac{\mathrm{1}}{\sqrt{d}}\mathrm{diag}\left({\omega }_n^{{\alpha }_{\mathrm{0}}},{\omega }_n^{{\alpha }_{\mathrm{1}}},\dots ,{\omega }_n^{{\alpha }_{d-\mathrm{1}}}\right),\end{array}$$ (7)

where 𝒜 = {α ₀, α ₁,…, α _d−1} ⊂ ℤ _n with α _j < α _k for j < k. It is called DFT frame kernel because {e _j}_j∈ℤn ⊂ ℂ ^d, where ${\mathbf{e}}_j=(\mathrm{1}/\sqrt{d}){({\omega }_n^{j{\alpha }_{\mathrm{0}}},{\omega }_n^{j{\alpha }_{\mathrm{1}}},\dots ,{\omega }_n^{j{\alpha }_{d-\mathrm{1}}})}^T$ is a DFT frame. In this paper, subsets 𝒜 ⊂ ℤ ⁺ are used, such that card⁡(𝒜) = d, although it does not represent a DFT frame.

Lemma 1 . —

Let W _n ∈ ℂ ^d×d be a hypercomplex DFT kernel or DFT frame kernel. Then

• (1) W _n ^j+r = W _n ^j · W _n ^r.
• (2) W _n ⁰ = W _n ⁿ = I _d.
• (3)If k ∈ ℤ and r ∈ ℤ _N, then W _n ^nk+r = W _n ^r.
• (4)If n = rs, then W _n ^rk = W _s ^k.

Proof —

For hypercomplex DFT kernel, the proof of each case is similar to proof of nth roots of unity. For DFT frame kernel, W _n is a diagonal matrix, and then the proof of each case is straightforward.

4. A Parallel Framework for n  =  rs

In this section, the main results of this paper are presented. Firstly, a block matrix representation of the vector-valued DFT is given. Secondly, a new mathematical framework from matrix representation of vector-valued DFT is derived, using a block matrix formalism (i.e., Theorem 2). This new result is inspired in the matrix representation of the Cooley-Tukey FFT algorithm for complex discrete-time signals, corresponding to the decomposition of the transform size n into the product of two factors r and s, which is developed in [10, 12, 13]. The result obtained in Theorem 2 is transformed in a new block matrix representation such that it contributes to analysis, design, and implementation of parallel algorithms (i.e., Corollary 3). This new result is inspired in (3). Finally, a computational complexity analysis of new algorithm is developed.

Similar to the DFT matrix representation explained in Section 2.2, there are two different approaches of representing the vector-valued DFT: as summations (see (5)) or using matrix-vector products. Both approaches allow a parallel implementation. In fact, the proof of Theorem 2 is developed using summation notation.

The vector-valued DFT can be presented as matrix-vector products. The block matrix representation of vector-valued DFT of x ∈ l ²(ℤ _n, ℂ ^d) is defined as ℱ _x ^d = F _n ^d x, where F _n ^d ∈ ℂ ^dn×dn such that (F _n ^d)_j,k = W _n ^−jk ∈ ℂ ^d×d, for j, k ∈ ℤ _n. We clarify that the superscript d is an index, not power. In this section, a block matrix factorization of F _n ^d is developed, and it is inspired in (3). First, a generalization of stride permutation is defined. Let n = rs. The block stride permutation matrix [14, 17] is defined as L _s ^n,d ∈ ℂ ^dn×dn such that L _s ^n,d = L _s ⁿ ⊗ I _d, and, for each x ∈ ℂ ^dn with n blocks x _j ∈ ℂ ^d, the operation L _s ^n,d x permutes each block of the input block x as jr + k → ks + j, j ∈ ℤ _s, and k ∈ ℤ _r.

Theorem 2 . —

Let n = rs and let F _n ^d ∈ ℂ ^dn×dn be the block matrix of DFT for vector-valued signals. Then

$$\begin{array}{c}{\mathbf{F}}_n^d=\left({\mathbf{F}}_s^d\otimes {\mathbf{I}}_r\right){\mathbf{T}}_r^{n,d}\left({\mathbf{I}}_s\otimes {\mathbf{F}}_r^d\right){\mathbf{L}}_s^{n,d},\end{array}$$ (8)

where T _r ^n,d = ⨁_j∈ℤs D _r ^j such that D _r = ⨁_k∈ℤr W _n ^−k.

Proof —

Let x ∈ ℂ ^dn, let l ₁, k ₁ ∈ ℤ _r, and let l ₂, k ₂ ∈ ℤ _s. The block vector y = (I _s ⊗ F _r ^d)L _s ^n,d x is defined. Then

$$\begin{array}{c}{\mathbf{y}}_{k_{\mathrm{2}}r+l_{\mathrm{1}}}={\displaystyle \sum }_{k_{\mathrm{1}}\in {\mathbb{Z}}_r}{\mathbf{W}}_r^{-k_{\mathrm{1}}{l}_{\mathrm{1}}}{\mathbf{x}}_{s{k}_{\mathrm{1}}+k_{\mathrm{2}}}.\end{array}$$ (9)

Now, let z = T _r ^n,d y. From Lemma 1, W _r ^−k₁l₁ = W _n ^−sk₁l₁; then

$$\begin{array}{c}{\mathbf{z}}_{k_{\mathrm{2}}r+l_{\mathrm{1}}}{\mathbf{W}}_n^{-k_{\mathrm{2}}{l}_{\mathrm{1}}}{\mathbf{y}}_{k_{\mathrm{2}}r+l_{\mathrm{1}}}={\mathbf{W}}_n^{-k_{\mathrm{2}}{l}_{\mathrm{1}}}{\displaystyle \sum }_{k_{\mathrm{1}}\in {\mathbb{Z}}_r}{\mathbf{W}}_n^{-s{k}_{\mathrm{1}}{l}_{\mathrm{1}}}{\mathbf{x}}_{s{k}_{\mathrm{1}}+k_{\mathrm{2}}}\\ ={\displaystyle \sum }_{k_{\mathrm{1}}\in {\mathbb{Z}}_r}{\mathbf{W}}_n^{-\left(s{k}_{\mathrm{1}}{l}_{\mathrm{1}}+k_{\mathrm{2}}{l}_{\mathrm{1}}\right)}{\mathbf{x}}_{s{k}_{\mathrm{1}}+k_{\mathrm{2}}}.\end{array}$$ (10)

Let w = (F _s ^d ⊗ I _r)z. Then

$$\begin{array}{c}{\mathbf{w}}_{l_{\mathrm{1}}+l_{\mathrm{2}}r}{\displaystyle \sum }_{k_{\mathrm{2}}\in {\mathbb{Z}}_s}{\mathbf{W}}_s^{-k_{\mathrm{2}}{l}_{\mathrm{2}}}{\mathbf{z}}_{k_{\mathrm{2}}r+l_{\mathrm{1}}}\\ ={\displaystyle \sum }_{k_{\mathrm{2}}\in {\mathbb{Z}}_s}{\mathbf{W}}_s^{-k_{\mathrm{2}}{l}_{\mathrm{2}}}\left({\displaystyle \sum }_{k_{\mathrm{1}}\in {\mathbb{Z}}_r}{\mathbf{W}}_n^{-\left(s{k}_{\mathrm{1}}{l}_{\mathrm{1}}+k_{\mathrm{2}}{l}_{\mathrm{1}}\right)}{\mathbf{x}}_{s{k}_{\mathrm{1}}+k_{\mathrm{2}}}\right)\\ ={\displaystyle \sum }_{k_{\mathrm{2}}\in {\mathbb{Z}}_s}{\mathbf{W}}_n^{-r{k}_{\mathrm{2}}{l}_{\mathrm{2}}}\left({\displaystyle \sum }_{k_{\mathrm{1}}\in {\mathbb{Z}}_r}{\mathbf{W}}_n^{-\left(s{k}_{\mathrm{1}}{l}_{\mathrm{1}}+k_{\mathrm{2}}{l}_{\mathrm{1}}\right)}{\mathbf{x}}_{s{k}_{\mathrm{1}}+k_{\mathrm{2}}}\right)\\ ={\displaystyle \sum }_{k_{\mathrm{2}}\in {\mathbb{Z}}_s}\left({\displaystyle \sum }_{k_{\mathrm{1}}\in {\mathbb{Z}}_r}{\mathbf{W}}_n^{-\left(r{k}_{\mathrm{2}}{l}_{\mathrm{2}}+s{k}_{\mathrm{1}}{l}_{\mathrm{1}}+k_{\mathrm{2}}{l}_{\mathrm{1}}\right)}{\mathbf{x}}_{s{k}_{\mathrm{1}}+k_{\mathrm{2}}}\right).\end{array}$$ (11)

But rk ₂ l ₂ + sk ₁ l ₁ + k ₂ l ₁ ≡ (k ₂ + k ₁ s)(l ₁ + l ₂ r)mod⁡n; then

$$\begin{array}{c}{\mathbf{w}}_{l_{\mathrm{1}}+l_{\mathrm{2}}r}{\displaystyle \sum }_{k_{\mathrm{2}}\in {\mathbb{Z}}_s}\left({\displaystyle \sum }_{k_{\mathrm{1}}\in {\mathbb{Z}}_r}{\mathbf{W}}_n^{-\left(k_{\mathrm{2}}+k_{\mathrm{1}}s\right)\left(l_{\mathrm{1}}+l_{\mathrm{2}}r\right)}{\mathbf{x}}_{s{k}_{\mathrm{1}}+k_{\mathrm{2}}}\right)\\ =\hspace{0.17em}{\displaystyle \sum }_{k_{\mathrm{2}}\in {\mathbb{Z}}_s}\hspace{0.17em}{\displaystyle \sum }_{k_{\mathrm{1}}\in {\mathbb{Z}}_r}{\mathbf{W}}_n^{-\left(k_{\mathrm{2}}+k_{\mathrm{1}}s\right)\left(l_{\mathrm{1}}+l_{\mathrm{2}}r\right)}{\mathbf{x}}_{s{k}_{\mathrm{1}}+k_{\mathrm{2}}}.\end{array}$$ (12)

Let m = sk ₁ + k ₂, let k = l ₁ + l ₂ r, and let m, k ∈ ℤ _n because l ₁, k ₁ ∈ ℤ _r, l ₂ k ₂ ∈ ℤ _s, and n = rs. Then

$$\begin{array}{c}{\displaystyle \sum }_{m\in {\mathbb{Z}}_n}{\mathbf{W}}_n^{-mk}{\mathbf{x}}_m={\mathcal{F}}_{\mathbf{x}}^d\left(k\right).\end{array}$$ (13)

Now, if n = rs, A ∈ ℂ ^r×r, and B ∈ ℂ ^ds×ds, the following equality [17] is obtained:

$$\begin{array}{c}\mathbf{B}\otimes \mathbf{A}={\mathbf{L}}_s^{n,d}\left(\mathbf{A}\otimes \mathbf{B}\right){\mathbf{L}}_r^{n,d}.\end{array}$$ (14)

From Theorem 2 and (14), the following corollary presents a matrix factorization of F _n ^d such that it permits an implementation using parallel computing.

Corollary 3 . —

Let n = rs and let F _n ^d ∈ ℂ ^dn×dn be the block matrix of DFT for vector-valued signals. Then

$$\begin{array}{c}{\mathbf{F}}_n^d={\mathbf{L}}_s^{n,d}\left({\mathbf{I}}_r\otimes {\mathbf{F}}_s^d\right){\mathbf{L}}_r^{n,d}{\mathbf{T}}_r^{n,d}\left({\mathbf{I}}_s\otimes {\mathbf{F}}_r^d\right){\mathbf{L}}_s^{n,d},\end{array}$$ (15)

where T _r ^n,d was defined in Theorem 2.

Algorithm 2 shows a parallel implementation of (15).

Algorithm 2.

Vector-valued DFT (parallel algorithm).

r independent processes in Steps (3)–(5), and 2s independent processes in Steps (6)–(8) and (12)–(14) are observed, making this approach a parallel operation. A model of Algorithm 2 is shown in Figure 1.

Figure 1.

Parallel model of vector-valued DFT for x ∈ l ²(ℤ _n, ℂ ^d), n = rs, using a matrix representation.

4.1. Computational Complexity Analysis

In this section, the computational complexity analysis of (15) is developed. First, consider the matrix operation L _s ^n,d v. The computational complexity (CC) of L _s ^n,d v is 𝒪(nd) [8] because it is the multiplication between a block matrix in ℂ ^dn×dn and a block vector in ℂ ^dn. But the operation L _s ^n,d v can be implemented with a CC 𝒪(sd) (see, e.g., [12, 14]).

Let F _n ^d ∈ ℂ ^dn×dn be the block matrix and vector-valued signal x ∈ l ²(ℤ _n, ℂ ^d), where n = rs. It is known that the CC of operation y = F _n ^d x is 𝒪(n ² d ²) = 𝒪(r ² s ² d ²). Now consider operation y = F _n ^d x using (15). If we consider each matrix-vector multiplication, we obtain the following:

• (1)The CC of y ₁ = L _s ^n,d x is 𝒪(sd).
• (2)The CC of y ₂ = (I _s ⊗ F _r ^d)y ₁ is 𝒪(sr ² d ²), because it is a block diagonal matrix multiplication.
• (3)The CC of y ₃ = T _r ^n,d y ₂ is 𝒪(nd), because T _r ^n,d is a diagonal matrix multiplication.
• (4)The CC of y ₄ = L _r ^n,d y ₃ is 𝒪(rd).
• (5)The CC of y ₅ = (I _r ⊗ F _s ^d)y ₄ is 𝒪(rs ² d ²), because it is a block diagonal matrix multiplication.
• (6)The CC of y = L _s ^n,d y ₅ is 𝒪(sd).

Therefore, the CC of F _n ^d x using (15) is

$$\begin{array}{c}\mathcal{O}\left(sd\right)+\mathcal{O}\left(s{r}^{\mathrm{2}}{d}^{\mathrm{2}}\right)+\mathcal{O}\left(nd\right)+\mathcal{O}\left(rd\right)+\mathcal{O}\left(r{s}^{\mathrm{2}}{d}^{\mathrm{2}}\right)\\ +\mathcal{O}\left(sd\right)=\mathcal{O}\left(sr\left(r+s\right)d^{\mathrm{2}}\right).\end{array}$$ (16)

Thus, the CC of operation F _n ^d x is 𝒪(r ² s ² d ²) and the CC of operation F _n ^d x using (15) is 𝒪(sr(r + s)d ²). The above mentioned shows the efficiency of matrix formulation in (15).

5. Implementation and Experimental Investigation

5.1. General Information

The investigations have been carried out on a computer with multicore processor. The computer consists of 4 cores with Intel Core i7-3632QM CPU processor, system clock of 2.20 GHz, and 8 GB of RAM. The experiment develops the implementation and testing of Algorithms 1 and 2 with the hypercomplex DFT kernel and the DFT frame kernel is developed. Algorithm 1 does not use any parallel implementation, unlike Algorithm 2. A CAZAC signal in l ²(ℤ _n, ℂ ^d) is used; it is generated using a Wiener CAZAC signal in l ²(ℤ _n) [9] with d = 5 and n = rs, where n = 1024 = 32 · 32, n = 2048 = 64 · 32, n = 4096 = 64 · 64, n = 8192 = 128 · 64, and n = 16384 = 128 · 128.

The implementation of Algorithms 1 and 2 to compute the vector-valued DFT is performed using MATLAB. Algorithm 2 is computed using Parallel Computing Toolbox. MATLAB uses built-in multithreading and parallelism using MATLAB workers. Parallelism using MATLAB workers is used. We can run multiple MATLAB workers (MATLAB computational engines) on a multicore computer to execute applications in parallel with the Parallel Computing Toolbox. This approach allows more control over the parallelism compared to built-in multithreading. With programming constructs, such as parallel-for-loops (parfor) and batch, we write the parallel MATLAB programs of the parallel framework for the vector-valued DFT.

5.2. Results and Discussion

Let T _∗ be the execution time of Algorithm 1 without any parallel implementation, and let T _p be the execution time of Algorithm 2, where p is the number of cores. The value of T _p needs to be less than that of T _∗ for two reasons: Algorithm 2 has a parallel implementation and the matrix multiplication size is different. Algorithm 2 is computed with matrices in ℂ ^dr×dr and ℂ ^ds×ds. Algorithm 1 is computed with matrices in ℂ ^dn×dn, where n = rs.

The computational performance analysis of Algorithm 2 is evaluated using the metrics speedup (or acceleration) and efficiency. The speedup is the ratio between the execution times of parallel implementations with one core and parallel implementations with two or more cores [18]. The speedup is represented by the formula S = T ₁/T _p. The efficiency estimates how well utilized the processors are in solving the problem compared to how much effort is wasted in communication and synchronization [18]. The efficiency is determined by the ratio between the speedup and the number of processing elements, represented by the formula E = T ₁/(pT _p).

Table 1 shows the execution time, in seconds (s), of both algorithms. A significant reduction in the parallel execution time of the vector-valued DFT is observed. Table 1 shows that Algorithm 1 with hypercomplex kernel for a Wiener CAZAC signal in l ²(ℤ ₈₁₉₂, ℂ ⁵) produces a time of serial execution T _∗ = 13408 s. Using Algorithm 2, however, we obtain T ₁ = 106.7 (0.80% of T _∗), T ₂ = 80.44 s (0.60% of T _∗), T ₃ = 57.35 s (0.43% of T _∗), and T ₄ = 32.67 s (0.24% of T _∗). This result shows the advantage of using multicore processors and a parallel computing environment to minimize the high execution time in the vector-valued DFT. This is because parallel computing is a form of computation in which many calculations are carried out simultaneously [19, 20], operating on the principle that large problems can often be divided into smaller ones, which are then solved concurrently, and minimize the execution time [20, 21]. The difference between T _∗ and T _p is because T _p is computed with matrices in ℂ ^dr×dr and ℂ ^ds×ds. Algorithm 1 is computed with matrices in ℂ ^dn×dn, where n = rs.

Table 1.

Computing time of Algorithms 1 and 2 (in seconds).

Kernel	p	n
		1024	2048	4096	8192	16384
Hypercomplex DFT	∗	36.80	163.9	853.5	13408	+15000
	1	3.142	8.950	18.78	106.7	263.4
	2	2.363	4.276	17.25	80.44	180.9
	3	1.695	3.222	12.75	57.35	154.7
	4	0.983	2.966	6.481	32.67	82.65
DFT frame	∗	40.50	173.1	881.0	13913	+15000
	1	2.438	9.749	20.97	95.29	251.6
	2	1.911	5.798	16.38	58.72	179.5
	3	1.531	5.126	12.33	57.40	151.4
	4	1.199	2.329	5.366	31.46	73.42

Test signal in l ²(ℤ _n, ℂ ^d), where n = rs and d = 5.

p = ∗ is time execution of Algorithm 1.

p > 0 is the number of cores.

Table 2 represents the speedup of Algorithm 2. The acceleration of the vector-valued DFT increases when p increases regardless of the value of n. The results show that, using the proposed parallel implementation with p cores, where p = 2,3, 4, the speedup to compute the vector-valued DFT of a Wiener CAZAC signal is 1.09, 1.47, and 2.99, respectively. These results imply that, to get the highest speedup, one should prefer the approach with four cores.

Table 2.

Speedup of Algorithm 2.

Kernel	p	n
		1024	2048	4096	8192	16384
Hypercomplex DFT	2	1.333	2.093	1.089	1.326	1.456
	3	1.853	2.778	1.473	1.860	1.703
	4	3.196	3.017	2.987	3.265	3.187
DFT frame	2	1.275	1.509	1.281	1.623	1.402
	3	1.592	1.707	1.701	1.660	1.661
	4	2.033	3.757	3.901	3.029	3.426

Test signal in l ²(ℤ _n, ℂ ^d), where n = rs and d = 5.

p is the number of cores.

Table 3 represents efficiency of Algorithm 2. The information in this table shows that a good efficiency (greater than 65%) is reached with p = 2. But the efficiency of the vector-valued DFT decreases (until 36%) when p increases regardless of the value of n. It is attributed to a decrease in the share of simultaneous computation of the partial vector-valued DFT in Algorithm 2 (steps (3)–(5) and (12)–(14)), which is responsible for the main effect. The results obtained in Table 3 imply that, to get a better efficiency, one should prefer the approach with two cores, because we obtain the highest efficiency.

Table 3.

Efficiency of Algorithm 2.

Kernel	p	n
		1024	2048	4096	8192	16384
Hypercomplex DFT	2	0.665	1.046	0.544	0.663	0.728
	3	0.463	0.694	0.368	0.465	0.426
	4	0.400	0.377	0.362	0.408	0.398
DFT frame	2	0.637	0.755	0.645	0.811	0.701
	3	0.530	0.427	0.425	0.415	0.415
	4	0.508	0.470	0.489	0.379	0.428

Test signal in l ²(ℤ _n, ℂ ^d), where n = rs and d = 5.

p is the number of cores.

6. Conclusion

This work presented a parallel framework of vector-valued DFT for vector-valued discrete-time signals. This mathematical framework was inspired in the matrix representation of the Cooley-Tukey FFT algorithm for complex discrete-time signals, corresponding to the decomposition of the transform size n into the product of two factors r and s, which is developed in [10, 12]. It was expressed in (15) and Algorithm 2. This parallel framework was performed in terms of a matrix representation using a set of block matrix operations: Kronecker product, direct sum, stride permutation, vec operator, and vec inverse operator. These operations contributed to analysis, design, and implementation in parallel. Two kernels are used in the vector-valued DFT: hypercomplex DFT kernel and DFT frame kernel.

The experimental investigation indicated there are profit using MATLAB with the Parallel Computing Toolbox in a computer with multicore processors. First, there was advantage to use multicore processors and a parallel computing environment to minimize the high execution time (with hypercomplex DFT kernel, we obtained T _∗ = 13408 s, T ₁ = 106.7, T ₂ = 80.44 s, T ₃ = 57.35 s, and T ₄ = 32.67 s). Second, speedup increased when p increased regardless of the value of n, and a good efficiency too was obtained when p = 2 (above 65%).

As future work, we would like to extend the proposed parallel framework to vector-valued discrete-time signals in l ²(ℤ _n, ℂ ^d), where n = 2^k, using the idea of Pease algorithm for complex discrete-time signals [22]. Additionally, we would like to take advantage of more design tradeoffs of different approaches besides what have been shown in this paper, for example, the approach developed in [23].

Conflict of Interests

The author declares that there is no conflict of interests regarding the publication of this paper.