Delay Bound Optimization in NoC Using a Discrete Firefly Algorithm

Abstract

The delay bound in system on chips (SoC) represents the worst-case traverse time of on-chip communication. In network on chip (NoC)-based SoC, optimizing the delay bound is challenging due to two aspects: (1) the delay bound is hard to obtain by traditional methods such as simulation; (2) the delay bound changes with the different application mappings. In this paper, we propose a delay bound optimization method using discrete firefly optimization algorithms (DBFA). First, we present a formal analytical delay bound model based on network calculus for both unipath and multipath routing in NoCs. We then set every flow in the application as the target flow and calculate the delay bound using the proposed model. Finally, we adopt firefly algorithm (FA) as the optimization method for minimizing the delay bound. We used industry patterns (video object plane decoder (VOPD), multiwindow display (MWD), etc.) to verify the effectiveness of delay bound optimization method. Experiments show that the proposed method is both effective and reliable, with a maximum optimization of 42.86%.

1. Introduction

In modern system on chips (SoC) design, average [1,2,3] and worst-case [4,5,6,7,8,9,10,11,12,13,14,15] performance are two essential metrics for communication architecture. Quality-of-service (QoS) in network on chip (NoC) represents the worst-case traverse time of on-chip communications. In NoC based SoC, optimizing the delay bound is challenging. Formal approaches have been proposed for delay bound modeling [16,17,18,19,20,21]. Wang et al. [16] used signal flow chart and signal time measures to analyze the upper bound of transmission delay time. Ren et al. [17] analyzed the communication delay bound for individual flows in NoC using an improved asymmetric multichannel structure of a router. Lu et al. [19,20] modeled a classic input-queuing virtual channel router and a unified platform in Simulink based on xMAS to improve the accuracy of NoC performance analysis.

As an effective tool, network calculus has been applied in NoC performance analysis [21,22]. How to improve the tightness of a NoC performance model based on network calculus has become one of the important research directions. Saggio et al. [23] validated the effectiveness of network calculus for delay bound modeling. To improve the accuracy of a NoC delay bound, Zhao et al. [24] used simulated annealing (SA) to automatically calculate the simulation parameters. They also extended the method from delay bound to a backlog bound tightness study [25], where SA was replaced by an adaptive simulated annealing (ASA) algorithm, with higher efficiency and precision.

The works above show that heuristic approaches can be an effective tool for worst-case performance analysis and that motivated us to improve the delay bound tightness under different mappings. Other than optimizing specific configuration, we focused on optimizing the delay bound in specific application mapping. We observed that different mapping schemes have different delay bounds for NoC traffic flows. When the mapping scheme changes, the contention scenarios also change. However, delay bound optimization is challenging not only because such problems are hard, but also its model should be both accurate and fast enough for solution exploration.

The firefly algorithm (FA) was inspired by the behavior of fireflies flashing and was first put forward by Xin-She Yang [26]. In recent years, FA has been widely used to optimize NoC design in design spaces [27,28,29]. In this paper, we propose a delay bound optimization method using firefly algorithms (DBFA). Instead of improving the simulation parameter accuracy and analyzing network contention, DBFA attempts to find the optimal mapping scheme directly. The experimental results show that the mapping scheme determined by FA is closer to the optimal mapping scheme than discrete particle swarm optimization (DPSO) [30]. Our contribution is summarized as follows:

• We modeled the worst-case delay bound in network on chip using network calculus. It is suitable for both unipath and multipath routing NoCs.
• We adopted FA to optimize the end-to-end delay bound. FA shows high efficiency in many other fields, such as scheduling. To the best of our knowledge, this is the first work using FA for delay bound optimization.
• We performed extensive experiments using both synthetic and industry patterns. We also integrated our delay bound model into DPSO, a state-of-the-art algorithm, for performance comparison.

2. Delay Bound Analysis Using Network Calculus

Simulation experiments [31] can easily obtain latency and communication costs, but it is difficult to obtain a delay bound. The network calculus fills the gap. In Figure 1, $R\left(t\right)$ and $R^{\ast }\left(t\right)$ represent the actual arrival curve and service curve of NoC, respectively. A linear function $\alpha \left(t\right)$ covers the maximum rate of $R\left(t\right)$; $\beta \left(t\right)$ represents the minimum service rate of $R^{\ast }\left(t\right)$. Both are defined as follows:

$$\alpha \left(t\right)=\left\{\begin{array}{cc}\hfill rt+b& t>0\hfill \\ \hfill 0& otherwise\hfill \end{array}\right.$$

$$\beta \left(t\right)=\left\{\begin{array}{cc}\hfill R(t-T)& t>T\hfill \\ \hfill 0& otherwise\hfill \end{array}\right.$$

where r is the sustainable arrival rate, b is the burstiness, R is the minimum service rate, and T is the maximum processing latency. In particular, R is usually greater than r to ensure no packet dropping in NoC. Delay bound $\overline{D}\left(t\right)$ of a flow $f_i$ is calculated by finding the greatest horizontal distance $h(\alpha ,\beta )$ between its arrival curve $\alpha \left(t\right)$ and the system equivalent service curve $\beta \left(t\right)$. Hence the delay bound is derived as follows [9]:

$$\overline{D}\left(t\right)=h(\alpha ,\beta )=T+\frac{b}{R}.$$

(1)

To express more clearly, we show all the symbols in

Table 1. Symbols and Definitions.

Symbol	Definitions
$f[i,j]$	The flow injected at router i and ejected at router j
$\alpha (i,j)$	The arrival curve of f[i, j] at ingress node i
${\beta }_i$	The service curve of router i
${\beta }_{eq}^{f_{(i,j)}}$	The equivalent service curve of flow f(i, j)
$a^{+}$	if $a>0$, $a^{+}=a$, otherwise, $a^{+}=0$
$h(\alpha ,\beta )$	The function to compute the maximum horizontal distance between the arrival curve and service curve
$\in (.,.)$	The function to compute the equivalent service curve
$inf\{a,b\}$	To obtain the minimize value between a and b

.

3. Delay Bound Optimization Using Discrete Firefly Algorithms

3.1. Problem Formulation

We first present a general mapping process through the following definitions to optimize the total communication cost.

To map an application characteristic graph $G\left(V,E\right)$ to a NoC topology graph $P\left(U,F\right)$, the mapping function $map\left(\right)$ should satisfy the following constraints:

$$v_i\in V\Rightarrow map\left(v_i\right)\in U;$$

(2)

$$v_i\ne v_j\iff map\left(v_i\right)\ne map\left(v_j\right);$$

(3)

$$size\left(V\right)\le size\left(U\right);$$

(4)

$$b_{i,j}\le B_{i,j}.$$

(5)

The smaller the delay bound, the better the mapping results. In this paper, we assume the NoC topology is a mesh. Therefore, the delay bound is usually calculated by the following equations.

$$DelayBound=max(D_1,D_2,...,D_n),$$

(6)

where $D_n$ is delay bound of every target flow, whose calculation is shown in the rest of this section. Thus, the optimization target is $minDelayBound$.

3.2. Delay Bound Model

We present the delay bound calculation model in Algorithm 1. The key idea of the delay bound analysis is obtaining the end to end equivalent service curve (ESC) by considering all kinds of resource sharing, shown in line 3–13, and summarized in four steps.

$Step$ 1: Use the function ClassifyConFlow() to classify the flow contentions into a unified representation as $f_{[a,b]}$, where a and b, respectively, are the traffic injection and output router node. These flows could be a single flow or an aggregate flow consisting of several contention flows; i.e., both unipath and multipath routing are supported in this model.

$Step$ 2: Calculate the arrive curve of $f_{[a,b]}$ at node a.

$Step$ 3: Calculate the equivalent service curve for the target flow and obtain the delay bound.

$Step$ 4: Repeat Steps 1–3 to find the delay bound of every single flow and select the max value as the delay bound in the current mapping.

Algorithm 1 Delay bound calculation

1 Input    ${\beta }_i\left(t\right)=R_i{(t-T_i)}^{+}$, $1\le i\le X\ast Y$, ${\alpha }_{f_j}=r_{j}t+b_j$, $1\le j\le FlowNum$ 2 Output$D_{max}$ 3 for the flow $f_k\in \left\{TagFlowSet\right\}$ 4 { 5       $ESC\left(f_k\right)$                                                    //To calculate the Equivalent Service Curve of flow $f_k$. 6       $NodeSet\left(\right)$                                                 //find all nodes which $f_k$ has passed. 7       $CClassSet=ClassifyConFlow\left(\right)$                   //Classify all the contention flows. 8       for $f_{[a,b]}\in CClassSet$ 9       { 10             $ACSet=AC\left(f_{[a,b]}\right)$ 11             if $CrossContention$ 12                   Cut all cross-contention flows             //The treatments of cross contention situation. 13                   $ACSet=AC\_CrossCon(f_{[a,b]},ACSet)$ //Calculate the arrive curve of cut-flows and combine the same type flows. 14             else 15                   $ESC=ESCNoCrossCon(f_{[a,b]},ACSet)$ // The treatments of other contention situations. 16       } 17       $Delay(f_k,ESC)$                                           //obtain it delay bound. 18 } 19 $D_{max}=max\left(Delay(f_k,ESC)\right)$                            //Obtain the worst-delay-bound for one scheme.

3.3. Distance Calculation

The calculation of distance is as follows.

$$s_{mn}=\sum _{i=0}^{Tnum}\left(\right|x_i^m-x_i^n|+|y_i^m-y_i^n\left|\right),$$

(7)

where $s_{mn}$ is the Manhattan distance between firefly $X_m$ and $X_n$, $(x_i^m,y_i^m)$ represents the coordinates of the mapping scheme of firefly m in task i. Accordingly, $(x_i^n,y_i^n)$ represents the coordinates of the mapping scheme of firefly n in task i. And $T_{n}um$ is the total number of tasks.

In order to make the distance and the absorption coefficient in the same magnitude, we perform min-max operation to normalize the distance between two fireflies.

$$S_{mn}=\frac{s_{mn}-s_{min}}{s_{max}-s{}_{min}},$$

(8)

where $s_{min}$ is the minimum distance between two fireflies and $s_{max}$ is the maximum distance for the target firefly. To make it more clear, take Figure 2 as an example. There are two fireflies $X_m$ and $X_n$ in Figure 2a,b, respectively.

For firefly $X_m$, task numbers 1, 3, and 5 are mapped to (4, 4)(node F), (3, 4)(node B), and (2, 4)(node 7), respectively. For $X_n$, the positions of the above three tasks are (2, 1)(node 4), (2, 2)(node 5), and (2, 3)(node 6), respectively. According to the Equation (7), we can calculate $s_1=|4-2|+|4-1|=5$, $s_3=|3-2|+|4-2|=3$, and $s_5=|2-2|+|4-3|=1$. The positions of task numbers 0, 2, and 4 have not changed, so $s_0$, $s_2$ and $s_4$ are all 0. At last, we can calculate the distance between fireflies $X_m$ and $X_n$ as $s_{mn}=0+5+0+3+0+1=9$.

Figure 2c shows the theoretical max distance for firefly $X_m$, which does not exist actually. The max distance is a ideal up-bound value, which is defined as mapping the current task to the theoretical farthest corner node; e.g., task 0 and 2 are mapping to node 15. In this example, $s_{max}=6+5+5+5+5+6=32$. As a result, the distance between firefly $X_m$ and $X_n$ is $S_{mn}=\frac{9}{32}=0.28125$.

3.4. Refreshing of Firefly Locations

The original firefly location refreshing formula [26] is as the following:

$$X_i(t+1)=X_i\left(t\right)+\beta \left(r\right)·(X_j\left(t\right)-X_i\left(t\right))+\alpha ·Random\left(\right).$$

(9)

In our approach, we rewrite the firefly refreshing formula as follows.

$$X_i\left(t+1\right)=\left(1-\beta \left(r\right)\right)·X_i\left(t\right)+\beta \left(r\right)·X_j\left(t\right)+\alpha ·Random\left(\right)$$

(10)

Thus, this formula consists of the following two parts:

• β movement. Fireflies refresh because of the attractiveness between any two fireflies; it is related to attractiveness $\beta \left(r\right)$, so we call it $\beta$ movement.
• α movement. Fireflies refresh because of the random movement; it is related to the maximal random step $\alpha$, so we call it $\alpha$ movement.

Each firefly moves towards the brighter fireflies through $\beta$ movement (the mapping scheme least delay bound). Later, each firefly moves randomly though $\alpha$ movement to find a better mapping scheme. The $\alpha$ movement rule is different between the non optimal firefly and the optimal firefly, so we call the former $\alpha 1$ movement and the latter $\alpha 2$ movement.

1. $\alpha 1$ movement

In order to learn the $\alpha 1$ movement of firefly $X_i\left(t_i\right)$ after $\beta$ movement, we defined a set w to record the positions of elements which occupy different positions between $X_i\left(t_i\right)$ and $X_j\left(t_j\right)$. Then we chose $\alpha$ number of positions from w as exchange positions, and exchanged each two elements with probability p to finish the $\alpha 1$ movement.

2. $\alpha 2$ movement

The $\alpha 2$ movement is used for preventing an optimal firefly from falling into a local optimum. It increases the exploring capability of DBFA. We chose $\alpha$ number of positions in local optimum mapping scheme and exchanged each two elements with probability q to finish the $\alpha 2$ movement. The probability q was randomly generated by a uniform distribution function.

3.5. Pseudo Code of Firefly Algorithm

The pseudo code of DBFA is shown in Algorithm 2. All the steps described above are covered in this algorithm; i.e., defining firefly, calculating distance, refreshing locations, and optimizing the delay bounds.

For algorithm complexity, if there are n fireflies in the colony, we obtain a local optimum firefly in every generation when executing Algorithm 2. For other fireflies, the calculation process of each firefly from line $5-14$ would be carried out $(n-1)$ times. Thus the iterations of all fireflies is ${(n-1)}^2$. After all, the complexity of the FA is $O\left({(n-1)}^2\right)$. Therefore, the complexity of whole program of DBFA is $o\left(m{(n-1)}^2{\left(\frac{j\times (j+1)}{2}\right)}^l\right)$.

Algorithm 2 DBFA

1 Input    The application characteristic graph $G_f(PE,E_f)$, NoC topology graph $D_f(R,P_f)$, fireflies colony number $Fnum$,        maximum iterations $Gmax$, absorption coefficient $\gamma$, maximum attractiveness ${\beta }_0$, and maximal random step $\alpha$. 2 Output Global optimum firefly $X_{min}^{\mathrm{global}}$ 3 Set parameters to initialize fireflies 4 for all $G<GMax$ 5 { 6       $FindGlobal\left(\right)=minM\left(Dmax\right)$             // Search for the global optimum firefly $X_{min}^{\mathrm{global}}$ with a minimized delay bound. 7       for all $i<Fnum$ 8       { 9             for all $i<Fnum$ 10             { 11                   $S=ComputeDistance\left(X_{ij}\right)$    //Compute the distance between $X_i\left(t_i\right)$ and $X_j\left(t_j\right)$. 12                   if $\frac{1}{dela{y}_i}<\frac{1}{dela{y}_j}\times exp(-\gamma S_{ij})$ //Satisfy move condition that $X_i\left(t_i\right)$ moves towards $X_j\left(t_j\right)$. 13                   { 14                         Compute the attractiveness between $X_i\left(t_i\right)$ and $X_j\left(t_j\right)$. 15                         $X_i\left(t_i\right)$                         // execute $\beta$ movement. 16                         $X_i\left(t_i\right)$                         // execute $\alpha 1$ movement. 17                   } 18             } 19       } 20       $X_{min}^{\mathrm{global}}$                                           // execute $\alpha 2$ movement. 21 }

3.6. Example of the Delay Bound Optimizing Process

To further understand the movement procedure, still take Figure 2 as an example. We calculated the delay bound of firefly $X_m$ in Section 3 as ${\overline{D}}_m=1139.833$. Using the same method, we can also obtain the delay bound of firefly $X_n$${\overline{D}}_n=366$. The distance between $X_m$ and $X_n$ is $S_{mn}=0.3125$, so we assign $\gamma =0.3$, which satisfies the moving condition $\frac{1}{1139.833}<\frac{1}{366}\times exp(-0.3\times 0.3125)$.

Therefore firefly $X_m$ moves towards $X_n$.

The attractiveness between fireflies can be calculated with the following formula.

$$\beta \left(r\right)={\beta }_0{e}^{-\gamma s^2}.$$

(11)

We define ${\beta }_0=1$, so the attractiveness between $X_m$ and $X_n$ is $\beta =1\times e^{(-0.3\times {0.3125}^2)}=0.97$.

As Figure 3 shows, compared with the mapping scheme of $X_n$, there are three different positions in $X_m$ (regardless the position with the value $-1$). We can see that the first different value is 1, so we look for the location where 1 is in $X_m$. Use the probability $\beta$ to change the value in the last one with value in the fifth number. Repeat this step until all the different positions are changed to the same. So far we have already finished the $\beta$ movement.

The firefly $X_m$ which has gone through the $\beta$ movement continues to complete the $\alpha 1$ movement. This step makes sure the firefly will move towards a lighter firefly exactly (with a lower delay bound). We supposed firefly $X_n$ was the local optimum firefly, so we made it move according to the $\alpha 2$ movement rules. As Figure 4 shows, we randomly chose $\alpha$ positions in local optimum firefly and randomly produced a change probability q. In this case, we supposed that for $q=0.57$ and $\alpha =3$, the three positions would be <1,5,8>, changing the values with probability $0.57$ in turn. So far, we can finish the $\alpha 2$ movement.

4. Experiments and Results

We performed experiments for the following three purposes: (1) proving the effectiveness of DBFA in delay bound optimization, (2) comparing the results with state-of-the-art work DPSO, and (3) verifying the tightness of DBFA compared to a simulation.

4.1. Setting Up

We mapped some applications to a mesh-NoC to test the reliability of our method. The characteristic graphs of industry patterns [30] such as picture-in-picture(PIP) [32], multiwindow display (MWD) [33], 263DEC MP3DEC [34], MP3ENC MP3DEC [34], MP3ENC MP3DEC [34], video object plane decoder (VOPD) [35], and DVOPD [36] are as shown in Figure 5, Figure 6a, and Figure 7. The mesh-NoC scale was $4\times 4$ and the whole progress was simulated by $C++$ and run in the platform of $Ubuntu12.04$. Experimental parameter settings are shown in Figure 2. The experimental parameters are shown in

Table 2. DBFA parameter settings.

Applications	$\mathit{Vertexes}$	$\mathit{Edges}$	$\mathit{Fnum}$	$\mathit{GMax}$	$\mathit{\gamma }$	$\mathit{\alpha }$	NoC Mesh
PIP	8	8	10	300	0.29	3	4 × 2
VOPD	16	21	20	400	0.3	4	4 × 4
MWD	12	12	30	600	0.3	5	4 × 4
263ENC MP3DEC	12	12	25	800	0.2	3	4 × 4
MP3ENC MP3DEC	13	13	25	800	0.18	3	4 × 4
263DEC MP3DEC	14	15	25	800	0.25	3	4 × 4
DVOPD	32	44	20	6000	0.28	6	8 × 4

. $Fnum$ represents the total number of fireflies in fireflies group and $GMax$ represents the maximum number of iterations. $\gamma$ and $\alpha$ represent the absorption coefficient and the maximal random step, respectively.

4.2. Experiment Results

VOPD has 21 flows, which is the largest and most complex characteristic graph in this paper, and we take it as an example to prove that optimization performance of DBFA is more convincing. The mapping scheme using the RAND, DPSO, and DBFA methods is shown in Figure 6b–d, where circles represent tasks and rectangles represent network nodes. The mapping scheme obtained by the three methods has corresponding delays of 55, 46, and 42, respectively.

The results of minimum worst-case delay bound in every generation are shown in Figure 8. At first, the beginning the worst delay bound was 55 cycles; after 400-times optimization, the delay bound was 42, which reduced by $23.64\%$. Compared with DPSO, DBFA can avoid the situation of the algorithm falling into a local optimum. DBFA is designed for NoC, by introducing $\alpha$ movement and $\beta$ movement to successfully identify and jump out of local optimal traps. This is an important reason why DBFA is more efficient than DPSO. Its delay bound for each flow is shown in Figure 9.

In order to enhance the comparison of the results, we have added DVOPD to the original six industry patterns. The scale of DVOPD is much larger than any other pattern. The experimental results are shown in Figure 10. Although the scale of NoC has been greatly expanded, DBFA still has stronger performance than DPSO.

For other applications, the optimized results of every flow are shown in Figure 11, Figure 12, Figure 13, Figure 14 and Figure 15 and the biggest delay is the delay bound. What needs special explanation is in application PIP: DBFA is almost unoptimized because the PIP contains eight tasks and eight cores, seven of which are the same. The application is so simple that there is little room for optimization.

4.3. Scalability Analysis

The seven industry patterns in the experiments can be divided into small-scale, medium-scale and large-scale applications. Specifically, the scale of NoC in PIP is only 4 × 2, which is the smallest among all patterns, and the scale of NoC in DVOPD is 8 × 4, which is the largest among all patterns. We calculated the delay bound of PIP in NoCs of different scales. The experimental results are shown in Figure 16. Experimental data shows that, although the scale of NoC varies greatly, the delay bound is almost unchanged. This shows that DBFA and DPSO have strong stability in delay bound optimization.

4.4. Running Time of CPU

We also studied the feasibility of the DBFA. We mapped these applications, varying the scales of NoC and the whole CPU (Intel i5-8400) running time from initialization, to get optimal mapping schemes, which are shown in

Table 3. CPU running times.

Applications	IJCA’15 [30] ${}^{\mathbf{a}}$	DBFA	Applications	IJCA’15 [30]	DBFA
VOPD	116.45	97.20	263ENC MP3DEC	24.75	17.70
PIP	8.92	6.65	MP3ENC MP3DEC	41.28	32.98
MWD	21.06	13.39	263DEC MP3DEC	53.16	40.27

^a In order to compare the results under the same environment, we implemented the DPSO algorithm proposed in [30].

, where with the increasing of flows, the running time of CPU would increase by a slight to moderate amount. DBFA optimization time reduced compared to DPSO, which shows that DBFA is more efficient at optimizing delay bounds.

4.5. The Comparison of Optimized and Simulation Results

In order to verify the validity of DBFA, we performed simulations and compared the optimized analytical results with the simulation results, the using application MWD. In simulations, we used Verilog to design a $4\times 4$ NoC; the global clock network was 50 MHz and each router node handled one flit with two cycles, so the maximum delay of data in the network was four cycles. The experimental results are shown in Figure 17.This figure proves the validity of DBFA for optimizing the delay bound. For several flows (flow 8 and flow 11), the difference between theoretical results and stimulation results was minor, proving the tightness of the analytical results too. It is also important to point out that for some flows, such as flow 5 and flow 10, there existed a big gap. This is partly because the simulation time and flow contention were not well explored during the simulation.

5. Conclusions

Optimizing a delay bound in NoC is both important and hard. When the application mapping changes, the contentions between flows also change, which result in a different delay bound. In this paper, we first derived an analytical model for end-to-end flows in NoC, which can automatically compute delay bound for the target flow, when given the specified mapping. Then, we proposed a firefly algorithm for application mapping, with the delay bound minimization as the optimization objection. We called this framework as DBFA. Experiments showed that the proposed DBFA can not only optimize the delay bound for a specified application, with an optimization rate up to 42.86%, but also has a fast running time and tight accuracy.