VLSI-Friendly Filtering Algorithms for Deep Neural Networks

Abstract

The paper introduces a range of efficient algorithmic solutions for implementing the fundamental filtering operation in convolutional layers of convolutional neural networks on fully parallel hardware. Specifically, these operations involve computing M inner products between neighbouring vectors generated by a sliding time window from the input data stream and an M-tap finite impulse response filter. By leveraging the factorisation of the Hankel matrix, we have successfully reduced the multiplicative complexity of the matrix-vector product calculation. This approach has been applied to develop fully parallel and resource-efficient algorithms for M values of 3, 5, 7, and 9. The fully parallel hardware implementation of our proposed algorithms achieves approximately a 30% reduction in embedded multipliers compared to the naive calculation methods.

1. Introduction

The need for high-speed processing of large amounts of information stimulates the development and use of highly effective data processing systems. In such systems, the primary requirement for implementing computing methods is to minimise the time of data processing, ensuring the ability to fulfil the planned task within the allocated time for this application. This requirement is especially relevant in the implementation of algorithms for processing digital information in deep neural networks (DNNs) [1,2,3,4,5]. As is known, in deep neural networks, the primary and time-consuming operation is digital convolution. The need to quickly calculate digital convolution arises in both convolutional and capsule neural networks. Digital convolution calculations can be accelerated by algorithmic and hardware methods. In general, algorithmic methods primarily focus on minimising the number of arithmetic operations involved. One widely employed strategy for reducing the computational complexity of the digital convolution operation is utilising the Fast Fourier Transform (FFT) algorithm. This approach has found application in some deep neural networks [6,7,8,9,10,11]. However, modern convolutional and capsule neural networks use small filters more often than the traditionally used large filters computed using the FFT approach. The Winograd’s minimal filtering algorithm [1,12,13,14,15], which has recently gained significant popularity, is widely regarded as well-suited for such scenarios. This approach exhibits enhanced efficiency, specifically when employing small filters and tile sizes. In such cases, it performs linear convolution with minimal computational complexity. Indeed, this method calculates the dot products of adjacent vectors obtained from a sliding time window in the current data stream. It employs a third-order finite impulse response filter (FIR) for this purpose.

2. State of the Art

Since we are talking mainly about convolutional and capsular neural networks, it is clear that linear convolution is the main operation in their implementation. In general, convolutional layers tend to be the most time-intensive component, often accounting for over half of the total computation time in a typical implementation [16,17]. The convolution itself is also a time-consuming operation. For this reason, deep neural network builders are looking for and creating efficient ways to minimise convolution computation complexity [11].

Another opportunity to speed up calculations in deep neural networks is by utilising high-performance field-programmable gate arrays (FPGAs) [18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33], graphics processing units (GPUs) [33,34,35,36], and specialised application-specific integrated circuits (ASICs) [33,37,38,39].

When modern stationary data processing systems possess ample computing power, the design of mobile on-board systems powered by batteries encounters various conflicting factors that hinder peak performance. The conventional approach of parallelising computations to enhance data processing speed increases the data processing unit’s size, weight, and power consumption. Consequently, there is a necessity for solutions that effectively leverage computational parallelisation while concurrently optimising hardware costs.

Extensive research is being conducted on algorithms and structures for high-performance computing devices intended to process digital signals and images with practical applications in embedded systems. Developing micro-miniature processing units tailored for image processing and recognition in on-board mobile neural networks, known as Tiny ML or Edge AI, is of particular interest. These cutting-edge applications are at the forefront of modern technology.

For these reasons, the Tiny ML Summit has been held since 2019, bringing together experts from major companies and universities. The primary focus of this conference is to discuss the potential of transitioning machine learning from high-performance mainframes to small battery-powered signal microprocessors. The Tiny ML concept is continually evolving, driven by the development of dedicated chips designed for these applications. Notably, digital signal processing algorithms are pivotal in the systems under discussion. Over time, numerous algorithms and processor structures have been developed to address the challenges posed by these systems. With a focus on flexibility and versatility, the prevailing approach involves using universal signal microprocessors and FPGAs.

However, the high flexibility of the developed processors contradicts a highly efficient implementation. For example, a programmable signal processing unit is flexible, scalable and upgradable but highly inefficient in terms of performance, die area, weight, and power consumption.

Therefore, developing ASIC-centric solutions is best suited for portable applications as minimising power consumption, weight, and size of the processing unit in battery-powered systems has become an essential aspect of on-board processing.

At the algorithmic level, methods for reducing the above parameters usually focus on minimising the number of arithmetic operations, especially multiplications. In this regard, developing algorithms for performing the main filtering operations, characterised by minimal multiplicative complexity, is an urgent task. So, we again emphasise that convolution calculation is an essential mathematical macro operation in DNNs. And usually (though not always) it is computed using Winograd’s minimum filtering algorithm [1,12,14,18,20,21,22,40,41,42]. However, since, as already noted [43], this algorithm can only calculate two adjacent dot products, it is not suitable for all possible situations that can arise in neural networks. For example, Winograd’s minimum filtering algorithm is redundant for $M=3$ and tile size (5 × 5) or for $M=5$ and tile size (9 × 9). Many other examples could be given. In this article, we present algorithmic solutions for FIR filters with short-length impulse responses, which can be more efficient in some cases than Winograd’s minimal filtering algorithm.

3. Preliminary Remarks

The primary step in computing a 2D convolution involves taking the dot product between the vectors created by the sliding time window from the present data stream and the impulse response of an M-order finite impulse response (FIR) filter.

The procedure for computing convolution elements can be represented as follows in the most general case:

$$y_j=\sum _{i=0}^{M-1}{x}_{i+j}{w}_i$$

(1)

$$j=0,1,\dots ,N-M+1,$$

where N represents the length of the current data stream, with $\left\{x_{i+j}\right\}$ denoting the elements of the data stream, and $\left\{w_i\right\}$ represents the constant coefficients of the FIR filter’s impulse response.

In a more detailed form, expression (1) can be represented as follows:

$$\begin{array}{cc}& y_0=w_0{x}_0+w_1{x}_1+\cdots +w_{M-1}{x}_{M-1}\\ & y_1=w_0{x}_1+w_1{x}_2+\cdots +w_{M-1}{x}_M\\ & ⋮\\ & y_{N-M}=w_0{x}_{N-M}+w_1{x}_{N-M+1}+\cdots +w_{M-1}{x}_{N-1}\end{array}$$

(2)

Figure 1 illustrates the sequence of steps in calculating the moving dot product.

The equations above comprehensively describe all the mathematical operations required for the calculations. However, strictly speaking, they do not constitute an algorithm since they do not reveal the specific sequence of calculations. In some instances, expressing the sliding dot product operation as a matrix-vector product is more convenient:

$${\mathbf{Y}}_{\left(N-M+1\right)\times 1}={\mathbf{W}}_{\left(N-M+1\right)\times N}{\mathbf{X}}_{N\times 1}$$

(3)

where:

$${\mathbf{Y}}_{\left(N-M+1\right)\times 1}={\left[y_0,y_1,\dots ,y_{N-M}\right]}^{\mathrm{T}},$$

$${\mathbf{X}}_{N\times 1}={\left[x_0,x_1,\dots ,x_{N-1}\right]}^{\mathrm{T}},$$

$$\begin{array}{c}\hfill \begin{array}{c}{\mathbf{W}}_{\left(N-M+1\right)\times N}=\left[\begin{array}{ccccccc}{w}_0& w_1& \cdots & w_{M-1}& & & \\ & w_0& w_1& \cdots & w_{M-1}& & \\ & & \ddots & \ddots & \ddots & \ddots & \\ & & & w_0& w_1& \cdots & w_{M-1}\end{array}\right].\hfill \end{array}\end{array}$$

However, regarding the research task at hand, such a representation is unhelpful as it does not facilitate identifying opportunities for reducing the computational complexity of the procedure for determining the sliding inner product when the sequence is comprised of input signal samples.

Let us rewrite expressions (2) in the following form:

$${\mathbf{Y}}_{\left(N-M+1\right)\times 1}={\mathbf{X}}_{\left(N-M+1\right)\times M}{\mathbf{W}}_{M\times 1}$$

(4)

where:

$${\mathbf{W}}_{M\times 1}={\left[w_0,w_1,\dots ,w_{M-1}\right]}^{\mathrm{T}},$$

$$\begin{array}{c}\hfill {\mathbf{X}}_{\left(N-M+1\right)\times M}=\left[\begin{array}{cccc}{x}_0& x_1& \dots & x_{M-1}\\ x_1& x_2& \cdots & x_M\\ ⋮& ⋮& \ddots & ⋮\\ x_{N-M}& x_{N-M+1}& \cdots & x_{N-1}\end{array}\right].\end{array}$$

This form of writing is much more useful and legible, which will be visible in the next steps. It turns out that considering the structural properties of the matrix ${\mathbf{X}}_{\left(N-M+1\right)\times M}$ in the expression (4) allows for a fairly significant reduction in the number of arithmetic operations. Let us consider this problem in more detail. Let us impose certain conditions on the sizes of the input sequences. Suppose $N=M(K+1)-1$, where $K=1,2,3,\dots$ is a positive integer number. It is obvious that if the supposed requirement for N is not satisfied, sequences $\left\{x_n\right\},n=0,1,\dots ,N-1$ can be padded with zeros without losing computation precision.

Then the expression (4) takes the following form:

$${\mathbf{Y}}_{KM\times 1}={\mathbf{X}}_{KM\times M}{\mathbf{W}}_{M\times 1}$$

(5)

where:

$${\mathbf{Y}}_{KM\times 1}={\left[y_0,y_1,\dots ,y_{KM-1}\right]}^{\mathrm{T}},$$

$${\mathbf{X}}_{KM\times M}={\left[{\mathbf{X}}_{1\times M}^{\left(0\right)},{\mathbf{X}}_{1\times M}^{\left(1\right)},\dots ,{\mathbf{X}}_{1\times M}^{\left(KM-1\right)}\right]}^{\mathrm{T}},$$

and

$${\mathbf{X}}_{1\times M}^{\left(i\right)}=\left[x_i,x_{i+1},\dots ,x_{M-1+i}\right],i=0,1,\dots ,KM-1.$$

To see the structure of the matrix ${\mathbf{X}}_{KM\times M}$, we present expression (5) in a more detailed form:

$$\left[\begin{array}{c}{y}_0\\ y_1\\ ⋮\\ y_{KM-1}\end{array}\right]=\left[\begin{array}{cccc}{x}_0& x_1& \cdots & x_{M-1}\\ x_1& x_2& \cdots & x_M\\ ⋮& ⋮& \ddots & ⋮\\ x_{M-1}& x_M& \cdots & x_{2M-2}\\ x_M& x_{M+1}& \cdots & x_{2M-1}\\ x_{M+1}& x_{M+2}& \cdots & x_{2M}\\ ⋮& ⋮& \ddots & ⋮\\ x_{2M-1}& x_{2M}& \cdots & x_{3M-2}\\ ⋮& ⋮& ⋮& ⋮\\ x_{\left(K-1\right)M}& x_{\left(K-1\right)M+1}& \cdots & x_{KM-1}\\ x_{\left(K-1\right)M+1}& x_{\left(K-1\right)M+2}& \cdots & x_{KM}\\ ⋮& ⋮& \ddots & ⋮\\ x_{KM-1}& x_{KM}& \cdots & x_{\left(K-1\right)M-2}\end{array}\right]\left[\begin{array}{c}{w}_0\\ w_1\\ ⋮\\ w_{M-1}\end{array}\right]$$

(6)

By examining this description, it becomes evident that the matrix ${\mathbf{X}}_{KM\times M}$ possesses a block structure and comprises K submatrices of Hankel type. Thus, the calculation of the sliding dot product, taking into account the imposed conditions, comes down to multiplying the sequence of $\mathit{K}$ sub-matrices (i.e. the Hankel matrices) by the vector ${\mathbf{W}}_{M\times 1}$ and then combining the individual calculation results.

Hence, we establish the fundamental filtering operation in DNNs as multiplying the Hankel sub-matrix (formed from the current input data sequence using a sliding window of size M) by a vector whose elements are the impulse response coefficients of an M-order FIR filter. There are efficient algorithms for multiplying Hankel matrices by a vector. However, they are mainly focused on large matrices, the order of which is a power of two [44,45]. But in most cases of image processing in neural networks, the impulse responses of FIR filters are short and contain an odd number of coefficients. Under these conditions, we are dealing with Hankel matrices of small orders. When multiplying small-size Hankel matrices by small-length vectors, known algorithms are inefficient or even counterproductive. Therefore, we have developed our own algorithms explicitly focused on calculating matrix-vector products with Hankel matrices of small orders.

So, we define the basic filtering macrooperation as:

$${\mathbf{Y}}_{M\times 1}={\mathbf{X}}_M{\mathbf{W}}_{M\times 1}$$

(7)

where:

$${\mathbf{X}}_M=\left[\begin{array}{cccc}{x}_0& x_1& \cdots & x_{M-1}\\ x_1& x_2& \cdots & x_M\\ ⋮& ⋮& \ddots & ⋮\\ x_{M-1}& x_M& \cdots & x_{2M-2}\end{array}\right],$$

$${\mathbf{Y}}_{M\times 1}={\left[y_0^{\left(M\right)},y_1^{\left(M\right)},\dots ,y_{M-1}^{\left(M\right)}\right]}^{\mathrm{T}},$$

$${\mathbf{W}}_{M\times 1}={\left[w_0^{\left(M\right)},w_1^{\left(M\right)},\dots ,w_{M-1}^{\left(M\right)}\right]}^{\mathrm{T}}.$$

(Kindly take note that from this point forward, the superscript M will signify quantities associated with the basic filtering macrooperation employing an M-order filter).

We emphasise once again that, as a rule, small-order filters are used in deep neural networks when the impulse response vectors contain a small number of elements. And almost always, we are dealing with an odd number of records. Based on the information provided above, this article aims to create and describe resource-efficient filtering algorithms for FIR filters with widely used orders: M = 3, 5, 7, and 9.

4. Minimal Filtering Algorithms

Let us show, based on specific examples, how it works.

4.1. Algorithm 1, M = 3

Let ${\mathbf{X}}_{5\times 1}={\left[x_0,x_1,x_2,x_3,x_4\right]}^{\mathrm{T}}$ be a vector that represents the input data set, ${\mathbf{W}}_{3\times 1}=\left[w_0^{\left(3\right)},\right.$${\left.w_1^{\left(3\right)},w_2^{\left(3\right)}\right]}^{\mathrm{T}}$ be a vector that contains the coefficients of the impulse response of a 3-tap FIR filter, and ${\mathbf{Y}}_{3\times 1}={\left[y_0^{\left(3\right)},y_1^{\left(3\right)},y_2^{\left(3\right)}\right]}^{\mathrm{T}}$ be a vector describing the results of using a 3-tap FIR filter:

$${\mathbf{Y}}_{3\times 1}=\left[\begin{array}{ccc}{x}_0& x_1& x_2\\ x_1& x_2& x_3\\ x_2& x_3& x_4\end{array}\right]\left[\begin{array}{c}{w}_0^{\left(3\right)}\\ w_1^{\left(3\right)}\\ w_2^{\left(3\right)}\end{array}\right]$$

(8)

As can be seen, calculating the product (8) requires 9 multiplications and 6 additions.

We can formulate a streamlined algorithm for computing ${\mathbf{Y}}_{3\times 1}$ by utilising the following matrix-vector calculation procedure:

$${\mathbf{Y}}_{3\times 1}={\mathbf{T}}_{3\times 6}^{\left(3\right)}{\mathbf{D}}_6^{\left(3\right)}{\mathbf{T}}_{6\times 5}^{\left(3\right)}{\mathbf{X}}_{5\times 1}$$

(9)

where

$${\mathbf{T}}_{3\times 6}^{\left(3\right)}=\left[\begin{array}{cccccc}1& 1& & 1& & \\ & 1& 1& & 1& \\ & & & 1& 1& 1\end{array}\right],$$

$${\mathbf{T}}_{6\times 5}^{\left(3\right)}=\left[\begin{array}{ccccc}1& -1& -1& & \\ & 1& & & \\ & -1& 1& -1& \\ & & 1& & \\ & & & 1& \\ & & -1& -1& 1\end{array}\right],$$

and

$${\mathbf{D}}_6^{\left(3\right)}=diag\left(s_0^{\left(3\right)},s_1^{\left(3\right)},\dots ,s_5^{\left(3\right)}\right),$$

$$s_0^{\left(3\right)},=w_0^{\left(3\right)},s_1^{\left(3\right)},=w_0^{\left(3\right)}+w_1^{\left(3\right)},s_2^{\left(3\right)},=w_1^{\left(3\right)}$$

$$s_3^{\left(3\right)}=w_0^{\left(3\right)}+w_2^{\left(3\right)},s_4^{\left(3\right)}=w_1^{\left(3\right)}+w_2^{\left(3\right)},s_5^{\left(3\right)}=w_2^{\left(3\right)}.$$

Figure 2 depicts a data flow graph of the proposed algorithm for implementing the basic filtering operation for a 3-tap FIR filter. In this paper, the data flow diagrams are arranged from left to right, and straight lines in the figures represent data transfer operations. The circles in these figures indicate multiplication operations, with the corresponding numbers written inside the circles. The convergence points of the lines indicate summation, while dashed lines represent data transfer operations with a simultaneous change of sign. To maintain clarity, the figures utilise simple lines without arrows. Furthermore, to simplify the presentation, the superscripts of variables have been omitted in all figures, as the vector sizes involved in each case can be inferred from the figures themselves.

4.2. Algorithm 2, M = 5

Let ${\mathbf{X}}_{9\times 1}={\left[x_0,x_1,x_2,x_3,x_4,x_5,x_6,x_7,x_8\right]}^{\mathrm{T}}$ be a vector that represents the input data set, ${\mathbf{W}}_{5\times 1}={\left[w_0^{\left(5\right)},w_1^{\left(5\right)},w_2^{\left(5\right)},w_3^{\left(5\right)},w_4^{\left(5\right)}\right]}^{\mathrm{T}}$ be a vector that contains the coefficients of the impulse response of a 5-tap FIR filter, and ${\mathbf{Y}}_{5\times 1}={\left[y_0^{\left(5\right)},y_1^{\left(5\right)},y_2^{\left(5\right)},y_3^{\left(5\right)},y_4^{\left(5\right)}\right]}^{\mathrm{T}}$ be a vector describing the results of using a 5-tap FIR filter:

$${\mathbf{Y}}_{5\times 1}=\left[\begin{array}{ccccc}{x}_0& x_1& x_2& x_3& x_4\\ x_1& x_2& x_3& x_4& x_5\\ x_2& x_3& x_4& x_5& x_6\\ x_3& x_4& x_5& x_6& x_7\\ x_4& x_5& x_6& x_7& x_8\end{array}\right]\left[\begin{array}{c}{w}_0^{\left(5\right)}\\ w_1^{\left(5\right)}\\ w_2^{\left(5\right)}\\ w_3^{\left(5\right)}\\ w_4^{\left(5\right)}\end{array}\right]$$

(10)

As can be seen, calculating the product (10) requires 25 multiplications and 20 additions.

We can devise a streamlined algorithm to compute ${\mathbf{Y}}_{5\times 1}$ by employing the following matrix-vector calculation procedure:

$${\mathbf{Y}}_{5\times 1}={\mathbf{T}}_{5\times 14}^{\left(5\right)}{\mathbf{D}}_{14}^{\left(5\right)}{\mathbf{T}}_{14\times 9}^{\left(5\right)}{\mathbf{X}}_{9\times 1}$$

(11)

where

$$\begin{array}{c}\hfill \begin{array}{c}{\mathbf{T}}_{5\times 14}^{\left(5\right)}=\left[\begin{array}{cccccccccccccc}1& 1& 1& 1& & 1& & & & & & & & \\ & 1& & 1& 1& & 1& & & 1& & & & \\ & & 1& 1& & & & 1& 1& & & 1& & \\ & & & 1& & & 1& 1& & & 1& & 1& \\ & & & & & 1& & & & 1& & 1& 1& 1\end{array}\right],\end{array}\end{array}$$

$$\begin{array}{c}\hfill \begin{array}{c}{\mathbf{T}}_{14\times 9}^{\left(5\right)}=\left[\begin{array}{ccccccccc}1& -1& -1& 1& -1& & & & \\ & 1& & -1& & & & & \\ & & 1& -1& & & & & \\ & & & 1& & & & & \\ & -1& 1& 1& -1& -1& & & \\ & & & & 1& & & & \\ & & & -1& 1& & & & \\ & & & -1& & 1& & & \\ & & -1& 1& 1& -1& -1& & \\ & & & & & 1& & & \\ & & & 1& -1& -1& 1& -1& \\ & & & & & & 1& & \\ & & & & & & & 1& \\ & & & & -1& -1& -1& -1& 1\end{array}\right],\end{array}\end{array}$$

and

$${\mathbf{D}}_{14}^{\left(5\right)}=diag\left(s_0^{\left(5\right)},s_1^{\left(5\right)},\dots ,s_{13}^{\left(5\right)}\right),$$

$$s_0^{\left(5\right)}=w_0^{\left(5\right)},s_1^{\left(5\right)}=w_0^{\left(5\right)}+w_1^{\left(5\right)},s_2^{\left(5\right)}=w_0^{\left(5\right)}+w_2^{\left(5\right)},s_3^{\left(5\right)}=w_0^{\left(5\right)}+w_1^{\left(5\right)}+w_2^{\left(5\right)}+w_3^{\left(5\right)},$$

$$s_4^{\left(5\right)}=w_1^{\left(5\right)},s_5^{\left(5\right)}=w_0^{\left(5\right)}+w_4^{\left(5\right)},s_6^{\left(5\right)}=w_1^{\left(5\right)}+w_3^{\left(5\right)},s_7^{\left(5\right)}=w_2^{\left(5\right)}+w_3^{\left(5\right)},$$

$$s_8^{\left(5\right)}=w_2^{\left(5\right)},s_9^{\left(5\right)}=w_1^{\left(5\right)}+w_4^{\left(5\right)},s_{10}^{\left(5\right)}=w_3^{\left(5\right)},s_{11}^{\left(5\right)}=w_2^{\left(5\right)}+w_4^{\left(5\right)},$$

$$s_{12}^{\left(5\right)}=w_3^{\left(5\right)}+w_4^{\left(5\right)},s_{13}^{\left(5\right)}=w_4^{\left(5\right)}.$$

Figure 3 illustrates a data flow graph of the proposed algorithm for implementing the basic filtering operation for a 5-tap FIR filter.

4.3. Algorithm 3, M = 7

Let ${\mathbf{X}}_{13\times 1}={\left[x_0,x_1,\dots ,x_{12}\right]}^{\mathrm{T}}$ be a vector that represents the input data set, ${\mathbf{W}}_{7\times 1}=\left[w_0^{\left(7\right)},w_1^{\left(7\right)},\right.$${\left.\dots ,w_6^{\left(7\right)}\right]}^{\mathrm{T}}$ be a vector that contains the coefficients of the impulse response of a 7-tap FIR filter, and ${\mathbf{Y}}_{7\times 1}={\left[y_0^{\left(7\right)},y_1^{\left(7\right)},\dots ,y_6^{\left(7\right)}\right]}^{\mathrm{T}}$ be a vector describing the results of using a 7-tap FIR filter:

$${\mathbf{Y}}_{7\times 1}=\left[\begin{array}{ccccccc}{x}_0& x_1& x_2& x_3& x_4& x_5& x_6\\ x_1& x_2& x_3& x_4& x_5& x_6& x_7\\ x_2& x_3& x_4& x_5& x_6& x_7& x_8\\ x_3& x_4& x_5& x_6& x_7& x_8& x_9\\ x_4& x_5& x_6& x_7& x_8& x_9& x_{10}\\ x_5& x_6& x_7& x_8& x_9& x_{10}& x_{11}\\ x_6& x_7& x_8& x_9& x_{10}& x_{11}& x_{12}\end{array}\right]\left[\begin{array}{c}{w}_0^{\left(7\right)}\\ w_1^{\left(7\right)}\\ w_2^{\left(7\right)}\\ w_3^{\left(7\right)}\\ w_4^{\left(7\right)}\\ w_5^{\left(7\right)}\\ w_6^{\left(7\right)}\end{array}\right]$$

(12)

As can be seen, calculating the product (12) requires 49 multiplications and 42 additions.

We can formulate a streamlined algorithm for computing ${\mathbf{Y}}_{7\times 1}$ by utilising the following matrix-vector calculation procedure:

$${\mathbf{Y}}_{7\times 1}={\mathbf{T}}_{7\times 15}^{\left(7\right)}{\mathbf{T}}_{15\times 25}^{\left(7\right)}{\mathbf{D}}_{25}^{\left(7\right)}{\mathbf{T}}_{25\times 18}^{\left(7\right)}{\mathbf{T}}_{18\times 13}^{\left(7\right)}{\mathbf{X}}_{13\times 1}$$

(13)

where

$$\begin{array}{c}{\mathbf{T}}_{7\times 15}^{\left(7\right)}=\left[\begin{array}{ccccccccccccccc}1& & & & & & 1& & & & & & & & \\ & 1& & & & & & 1& & & 1& & & & \\ & & 1& & & & & & 1& & & 1& & & \\ & & & 1& & & -1& & & & & & 1& & \\ & & & & 1& & & -1& & & & & & 1& \\ & & & & & 1& & & -1& & & & & & 1\\ & & & & & & & & & 1& & & & & \end{array}\right],\hfill \end{array}$$

$${\mathbf{T}}_{9\times 18}^{\left(7\right)}=\left[\begin{array}{ccc}{\mathbf{T}}_{3\times 6}^{\left(3\right)}& {\mathbf{0}}_{3\times 6}& {\mathbf{0}}_{3\times 6}\\ {\mathbf{0}}_{3\times 6}& {\mathbf{T}}_{3\times 6}^{\left(3\right)}& {\mathbf{0}}_{3\times 6}\\ {\mathbf{0}}_{3\times 6}& {\mathbf{0}}_{3\times 6}& {\mathbf{T}}_{3\times 6}^{\left(3\right)}\end{array}\right],{\mathbf{T}}_{9\times 7}^{\left(7\right)}=\left[\begin{array}{cc}1& {\mathbf{0}}_{1\times 6}\\ {\mathbf{0}}_{8\times 1}& {\mathbf{0}}_{8\times 6}\end{array}\right],$$

$${\mathbf{T}}_{6\times 7}^{\left(7\right)}=\left[\begin{array}{ccccccc}1& 1& 1& 1& 1& 1& 1\\ & 1& & & & & \\ & & 1& & & & \\ & & & 1& & & \\ & & & & 1& & \\ & & & & & 1& \end{array}\right],{\mathbf{T}}_{15\times 25}^{\left(7\right)}=\left[\begin{array}{cc}{\mathbf{T}}_{9\times 18}^{\left(7\right)}& {\mathbf{T}}_{9\times 7}^{\left(7\right)}\\ {\mathbf{0}}_{6\times 18}& {\mathbf{T}}_{6\times 7}^{\left(7\right)}\end{array}\right],$$

$${\mathbf{T}}_{6\times 8}^{\left(7\right)}=\left[\begin{array}{cc}{\mathbf{T}}_{6\times 5}^{\left(3\right)}& {\mathbf{0}}_{6\times 3}\end{array}\right],{\tilde{\mathbf{T}}}_{6\times 8}^{\left(7\right)}=\left[\begin{array}{cc}{\mathbf{0}}_{6\times 3}& {\mathbf{T}}_{6\times 5}^{\left(3\right)}\end{array}\right],{\mathbf{T}}_{12\times 8}^{\left(7\right)}=\left[\begin{array}{c}{\mathbf{T}}_{6\times 8}^{\left(7\right)}\\ {\tilde{\mathbf{T}}}_{6\times 8}^{\left(7\right)}\end{array}\right],$$

$${\mathbf{T}}_{10\times 5}^{\left(7\right)}=\left[\begin{array}{ccccc}-1& & & & \\ & & & & \\ & & & & \\ & -1& & & \\ & & -1& & \\ & & & & \\ & & & -1& \\ & & & & \\ & & & & \\ & & & & -1\end{array}\right],{\mathbf{T}}_{10}^{\left(7\right)}=\left[\begin{array}{ccc}{\mathbf{0}}_{10\times 4}& {\mathbf{T}}_{10\times 5}^{\left(7\right)}& {\mathbf{0}}_{10\times 1}\end{array}\right],$$

$${\mathbf{T}}_{12\times 10}^{\left(7\right)}=\left[\begin{array}{c}{\mathbf{0}}_{2\times 10}\\ {\mathbf{T}}_{10}^{\left(7\right)}\end{array}\right],{\mathbf{T}}_{6\times 10}^{\left(7\right)}=\left[\begin{array}{cc}{\mathbf{T}}_{6\times 5}^{\left(3\right)}& {\mathbf{0}}_{6\times 5}\end{array}\right],{\mathbf{T}}_{6\times 7}^{\left(7\right)}=\left[\begin{array}{cc}{\mathbf{I}}_6& {\mathbf{0}}_{6\times 1}\end{array}\right],$$

$$\begin{array}{c}\hfill {\mathbf{T}}_{1\times 7}^{\left(7\right)}=\left[\begin{array}{ccccccc}-1& -1& -1& -1& -1& -1& 1\end{array}\right],\end{array}$$

$${\mathbf{T}}_7^{\left(7\right)}=\left[\begin{array}{c}{\mathbf{T}}_{6\times 7}^{\left(7\right)}\\ {\mathbf{T}}_{1\times 7}^{\left(7\right)}\end{array}\right],{\mathbf{T}}_{7\times 10}^{\left(7\right)}=\left[\begin{array}{cc}{\mathbf{0}}_{7\times 3}& {\mathbf{T}}_7^{\left(7\right)}\end{array}\right],{\mathbf{T}}_{13\times 10}^{\left(7\right)}=\left[\begin{array}{c}{\mathbf{T}}_{6\times 10}^{\left(7\right)}\\ {\mathbf{T}}_{7\times 10}^{\left(7\right)}\end{array}\right],$$

$${\mathbf{T}}_{25\times 18}=\left[\begin{array}{cc}{\mathbf{T}}_{12\times 8}^{\left(7\right)}& {\mathbf{T}}_{12\times 10}\\ {\mathbf{0}}_{13\times 8}& {\mathbf{T}}_{13\times 10}\end{array}\right],$$

$$\begin{array}{c}\hfill {\mathbf{T}}_{8\times 11}^{\left(7\right)}=\left[\begin{array}{ccccccccccc}1& & & 1& & & -1& & & & \\ & 1& & & 1& & & & & & \\ & & 1& & & 1& & & & & \\ & & & 1& & & 1& & & & \\ & & & & 1& & & 1& & & \\ & & & & & 1& & & 1& & \\ & & & & & & 1& & & 1& \\ & & & & & & & 1& & & 1\end{array}\right],\end{array}$$

$${\mathbf{T}}_{8\times 13}^{\left(7\right)}=\left[\begin{array}{cc}{\mathbf{T}}_{8\times 11}^{\left(7\right)}& {\mathbf{0}}_{8\times 2}\end{array}\right],{\mathbf{T}}_{10\times 13}^{\left(7\right)}=\left[\begin{array}{cc}{\mathbf{0}}_{10\times 3}& {\mathbf{I}}_{10}\end{array}\right],{\mathbf{T}}_{18\times 13}=\left[\begin{array}{c}{\mathbf{T}}_{8\times 13}^{\left(7\right)}\\ {\mathbf{T}}_{10\times 13}^{\left(7\right)}\end{array}\right],$$

and

$${\mathbf{D}}_{25}^{\left(7\right)}=diag\left(s_0^{\left(7\right)},s_1^{\left(7\right)},\dots ,s_{24}^{\left(7\right)}\right),$$

$$s_0^{\left(7\right)}=w_0^{\left(7\right)},s_1^{\left(7\right)}=w_0^{\left(7\right)}+w_1^{\left(7\right)},s_2^{\left(7\right)}=w_1^{\left(7\right)},s_3^{\left(7\right)}=w_0^{\left(7\right)}+w_2^{\left(7\right)},s_4^{\left(7\right)}=w_1^{\left(7\right)}+w_2^{\left(7\right)},$$

$$s_5^{\left(7\right)}=w_2^{\left(7\right)},s_6^{\left(7\right)}=w_3^{\left(7\right)},s_7^{\left(7\right)}=w_3^{\left(7\right)}+w_4^{\left(7\right)},s_8^{\left(7\right)}=w_4^{\left(7\right)},s_9^{\left(7\right)}=w_3^{\left(7\right)}+w_5^{\left(7\right)},$$

$$s_{10}^{\left(7\right)}=w_4^{\left(7\right)}+w_5^{\left(7\right)},s_{11}^{\left(7\right)}=w_5^{\left(7\right)},s_{12}^{\left(7\right)}=w_3^{\left(7\right)}-w_0^{\left(7\right)},s_{13}^{\left(7\right)}=w_3^{\left(7\right)}+w_4^{\left(7\right)}-w_0^{\left(7\right)}-w_1^{\left(7\right)},$$

$$s_{14}^{\left(7\right)}=w_4^{\left(7\right)}-w_1^{\left(7\right)},s_{15}^{\left(7\right)}=w_3^{\left(7\right)}+w_5^{\left(7\right)}-w_0^{\left(7\right)}-w_2^{\left(7\right)},s_{16}^{\left(7\right)}=w_4^{\left(7\right)}+w_5^{\left(7\right)}-w_1^{\left(7\right)}-w_2^{\left(7\right)},$$

$$s_{17}^{\left(7\right)}=w_5^{\left(7\right)}-w_2^{\left(7\right)},s_{18}^{\left(7\right)}=w_0^{\left(7\right)}+w_6^{\left(7\right)},s_{19}^{\left(7\right)}=w_1^{\left(7\right)}+w_6^{\left(7\right)},s_{20}^{\left(7\right)}=w_2^{\left(7\right)}+w_6^{\left(7\right)},$$

$$s_{21}^{\left(7\right)}=w_3^{\left(7\right)}+w_6^{\left(7\right)},s_{22}^{\left(7\right)}=w_4^{\left(7\right)}+w_6^{\left(7\right)},s_{23}^{\left(7\right)}=w_5^{\left(7\right)}+w_6^{\left(7\right)},s_{24}^{\left(7\right)}=w_6^{\left(7\right)}.$$

Figure 4 illustrates a data flow graph of the proposed algorithm for implementing the basic filtering operation for a 7-tap FIR filter.

4.4. Algorithm 4, M = 9

Let ${\mathbf{X}}_{17\times 1}={\left[x_0,x_1,\dots ,x_{16}\right]}^{\mathrm{T}}$ be a vector that represents the input data set, ${\mathbf{W}}_{9\times 1}=\left[w_0^{\left(9\right)},w_1^{\left(9\right)},\right.$${\left.\dots ,w_8^{\left(9\right)}\right]}^{\mathrm{T}}$ be a vector that contains the coefficients of the impulse response of a 9-tap FIR filter, and ${\mathbf{Y}}_{9\times 1}={\left[y_0^{\left(9\right)},y_1^{\left(9\right)},\dots ,y_8^{\left(9\right)}\right]}^{\mathrm{T}}$ be a vector describing the results of using a 9-tap FIR filter:

$${\mathbf{Y}}_{9\times 1}=\left[\begin{array}{ccccccccc}{x}_0& x_1& x_2& x_3& x_4& x_5& x_6& x_7& x_8\\ x_1& x_2& x_3& x_4& x_5& x_6& x_7& x_8& x_9\\ x_2& x_3& x_4& x_5& x_6& x_7& x_8& x_9& x_{10}\\ x_3& x_4& x_5& x_6& x_7& x_8& x_9& x_{10}& x_{11}\\ x_4& x_5& x_6& x_7& x_8& x_9& x_{10}& x_{11}& x_{12}\\ x_5& x_6& x_7& x_8& x_9& x_{10}& x_{11}& x_{12}& x_{13}\\ x_6& x_7& x_8& x_9& x_{10}& x_{11}& x_{12}& x_{13}& x_{14}\\ x_7& x_8& x_9& x_{10}& x_{11}& x_{12}& x_{13}& x_{14}& x_{15}\\ x_8& x_9& x_{10}& x_{11}& x_{12}& x_{13}& x_{14}& x_{15}& x_{16}\end{array}\right]\left[\begin{array}{c}{w}_0^{\left(9\right)}\\ w_1^{\left(9\right)}\\ w_2^{\left(9\right)}\\ w_3^{\left(9\right)}\\ w_4^{\left(9\right)}\\ w_5^{\left(9\right)}\\ w_6^{\left(9\right)}\\ w_7^{\left(9\right)}\\ w_8^{\left(9\right)}\end{array}\right]$$

(14)

As can be seen, calculating the product (14) requires 81 multiplications and 72 additions.

We can formulate a streamlined algorithm for computing ${\mathbf{Y}}_{9\times 1}$ by utilising the following matrix-vector calculation procedure:

$${\mathbf{Y}}_{9\times 1}={\mathbf{T}}_{9\times 18}^{\left(9\right)}{\mathbf{T}}_{18\times 36}^{\left(9\right)}{\mathbf{D}}_{36}^{\left(9\right)}{\mathbf{T}}_{36\times 30}^{\left(9\right)}{\mathbf{T}}_{30\times 17}^{\left(9\right)}{\mathbf{X}}_{17\times 1}$$

(15)

where

$$\begin{array}{c}\hfill \begin{array}{c}{\mathbf{T}}_{9\times 18}^{\left(9\right)}=\left[\begin{array}{cccccccccccccccccc}1& & & 1& & & & & & 1& & & & & & & & \\ & 1& & & 1& & & & & & 1& & & & & & & \\ & & 1& & & 1& & & & & & 1& & & & & & \\ & & & 1& & & 1& & & & & & 1& & & & & \\ & & & & 1& & & 1& & & & & & 1& & & & \\ & & & & & 1& & & 1& & & & & & 1& & & \\ & & & & & & & & & 1& & & 1& & & 1& & \\ & & & & & & & & & & 1& & & 1& & & 1& \\ & & & & & & & & & & & 1& & & 1& & & 1\end{array}\right],\hfill \end{array}\end{array}$$

$${\tilde{\mathbf{T}}}_{9\times 18}^{\left(9\right)}=\left[\begin{array}{ccc}{\mathbf{T}}_{3\times 6}^{\left(3\right)}& {\mathbf{0}}_{3\times 6}& {\mathbf{0}}_{3\times 6}\\ {\mathbf{0}}_{3\times 6}& {\mathbf{T}}_{3\times 6}^{\left(3\right)}& {\mathbf{0}}_{3\times 6}\\ {\mathbf{0}}_{3\times 6}& {\mathbf{0}}_{3\times 6}& {\mathbf{T}}_{3\times 6}^{\left(3\right)}\end{array}\right],{\mathbf{T}}_{18\times 36}^{\left(9\right)}=\left[\begin{array}{cc}{\tilde{\mathbf{T}}}_{9\times 18}^{\left(9\right)}& {\mathbf{0}}_{9\times 18}\\ {\mathbf{0}}_{9\times 18}& {\tilde{\mathbf{T}}}_{9\times 18}^{\left(9\right)}\end{array}\right],$$

$${\mathbf{T}}_{6\times 10}^{\left(9\right)}=\left[\begin{array}{cc}{\mathbf{T}}_{6\times 5}^{\left(3\right)}& {\mathbf{0}}_{6\times 5}\end{array}\right],{\tilde{\mathbf{T}}}_{6\times 10}^{\left(9\right)}=\left[\begin{array}{cc}{\mathbf{0}}_{6\times 5}& {\mathbf{T}}_{6\times 5}^{\left(3\right)}\end{array}\right],{\mathbf{T}}_{12\times 10}^{\left(9\right)}=\left[\begin{array}{c}{\mathbf{T}}_{6\times 10}^{\left(9\right)}\\ {\tilde{\mathbf{T}}}_{6\times 10}^{\left(9\right)}\end{array}\right],$$

$${\mathbf{T}}_{36\times 30}^{\left(9\right)}=\left[\begin{array}{ccc}{\mathbf{T}}_{12\times 10}^{\left(9\right)}& {\mathbf{0}}_{12\times 10}& {\mathbf{0}}_{12\times 10}\\ {\mathbf{0}}_{12\times 10}& {\mathbf{T}}_{12\times 10}^{\left(9\right)}& {\mathbf{0}}_{12\times 10}\\ {\mathbf{0}}_{12\times 10}& {\mathbf{0}}_{12\times 10}& {\mathbf{T}}_{12\times 10}^{\left(9\right)}\end{array}\right],$$

$$\begin{array}{c}\hfill \begin{array}{c}{\mathbf{T}}_{5\times 11}^{\left(9a\right)}=\left[\begin{array}{ccccccccccc}1& & & -1& & & -1& & & & \\ & 1& & & -1& & & -1& & & \\ & & 1& & & -1& & & -1& & \\ & & & 1& & & -1& & & -1& \\ & & & & 1& & & -1& & & -1\end{array}\right],\hfill \end{array}\end{array}$$

$$\begin{array}{c}\hfill \begin{array}{c}{\mathbf{T}}_{5\times 11}^{\left(9b\right)}=\left[\begin{array}{ccccccccccc}-1& & & 1& & & -1& & & & \\ & -1& & & 1& & & -1& & & \\ & & -1& & & 1& & & -1& & \\ & & & -1& & & 1& & & -1& \\ & & & & -1& & & 1& & & -1\end{array}\right],\hfill \end{array}\end{array}$$

$$\begin{array}{c}\hfill \begin{array}{c}{\mathbf{T}}_{5\times 11}^{\left(9c\right)}=\left[\begin{array}{ccccccccccc}-1& & & -1& & & 1& & & & \\ & -1& & & -1& & & 1& & & \\ & & -1& & & -1& & & 1& & \\ & & & -1& & & -1& & & 1& \\ & & & & -1& & & -1& & & 1\end{array}\right],\hfill \end{array}\end{array}$$

$${\mathbf{T}}_{5\times 17}^{\left(9a\right)}=\left[\begin{array}{cc}{\mathbf{T}}_{5\times 11}^{\left(9a\right)}& {\mathbf{0}}_{5\times 6}\end{array}\right],{\mathbf{T}}_{5\times 17}^{\left(9b\right)}=\left[\begin{array}{ccc}{\mathbf{0}}_{5\times 3}& {\mathbf{I}}_5& {\mathbf{0}}_{5\times 9}\end{array}\right],$$

$${\mathbf{T}}_{5\times 17}^{\left(9c\right)}=\left[\begin{array}{ccc}{\mathbf{0}}_{5\times 3}& {\mathbf{T}}_{5\times 11}^{\left(9b\right)}& {\mathbf{0}}_{5\times 3}\end{array}\right],{\mathbf{T}}_{5\times 17}^{\left(9d\right)}=\left[\begin{array}{ccc}{\mathbf{0}}_{5\times 6}& {\mathbf{I}}_5& {\mathbf{0}}_{5\times 6}\end{array}\right],$$

$${\mathbf{T}}_{5\times 17}^{\left(9e\right)}=\left[\begin{array}{ccc}{\mathbf{0}}_{5\times 9}& {\mathbf{I}}_5& {\mathbf{0}}_{5\times 3}\end{array}\right],{\mathbf{T}}_{5\times 17}^{\left(9f\right)}=\left[\begin{array}{cc}{\mathbf{0}}_{5\times 6}& {\mathbf{T}}_{5\times 11}^{\left(9c\right)}\end{array}\right],$$

$${\mathbf{T}}_{30\times 17}^{\left(9\right)}=\left[\begin{array}{c}{\mathbf{T}}_{5\times 17}^{\left(9a\right)}\\ {\mathbf{T}}_{5\times 17}^{\left(9b\right)}\\ {\mathbf{T}}_{5\times 17}^{\left(9c\right)}\\ {\mathbf{T}}_{5\times 17}^{\left(9d\right)}\\ {\mathbf{T}}_{5\times 17}^{\left(9e\right)}\\ {\mathbf{T}}_{5\times 17}^{\left(9f\right)}\end{array}\right],$$

$${\mathbf{D}}_{36}^{\left(9\right)}=diag\left(s_0^{\left(9\right)},s_1^{\left(9\right)},\dots ,s_{35}^{\left(9\right)}\right),$$

$$s_0^{\left(9\right)}=w_0^{\left(9\right)},s_1^{\left(9\right)}=w_0^{\left(9\right)}+w_1^{\left(9\right)},s_2^{\left(9\right)}=w_1^{\left(9\right)},s_3^{\left(9\right)}=w_0^{\left(9\right)}+w_2^{\left(9\right)},s_4^{\left(9\right)}=w_1^{\left(9\right)}+w_2^{\left(9\right)},$$

$$s_5^{\left(9\right)}=w_2^{\left(9\right)},s_6^{\left(9\right)}=w_0^{\left(9\right)}+w_3^{\left(9\right)},s_7^{\left(9\right)}=w_0^{\left(9\right)}+w_1^{\left(9\right)}+w_3^{\left(9\right)}+w_4^{\left(9\right)},s_8^{\left(9\right)}=w_1^{\left(9\right)}+w_4^{\left(9\right)},$$

$$s_9^{\left(9\right)}=w_0^{\left(9\right)}+w_2^{\left(9\right)}+w_3^{\left(9\right)}+w_5^{\left(9\right)},s_{10}^{\left(9\right)}=w_1^{\left(9\right)}+w_2^{\left(9\right)}+w_4^{\left(9\right)}+w_5^{\left(9\right)},s_{11}^{\left(9\right)}=w_2^{\left(9\right)}+w_5^{\left(9\right)},$$

$$s_{12}^{\left(9\right)}=w_3^{\left(9\right)},s_{13}^{\left(9\right)}=w_3^{\left(9\right)}+w_4^{\left(9\right)},s_{14}^{\left(9\right)}=w_4^{\left(9\right)},s_{15}^{\left(9\right)}=w_3^{\left(9\right)}+w_5^{\left(9\right)},s_{16}^{\left(9\right)}=w_4^{\left(9\right)}+w_5^{\left(9\right)},$$

$$s_{17}^{\left(9\right)}=w_5^{\left(9\right)},s_{18}^{\left(9\right)}=w_0^{\left(9\right)}+w_6^{\left(9\right)},s_{19}^{\left(9\right)}=w_0^{\left(9\right)}+w_1^{\left(9\right)}+w_6^{\left(9\right)}+w_7^{\left(9\right)},s_{20}^{\left(9\right)}=w_1^{\left(9\right)}+w_7^{\left(9\right)},$$

$$s_{21}^{\left(9\right)}=w_0^{\left(9\right)}+w_2^{\left(9\right)}+w_6^{\left(9\right)}+w_8^{\left(9\right)},s_{22}^{\left(9\right)}=w_1^{\left(9\right)}+w_2^{\left(9\right)}+w_7^{\left(9\right)}+w_8^{\left(9\right)},s_{23}^{\left(9\right)}=w_2^{\left(9\right)}+w_8^{\left(9\right)},$$

$$s_{24}^{\left(9\right)}=w_3^{\left(9\right)}+w_6^{\left(9\right)},s_{25}^{\left(9\right)}=w_3^{\left(9\right)}+w_4^{\left(9\right)}+w_6^{\left(9\right)}+w_7^{\left(9\right)},s_{26}^{\left(9\right)}=w_4^{\left(9\right)}+w_7^{\left(9\right)},$$

$$s_{27}^{\left(9\right)}=w_3^{\left(9\right)}+w_5^{\left(9\right)}+w_6^{\left(9\right)}+w_8^{\left(9\right)},s_{28}^{\left(9\right)}=w_4^{\left(9\right)}+w_5^{\left(9\right)}+w_7^{\left(9\right)}+w_8^{\left(9\right)},s_{29}^{\left(9\right)}=w_5^{\left(9\right)}+w_8^{\left(9\right)},$$

$$s_{30}^{\left(9\right)}=w_6^{\left(9\right)},s_{31}^{\left(9\right)}=w_6^{\left(9\right)}+w_7^{\left(9\right)},s_{32}^{\left(9\right)}=w_7^{\left(9\right)},s_{33}^{\left(9\right)}=w_6^{\left(9\right)}+w_8^{\left(9\right)},s_{34}^{\left(9\right)}=w_7^{\left(9\right)}+w_8^{\left(9\right)},$$

$$s_{35}^{\left(9\right)}=w_8^{\left(9\right)}.$$

Figure 5 illustrates a data flow graph of the proposed algorithm for implementing the basic filtering operation for a 9-tap FIR filter.

5. Implementation Complexity

Due to the relatively small lengths of the input sequences and the straightforward nature of the data flow diagrams depicting the computation process, it is easy to assess the implementation complexity of the proposed solutions.

Table 1. The complexities of implementing of the naive and proposed solutions.

Size M	Numbers of Arithmetic Blocks
	Naive Method		Proposed Algorithm
	Multipliers	M-Input Adders	Multipliers	2-Input Adders	3-Input Adders	4-Input Adders	$\mathbf{M}$-Input Adders
3	9	3	6	-	6	-	-
5	25	5	14	4	-	-	10
7	49	7	25	7	24	1	1
9	81	9	36	-	60	-	-

estimates the number of arithmetic blocks required for the fully parallel implementation of the filtering algorithms designed for short lengths. The values presented in the table can be regarded as an approximate measure of the implementation cost on an ASIC.

As we can see, using the proposed algorithmic solutions to construct digital filtering cores results in fewer multipliers being needed than using naive approaches to their design. In the context of designing specialised fully parallel VLSI processors, minimising the number of multipliers is of paramount importance. This approach significantly reduces the cost of implementing the entire system and mitigates power dissipation. This is due to the hardware multiplier’s higher level of complexity and larger chip area occupation than the adder. It has been demonstrated that the hardware cost of a binary adder rises linearly with the operand size. In contrast, the implementation cost of a hardwired multiplier escalates quadratically with the operand size [46]. Hence, reducing the number of multipliers, even if it results in a slight increase in the number of adders, significantly influences the hardware implementation of digital filtering cores.

The proposed algorithms have been exemplarily implemented in FPGAs on the simplest possible devices of Xilinx’s Spartan 3 series. The criterion for selecting a model from the Spartan 3 family was to provide a sufficient number of inputs and outputs. The 8-bit inputs ${\mathbf{X}}_{(2M-1)\times 1}$, 16-bit outputs ${\mathbf{Y}}_{9\times 1}$, and fixed 8-bit coefficients of the impulse response of the FIR filter ${\mathbf{W}}_{M\times 1}$, were assumed.

Table 2. The number of the multipliers MULT 18 × 18, and the slices used in the Spartan 3 FPGA implementations.

		MULT 18 × 18		Slices
Size M	Devices	School	Proposed	School	Proposed	Reduction
3	xc3s50-4pq208	4	4	111	110	0.9%
5	xc3s400-4fg456	16	14	563	342	39.3%
7	xc3s400-4fg456	16	16	776	684	11.9%
9	xc3s1000-4fg676	24	24	1303	1066	18.2%

shows the number of slices used in the Spartan 3 FPGA implementation. The number of uses multipliers MULT 18 × 18 is also shown in this table, but both algorithms mostly used all hardware-accessible multipliers. Only for size $M=5$ was the number of available multipliers is for the proposed algorithm greater than required, and only in this case did the algorithm not use all of them.

Table 3. The number of the 4 input LUTs used in the Spartan 3 FPGA implementations.

		4 Input LUTs
Size M	Devices	School	Proposed	Reduction
3	xc3s50-4pq208	207	202	2.4%
5	xc3s400-4fg456	1040	636	38.8%
7	xc3s400-4fg456	1441	1284	10.9%
9	xc3s1000-4fg676	2456	1994	18.8%

shows the number of four input LUTs used in the Spartan 3 FPGA implementation. For each size M, the proposed algorithms achieved a reduction of the logic blocks used. The smallest was for the size $M=3$, where the reduction was only about 1% for the slices and 2,4% for four inputs LUTs. The biggest was for size $M=5$, which achieves nearly a 40% decrease in logical blocks.

6. Conclusions

This study explores methods to reduce the multiplicative complexity of conducting basic filtering operations for M-tap FIR filters with short impulse responses, commonly used in convolutional neural networks. Additionally, new algorithms for resource-efficient implementations of these algorithms have been devised for M values of 3, 5, 7, and 9. By utilising these algorithms, basic filtering operations computational complexity is reduced, which also lessens the difficulty of their hardware implementation. Reducing the number of multiplications in the algorithms comes at the expense of some increase in the number of additions. However, this is not significant due to the much higher implementation cost of the hardware multiplier relative to the adder. Some limitation of the proposed algorithms is the increased complexity of data manipulation. For this reason, it seems particularly advantageous to implement the proposed solutions in ASICs. The distinctive feature of all the proposed algorithms is their evident parallel and modular structures. The modularity allows unifying the implementation of the algorithms in FPGAs and makes it easier to map them into ASIC structures. Consequently, the parallelisation of computing processes enables accelerated computations during the execution of these algorithms. The implementation of the proposed algorithms in DNNs will be a target for further research.