corrected the first two pages

[mpi-energy2.git] / Heter_paper.tex

diff --git a/Heter_paper.tex b/Heter_paper.tex
index 6a62dfdcf8bd2a59cf629fe82ea4d4ba040c1a44..5be2093240fbadc541f75bc58e03a256235a58a0 100644 (file)
--- a/Heter_paper.tex
+++ b/Heter_paper.tex
@@ -97,64 +97,54 @@
 %   can be deleted if we need space, we can just say we are interested in this
 %   paper in homogeneous clusters}
 
 %   can be deleted if we need space, we can just say we are interested in this
 %   paper in homogeneous clusters}
 

-\subsection{The performance of parallel tasks on heterogeneous cluster}
+\subsection{The execution time of message passing distributed iterative applications on a heterogeneous platform}
+In this paper, we are interested in reducing the energy consumption of message passing distributed iterative synchronous applications running over  heterogeneous platforms. We define a heterogeneous platform as  a collection of  heterogeneous  computing nodes interconnected via a high speed  homogeneous network. Therefore, each node has different characteristics such as computing power (FLOPS), energy consumption, cpu's frequency range, ... but they all have the same network bandwidth and latency.

 
 

-The  heterogeneous cluster is a collection of non identical computing nodes. Each node in 
-a cluster is connected via a high speed network. The communication capabilities between nodes  
-are  identical or different. In this work we are interested in identical communications. While each 
-node has different processing capabilities such as CPU speeds and memory. Tasks executed
-on this model can be either synchronous or asynchronous. In this paper we are consider execution of 
-the synchronous tasks on distributed heterogeneous platform. These tasks can exchange
-the data via synchronous message passing. 

 
 \begin{figure}[t]
   \centering
     \includegraphics[scale=0.6]{fig/commtasks}
 
 \begin{figure}[t]
   \centering
     \includegraphics[scale=0.6]{fig/commtasks}

-  \caption{Parallel tasks on heterogeneous platform}
+  \caption{Parallel tasks on a heterogeneous platform}

   \label{fig:heter}
 \end{figure}
 
   \label{fig:heter}
 \end{figure}
 

- Therefore, the  execution time of a task consists of the computation time and
- the communication time. Due to  heterogeneous computations can lead to slack times while the tasks 
- wait at the synchronization barrier for other tasks to finish  their jobs (see Figure~(\ref{fig:heter})). 
- In this case the fastest tasks  have to wait at the synchronization barrier for the slowest ones  to begin
- the next task. Therefore,  the overall execution time  of the program is the execution time of the slowest
- task as in  EQ~(\ref{eq:T1}).
-\begin{equation}
-  \label{eq:T1}
-  \textit{Program Time} = \max_{i=1,2,\dots,N} T_i
-\end{equation}
- where $T_i$ is the execution time of the task $i$ and all the tasks are executed concurrently on different processors. DVFS is a process that is allowed in modern processors to reduce the dynamic
-power by scaling down the voltage and frequency. Then any DVFS operation used to reduce energy of the processor has direct affect on the execution time of the MPI program. The reduction process of the frequency can be  expressed by the scaling factor S which is the ratio between  the maximum and the new frequency as in EQ (\ref{eq:s}).
+ The  overall execution time  of a distributed iterative synchronous application over a heterogeneous platform  consists of the sum of the computation time and the communication time for every iteration on a node. However, due to the heterogeneous computation power of the computing nodes, slack times might occur when fast nodes have to
+ wait, during synchronous communications, for  the slower nodes to finish  their computations (see Figure~(\ref{fig:heter})). 
+ Therefore,  the overall execution time  of the program is the execution time of the slowest
+ task which have the highest computation time and no slack time.
+ 
+Dynamic Voltage and Frequency Scaling (DVFS) is a process, implemented in modern processors, that reduces the energy consumption
+of a CPU by scaling down its voltage and frequency.  Since DVFS lowers the frequency of a CPU and consequently its computing power, the execution time of a program running over that scaled down processor might increase, especially if the program is compute bound.  The frequency reduction process can be  expressed by the scaling factor S which is the ratio between  the maximum and the new frequency of a CPU as in EQ (\ref{eq:s}).

 \begin{equation}
   \label{eq:s}
  S = \frac{F_\textit{max}}{F_\textit{new}}
 \end{equation}
 \begin{equation}
   \label{eq:s}
  S = \frac{F_\textit{max}}{F_\textit{new}}
 \end{equation}

- The execution time of a parallel program is linearly proportional to the frequency scaling factor $S$. 
- However, in most  MPI applications the processes exchange data. During these  communications the
- processors involved remain idle until the  communications are finished. For that reason, any change in
- the frequency has no impact on the time of communication~\cite{17}. The communication time for a task is the summation of periods
- of time that begin with an MPI call for sending or receiving   a message till the message is synchronously sent or received.
- Each node has different DVFS features such as frequency values and the number of available frequencies 
- (Pstates) for each node. By contrast there are different frequency scaling factors for each node $S_1, S_2,..., S_N$. To be able to predict the execution time of MPI program, the  communication time and the computation time for the slowest
- task must be measured before scaling. These times are used to  predict the execution time for any MPI program running on heterogeneous cluster as a function
- of the new scaling factors as in EQ (\ref{eq:perf}). The model is computes the maximum production of  computation time 
- with scaling factor from each node  added to the minimum communication time of the slowest node, it means  only the
- communication time without slack times, because in MPI the slack times is measured with communication times. 
+ The execution time of a compute bound sequential program is linearly proportional to the frequency scaling factor $S$. 
+ On the other hand,  message passing distributed applications consist of two parts: computation and communication. The execution time of the computation part is linearly proportional to the frequency scaling factor $S$ but  the communication time is not affected by the scaling factor because  the processors involved remain idle during the  communications~\cite{17}. The communication time for a task is the summation of periods of time that begin with an MPI call for sending or receiving   a message till the message is synchronously sent or received.
+
+Since in a heterogeneous platform, each node has different characteristics, especially different frequency gears, when applying DVFS operations on these nodes, they may get different scaling factors represented by a scaling vector: $(S_1, S_2,..., S_N)$ where $S_i$ is the scaling factor of processor $i$. To be able to predict the execution time of message passing synchronous iterative applications running over a heterogeneous platform, for different vectors of scaling factors, the  communication time and the computation time  for all the 
+ tasks must be measured during the first iteration before applying any DVFS operation. Then the execution time for one iteration of the application with any vector of scaling factors  can be  predicted using EQ (\ref{eq:perf}).
+ 
+  
+  

 \begin{multline}
   \label{eq:perf}
 \begin{multline}
   \label{eq:perf}

- \textit  T_\textit{new} = \\ 
- {} \max_{i=1,2,\dots,N} (TcpOld_{i} \cdot S_{i}) +  
- \min_{i=1,2,\dots,N} Tcm Old_{i}
+ \textit  T_\textit{new} = 
+ {} \max_{i=1,2,\dots,N} (TcpOld_{i} \cdot S_{i}) +  TcmOld_{j}

 \end{multline}
 \end{multline}

-This prediction modal is developed from our model for predicting the execution time of parallel task on homogeneous architecture~\cite{45}. The execution time predicting model is useful to used in our method for optimizing both energy and performance of iterative methods as in the coming sections.
+where $TcpOld_i$ is the computation time  of processor $i$ during the first iteration and $TcmOld_j$ is the communication time of the slowest processor $j$.
+  The model computes the maximum computation time 
+ with scaling factor from each node  added to the communication time of the slowest node, it means  only the
+ communication time without any slack time. 
+
+This prediction model is based on our model for predicting the execution time of message passing distributed applications for homogeneous architectures~\cite{45}. The execution time prediction model is used in our method for optimizing both energy consumption and performance of iterative methods, which is presented in the following sections.

 
 
 \subsection{Energy model for heterogeneous platform}
 
 Many researchers~\cite{9,3,15,26} divide the power consumed by a processor into
 two power metrics: the static and the dynamic power.  While the first one is
 
 
 \subsection{Energy model for heterogeneous platform}
 
 Many researchers~\cite{9,3,15,26} divide the power consumed by a processor into
 two power metrics: the static and the dynamic power.  While the first one is

-consumed as long as the computing unit is on, the latter is only consumed during
+consumed as long as the computing unit is turned on, the latter is only consumed during

 computation times.  The dynamic power $P_{d}$ is related to the switching
 activity $\alpha$, load capacitance $C_L$, the supply voltage $V$ and
 operational frequency $F$, as shown in EQ(\ref{eq:pd}).
 computation times.  The dynamic power $P_{d}$ is related to the switching
 activity $\alpha$, load capacitance $C_L$, the supply voltage $V$ and
 operational frequency $F$, as shown in EQ(\ref{eq:pd}).


@@ -177,7 +167,7 @@ to execute a given program can be computed as:
 \end{equation}
 where $T$ is the execution time of the program, $T_{cp}$ is the computation
 time and $T_{cp} \leq T$.  $T_{cp}$ may be equal to $T$ if there is no
 \end{equation}
 where $T$ is the execution time of the program, $T_{cp}$ is the computation
 time and $T_{cp} \leq T$.  $T_{cp}$ may be equal to $T$ if there is no

-communication, no slack time and no synchronization.
+communication and no slack time.

 
 The main objective of DVFS operation is to
 reduce the overall energy consumption~\cite{37}.  The operational frequency $F$
 
 The main objective of DVFS operation is to
 reduce the overall energy consumption~\cite{37}.  The operational frequency $F$


@@ -186,53 +176,49 @@ constant $\beta$.  This equation is used to study the change of the dynamic
 voltage with respect to various frequency values in~\cite{3}.  The reduction
 process of the frequency can be expressed by the scaling factor $S$ which is the
 ratio between the maximum and the new frequency as in EQ~(\ref{eq:s}).
 voltage with respect to various frequency values in~\cite{3}.  The reduction
 process of the frequency can be expressed by the scaling factor $S$ which is the
 ratio between the maximum and the new frequency as in EQ~(\ref{eq:s}).

-The value of the scaling factor $S$ is greater than 1 when changing the
-frequency of the CPU to any new frequency value~(\emph{P-state}) in the
-governor.  The CPU governor is an interface driver supplied by the operating
+The CPU governors are power schemes supplied by the operating

 system's kernel to lower a core's frequency. we can calculate the new frequency 
 $F_{new}$ from EQ(\ref{eq:s}) as follow:
 \begin{equation}
   \label{eq:fnew}
    F_\textit{new} = S^{-1} .  F_\textit{max}
 \end{equation}
 system's kernel to lower a core's frequency. we can calculate the new frequency 
 $F_{new}$ from EQ(\ref{eq:s}) as follow:
 \begin{equation}
   \label{eq:fnew}
    F_\textit{new} = S^{-1} .  F_\textit{max}
 \end{equation}

-By substituting this equation in EQ(\ref{eq:pd}) results the following equation for dynamic 
+Replacing $F_{new}$ in EQ(\ref{eq:pd}) as in EQ(\ref{eq:fnew}) gives the following equation for dynamic 

 power consumption:
 \begin{multline}
   \label{eq:pdnew}
 power consumption:
 \begin{multline}
   \label{eq:pdnew}

-   {P}_\textit{d} = \alpha \cdot C_L \cdot V^2 \cdot F_{new} = \alpha \cdot C_L \cdot \beta^2 \cdot F_{new}^3 \\
-   = \alpha \cdot C_L \cdot V^2 \cdot F \cdot S^{-3} = P_{d} \cdot S^{-3}
+   {P}_\textit{dNew} = \alpha \cdot C_L \cdot V^2 \cdot F_{new} = \alpha \cdot C_L \cdot \beta^2 \cdot F_{new}^3 \\
+   = \alpha \cdot C_L \cdot V^2 \cdot F \cdot S^{-3} = P_{dOld} \cdot S^{-3}

 \end{multline}
 \end{multline}

-According to EQ(\ref{eq:pdnew}) the dynamic power is reduce by a factor of $S^{-3}$ when 
-reducing the frequency by a factor of $S$~\cite{3}. The dynamic energy is the energy consumed by a CPU when its in the computation mode. 
-So, the dynamic energy is the  dynamic power multiply by the time of computations. While the time of computation is decreased by a factor of $S$. Therefore the 
-the dynamic energy  is decreased by a factor of $S^{-2}$ as follow:
+where $ {P}_\textit{dNew}$  and $P_{dOld}$ are the  dynamic power consumed with the new frequency and the maximum frequency respectively.
+
+According to EQ(\ref{eq:pdnew}) the dynamic power is reduced by a factor of $S^{-3}$ when 
+reducing the frequency by a factor of $S$~\cite{3}. Since the FLOPS of a CPU is proportional to the frequency of a CPU, the computation time is increased proportionally to $S$.  The new dynamic energy is the  dynamic power multiplied by the new time of computation and is given by the following equation:

 \begin{equation}
   \label{eq:Edyn}
 \begin{equation}
   \label{eq:Edyn}

-   E_\textit{d} = P_{d} \cdot S^{-3} \cdot (Tcp \cdot S)= S^{-2}\cdot P_{d} \cdot  Tcp 
+   E_\textit{dNew} = P_{dOld} \cdot S^{-3} \cdot (T_{cp} \cdot S)= S^{-2}\cdot P_{dOld} \cdot  T_{cp} 

 \end{equation}
 \end{equation}

-The static power is related to leakage power consumption, its mean the CPU continue consumes energy 
-whereas in idle state. Therefore, we are make an assumption that the static power is constant as in~\cite{3,46}.
-The static energy is the static power multiply by the execution time of the program. Moreover, the CPU consumes static
-energy in all times of the program such as computation, communication and slacks times. According to the execution time model in EQ(\ref{eq:perf}), 
-the execution time of the program is the summation of the computation and the communication times. The computation time is related  
-to frequency scaling factor linearly, while this scaling factor not affecting on the time of communication~\cite{17}, then  the static energy 
-of individual processor is as follow: 
+The static power is related to the power leakage of the CPU and is consumed during computation and even when idle. As in~\cite{3,46}, we assume that the static power of a processor is constant during idle and computation periods, and for all its available frequencies. 
+The static energy is the static power multiplied by the execution time of the program. According to the execution time model in EQ(\ref{eq:perf}), 
+the execution time of the program is the summation of the computation and the communication times. The computation time is linearly related  
+to the frequency scaling factor, while this scaling factor does not affect the communication time. The static energy 
+of a processor after scaling its frequency is computed as follows: 

 
 \begin{equation}
   \label{eq:Estatic}
 
 \begin{equation}
   \label{eq:Estatic}

- E_\textit{s} = P_\textit{s} \cdot (Tcp \cdot S  + Tcm)
+ E_\textit{s} = P_\textit{s} \cdot (T_{cp} \cdot S  + T_{cm})

 \end{equation}
 \end{equation}

-In heterogeneous architecture there is a  number of different processors $P_1, P_2,...,P_N$, where $N$ is the number of nodes . Moreover, each processor perhaps has different frequency  scaling factor, so there are a set of frequency scaling factors for such platform  $S_1,S_2,...,S_N$. According  to these  different 
-scaling factors producing different computation time, $Tcp_1,Tcp_2,...,Tcp_N$, because these times linearly related to these scaling factors. In MPI program the communication times is measured with slacks times. The slack times also has linear relation with the scaling factors. So, there are different mesured communication times $Tcm_1,Tcm_2,...,Tcm_N$ even if its identical communications, e.g. see figure(\ref{fig:heter}). The energy modal of an  heterogeneous architecture represents the summation of all dynamic and static energies from each  processors, each processor has its dynamic and static powers, for example, in the hole architecture their are: $Pd_1,Pd_2,...,Pd_N$ and $Ps_1,Ps_2,...,Ps_N$.  The dynamic energy is computes as in EQ(\ref{eq:Edyn}) with regarding to the frequency scaling factor and the dynamic power of each node. While the static energy is computes using EQ(\ref{eq:perf}) multiplied  by the static power of each processor. So, the energy modal of an heterogeneous platform has the following form:
+
+In the considered heterogeneous platform, each processor $i$ might have different dynamic and static powers, noted as $P_{di}$ and $P_{si}$ respectively. Therefore, even if the distributed message passing iterative application is load balanced, the computation time of each CPU $i$ noted $T_{cpi}$ might be different and different frequency  scaling factors might be computed in order to decrease the overall energy consumption of the application and reduce the slack times. The communication time of a processor $i$ is noted as $T_{cmi}$ and could contain slack times if it is communicating with slower nodes, see figure(\ref{fig:heter}). Therefore, all nodes do not have equal communication times. While the dynamic energy is computed according to the  frequency scaling factor and the dynamic power of each node as in EQ(\ref{eq:Edyn}),  the static energy is computed as the sum of the execution time of each processor multiplied by its static power. The overall energy consumption of a message passing  distributed application  executed over a heterogeneous platform is the summation of all dynamic and static energies for each  processor.  It is computed as follows:

 \begin{multline}
   \label{eq:energy}
 \begin{multline}
   \label{eq:energy}

- E = \sum_{i=1}^{N} {(S_i^{-2} \cdot Pd_i \cdot  Tcp_i)} +\\ 
- {}\sum_{i=1}^{N} {(Ps_i \cdot (\max_{i=1,2,\dots,N} (Tcp_{i} \cdot S_{i}) +} 
- {}\min_{i=1,2,\dots,N} {Tcm_{i}))} 
+ E = \sum_{i=1}^{N} {(S_i^{-2} \cdot P_{di} \cdot  T_{cpi})} +\\ 
+ {}\sum_{i=1}^{N} {(P_{si} \cdot (\max_{i=1,2,\dots,N} (T_{cpi} \cdot S_{i}) +} 
+ {}\min_{i=1,2,\dots,N} {T_{cmi}))} 

  \end{multline}
  
  \end{multline}
  

-These set of frequency scaling factors $S_i$ reduce quadratically the dynamic power which may cause degradation in performance and thus, the
-increase of the static energy because the execution time is increased~\cite{36}.
+Reducing the the frequencies of the processors according to the vector of scaling factors $(S_1, S_2,..., S_N)$  may degrade the  performance of the application and thus,
+increase the static energy because the execution time is increased~\cite{36}.

 
 \section{Optimization of both energy consumption and performance}
 \label{sec.compet}
 
 \section{Optimization of both energy consumption and performance}
 \label{sec.compet}


@@ -312,7 +298,7 @@ In this section we proposed an heterogeneous scaling algorithm, (figure~\ref{HSA
 The algorithm is numerates the suitable range of available scaling factors for each node in the heterogeneous cluster, returns a set of optimal frequency scaling factors for each node. Using heterogeneous cluster is produces different workloads for each node. Therefore, the fastest nodes waiting at the barrier for the slowest nodes to finish there work as in figure (\ref{fig:heter}). Our algorithm takes into account these imbalanced workloads when is starts to search for selecting the best scaling factors. So, the algorithm is selecting the initial frequencies values for each node proportional to the times of computations that gathered from the first iteration. As an example in figure (\ref{fig:st_freq}), the algorithm don't test the first frequencies of the fastest nodes until it converge their frequencies to the frequency of the slowest node. If the algorithm is starts test changing the frequency of the slowest nodes from beginning, we are loosing performance and then not selecting the best tradeoff (the distance). This case will be similar to the homogeneous cluster when all nodes scales their frequencies together from the  beginning. In this case there is a small distance between energy and performance curves, for example see the figure(\ref{fig:r1}).  Then the algorithm searching for optimal frequency  scaling factor from the selected frequencies until the last available ones. 
 \begin{figure}[t]
   \centering
 The algorithm is numerates the suitable range of available scaling factors for each node in the heterogeneous cluster, returns a set of optimal frequency scaling factors for each node. Using heterogeneous cluster is produces different workloads for each node. Therefore, the fastest nodes waiting at the barrier for the slowest nodes to finish there work as in figure (\ref{fig:heter}). Our algorithm takes into account these imbalanced workloads when is starts to search for selecting the best scaling factors. So, the algorithm is selecting the initial frequencies values for each node proportional to the times of computations that gathered from the first iteration. As an example in figure (\ref{fig:st_freq}), the algorithm don't test the first frequencies of the fastest nodes until it converge their frequencies to the frequency of the slowest node. If the algorithm is starts test changing the frequency of the slowest nodes from beginning, we are loosing performance and then not selecting the best tradeoff (the distance). This case will be similar to the homogeneous cluster when all nodes scales their frequencies together from the  beginning. In this case there is a small distance between energy and performance curves, for example see the figure(\ref{fig:r1}).  Then the algorithm searching for optimal frequency  scaling factor from the selected frequencies until the last available ones. 
 \begin{figure}[t]
   \centering

-    \includegraphics[scale=0.5]{fig/start_freq}
+    \includegraphics[scale=0.5]{fig/start_freq.pdf}

   \caption{Selecting the initial frequencies}
   \label{fig:st_freq}
 \end{figure}
   \caption{Selecting the initial frequencies}
   \label{fig:st_freq}
 \end{figure}


@@ -688,11 +674,11 @@ The results of the previous section are obtained using a percentage of 80\% for
 \begin{figure}
   \centering
   \subfloat[Comparison the average of the results on 8 nodes]{%
 \begin{figure}
   \centering
   \subfloat[Comparison the average of the results on 8 nodes]{%

-    \includegraphics[width=.22\textwidth]{fig/sen_comp}\label{fig:sen_comp}}%
+    \includegraphics[width=.22\textwidth]{fig/sen_comp.pdf}\label{fig:sen_comp}}%

   \quad%
   \subfloat[Comparison the selected frequency scaling factors for 8 nodes]{%
   \quad%
   \subfloat[Comparison the selected frequency scaling factors for 8 nodes]{%

-    \includegraphics[width=.24\textwidth]{fig/three_scenarios}\label{fig:scales_comp}}
-  \label{fig:comp}
+    \includegraphics[width=.24\textwidth]{fig/three_scenarios.pdf}\label{fig:scales_comp}}
+  \label{fig:avg}

   \caption{The comparison of the three power scenarios}
 \end{figure}
 
   \caption{The comparison of the three power scenarios}
 \end{figure}