1st english corrections

[mpi-energy2.git] / Heter_paper.tex

diff --git a/Heter_paper.tex b/Heter_paper.tex
index d2180d904ec37af141ef961e3e2e8289a23dc89d..50fc783f09869fee9ea5478943a807a4f0593bc8 100644 (file)
--- a/Heter_paper.tex
+++ b/Heter_paper.tex
@@ -8,7 +8,7 @@
 \usepackage{algorithm}
 \usepackage{subfig}
 \usepackage{amsmath}
 \usepackage{algorithm}
 \usepackage{subfig}
 \usepackage{amsmath}

-
+\usepackage{multirow}

 \usepackage{url}
 \DeclareUrlCommand\email{\urlstyle{same}}
 
 \usepackage{url}
 \DeclareUrlCommand\email{\urlstyle{same}}
 


@@ -53,7 +53,7 @@
 \newcommand{\Told}{\Xsub{T}{Old}} 
 \begin{document} 
 
 \newcommand{\Told}{\Xsub{T}{Old}} 
 \begin{document} 
 

-\title{Energy Consumption Reduction in a Heterogeneous Architecture Using DVFS}
+\title{Energy Consumption Reduction for Message Passing Iterative  Applications in Heterogeneous Architecture Using DVFS}

  
 \author{% 
   \IEEEauthorblockN{%
  
 \author{% 
   \IEEEauthorblockN{%


@@ -76,48 +76,67 @@
 \maketitle
 
 \begin{abstract}
 \maketitle
 
 \begin{abstract}

-Computing platforms are consuming more and more energy due to the increase of the number of nodes composing them. 
-To minimize the operating costs of these platforms many techniques have been used. Dynamic voltage and frequency 
-scaling (DVFS) is one of them, it reduces the frequency of a CPU to lower its energy consumption. However, 
-lowering the frequency of a CPU might increase the execution time of an application running on that processor. 
-Therefore, the frequency that gives the best  tradeoff between the energy consumption and the performance of an 
-application must be selected. 
-
-In this paper, a new online frequencies selecting algorithm for heterogeneous platforms is presented. 
-It selects the frequency that give the best tradeoff between energy saving and performance degradation, 
-for each node computing the message passing iterative application. The algorithm has a small overhead and 
-works without training or profiling. It uses a new energy model for message passing iterative applications 
-running on a heterogeneous platform. The proposed algorithm evaluated  on the Simgrid simulator while 
-running the NAS parallel benchmarks. The experiments demonstrated that it reduces the energy consumption 
-up to 35\% while limiting the performance degradation as much as possible.
+Computing platforms  are consuming  more and more  energy due to  the increasing
+number  of nodes  composing  them.  To  minimize  the operating  costs of  these
+platforms many techniques have been  used. Dynamic voltage and frequency scaling
+(DVFS) is  one of them. It  reduces the frequency of  a CPU to  lower its energy
+consumption.  However,  lowering the  frequency  of  a  CPU might  increase  the
+execution  time of  an application  running on  that processor.   Therefore, the
+frequency that  gives the best tradeoff  between the energy  consumption and the
+performance of an application must be selected.
+
+In this  paper, a new  online frequencies selecting algorithm  for heterogeneous
+platforms is presented.   It selects the frequency which tries  to give the best
+tradeoff  between  energy saving  and  performance  degradation,  for each  node
+computing the message  passing iterative application. The algorithm  has a small
+overhead and works without training or profiling. It uses a new energy model for
+message passing iterative applications  running on a heterogeneous platform. The
+proposed algorithm is  evaluated on the Simgrid simulator  while running the NAS
+parallel  benchmarks.  The  experiments   show  that  it  reduces  the  energy
+consumption by up to 35\% while  limiting the performance degradation as much as
+possible.   Finally,  the algorithm  is  compared  to  an existing  method,  the
+comparison results showing that it outperforms the latter.
+

 \end{abstract}
 
 \section{Introduction}
 \label{sec.intro}
 \end{abstract}
 
 \section{Introduction}
 \label{sec.intro}

-The need for more computing power is continually increasing. To partially satisfy this need, most supercomputers 
-constructors just put more computing nodes in their platform. The resulting platform might achieve higher floating 
-point operations per second (FLOPS), but the energy consumption and the heat dissipation are also increased. 
-As an example, the Chinese supercomputer Tianhe-2 had the highest FLOPS in November 2014 according to the Top500 
-list \cite{TOP500_Supercomputers_Sites}.  However, it was also the  most power hungry platform with its over 3 millions 
-cores consuming around 17.8 megawatts. Moreover, according to the U.S. annual energy outlook 2014 
-\cite{U.S_Annual.Energy.Outlook.2014}, the price of energy for 1 megawatt-hour 
-was approximately equal to \$70. 
-Therefore, the price of the energy consumed by the 
-Tianhe-2 platform is approximately more than \$10 millions each year. 
-The computing platforms must be more energy efficient and offer the highest number of FLOPS per watt possible, 
-such as the L-CSC from the GSI Helmholtz Center which  
-became the top of the Green500 list in November 2014 \cite{Green500_List}. 
-This heterogeneous platform executes more than 5  GFLOPS per watt while consuming 57.15 kilowatts.
-
-Besides hardware improvements, there are many software techniques to lower the energy consumption of these platforms, 
-such as scheduling, DVFS, ... DVFS is a widely  used process to reduce the energy consumption of a processor by lowering 
-its frequency \cite{Rizvandi_Some.Observations.on.Optimal.Frequency}. However, it also  reduces the number of FLOPS 
-executed by the processor which might increase  the execution time of the application running over that processor.
-Therefore, researchers used different optimization strategies to select the frequency that gives the best tradeoff  
-between the energy reduction and 
-performance degradation ratio. In \cite{Our_first_paper},  a frequency selecting algorithm 
-was proposed to reduce the energy consumption of message passing iterative applications running over homogeneous platforms. The  results of the experiments showed significant energy consumption reductions. In this paper,  a new frequency selecting algorithm  adapted for heterogeneous platform  is presented. It selects the vector of frequencies, for a heterogeneous platform running a message passing iterative application,  that simultaneously tries to give the maximum energy reduction and minimum performance degradation ratio. The algorithm has a very small 
-overhead, works online and does not need any training or profiling.  
+The  need for  more  computing  power is  continually  increasing. To  partially
+satisfy  this need,  most supercomputers  constructors just  put  more computing
+nodes in their  platform. The resulting platforms might  achieve higher floating
+point operations  per second  (FLOPS), but the  energy consumption and  the heat
+dissipation  are  also increased.   As  an  example,  the Chinese  supercomputer
+Tianhe-2 had  the highest FLOPS  in November 2014  according to the  Top500 list
+\cite{TOP500_Supercomputers_Sites}.  However, it was  also the most power hungry
+platform  with  its  over  3  million cores  consuming  around  17.8  megawatts.
+Moreover,    according   to    the    U.S.    annual    energy   outlook    2014
+\cite{U.S_Annual.Energy.Outlook.2014}, the  price of energy  for 1 megawatt-hour
+was approximately equal to \$70.  Therefore, the price of the energy consumed by
+the Tianhe-2  platform is approximately more  than \$10 million  each year.  The
+computing platforms must  be more energy efficient and  offer the highest number
+of FLOPS  per watt  possible, such as  the L-CSC  from the GSI  Helmholtz Center
+which became the top of the Green500 list in November 2014 \cite{Green500_List}.
+This heterogeneous platform executes more than 5 GFLOPS per watt while consuming
+57.15 kilowatts.
+
+Besides platform  improvements, there are many software  and hardware techniques
+to lower  the energy consumption of  these platforms, such  as scheduling, DVFS,
+...   DVFS is  a  widely used  process to  reduce  the energy  consumption of  a
+processor            by             lowering            its            frequency
+\cite{Rizvandi_Some.Observations.on.Optimal.Frequency}. However, it also reduces
+the number of FLOPS executed by the processor which might increase the execution
+time of the application running over that processor.  Therefore, researchers use
+different optimization  strategies to select  the frequency that gives  the best
+tradeoff  between the  energy reduction  and performance  degradation  ratio. In
+\cite{Our_first_paper}, a  frequency selecting algorithm was  proposed to reduce
+the energy  consumption of message  passing iterative applications  running over
+homogeneous platforms.  The results of  the experiments show  significant energy
+consumption  reductions. In  this  paper, a  new  frequency selecting  algorithm
+adapted  for heterogeneous  platform  is  presented. It  selects  the vector  of
+frequencies, for  a heterogeneous platform  running a message  passing iterative
+application, that simultaneously tries to offer the maximum energy reduction and
+minimum performance degradation ratio. The  algorithm has a very small overhead,
+works online and does not need any training or profiling.

 
 This paper is organized as follows: Section~\ref{sec.relwork} presents some
 related works from other authors.  Section~\ref{sec.exe} describes how the
 
 This paper is organized as follows: Section~\ref{sec.relwork} presents some
 related works from other authors.  Section~\ref{sec.exe} describes how the


@@ -127,16 +146,32 @@ the energy-performance objective function that maximizes the reduction of energy
 consumption while minimizing the degradation of the program's performance.
 Section~\ref{sec.optim} details the proposed frequency selecting algorithm then the precision of the proposed algorithm is verified. 
 Section~\ref{sec.expe} presents the results of applying the algorithm on  the NAS parallel benchmarks and executing them 
 consumption while minimizing the degradation of the program's performance.
 Section~\ref{sec.optim} details the proposed frequency selecting algorithm then the precision of the proposed algorithm is verified. 
 Section~\ref{sec.expe} presents the results of applying the algorithm on  the NAS parallel benchmarks and executing them 

-on a heterogeneous platform. It also shows the results of running three 
-different power scenarios and comparing them. 
-Finally, in Section~\ref{sec.concl} the paper is ended with a summary and some future works.
+on a heterogeneous platform. It shows the results of running three 
+different power scenarios and comparing them. Moreover, it also shows the comparison results
+between the proposed method and an existing method.
+Finally, in Section~\ref{sec.concl} the paper ends with a summary and some future works.

 
 \section{Related works}
 \label{sec.relwork}
 
 \section{Related works}
 \label{sec.relwork}

-DVFS is a technique enabled 
-in modern processors to scale down both the voltage and the frequency of 
-the CPU while computing, in order to reduce the energy consumption of the processor. DVFS is 
-also  allowed in the GPUs to achieve the same goal. Reducing the frequency of a processor lowers its number of FLOPS and might degrade the performance of the application running on that processor, especially if it is compute bound. Therefore selecting the appropriate frequency for a processor to satisfy some objectives and while taking into account all the constraints, is not a trivial operation.  Many researchers used different strategies to tackle this problem. Some of them developed online methods that compute the new frequency while executing the application, such as ~\cite{Hao_Learning.based.DVFS,Dhiman_Online.Learning.Power.Management}. Others used offline methods that might need to run the application and profile it before selecting the new frequency, such as ~\cite{Rountree_Bounding.energy.consumption.in.MPI,Cochran_Pack_and_Cap_Adaptive_DVFS}. The methods could be heuristics, exact  or brute force methods that satisfy varied objectives such as energy reduction or performance. They also could be adapted to the execution's environment and the type of the application such as sequential, parallel or distributed architecture, homogeneous or heterogeneous platform,  synchronous or asynchronous application, ... 
+DVFS is a technique used in modern processors to scale down both the voltage and
+the  frequency  of the  CPU  while  computing, in  order  to  reduce the  energy
+consumption of  the processor. DVFS is also  allowed in  GPUs  to achieve the
+same goal. Reducing the frequency of  a processor lowers its number of FLOPS and
+might  degrade the  performance of  the application  running on  that processor,
+especially if it is compute bound. Therefore selecting the appropriate frequency
+for a processor to satisfy some objectives while taking into account all the
+constraints,  is  not a  trivial  operation.   Many  researchers used  different
+strategies to  tackle this problem. Some  of them developed  online methods that
+compute   the  new   frequency  while   executing  the   application,   such  as
+~\cite{Hao_Learning.based.DVFS,Spiliopoulos_Green.governors.Adaptive.DVFS}. Others
+used  offline methods  that might  need to  run the  application and  profile it
+before       selecting       the        new       frequency,       such       as
+~\cite{Rountree_Bounding.energy.consumption.in.MPI,Cochran_Pack_and_Cap_Adaptive_DVFS}. The
+methods could  be heuristics, exact or  brute force methods  that satisfy varied
+objectives such as  energy reduction or performance. They  also could be adapted
+to  the  execution's  environment  and  the  type of  the  application  such  as
+sequential, parallel  or distributed architecture,  homogeneous or heterogeneous
+platform, synchronous or asynchronous application, ...

 
 In this paper, we are interested in reducing energy for message passing iterative synchronous applications running over heterogeneous platforms.
 Some works have already been done for such platforms and they can be classified into two types of heterogeneous platforms: 
 
 In this paper, we are interested in reducing energy for message passing iterative synchronous applications running over heterogeneous platforms.
 Some works have already been done for such platforms and they can be classified into two types of heterogeneous platforms: 


@@ -147,7 +182,7 @@ Some works have already been done for such platforms and they can be classified
 
 \end{itemize}
 
 
 \end{itemize}
 

-For the first type of platform, the compute intensive parallel tasks are executed on the  GPUs and the rest are executed 
+For the first type of platform, the computing intensive parallel tasks are executed on the  GPUs and the rest are executed 

 on the CPUs.  Luley et al.
 ~\cite{Luley_Energy.efficiency.evaluation.and.benchmarking}, proposed  a heterogeneous 
 cluster composed of Intel Xeon CPUs and NVIDIA GPUs. Their main goal was to maximize the 
 on the CPUs.  Luley et al.
 ~\cite{Luley_Energy.efficiency.evaluation.and.benchmarking}, proposed  a heterogeneous 
 cluster composed of Intel Xeon CPUs and NVIDIA GPUs. Their main goal was to maximize the 


@@ -168,15 +203,15 @@ of Intel and AMD processors. They use a gradient method to predict the impact of
 In~\cite{Shelepov_Scheduling.on.Heterogeneous.Multicore} and \cite{Li_Minimizing.Energy.Consumption.for.Frame.Based.Tasks}, 
  the best frequencies for a specified heterogeneous cluster are selected offline using some 
 heuristic. Chen et al.~\cite{Chen_DVFS.under.quality.of.service.requirements} used a greedy dynamic programming approach to  
 In~\cite{Shelepov_Scheduling.on.Heterogeneous.Multicore} and \cite{Li_Minimizing.Energy.Consumption.for.Frame.Based.Tasks}, 
  the best frequencies for a specified heterogeneous cluster are selected offline using some 
 heuristic. Chen et al.~\cite{Chen_DVFS.under.quality.of.service.requirements} used a greedy dynamic programming approach to  

-minimize the power consumption of heterogeneous severs  while respecting given time constraints. This approach 
+minimize the power consumption of heterogeneous servers  while respecting given time constraints. This approach 

 had considerable overhead.
 In contrast to the above described papers, this paper presents the following contributions :
 \begin{enumerate}
 \item  two new energy and performance models for message passing iterative synchronous applications running over 
 had considerable overhead.
 In contrast to the above described papers, this paper presents the following contributions :
 \begin{enumerate}
 \item  two new energy and performance models for message passing iterative synchronous applications running over 

-       a heterogeneous platform. Both models takes into account the communication and slack times. The models can predict the required energy and the execution time of the application.
+       a heterogeneous platform. Both models take into account  communication and slack times. The models can predict the required energy and the execution time of the application.

        
 \item a new online frequency selecting algorithm for heterogeneous platforms. The algorithm has a very small 
        
 \item a new online frequency selecting algorithm for heterogeneous platforms. The algorithm has a very small 

-      overhead and does not need for any training or profiling. It uses a new optimization function which simultaneously maximizes the performance and minimizes the energy consumption of a message passing iterative synchronous application.
+      overhead and does not need any training or profiling. It uses a new optimization function which simultaneously maximizes the performance and minimizes the energy consumption of a message passing iterative synchronous application.

       
 \end{enumerate}
 
       
 \end{enumerate}
 


@@ -203,7 +238,7 @@ 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
 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.
+task which has the highest computation time and no slack time.

   
  \begin{figure}[t]
   \centering
   
  \begin{figure}[t]
   \centering


@@ -235,7 +270,7 @@ as in (\ref{eq:s}).
  time that begin with an MPI call for sending or receiving   a message 
  until the message is synchronously sent or received.
 
  time that begin with an MPI call for sending or receiving   a message 
  until the message is synchronously sent or received.
 

-Since in a heterogeneous platform, each node has different characteristics,
+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,\dots, S_N)$ where $S_i$ is the scaling factor of processor $i$. To
 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,\dots, S_N)$ where $S_i$ is the scaling factor of processor $i$. To


@@ -252,23 +287,23 @@ vector of scaling factors can be predicted using (\ref{eq:perf}).
 \end{equation}
 Where:\\
 \begin{equation}
 \end{equation}
 Where:\\
 \begin{equation}

-\label{eq:perf}
+\label{eq:perf2}

  MinTcm = \min_{i=1,2,\dots,N} (Tcm_i)
 \end{equation}
  MinTcm = \min_{i=1,2,\dots,N} (Tcm_i)
 \end{equation}

-where $TcpOld_i$ is the computation time  of processor $i$ during the first 
-iteration and $MinTcm$ is the communication time of the slowest processor from 
-the first iteration.  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. 
-Therefore, the execution time of the iterative application is 
-equal to the execution time of one iteration as in (\ref{eq:perf}) multiplied 
-by the number of iterations of that application.
-
-This prediction model is developed from the model for predicting the execution time of 
-message passing distributed applications for homogeneous architectures~\cite{Our_first_paper}. 
-The execution time prediction model is used in the method for optimizing both 
-energy consumption and performance of iterative methods, which is presented in the 
-following sections.
+where  $TcpOld_i$ is  the computation  time of  processor $i$  during  the first
+iteration and $MinTcm$  is the communication time of  the slowest processor from
+the  first iteration.   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 is taken into
+account.  Therefore, the execution time of the iterative application is equal to
+the  execution time of  one iteration  as in  (\ref{eq:perf}) multiplied  by the
+number of iterations of that application.
+
+This prediction model is developed from  the model to predict the execution time
+of     message    passing     distributed    applications     for    homogeneous
+architectures~\cite{Our_first_paper}.   The execution  time prediction  model is
+used in  the method  to optimize both the energy consumption and the performance of
+iterative methods, which is presented in the following sections.

 
 
 \subsection{Energy model for heterogeneous platform}
 
 
 \subsection{Energy model for heterogeneous platform}


@@ -291,7 +326,7 @@ The static power $Ps$ captures the leakage power as follows:
 \end{equation}
 where V is the supply voltage, $N_{trans}$ is the number of transistors,
 $K_{design}$ is a design dependent parameter and $I_{leak}$ is a
 \end{equation}
 where V is the supply voltage, $N_{trans}$ is the number of transistors,
 $K_{design}$ is a design dependent parameter and $I_{leak}$ is a

-technology-dependent parameter.  The energy consumed by an individual processor
+technology dependent parameter.  The energy consumed by an individual processor

 to execute a given program can be computed as:
 \begin{equation}
   \label{eq:eind}
 to execute a given program can be computed as:
 \begin{equation}
   \label{eq:eind}


@@ -339,7 +374,7 @@ and even when idle. As in~\cite{Rauber_Analytical.Modeling.for.Energy,Zhuo_Energ
 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 (\ref{eq:perf}), the execution time of the program 
 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 (\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  
+is the sum 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}
 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}


@@ -347,19 +382,22 @@ The static energy of a processor after scaling its frequency is computed as foll
  E_\textit{s} = Ps \cdot (Tcp \cdot S  + Tcm)
 \end{equation}
 
  E_\textit{s} = Ps \cdot (Tcp \cdot S  + Tcm)
 \end{equation}
 

-In the considered heterogeneous platform, each processor $i$ might have different dynamic and 
-static powers, noted as $Pd_{i}$ and $Ps_{i}$ respectively. Therefore, even if the distributed 
-message passing iterative application is load balanced, the computation time of each CPU $i$ 
-noted $Tcp_{i}$ 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 $Tcm_{i}$ 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 (\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 during one iteration is the summation of all dynamic and static energies 
-for each  processor.  It is computed as follows:
+In  the  considered  heterogeneous  platform,  each  processor  $i$  might  have
+different   dynamic  and  static   powers,  noted   as  $Pd_{i}$   and  $Ps_{i}$
+respectively.  Therefore,  even if  the  distributed  message passing  iterative
+application  is  load balanced,  the  computation time  of  each  CPU $i$  noted
+$Tcp_{i}$ might  be different and  different frequency scaling factors  might be
+computed in order to decrease  the overall energy consumption of the application
+and reduce slack  times.  The communication time of a processor  $i$ is noted as
+$Tcm_{i}$  and could  contain slack  times when  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
+(\ref{eq:Edyn}), the static energy is computed  as the sum of the execution time
+of  one iteration multiplied  by the static  power of  each processor.   The overall
+energy consumption of a message  passing distributed application executed over a
+heterogeneous platform during one iteration  is the summation of all dynamic and
+static energies for each processor.  It is computed as follows:

 \begin{multline}
   \label{eq:energy}
  E = \sum_{i=1}^{N} {(S_i^{-2} \cdot Pd_{i} \cdot  Tcp_i)} + {} \\
 \begin{multline}
   \label{eq:energy}
  E = \sum_{i=1}^{N} {(S_i^{-2} \cdot Pd_{i} \cdot  Tcp_i)} + {} \\


@@ -378,32 +416,37 @@ multiplied by the number of iterations of that application.
 \section{Optimization of both energy consumption and performance}
 \label{sec.compet}
 
 \section{Optimization of both energy consumption and performance}
 \label{sec.compet}
 

-Using the lowest frequency for each processor does not necessarily gives the most energy 
-efficient execution of an application. Indeed, even though the dynamic power is reduced 
-while scaling down the frequency of a processor, its computation power is proportionally 
-decreased and thus the execution time might be drastically increased during which dynamic 
-and static powers are being consumed. Therefore,  it might cancel any gains achieved by 
-scaling down the frequency of all nodes to the minimum  and the overall energy consumption 
-of the application might not be the optimal one. It is not trivial to select the appropriate 
-frequency scaling factor for each processor while considering the characteristics of each processor 
-(computation power, range of frequencies, dynamic and static powers) and the task executed 
-(computation/communication ratio) in order to reduce the overall energy consumption and not 
-significantly increase the execution time. In our previous work~\cite{Our_first_paper}, we  proposed a method 
-that selects the optimal frequency scaling factor for a homogeneous cluster executing a message 
-passing iterative synchronous application while giving the best trade-off  between the energy 
-consumption and the performance for such applications. In this work we are interested in 
-heterogeneous clusters as described above. Due to the heterogeneity of the processors, not 
-one but a  vector of scaling factors should be selected and it must  give the best trade-off 
-between energy consumption and performance. 
-
-The relation between the energy consumption and the execution time for an application is 
-complex and nonlinear, Thus, unlike the relation between the execution time 
-and the scaling factor, the relation of the energy with the frequency scaling
-factors is nonlinear, for more details refer to~\cite{Freeh_Exploring.the.Energy.Time.Tradeoff}.  
-Moreover, they are not measured using the same metric.  To solve this problem,  the
-execution time is normalized by computing the ratio between the new execution time (after 
-scaling down the frequencies of some processors) and the initial one (with maximum 
-frequency for all nodes,) as follows:
+Using the lowest frequency for each processor does not necessarily give the most
+energy efficient  execution of an  application. Indeed, even though  the dynamic
+power  is  reduced  while  scaling  down  the  frequency  of  a  processor,  its
+computation power  is proportionally decreased. Hence, the  execution time might
+be drastically  increased and  during that time,  dynamic and static  powers are
+being consumed.  Therefore,  it might cancel any gains  achieved by scaling down
+the frequency of all nodes to  the minimum and the overall energy consumption of
+the application might not  be the optimal one.  It is not  trivial to select the
+appropriate frequency  scaling factor for  each processor while  considering the
+characteristics  of each  processor  (computation power,  range of  frequencies,
+dynamic  and static  powers)  and the  task executed  (computation/communication
+ratio). The  aim being  to reduce  the overall energy  consumption and  to avoid
+increasing    significantly    the    execution    time.   In    our    previous
+work~\cite{Our_first_paper},  we  proposed a  method  that  selects the  optimal
+frequency scaling factor  for a homogeneous cluster executing  a message passing
+iterative synchronous  application while giving  the best trade-off  between the
+energy consumption and  the performance for such applications.   In this work we
+are  interested  in heterogeneous  clusters  as  described  above.  Due  to  the
+heterogeneity of the processors, a vector of scaling factors should
+be selected and  it must give the best trade-off  between energy consumption and
+performance.
+
+The  relation between  the  energy consumption  and  the execution  time for  an
+application  is complex  and nonlinear,  Thus, unlike  the relation  between the
+execution time and  the scaling factor, the relation between  the energy and the
+frequency   scaling    factors   is   nonlinear,   for    more   details   refer
+to~\cite{Freeh_Exploring.the.Energy.Time.Tradeoff}.   Moreover,  these relations
+are not  measured using the same  metric.  To solve this  problem, the execution
+time is normalized by computing the  ratio between the new execution time (after
+scaling  down the  frequencies of  some processors)  and the  initial  one (with
+maximum frequency for all nodes) as follows:

 \begin{multline}
   \label{eq:pnorm}
   P_\textit{Norm} = \frac{T_\textit{New}}{T_\textit{Old}}\\
 \begin{multline}
   \label{eq:pnorm}
   P_\textit{Norm} = \frac{T_\textit{New}}{T_\textit{Old}}\\


@@ -427,13 +470,13 @@ Where $E_\textit{Reduced}$ and $E_\textit{Original}$ are computed using (\ref{eq
 While the main 
 goal is to optimize the energy and execution time at the same time, the normalized 
 energy and execution time curves are not in the same direction. According 
 While the main 
 goal is to optimize the energy and execution time at the same time, the normalized 
 energy and execution time curves are not in the same direction. According 

-to the equations~(\ref{eq:enorm}) and~(\ref{eq:pnorm}), the vector  of frequency
+to the equations~(\ref{eq:pnorm}) and (\ref{eq:enorm}), the vector  of frequency

 scaling factors $S_1,S_2,\dots,S_N$ reduce both the energy and the execution
 time simultaneously.  But the main objective is to produce maximum energy
 reduction with minimum execution time reduction.  
   
 This problem can be solved by making the optimization process for energy and 
 scaling factors $S_1,S_2,\dots,S_N$ reduce both the energy and the execution
 time simultaneously.  But the main objective is to produce maximum energy
 reduction with minimum execution time reduction.  
   
 This problem can be solved by making the optimization process for energy and 

-execution time follow the same direction.  Therefore, the equation of the 
+execution time following the same direction.  Therefore, the equation of the 

 normalized execution time is inverted which gives the normalized performance equation, as follows:
 \begin{multline}
   \label{eq:pnorm_inv}
 normalized execution time is inverted which gives the normalized performance equation, as follows:
 \begin{multline}
   \label{eq:pnorm_inv}


@@ -455,9 +498,9 @@ normalized execution time is inverted which gives the normalized performance equ
   \caption{The energy and performance relation}
 \end{figure}
 
   \caption{The energy and performance relation}
 \end{figure}
 

-Then, the objective function can be modeled   as finding the maximum distance
-between the energy curve EQ~(\ref{eq:enorm}) and the  performance
-curve EQ~(\ref{eq:pnor@+eYd162m_inv}) over all available sets of scaling factors.  This
+Then, the objective function can be modeled in order to find the maximum distance
+between the energy curve (\ref{eq:enorm}) and the  performance
+curve (\ref{eq:pnorm_inv}) over all available sets of scaling factors.  This

 represents the minimum energy consumption with minimum execution time (maximum 
 performance) at the same time, see figure~(\ref{fig:r1}) or figure~(\ref{fig:r2}). Then the objective
 function has the following form:
 represents the minimum energy consumption with minimum execution time (maximum 
 performance) at the same time, see figure~(\ref{fig:r1}) or figure~(\ref{fig:r2}). Then the objective
 function has the following form:


@@ -468,8 +511,8 @@ function has the following form:
       (\overbrace{P_\textit{Norm}(S_{ij})}^{\text{Maximize}} -
        \overbrace{E_\textit{Norm}(S_{ij})}^{\text{Minimize}} )
 \end{equation}
       (\overbrace{P_\textit{Norm}(S_{ij})}^{\text{Maximize}} -
        \overbrace{E_\textit{Norm}(S_{ij})}^{\text{Minimize}} )
 \end{equation}

-where $N$ is the number of nodes and $F$ is the  number of available frequencies for each nodes. 
-Then, the optimal set of scaling factors that satisfies EQ~(\ref{eq:max}) can be selected.  
+where $N$ is the number of nodes and $F$ is the  number of available frequencies for each node. 
+Then, the optimal set of scaling factors that satisfies (\ref{eq:max}) can be selected.  

 The objective function can work with any energy model or any power values for each node 
 (static and dynamic powers). However, the most energy reduction gain can be achieved when 
 the energy curve has a convex form as shown in~\cite{Zhuo_Energy.efficient.Dynamic.Task.Scheduling,Rauber_Analytical.Modeling.for.Energy,Hao_Learning.based.DVFS}.
 The objective function can work with any energy model or any power values for each node 
 (static and dynamic powers). However, the most energy reduction gain can be achieved when 
 the energy curve has a convex form as shown in~\cite{Zhuo_Energy.efficient.Dynamic.Task.Scheduling,Rauber_Analytical.Modeling.for.Energy,Hao_Learning.based.DVFS}.


@@ -478,14 +521,14 @@ the energy curve has a convex form as shown in~\cite{Zhuo_Energy.efficient.Dynam
 \label{sec.optim}
 
 \subsection{The algorithm details}
 \label{sec.optim}
 
 \subsection{The algorithm details}

-In this section algorithm~(\ref{HSA}) is presented. It selects the frequency scaling factors 
+In this section, algorithm \ref{HSA} is presented. It selects the frequency scaling factors 

 vector that gives the best trade-off between minimizing the energy consumption  and maximizing 
 the performance of a message passing synchronous iterative application executed on a heterogeneous 
 platform. It works online during the execution time of the iterative message passing program.  
 It uses information gathered during the first iteration such as the computation time and the 
 communication time in one iteration for each node. The algorithm is executed  after the first 
 iteration and returns a vector of optimal frequency scaling factors   that satisfies the objective 
 vector that gives the best trade-off between minimizing the energy consumption  and maximizing 
 the performance of a message passing synchronous iterative application executed on a heterogeneous 
 platform. It works online during the execution time of the iterative message passing program.  
 It uses information gathered during the first iteration such as the computation time and the 
 communication time in one iteration for each node. The algorithm is executed  after the first 
 iteration and returns a vector of optimal frequency scaling factors   that satisfies the objective 

-function (\ref{eq:max}). The program apply DVFS operations to change the frequencies of the CPUs 
+function (\ref{eq:max}). The program applies DVFS operations to change the frequencies of the CPUs 

 according to the computed scaling factors.  This algorithm is called just once during the execution 
 of the program. Algorithm~(\ref{dvfs}) shows where and when the proposed scaling algorithm is called 
 in the iterative MPI program.
 according to the computed scaling factors.  This algorithm is called just once during the execution 
 of the program. Algorithm~(\ref{dvfs}) shows where and when the proposed scaling algorithm is called 
 in the iterative MPI program.


@@ -524,7 +567,7 @@ scaling factors starts the search method from these initial frequencies and take
 toward lower frequencies. The algorithm iterates on all left frequencies, from the higher bound until all 
 nodes reach their minimum frequencies, to compute their overall energy consumption and performance, and select 
 the optimal frequency scaling factors vector. At each iteration the algorithm determines the slowest node 
 toward lower frequencies. The algorithm iterates on all left frequencies, from the higher bound until all 
 nodes reach their minimum frequencies, to compute their overall energy consumption and performance, and select 
 the optimal frequency scaling factors vector. At each iteration the algorithm determines the slowest node 

-according to (\ref{eq:perf}) and keeps its frequency unchanged, while it lowers the frequency of  
+according to the equation (\ref{eq:perf}) and keeps its frequency unchanged, while it lowers the frequency of  

 all other nodes by one gear.
 The new overall energy consumption and execution time are computed according to the new scaling factors. 
 The optimal set of frequency scaling factors is the set that gives the highest distance according to  the objective 
 all other nodes by one gear.
 The new overall energy consumption and execution time are computed according to the new scaling factors. 
 The optimal set of frequency scaling factors is the set that gives the highest distance according to  the objective 


@@ -569,12 +612,11 @@ which results in bigger energy savings.
     \State Round the computed initial frequencies $F_i$ to the closest one available in each node.
     \If{(not the first frequency)}
           \State $F_i \gets F_i+Fdiff_i,~i=1,\dots,N.$
     \State Round the computed initial frequencies $F_i$ to the closest one available in each node.
     \If{(not the first frequency)}
           \State $F_i \gets F_i+Fdiff_i,~i=1,\dots,N.$

-          \State where $i=1,\dots,N$ means for loop.

     \EndIf 
     \State $T_\textit{Old} \gets max_{~i=1,\dots,N } (Tcp_i+Tcm_i)$
     \State $E_\textit{Original} \gets \sum_{i=1}^{N}{( Pd_i \cdot  Tcp_i)} +\sum_{i=1}^{N} {(Ps_i \cdot T_{Old})}$
     \EndIf 
     \State $T_\textit{Old} \gets max_{~i=1,\dots,N } (Tcp_i+Tcm_i)$
     \State $E_\textit{Original} \gets \sum_{i=1}^{N}{( Pd_i \cdot  Tcp_i)} +\sum_{i=1}^{N} {(Ps_i \cdot T_{Old})}$

-    \State  $Sopt_{i} \gets \frac{Fmax_i}{F_i},~i=1,\dots,N. $
-    \State Computing the initial distance  $Dist \gets\Pnorm(Sopt_i) - \Enorm(Sopt_i) $
+    \State  $Sopt_{i} \gets 1,~i=1,\dots,N. $
+    \State $Dist \gets 0 $

     \While {(all nodes not reach their  minimum  frequency)}
         \If{(not the last freq. \textbf{and} not the slowest node)}
         \State $F_i \gets F_i - Fdiff_i,~i=1,\dots,N.$
     \While {(all nodes not reach their  minimum  frequency)}
         \If{(not the last freq. \textbf{and} not the slowest node)}
         \State $F_i \gets F_i - Fdiff_i,~i=1,\dots,N.$


@@ -616,12 +658,12 @@ which results in bigger energy savings.
   \label{dvfs}
 \end{algorithm}
 
   \label{dvfs}
 \end{algorithm}
 

-\subsection{The verifications of the proposed algorithm}
+\subsection{The evaluation of the proposed algorithm}

 \label{sec.verif.algo}
 The precision of the proposed algorithm mainly depends on the execution time prediction model defined in 
 (\ref{eq:perf}) and the energy model computed by (\ref{eq:energy}). 
 The energy model is also significantly dependent  on the execution time model because the static energy is 
 \label{sec.verif.algo}
 The precision of the proposed algorithm mainly depends on the execution time prediction model defined in 
 (\ref{eq:perf}) and the energy model computed by (\ref{eq:energy}). 
 The energy model is also significantly dependent  on the execution time model because the static energy is 

-linearly related the execution time and the dynamic energy is related to the computation time. So, all of 
+linearly related to the execution time and the dynamic energy is related to the computation time. So, all of 

 the works presented in this paper is based on the execution time model. To verify this model, the predicted 
 execution time was compared to  the real execution time over SimGrid/SMPI simulator, v3.10~\cite{casanova+giersch+legrand+al.2014.versatile}, 
 for all  the NAS parallel benchmarks NPB v3.3 
 the works presented in this paper is based on the execution time model. To verify this model, the predicted 
 execution time was compared to  the real execution time over SimGrid/SMPI simulator, v3.10~\cite{casanova+giersch+legrand+al.2014.versatile}, 
 for all  the NAS parallel benchmarks NPB v3.3 


@@ -635,7 +677,7 @@ that tests all the possible solutions. The brute force algorithm was applied to
 different number of nodes. The solutions returned by the brute force algorithm and the proposed algorithm were identical 
 and the proposed algorithm was on average 10 times faster than the brute force algorithm. It has a small execution time: 
 for a heterogeneous cluster composed of four different types of nodes having the characteristics presented in 
 different number of nodes. The solutions returned by the brute force algorithm and the proposed algorithm were identical 
 and the proposed algorithm was on average 10 times faster than the brute force algorithm. It has a small execution time: 
 for a heterogeneous cluster composed of four different types of nodes having the characteristics presented in 

-table~(\ref{table:platform}), it takes on average \np[ms]{0.04}  for 4 nodes and \np[ms]{0.15} on average for 144 nodes 
+table~\ref{table:platform}, it takes on average \np[ms]{0.04}  for 4 nodes and \np[ms]{0.15} on average for 144 nodes 

 to compute the best scaling factors vector.  The algorithm complexity is $O(F\cdot (N \cdot4) )$, where $F$ is the number 
 of iterations and $N$ is the number of computing nodes. The algorithm needs  from 12 to 20 iterations to select the best 
 vector of frequency scaling factors that gives the results of the next sections.
 to compute the best scaling factors vector.  The algorithm complexity is $O(F\cdot (N \cdot4) )$, where $F$ is the number 
 of iterations and $N$ is the number of computing nodes. The algorithm needs  from 12 to 20 iterations to select the best 
 vector of frequency scaling factors that gives the results of the next sections.


@@ -671,16 +713,16 @@ Finally, These nodes were connected via an ethernet network with 1 Gbit/s bandwi
                   &           & GHz      & GHz          &GHz             &              &       \\
     \hline
     1             &40         & 2.5      & 1.2          & 0.1            & 20~w         &4~w    \\
                   &           & GHz      & GHz          &GHz             &              &       \\
     \hline
     1             &40         & 2.5      & 1.2          & 0.1            & 20~w         &4~w    \\

-                  &           &          &              &                &              &  \\
+         

     \hline
     2             &50         & 2.66     & 1.6          & 0.133          & 25~w         &5~w    \\
     \hline
     2             &50         & 2.66     & 1.6          & 0.133          & 25~w         &5~w    \\

-                  &           &          &              &                &              &  \\
+                  

     \hline
     3             &60         & 2.9      & 1.2          & 0.1            & 30~w         &6~w    \\
     \hline
     3             &60         & 2.9      & 1.2          & 0.1            & 30~w         &6~w    \\

-                  &           &          &              &                &              &  \\
+                  

     \hline
     4             &70         & 3.4      & 1.6          & 0.133          & 35~w         &7~w    \\
     \hline
     4             &70         & 3.4      & 1.6          & 0.133          & 35~w         &7~w    \\

-                  &           &          &              &                &              &  \\
+                  

     \hline
   \end{tabular}
   \label{table:platform}
     \hline
   \end{tabular}
   \label{table:platform}


@@ -709,7 +751,7 @@ The other benchmarks such as BT and SP should be executed on $1, 4, 9, 16, 36, 6
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline

-    Method     & Execution     & Energy         & Energy      & Performance        & Distance      \\
+    Program     & Execution     & Energy         & Energy      & Performance        & Distance      \\

     name       & time/s        & consumption/J  & saving\%    & degradation\%      &               \\
     \hline
     CG         &  64.64        & 3560.39        &34.16        &6.72               &27.44       \\
     name       & time/s        & consumption/J  & saving\%    & degradation\%      &               \\
     \hline
     CG         &  64.64        & 3560.39        &34.16        &6.72               &27.44       \\


@@ -736,7 +778,7 @@ The other benchmarks such as BT and SP should be executed on $1, 4, 9, 16, 36, 6
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline

-    Method     & Execution     & Energy         & Energy      & Performance        & Distance      \\
+    Program    & Execution     & Energy         & Energy      & Performance        & Distance      \\

     name       & time/s        & consumption/J  & saving\%    & degradation\%      &               \\
     \hline
     CG         &36.11             &3263.49             &31.25        &7.12                    &24.13     \\
     name       & time/s        & consumption/J  & saving\%    & degradation\%      &               \\
     \hline
     CG         &36.11             &3263.49             &31.25        &7.12                    &24.13     \\


@@ -763,7 +805,7 @@ The other benchmarks such as BT and SP should be executed on $1, 4, 9, 16, 36, 6
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline

-    Method     & Execution     & Energy         & Energy      & Performance        & Distance      \\
+    Program     & Execution     & Energy         & Energy      & Performance        & Distance      \\

     name       & time/s        & consumption/J  & saving\%    & degradation\%      &               \\
     \hline
     CG         &31.74         &4373.90         &26.29        &9.57                    &16.72          \\
     name       & time/s        & consumption/J  & saving\%    & degradation\%      &               \\
     \hline
     CG         &31.74         &4373.90         &26.29        &9.57                    &16.72          \\


@@ -790,7 +832,7 @@ The other benchmarks such as BT and SP should be executed on $1, 4, 9, 16, 36, 6
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline

-    Method     & Execution     & Energy         & Energy      & Performance        & Distance      \\
+    Program    & Execution     & Energy         & Energy      & Performance        & Distance      \\

     name       & time/s        & consumption/J  & saving\%    & degradation\%      &               \\
     \hline
     CG         &32.35         &6704.21         &16.15        &5.30                    &10.85           \\
     name       & time/s        & consumption/J  & saving\%    & degradation\%      &               \\
     \hline
     CG         &32.35         &6704.21         &16.15        &5.30                    &10.85           \\


@@ -817,7 +859,7 @@ The other benchmarks such as BT and SP should be executed on $1, 4, 9, 16, 36, 6
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline

-    Method     & Execution     & Energy         & Energy      & Performance        & Distance      \\
+    Program    & Execution     & Energy         & Energy      & Performance        & Distance      \\

     name       & time/s        & consumption/J  & saving\%    & degradation\%      &               \\
     \hline
     CG         &46.65         &17521.83            &8.13             &1.68                    &6.45           \\
     name       & time/s        & consumption/J  & saving\%    & degradation\%      &               \\
     \hline
     CG         &46.65         &17521.83            &8.13             &1.68                    &6.45           \\


@@ -845,7 +887,7 @@ The other benchmarks such as BT and SP should be executed on $1, 4, 9, 16, 36, 6
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline
   \centering
   \begin{tabular}{|*{7}{l|}}
     \hline

-    Method     & Execution     & Energy         & Energy      & Performance        & Distance     \\
+    Program    & Execution     & Energy         & Energy      & Performance        & Distance     \\

     name       & time/s        & consumption/J  & saving\%    & degradation\%      &              \\
     \hline
     CG         &56.92         &41163.36        &4.00         &1.10                    &2.90          \\
     name       & time/s        & consumption/J  & saving\%    & degradation\%      &              \\
     \hline
     CG         &56.92         &41163.36        &4.00         &1.10                    &2.90          \\


@@ -965,7 +1007,7 @@ results in less energy saving but less performance degradation.
   \centering
   \begin{tabular}{|*{6}{l|}}
     \hline
   \centering
   \begin{tabular}{|*{6}{l|}}
     \hline

-    Method     & Energy          & Energy      & Performance        & Distance     \\
+    Program    & Energy          & Energy      & Performance        & Distance     \\

     name       & consumption/J   & saving\%    & degradation\%      &              \\
     \hline
     CG         &4144.21          &22.42        &7.72                &14.70         \\
     name       & consumption/J   & saving\%    & degradation\%      &              \\
     \hline
     CG         &4144.21          &22.42        &7.72                &14.70         \\


@@ -994,7 +1036,7 @@ results in less energy saving but less performance degradation.
   \centering
   \begin{tabular}{|*{6}{l|}}
     \hline
   \centering
   \begin{tabular}{|*{6}{l|}}
     \hline

-    Method     & Energy          & Energy      & Performance        & Distance     \\
+    Program    & Energy          & Energy      & Performance        & Distance     \\

     name       & consumption/J   & saving\%    & degradation\%      &              \\
     \hline
     CG         &2812.38                 &36.36        &6.80                &29.56         \\
     name       & consumption/J   & saving\%    & degradation\%      &              \\
     \hline
     CG         &2812.38                 &36.36        &6.80                &29.56         \\


@@ -1018,7 +1060,7 @@ results in less energy saving but less performance degradation.
 
 \begin{figure}
   \centering
 
 \begin{figure}
   \centering

-  \subfloat[Comparison the average of the results on 8 nodes]{%
+  \subfloat[Comparison  of the results on 8 nodes]{%

     \includegraphics[width=.33\textwidth]{fig/sen_comp}\label{fig:sen_comp}}%
 
   \subfloat[Comparison the selected frequency scaling factors of MG benchmark class C running on 8 nodes]{%
     \includegraphics[width=.33\textwidth]{fig/sen_comp}\label{fig:sen_comp}}%
 
   \subfloat[Comparison the selected frequency scaling factors of MG benchmark class C running on 8 nodes]{%


@@ -1030,21 +1072,74 @@ results in less energy saving but less performance degradation.
 
 
 
 
 
 

+\subsection{The comparison of the proposed scaling algorithm }
+\label{sec.compare_EDP}
+In this section, the scaling  factors selection algorithm, called MaxDist,
+is compared to Spiliopoulos et al. algorithm \cite{Spiliopoulos_Green.governors.Adaptive.DVFS}, called EDP. 
+They developed a green governor that regularly applies an online frequency selecting algorithm to reduce the energy consumed by a multicore architecture without degrading much its performance. The algorithm selects the frequencies that minimize the energy and delay products, $EDP=Enegry*Delay$ using the predicted overall energy consumption and execution time delay for each frequency.
+To fairly compare both algorithms, the same energy and execution time models, equations (\ref{eq:energy}) and  (\ref{eq:fnew}), were used for both algorithms to predict the energy consumption and the execution times. Also Spiliopoulos et al. algorithm was adapted to  start the search from the 
+initial frequencies computed using the equation (\ref{eq:Fint}). The resulting algorithm is an exhaustive search algorithm that minimizes the EDP and has the initial frequencies values as an upper bound.
+
+Both algorithms were applied to the parallel NAS benchmarks to compare their efficiency. Table \ref{table:compare_EDP}  presents the results of comparing the execution times and the energy consumptions for both versions of the NAS benchmarks while running the class C of each benchmark over 8 or 9 heterogeneous nodes. The results show that our algorithm gives better energy savings than Spiliopoulos et al. algorithm, 
+on average it results in 29.76\% energy saving while their algorithm returns just 25.75\%. The average of performance degradation percentage is approximately the same for both algorithms, about 4\%. 
+
+
+For all benchmarks, our algorithm outperforms 
+Spiliopoulos et al. algorithm in term of energy and performance tradeoff, see figure (\ref{fig:compare_EDP}), because it maximizes the distance between the energy saving and the performance degradation values while giving the same weight for both metrics. 
+
+
+
+
+\begin{table}[h]
+ \caption{Comparing the proposed algorithm}
+ \centering
+\begin{tabular}{|l|l|l|l|l|l|l|l|}
+\hline
+\multicolumn{2}{|l|}{\multirow{2}{*}{\begin{tabular}[c]{@{}l@{}}Program \\ name\end{tabular}}} & \multicolumn{2}{l|}{Energy saving \%} & \multicolumn{2}{l|}{Perf.  degradation \%} & \multicolumn{2}{l|}{Distance} \\ \cline{3-8} 
+\multicolumn{2}{|l|}{}                                                                         & EDP             & MaxDist          & EDP            & MaxDist           & EDP          & MaxDist        \\ \hline
+\multicolumn{2}{|l|}{CG}                                                                       & 27.58           & 31.25            & 5.82           & 7.12              & 21.76        & 24.13          \\ \hline
+\multicolumn{2}{|l|}{MG}                                                                       & 29.49           & 33.78            & 3.74           & 6.41              & 25.75        & 27.37          \\ \hline
+\multicolumn{2}{|l|}{LU}                                                                       & 19.55           & 28.33            & 0.0            & 0.01              & 19.55        & 28.22          \\ \hline
+\multicolumn{2}{|l|}{EP}                                                                       & 28.40           & 27.04            & 4.29           & 0.49              & 24.11        & 26.55          \\ \hline
+\multicolumn{2}{|l|}{BT}                                                                       & 27.68           & 32.32            & 6.45           & 7.87              & 21.23        & 24.43          \\ \hline
+\multicolumn{2}{|l|}{SP}                                                                       & 20.52           & 24.73            & 5.21           & 2.78              & 15.31         & 21.95         \\ \hline
+\multicolumn{2}{|l|}{FT}                                                                       & 27.03           & 31.02            & 2.75           & 2.54              & 24.28        & 28.48           \\ \hline
+
+\end{tabular}
+\label{table:compare_EDP}
+\end{table}
+
+
+
+
+
+\begin{figure}[t]
+  \centering
+   \includegraphics[scale=0.5]{fig/compare_EDP.pdf}
+  \caption{Tradeoff comparison for NAS benchmarks class C}
+  \label{fig:compare_EDP}
+\end{figure}
+

 
 \section{Conclusion}
 \label{sec.concl} 
 In this paper, a new online frequency selecting algorithm has been presented. It selects the best possible vector of frequency scaling factors that gives the maximum distance (optimal tradeoff) between the predicted energy and 
 the predicted performance curves for a heterogeneous platform. This algorithm uses a new energy model for measuring  
 and predicting the energy of distributed iterative applications running over heterogeneous 
 
 \section{Conclusion}
 \label{sec.concl} 
 In this paper, a new online frequency selecting algorithm has been presented. It selects the best possible vector of frequency scaling factors that gives the maximum distance (optimal tradeoff) between the predicted energy and 
 the predicted performance curves for a heterogeneous platform. This algorithm uses a new energy model for measuring  
 and predicting the energy of distributed iterative applications running over heterogeneous 

-platform. To evaluate the proposed method, it  was  applied on the NAS parallel benchmarks and executed over a heterogeneous platform simulated by  Simgrid. The results of the experiments showed that the algorithm reduces up to 35\% the energy consumption of a message passing iterative method while limiting the degradation of the performance. The algorithm also  selects different scaling factors   according to the percentage of the computing and communication times, and according to the values of  the static and  dynamic powers of the CPUs. 
+platform. To evaluate the proposed method, it  was  applied on the NAS parallel benchmarks and executed over a heterogeneous platform simulated by  Simgrid. The results of the experiments showed that the algorithm reduces up to 35\% the energy consumption of a message passing iterative method while limiting the degradation of the performance. The algorithm also  selects different scaling factors   according to the percentage of the computing and communication times, and according to the values of  the static and  dynamic powers of the CPUs. Finally, the algorithm was compared to Spiliopoulos et al. algorithm and the results showed that it 
+ outperforms their algorithm in term of energy-time tradeoff.

 
 In the near future, this method will be applied to real heterogeneous platforms to evaluate its performance in a real study case. It would also be interesting to evaluate its scalability over large scale heterogeneous platform and measure the energy consumption reduction it can produce. Afterward, we would like  to develop a similar method that is adapted to asynchronous  iterative applications 
 
 In the near future, this method will be applied to real heterogeneous platforms to evaluate its performance in a real study case. It would also be interesting to evaluate its scalability over large scale heterogeneous platform and measure the energy consumption reduction it can produce. Afterward, we would like  to develop a similar method that is adapted to asynchronous  iterative applications 

-where each task does not wait for others tasks to finish there works. The development of such method might require a new 
+where each task does not wait for others tasks to finish their works. The development of such method might require a new 

 energy model because the number of iterations is not 
 known in advance and depends on the global convergence of the iterative system.
 
 \section*{Acknowledgment}
 
 energy model because the number of iterations is not 
 known in advance and depends on the global convergence of the iterative system.
 
 \section*{Acknowledgment}
 

+This work has been partially supported by the Labex
+ACTION project (contract “ANR-11-LABX-01-01”). As a PhD student, 
+Mr. Ahmed Fanfakh, would like to thank the University of
+Babylon (Iraq) for supporting his work. 

 
 
 % trigger a \newpage just before the given reference
 
 
 % trigger a \newpage just before the given reference


@@ -1056,7 +1151,7 @@ known in advance and depends on the global convergence of the iterative system.
 \bibliographystyle{IEEEtran}
 \bibliography{IEEEabrv,my_reference}
 \end{document}
 \bibliographystyle{IEEEtran}
 \bibliography{IEEEabrv,my_reference}
 \end{document}

-
+   

 %%% Local Variables:
 %%% mode: latex
 %%% TeX-master: t
 %%% Local Variables:
 %%% mode: latex
 %%% TeX-master: t