% En general Hay que quitar paja y centrarse en los aspectos claves: que medida, granularidad y plataformas si esta restringido

\subsubsection{Cronometrados}
\label{sub:cronometrados}

Este modo de medición calcula el tiempo de ejecución de un programa concreto. 
Como podemos ver en la tabla mostrada en la figura \ref{fig:TimersTable},
Las herramientas pertenecientes a este modo de medición pueden clasificarse por el tipo de resultado y por la forma de uso.
Dependiendo de la herramienta utilizada,
el resultado indicará o bien el tiempo real o bien el tiempo de CPU,
mientras que su forma de uso se realizará mediante línea de comando o scripts en {\it Shell}
o a partir de subrutinas de un lenguaje de programación específico.

\begin{figure}[!ht] 
	\centering
	\fbox{\pdfimage width 6in {Imagenes/TimersTables.png}}
	\caption{Listado de herramientas de cronometrado} 
	\label{fig:TimersTable}
\end{figure}


La herramienta de medición de tiempo a partir de línea de comando más utilizada en Unix/Linux es {\it Time}.
tiene dos formatos de salida, {\it csh} y {\it ksh}, siendo éste último el más usado.
{\it ksh} devuelve los tiempos de usuario, de sistema y el tiempo real.
Debido a que su resolución es de un milisengundo, los resultados únicamente son válidos en procesos largos.
Una ampliación de esta herramienta es {\it Timex} la cual muestra una amplia variedad de información adicional relacionada con el sistema como estadísticas de entrada salida, efectividad de la cache, llamadas, estadísticas de cola o procesos de actividad de kernel entre otros

Las herramientas de medición de tiempo a partir de subrutinas se caracterizan por encapsular el código a evaluar mediante la llamada de una función antes y después de dicho fragmento de código.
Un ejemplo de encapsulamiento de código es la subrutina {\it gettimeofday()}.
Esta función forma parte de la librería estándar de C {\it libc.a} en sistemas UNIX.
Devuelve el tiempo real en segundos y microsegundos transcurrido desde la medianoche del 1 de enero de 1970.
Como se muestra en la list \ref{code:gettimeofday}, el proceso cronometrado se delimita por la llamada a la función {\it gettimeofday()} antes del inicio y después del final del proceso.
\begin{lstlisting}[
	caption={Ejemplo código gettimeofday()},
	label={code:gettimeofday},
	language={C++}
	]
#include <stdio.h>
#include <sys/time.h>
#include <time.h>

struct timeval start_time, end_time;

main()
{
   int total_usecs;

   gettimeofday(&start_time, (struct timeval*)0);

   /*   do some work */

   gettimeofday(&end_time, (struct timeval*)0);  

   total_usecs = (end_time.tv_sec-start_time.tv_sec) * 1000000 +
                 (end_time.tv_usec-start_time.tv_usec);
   printf("Total time was %d uSec.\n", total_usecs);
}
\end{lstlisting}

La idea de encapsular el código a cronometrar es relevante en nuestro proyecto.
De hecho, los tests de eficiencia tienen como objetivo encapsular el código a evaluar mediante tags al principio y al final del código.
Sin embargo, el cálculo de tiempo con estas herramientas no tiene en cuenta dos aspectos primordiales para la comparación de diferentes ejecuciones..
El primero es que el tiempo obtenido tiene una larga lista de dependencias como la arquitectura, la velocidad del procesador o el número de tareas en ejecución, lo que causa que el resultado obtenido en una comprobación sea dificilmente repetible debido al margen de error existente.
El segundo problema es la poca granularidad de los resultados ya que el tiempo resultante solo es dividido en tiempo de usuario y de sistema.





% \paragraph{MPI: }

% dgg: MPI es que? Una libreria? Una llamada al sistema de algun sistema operativo? ponlo.

% MPI es una librería que incluye dos rutinas llamadas WTime y Wtick.
% la primera devuelve el tiempo real de la ejecución en segundos, mientras que la segunda calcula el tiempo de ejecución de WTime y así saber cuántos segundos del tiempo real no pertenecen a la ejecución del programa que queremos evaluar.
% {\it MPI} tiene librerías tanto para {\it Fortran} como para {\it C++}\ref{code:MPI}.

% \begin{lstlisting}[
% 	caption={Ejemplo código MPI},
% 	label={code:MPI},
% 	language={C++}
% 	]
% #include "mpi.h"
% int main(argc,argv)
% int argc;
% char *argv[]; {
% 
%   int n=0,m;
%   double start,end,resolution;
%   MPI_Init(&argc,&argv);
%   start = MPI_Wtime();   /* start time */
%   for (m=0;m<2000000;m++)
%      n = n + m;
%   end = MPI_Wtime();     /* end time */
%   resolution = MPI_Wtick();
%   printf("Wallclock times(secs): start= %f end= %f \n",start,end);
%   printf("elapsed= %e resolution= %e\n", end-start,resolution);
%   MPI_Finalize ();
% } 
% \end{lstlisting}
% 
% 
% \paragraph{gettimeofday(): }
% 
% Esta función forma parte de la librería estándar de C {\it libc.a} en sistemas UNIX.
% Devuelve el tiempo en segundos y microsegundos transcurrido desde la medianoche del 1 de enero de 1970.
% Para calcular el tiempo que tarda en realizarse un proceso determinado, hay que llamar a la función {\it gettimeofday()} antes del inicio y después del final del proceso.
% \begin{lstlisting}[
% 	caption={Ejemplo código gettimeofday()},
% 	label={code:gettimeofday},
% 	language={C++}
% 	]
% #include <stdio.h>
% #include <sys/time.h>
% #include <time.h>
% 
% struct timeval start_time, end_time;
% 
% main()
% {
%    int total_usecs;
% 
%    gettimeofday(&start_time, (struct timeval*)0);
% 
%    /*   do some work */
% 
%    gettimeofday(&end_time, (struct timeval*)0);  
% 
%    total_usecs = (end_time.tv_sec-start_time.tv_sec) * 1000000 +
%                  (end_time.tv_usec-start_time.tv_usec);
%    printf("Total time was %d uSec.\n", total_usecs);
% }
% \end{lstlisting}
% 
% Como podemos ver en el código de la list \ref{code:gettimeofday}, la forma de calcular el tiempo necesario para realizar un proceso es llamando a la función {\it gettimeofday} antes y después de la realización de dicho proceso.
% La idea de englobar el código evaluado mediante un tag de inicio y otro de final es de la que partimos para generar nuestros tests de eficiencia.

% \paragraph{Read real time/ Read based time: }
% 
% Forman parte de la librería estándar de C {\it libc.a} para sistemas IBM AIX.
% Esta herramienta es una mezcla de {\it MPI} y {\it gettimeofday} ya que para calcular el tiempo del proceso lo hace englobándolo entre un {\it start} y un {\it stop} (al igual que {\it gettimeofday}), mientras que, al igual que en {\it MPI}, tenemos una funaicón adicional que indica la parte del tiempo real que ha sido usada para la ejecución de las función que marca el inicio y el fin de la contabilización del tiempo.
% Un ejemplo de código es el mostrado en la list \ref{}
% 
% \begin{lstlisting}[
% 	caption={Ejemplo código read real time},
% 	label={code:RRT},
% 	language={C++}
% 	]
% #include <stdio.h>
% #include <sys/time.h>
%  
% int main(void)
% {
%    timebasestruct_t start, finish;
%    int secs, n_secs;
%  
%    read_real_time(&start, TIMEBASE_SZ);
%  
%    /* do some work */
%  
%    read_real_time(&finish, TIMEBASE_SZ);
%  
%    /* Make sure both values are in seconds and nanoseconds */
%    time_base_to_time(&start, TIMEBASE_SZ);
%    time_base_to_time(&finish, TIMEBASE_SZ);
%  
%    /* Subtract the starting time from the ending time */
%    secs = finish.tb_high - start.tb_high;
%    n_secs = finish.tb_low - start.tb_low;
%  
%   /* Fix carry from low-order to high-order during the measurement */
%    if (n_secs < 0)  {
%       secs--;
%       n_secs += 1000000000;
%       }
%  
%    (void) printf("Sample time was %d seconds %d nanoseconds\n",
%                 secs, n_secs);
%  
%    exit(0);
% }
% \end{lstlisting}
















