-\begin{center}
-\Large
-\title*\textbf{Optimal Dynamic Frequency Scaling for Energy-Performance of Parallel MPI Programs}
- \end{center}
-\parskip 0pt
-\linespread{1.18}
-\normalsize
-\makeatletter
-\renewcommand*{\@seccntformat}[1]{\csname the#1\endcsname\hspace{0.01cm}}
-\makeatother
-\sectionfont{\large}
-\section{.~Introduction }
-The need for computing power is still increasing and it is not expected to slow down in the coming years. To satisfy this demand, researchers and supercomputers constructors have been regularly increasing the number of computing cores in supercomputers (for example in November 2013, according to the top 500 list~\cite{43}, the Tianhe-2 was the fastest supercomputer. It has more than 3 millions of cores and delivers more than 33 Tflop/s while consuming 17808 kW). This large increase in number of computing cores has led to large energy consumption by these architectures. Moreover, the price of energy is expected to continue its ascent according to the demand. For all these reasons energy reduction became an important topic in the high performance computing field. To tackle this problem, many researchers used DVFS (Dynamic Voltage Frequency Scaling) operations which reduce dynamically the frequency and voltage of cores and thus their energy consumption. However, this operation also degrades the performance of computation. Therefore researchers try to reduce the frequency to minimum when processors are idle (waiting for data from other processors or communicating with other processors). Moreover, depending on their objectives they use heuristics to find the best scaling factor during the computation. If they aim for performance they choose the best scaling factor that reduces the consumed energy while affecting as little as possible the performance. On the other hand, if they aim for energy reduction, the chosen scaling factor must produce the most energy efficient execution without considering the degradation of the performance. It is important to notice that lowering the frequency to minimum value does not always give the most efficient execution due to energy leakage. The best scaling factor might be chosen during execution (online) or during a pre-execution phase.
-In this paper we emphasize to develop an algorithm that selects the optimal frequency scaling factor that takes into consideration simultaneously the energy consumption and the performance. The main objective of HPC systems is to run the application with less execution time. Therefore, our algorithm selects the optimal scaling factor online with very small footprint. The proposed algorithm takes into account the communication times of the MPI programs to choose the scaling factor. This algorithm has ability to predict both energy consumption and execution time over all available scaling factors. The prediction achieved depends on some computing time information, gathered at the beginning of the runtime.
-We apply this algorithm to seven MPI benchmarks. These MPI programs are the NAS parallel penchmarks (NPB v3.3) developed by NASA~\cite{44}. Our experiments are executed using the simulator Simgrid/SMPI v3.10~\cite{45} over an homogeneous distributed memory architecture. Furthermore, we compare the proposed algorithm with Rauber's methods. The comparison's results show that our algorithm gives better energy-time trade off.
-\sectionfont{\large}
-\section{.~Related Works }
-In the this section some heuristics, to compute the scaling factor, are presented and classified in two parts : offline and online methods.
- \sectionfont{\large}
-\subsection{~The offline DVFS orientations}
-The DVFS offline methods are static and are not executed during the runtime of the program. Some approaches used heuristics to select the best DVFS state during the compilation phases as an example in Azevedo et al.~\cite{40}. He used intra-task algorithm to choose the DVFS setting when there are dependency points between tasks. While in~\cite{29}, Xie et al. used breadth-first search algorithm to do that. Their goal is saving energy with time limits. Another approaches gathers and stores the runtime information for each DVFS state , then used their methods offline to select the suitable DVFS that optimize energy-time trade offs. As an example~\cite{8}, Rountree et al. used liner programming algorithm, while in~\cite{38,34}, Cochran et al. used multi logistic regression algorithm for the same goal. The offline study that shown the DVFS impact on the communication time of the MPI program is~\cite{17}, Freeh et al. show that these times not changed when the frequency is scaled down.
-\sectionfont{\large}
-\subsection{~The online DVFS orientations}
-The objective of these works is to dynamically compute and set the frequency of the CPU during the runtime of the program for saving energy. Estimating and predicting approaches for the energy-time trade offs developed by ~\cite{11,2,31}. These works select the best DVFS setting depending on the slack times. These times happen when the processors have to wait for data from other processors to compute their task. For example, during the synchronous communication time that take place in the MPI programs, the processors are idle. The optimal DVFS can be selected using the learning methods. Therefore, in ~\cite{39,19} used machine learning to converge to the suitable DVFS configuration. Their learning algorithms have big time to converge when the number of available frequencies is high. Also, the communication time of the MPI program used online for saving energy as in~\cite{1}, Lim et al. developed an algorithm that detects the communication sections and changes the frequency during these sections only. This approach changes the frequency many times because an iteration may contain more than one communication section. The domain of analytical modeling used for choosing the optimal frequency as in ~\cite{3}, Rauber et al. developed an analytical mathematical model for determining the optimal frequency scaling factor for any number of concurrent tasks, without considering communication times. They set the slowest task to maximum frequency for maintaining performance.
-In this paper we compare our algorithm with Rauber's model~\cite{3}, because his model can be used for any number of concurrent tasks for homogeneous platform and this is the same direction of this paper.
-However, the primary contributions of this paper are:
-\\1-Selecting the optimal frequency scaling factor for energy and performance
- simultaneously. While taking into account the communication time.
-\\2-Adapting our scale factor to taking into account the imbalanced tasks.
-\\3-The execution time of our algorithm is very small when compared to other methods (e.g.,~\cite{19}).
-\\4-The proposed algorithm works online without profiling or training as in~\cite{38,34}.
-\sectionfont{\large}
-\section{.~Parallel Tasks Execution on Homogeneous Platform}
-A homogeneous cluster consists of identical nodes in terms of the hardware and the software. Each node has its own memory and at least one processor which can be a multi-core. The nodes are connected via a high bandwidth network. Tasks executed on this model can be either synchronous or asynchronous. In this paper we consider execution of the synchronous tasks on distributed homogeneous platform. These tasks can exchange the data via synchronous memory passing.
-\begin{figure}[h]
-\centering
-\subfloat[Synch. Imbalanced Communications]{\includegraphics[scale=0.67]{synch_tasks}\label{fig:h1}}
-\subfloat[Synch. Imbalanced Computations]{\includegraphics[scale=0.67]{compt}\label{fig:h2}}
- \caption{Parallel Tasks on Homogeneous Platform}
- \label{fig:homo}
-\end{figure}
-Therefore, the execution time of a task consists of the computation time and the communication time. Moreover, the synchronous communications between tasks can lead to idle time while tasks wait at the synchronous point for others tasks to finish their communications see figure~(\ref{fig:h1}).
-Another source for idle times is the imbalanced computations. This happen when processing different amounts of data on each processor as an example see figure~(\ref{fig:h2}). In this case the fastest tasks have to wait at the synchronous barrier for the slowest tasks to finish their job. In both two cases the overall execution time of the program is the execution time of the slowest task as :
-\begin{equation} \label{eq:T1}
- Program Time=MAX_{i=1,2,..,N} (T_i) \hfill
+
+\title{Optimal Dynamic Frequency Scaling for Energy-Performance of Parallel MPI Programs}
+
+\author{%
+ \IEEEauthorblockN{%
+ Ahmed Badri,
+ Jean-Claude Charr,
+ Raphaël Couturier and
+ Arnaud Giersch
+ }
+ \IEEEauthorblockA{%
+ FEMTO-ST Institute\\
+ University of Franche-Comté
+ }
+}
+
+\maketitle
+
+\AG{``Optimal'' is a bit pretentious in the title.\\
+ Complete affiliation, add an email address, etc.}
+
+\begin{abstract}
+ \AG{complete the abstract\dots}
+\end{abstract}
+
+\section{Introduction}
+\label{sec.intro}
+
+The need for computing power is still increasing and it is not expected to slow
+down in the coming years. To satisfy this demand, researchers and supercomputers
+constructors have been regularly increasing the number of computing cores in
+supercomputers (for example in November 2013, according to the TOP500
+list~\cite{43}, the Tianhe-2 was the fastest supercomputer. It has more than 3
+millions of cores and delivers more than 33 Tflop/s while consuming 17808
+kW). This large increase in number of computing cores has led to large energy
+consumption by these architectures. Moreover, the price of energy is expected to
+continue its ascent according to the demand. For all these reasons energy
+reduction became an important topic in the high performance computing field. To
+tackle this problem, many researchers used DVFS (Dynamic Voltage Frequency
+Scaling) operations which reduce dynamically the frequency and voltage of cores
+and thus their energy consumption. However, this operation also degrades the
+performance of computation. Therefore researchers try to reduce the frequency to
+minimum when processors are idle (waiting for data from other processors or
+communicating with other processors). Moreover, depending on their objectives
+they use heuristics to find the best scaling factor during the computation. If
+they aim for performance they choose the best scaling factor that reduces the
+consumed energy while affecting as little as possible the performance. On the
+other hand, if they aim for energy reduction, the chosen scaling factor must
+produce the most energy efficient execution without considering the degradation
+of the performance. It is important to notice that lowering the frequency to
+minimum value does not always give the most efficient execution due to energy
+leakage. The best scaling factor might be chosen during execution (online) or
+during a pre-execution phase. In this paper we emphasize to develop an
+algorithm that selects the optimal frequency scaling factor that takes into
+consideration simultaneously the energy consumption and the performance. The
+main objective of HPC systems is to run the application with less execution
+time. Therefore, our algorithm selects the optimal scaling factor online with
+very small footprint. The proposed algorithm takes into account the
+communication times of the MPI programs to choose the scaling factor. This
+algorithm has ability to predict both energy consumption and execution time over
+all available scaling factors. The prediction achieved depends on some
+computing time information, gathered at the beginning of the runtime. We apply
+this algorithm to seven MPI benchmarks. These MPI programs are the NAS parallel
+benchmarks (NPB v3.3) developed by NASA~\cite{44}. Our experiments are executed
+using the simulator SimGrid/SMPI v3.10~\cite{Casanova:2008:SGF:1397760.1398183}
+over an homogeneous distributed memory architecture. Furthermore, we compare the
+proposed algorithm with Rauber's methods.
+\AG{Add citation for Rauber's methods. Moreover, Rauber was not alone to to this work (use ``Rauber et al.'', or ``Rauber and Gudula'', or \dots)}
+The comparison's results show that our
+algorithm gives better energy-time trade off.
+%
+\AG{Correctly reword the following}%
+In Section~\ref{sec.relwork} we present works from other
+authors. Then, in Sections~\ref{sec.ptasks} and~\ref{sec.energy}, we
+introduce our model. [\dots] Finally, we conclude in
+Section~\ref{sec.concl}.
+
+\section{Related Works}
+\label{sec.relwork}
+
+\AG{Consider introducing the models (sec.~\ref{sec.ptasks},
+ maybe~\ref{sec.energy}) before related works}
+
+In the this section some heuristics, to compute the scaling factor, are
+presented and classified in two parts : offline and online methods.
+
+\subsection{The offline DVFS orientations}
+
+The DVFS offline methods are static and are not executed during the runtime of
+the program. Some approaches used heuristics to select the best DVFS state
+during the compilation phases as an example in Azevedo et al.~\cite{40}. He used
+intra-task algorithm
+\AG{what is an ``intra-task algorithm''?}
+to choose the DVFS setting when there are dependency points
+between tasks. While in~\cite{29}, Xie et al. used breadth-first search
+algorithm to do that. Their goal is saving energy with time limits. Another
+approaches gathers and stores the runtime information for each DVFS state, then
+used their methods offline to select the suitable DVFS that optimize energy-time
+trade offs. As an example~\cite{8}, Rountree et al. used liner programming
+algorithm, while in~\cite{38,34}, Cochran et al. used multi logistic regression
+algorithm for the same goal. The offline study that shown the DVFS impact on the
+communication time of the MPI program is~\cite{17}, Freeh et al. show that these
+times not changed when the frequency is scaled down.
+
+\subsection{The online DVFS orientations}
+
+The objective of these works is to dynamically compute and set the frequency of
+the CPU during the runtime of the program for saving energy. Estimating and
+predicting approaches for the energy-time trade offs developed by
+~\cite{11,2,31}. These works select the best DVFS setting depending on the slack
+times. These times happen when the processors have to wait for data from other
+processors to compute their task. For example, during the synchronous
+communication time that take place in the MPI programs, the processors are
+idle. The optimal DVFS can be selected using the learning methods. Therefore, in
+~\cite{39,19} used machine learning to converge to the suitable DVFS
+configuration. Their learning algorithms have big time to converge when the
+number of available frequencies is high. Also, the communication time of the MPI
+program used online for saving energy as in~\cite{1}, Lim et al. developed an
+algorithm that detects the communication sections and changes the frequency
+during these sections only. This approach changes the frequency many times
+because an iteration may contain more than one communication section. The domain
+of analytical modeling used for choosing the optimal frequency as in~\cite{3},
+Rauber et al. developed an analytical mathematical model for determining the
+optimal frequency scaling factor for any number of concurrent tasks, without
+considering communication times. They set the slowest task to maximum frequency
+for maintaining performance. In this paper we compare our algorithm with
+Rauber's model~\cite{3}, because his model can be used for any number of
+concurrent tasks for homogeneous platform and this is the same direction of this
+paper. However, the primary contributions of this paper are:
+\begin{enumerate}
+\item Selecting the optimal frequency scaling factor for energy and performance
+ simultaneously. While taking into account the communication time.
+\item Adapting our scale factor to taking into account the imbalanced tasks.
+\item The execution time of our algorithm is very small when compared to other
+ methods (e.g.,~\cite{19}).
+\item The proposed algorithm works online without profiling or training as
+ in~\cite{38,34}.
+\end{enumerate}
+
+\section{Parallel Tasks Execution on Homogeneous Platform}
+\label{sec.ptasks}
+
+A homogeneous cluster consists of identical nodes in terms of the hardware and
+the software. Each node has its own memory and at least one processor which can
+be a multi-core. The nodes are connected via a high bandwidth network. Tasks
+executed on this model can be either synchronous or asynchronous. In this paper
+we consider execution of the synchronous tasks on distributed homogeneous
+platform. These tasks can exchange the data via synchronous memory passing.
+\begin{figure*}[t]
+ \centering
+ \subfloat[Sync. Imbalanced Communications]{\includegraphics[scale=0.67]{synch_tasks}\label{fig:h1}}
+ \subfloat[Sync. Imbalanced Computations]{\includegraphics[scale=0.67]{compt}\label{fig:h2}}
+ \caption{Parallel Tasks on Homogeneous Platform}
+ \label{fig:homo}
+\end{figure*}
+\AG{On fig.~\ref{fig:h1}, how can there be a synchronization point without communications just before ?\\
+Use ``Sync.'' to abbreviate ``Synchronization''}
+Therefore, the execution time of a task consists of the computation time and the
+communication time. Moreover, the synchronous communications between tasks can
+lead to idle time while tasks wait at the synchronous point for others tasks to
+finish their communications see figure~(\ref{fig:h1}). Another source for idle
+times is the imbalanced computations. This happen when processing different
+amounts of data on each processor as an example see figure~(\ref{fig:h2}). In
+this case the fastest tasks have to wait at the synchronous barrier for the
+slowest tasks to finish their job. In both two cases the overall execution time
+of the program is the execution time of the slowest task as :
+\begin{equation}
+ \label{eq:T1}
+ \textit{Program Time} = \max_{i=1,2,\dots,N} T_i
