\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 try 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 demonstrated that it reduces the energy consumption
-up to 35\% while limiting the performance degradation as much as possible. Finally, the algorithm is compared to an existing method and the comparison results show that it outperforms the latter.
+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}
-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 consumed 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
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 is ended with a summary and some future works.
+Finally, in Section~\ref{sec.concl} the paper ends with a summary and some future works.
\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,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, ...
+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:
\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
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
- 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
- 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}
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
- \includegraphics[scale=0.5]{fig/commtasks}
+ \includegraphics[scale=0.6]{fig/commtasks}
\caption{Parallel tasks on a heterogeneous platform}
\label{fig:heter}
\end{figure}
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
\end{equation}
Where:\\
\begin{equation}
-\label{eq:perf}
+\label{eq:perf2}
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}
\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}
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}
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)} + {} \\
\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}}\\
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}
\begin{figure}
\centering
\subfloat[Homogeneous platform]{%
- \includegraphics[width=.30\textwidth]{fig/homo}\label{fig:r1}}%
+ \includegraphics[width=.33\textwidth]{fig/homo}\label{fig:r1}}%
\subfloat[Heterogeneous platform]{%
- \includegraphics[width=.30\textwidth]{fig/heter}\label{fig:r2}}
+ \includegraphics[width=.33\textwidth]{fig/heter}\label{fig:r2}}
\label{fig:rel}
\caption{The energy and performance relation}
\end{figure}
-Then, the objective function can be modeled as finding the maximum distance
+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
\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
-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.
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
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
\begin{figure}
\centering
\subfloat[Energy saving]{%
- \includegraphics[width=.30\textwidth]{fig/energy}\label{fig:energy}}%
+ \includegraphics[width=.33\textwidth]{fig/energy}\label{fig:energy}}%
\subfloat[Performance degradation ]{%
- \includegraphics[width=.30\textwidth]{fig/per_deg}\label{fig:per_deg}}
+ \includegraphics[width=.33\textwidth]{fig/per_deg}\label{fig:per_deg}}
\label{fig:avg}
\caption{The energy and performance for all NAS benchmarks running with difference number of nodes}
\end{figure}
\begin{figure}
\centering
\subfloat[Comparison of the results on 8 nodes]{%
- \includegraphics[width=.30\textwidth]{fig/sen_comp}\label{fig:sen_comp}}%
+ \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=.30\textwidth]{fig/three_scenarios}\label{fig:scales_comp}}
+ \includegraphics[width=.33\textwidth]{fig/three_scenarios}\label{fig:scales_comp}}
\label{fig:comp}
\caption{The comparison of the three power scenarios}
\end{figure}
\subsection{The comparison of the proposed scaling algorithm }
\label{sec.compare_EDP}
-
-In this section, the scaling factors selection algorithm
-is compared to Spiliopoulos et al. algorithm \cite{Spiliopoulos_Green.governors.Adaptive.DVFS}.
+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
+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. \textcolor{red}{The results show that our algorithm gives better energy savings than Spiliopoulos et al. algorithm,
-on average it is up to 17\% higher for energy saving compared to their algorithm. The average of performance degradation percentage using our method is higher on average by 3.82\%. The positive values for energy saving and distance are mean that our method outperform Spiliopoulos et al. method, while the inverse is happen for the negative values. The negative values for performance degradation percentage are mean our method is has the less delay in time, while the positive values mean the inverse. }
+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 \textcolor{red}{(on average it has up to 21\% of distance)}, 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.
+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
\end{table}
-\begin{table}[htb]
- \caption{Comparing the proposed algorithm}
- % title of Table
- \centering
- \begin{tabular}{|*{4}{l|}}
- \hline
- Program & Energy & Performance & Distance\% \\
- name & saving\% & degradation\% & \\
- \hline
- CG &13.31 &22.34 &10.89 \\
- \hline
- MG &14.55 &71.39 &6.29 \\
- \hline
- EP &44.4 &0.0 &44.42 \\
- \hline
- LU &-4.79 &-88.58 &10.12 \\
- \hline
- BT &16.76 &22.33 &15.07 \\
- \hline
- SP &20.52 &-46.64 &43.37 \\
- \hline
- FT &14.76 &-7.64 &17.3 \\
-\hline
- \end{tabular}
- \label{table:compare_EDP}
-\end{table}
-\begin{table}[htb]
- \caption{Comparing the proposed algorithm}
- % title of Table
- \centering
- \begin{tabular}{|*{4}{l|}}
- \hline
- Program & Energy & Performance & Distance\% \\
- name & saving\% & degradation\% & \\
- \hline
- CG &3.67 &1.3 &2.37 \\
- \hline
- MG &4.29 &2.67 &1.62 \\
- \hline
- EP &8.68 &0.01 &8.67 \\
- \hline
- LU &-1.36 &-3.8 &2.44 \\
- \hline
- BT &4.64 &1.44 &3.2 \\
- \hline
- SP &4.21 &-2.43 &6.64 \\
- \hline
- FT &3.99 &-0.21 &4.2
- \\
-\hline
- \end{tabular}
- \label{table:compare_EDP}
-\end{table}
+
+
\begin{figure}[t]
\centering
\includegraphics[scale=0.5]{fig/compare_EDP.pdf}
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
-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}
This work has been partially supported by the Labex
-ACTION project (contract “ANR-11-LABX-01-01”). As a PhD student,
+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.
+Babylon (Iraq) for supporting his work.
% trigger a \newpage just before the given reference
\bibliographystyle{IEEEtran}
\bibliography{IEEEabrv,my_reference}
\end{document}
-
+
%%% Local Variables:
%%% mode: latex
%%% TeX-master: t
