No hay duda de que las pruebas son una parte integral y uno de los aspectos más importantes del proceso de desarrollo de software. Y por prueba, no nos referimos solo a probar el código en busca de errores; por supuesto, la detección de errores es importante ya que nadie querría que su software tuviera errores; el rendimiento del código también es igualmente importante en estos días.
Si se desglosa hasta el último bit, las pruebas de rendimiento comprueban de forma eficaz cuánto tiempo consume una determinada pieza de código, por ejemplo, una función. Como suele ser el caso, una función o un grupo de funciones puede corresponder a una de las muchas características de un software. Por lo tanto, si a través de las pruebas de rendimiento podemos mejorar el rendimiento de estas funciones en el código, el rendimiento general del software será mejor.
Si es un programador que escribe código en lenguaje de programación C, Pascal o Fortran77 y utiliza Linux como plataforma de desarrollo, le alegrará saber que existe una poderosa herramienta a través de la cual puede verificar el rendimiento de su código:la herramienta en cuestión es Gprof. En este tutorial, discutiremos los detalles de cómo puede descargar, instalar y usar esta herramienta.
Antes de continuar, tenga en cuenta que todos los ejemplos e instrucciones mencionados en este tutorial se han probado en Ubuntu 14.04LTS y la versión de Gprof utilizada es 2.24.
¿Qué es Gprof?
Entonces, ¿qué es exactamente Gprof? Según la documentación oficial de la herramienta, brinda a los usuarios un perfil de ejecución de sus programas C, Pascal o Fortran77. Lo que hace básicamente Gprof es calcular la cantidad de tiempo empleado en cada rutina o función. "A continuación, estos tiempos se propagan a lo largo de los bordes del gráfico de llamadas. Se descubren ciclos y se realizan llamadas a un ciclo para compartir el tiempo del ciclo".
Si todo esto suena un poco confuso en este punto (especialmente la parte entre comillas), no se preocupe, ya que lo aclararemos a través de un ejemplo. Entonces, sigue leyendo.
Descargar e Instalar Gprof
Primero verifique si la herramienta ya está instalada en su sistema. Para hacer esto, simplemente ejecute el siguiente comando en una terminal.
$ gprof
Si recibe un error como:
$ a.out:No existe tal archivo o directorio
entonces esto significaría que la herramienta ya está instalada. De lo contrario, puede instalarlo usando el siguiente comando:
$ apt-get install binutils
Uso de Gprof
Ni que decir tiene que la mejor manera de entender una herramienta como Gprof es a través de un ejemplo práctico. Entonces, comenzaremos con un programa en lenguaje C, que perfilaremos a través de Gprof. Aquí está el programa:
//test_gprof.c
#include
void func4(void)
{
printf("\n Inside func4() \n");
for(int cuenta=0;cuenta<=0XFFFF;cuenta++);
}
void func3(void)
{
printf("\n Inside func3() \n");
for(int cuenta=0;cuenta<=0XFFFFFFF;cuenta++);
}
void func2(void)
{
printf("\n Inside func2() \n");
for(int cuenta=0;cuenta<=0XFFF;cuenta++ );
func3();
}
void func1(void)
{
printf("\n Inside func1() \n");
for(int cuenta=0;cuenta<=0XFFFFFF;cuenta++);
func2();
}
int main(void)
{
printf("\n main() comienza...\n");
for(int count=0;count<=0XFFFFF;count++);
func1();
func4();
printf("\n main() termina...\n");
devuelve 0;
}
Tenga en cuenta que el código que se muestra arriba (test_gprof.c ) está escrito específicamente para explicar Gprof; no está tomado de ningún proyecto de la vida real.
Ahora, continuando, el siguiente paso es compilar este código usando gcc. Tenga en cuenta que, idealmente, habría compilado el código anterior con el siguiente comando:
$ gcc -Muro -std=c99 test_gprof.c -o test_gprof
Pero como tenemos que perfilar el código usando Gprof, tendré que usar -pg opción de línea de comandos proporcionada por el compilador gcc. Entonces, el comando se convierte en:
$ gcc -Muro -std=c99 -pg prueba_gprof.c -o prueba_gprof
Si echa un vistazo a la página de manual de gcc, esto es lo que dice sobre -pg opción:
"Generar código adicional para escribir información de perfil adecuada para el programa de análisis gprof. Debe usar esta opción al compilar los archivos de origen sobre los que desea obtener datos, y también debe usarla al vincular".
Ahora, volviendo al comando anterior, después de que se ejecute con éxito, producirá un binario llamado test_gprof en la salida. El siguiente paso es lanzar ese ejecutable. Así es como inicié el binario en mi caso:
$ ./prueba_gprof
Una vez que se ejecuta el comando, verá que un archivo llamado gmon.out se generará en el directorio de trabajo actual.
$ ls gmon*
gmon.out
Es este archivo el que contiene toda la información que la herramienta Gprof requiere para producir datos de perfiles legibles por humanos. Entonces, ahora use la herramienta Gprof de la siguiente manera:
$ gprof test_gprof gmon.out> datos-perfil.txt
Básicamente, la sintaxis genérica de este comando es:
$ gprof [nombre-ejecutable] gmon.out> [nombre-del-archivo-que-contendrá-datos-de-perfil]
Ahora, antes de que veamos la información, profile-data.txt contiene, vale la pena mencionar que la salida legible por humanos que produce Gprof se divide en dos partes:perfil plano y gráfico de llamadas. Esto es lo que dice la página de manual de Gprof sobre la información en estas dos secciones:
"El perfil plano muestra cuánto tiempo pasó su programa en cada función y cuántas veces se llamó a esa función. Si simplemente desea saber qué funciones consumen la mayoría de los ciclos, aquí se indica de manera concisa".
"El gráfico de llamadas muestra, para cada función, qué funciones la llamaron, qué otras funciones llamaron y cuántas veces. También hay una estimación de cuánto tiempo se pasó en las subrutinas de cada función. Esto puede sugerir lugares donde podría intentar eliminar las llamadas a funciones que consumen mucho tiempo".
Armado con esta información, ahora estará en una mejor posición para comprender los datos presentes en su archivo de salida de perfiles (profile-data.txt en mi caso). Aquí está el perfil plano en mi caso:
Perfil plano:
Cada muestra cuenta como 0,01 segundos.
% acumulado propio total propio
tiempo segundos segundos llamadas ms/llamada ms/nombre de llamada
96,43 0.81 0.81 1 810.00 810.00 func3
3.57 0.84 0.03 1 30.00 840.00 func1
0.00 0.84 0.00 1 0.00 810.00 func2
0.00 0.84 0.00 4 0.0 func
Y esto es lo que significa cada campo:
Continuando, aquí está el gráfico de llamadas en mi caso:
Gráfico de llamadas (explicación a continuación)
granularidad:cada visita de muestra cubre 4 bytes durante 1,19 % de 0,84 segundos
índice % tiempo propio niños llamados nombre
0.03 0.81 1/1 principal [2]
[1] 100.0 0.03 0.81 1 func1 [1]
0.00 0.81 1/1 func2 [3]
-- ---------------------------------------------
[2] 100.0 0.00 0.84 principal [2]
0.03 0.81 1/1 func1 [1]
0.00 0.00 1/1 func4 [5]
---- -------------------------------------------
0,00 0,81 1 /1 func1 [1]
[3] 96.4 0.00 0.81 1 func2 [3]
0.81 0.00 1/1 func3 [4]
------------ -----------------------------------
0.81 0.00 1/1 func2 [3]
[4] 96.4 0.81 0.00 1 función3 [4]
--------------------------------- ----------- ---
0.00 0.00 1/1 principal [2]
[5] 0.0 0.00 0.00 1 func4 [5]Las siguientes capturas de pantalla explican la información que contiene el gráfico de llamadas:
Si se pregunta sobre el origen de las capturas de pantalla anteriores, permítame decirle que toda esta información está en el archivo de salida que contiene la información de creación de perfiles, incluido el perfil plano y el gráfico de llamadas. En caso de que desee omitir esta información de la salida, puede utilizar -b opción proporcionada por Gprof.
Conclusión
No hace falta decir que solo hemos arañado la superficie aquí, ya que Gprof ofrece muchas funciones (solo eche un vistazo a su página de manual). Sin embargo, todo lo que hemos cubierto aquí debería ser suficiente para comenzar. En caso de que ya use Gprof y desee compartir algo relacionado con la herramienta con todos los presentes, solo envíe un comentario a continuación.
