DISEÑO Y EVALUACIÓN DE CONFIGURACIONES

Práctica 6: DOMINGO LÓPEZ OLLER

Programación de un benchmark portable

Lista de correo

Me he suscrito a la lista de correo con el correo [email protected].

Me he dado de alta en el sistema de envío de prácticas, y tengo el nick domingolopezoller y el id 51


OBJETIVO DE LA PRÁCTICA

El objetivo de la práctica es desarrollar un benchamark en C++ para poder medir las características de diferentes máquinas y luego analizar cuál de ellas es mejor según los resultados obtenidos.

¿Qué voy a medir?

En este benchmark se va a realizar lo siguiente: Estas operaciones se detallarán más abajo y en todos los casos lo que se hará es medir tiempo en segundos y está claro que cuanto menor sea mejor será la máquina que estamos analizando.

¿CÓMO LO VOY A HACER?

Para realizar la medición de tiempo voy a utilizar la librería time de C, con la función clock(), y tomaré el tiempo antes y después de las operaciones para luego presentar el tiempo en segundos transcurrido. Estas operaciones van a suponer un tiempo y lo que queremos ver con las distintas máquinas es cuál de ellas lo hace más rápido y en qué operación, porque podría darse el caso de que una máquina tenga muy buenos resultados en una prueba y muy malos en otra, de ahí que no nos baste el valor absoluto de las pruebas por separado, sino que haya que ver también la media y comparar así mejor las máquinas. Lo que sí está claro es que cuanto menor sea el tiempo obtenido en las pruebas mejor.

Una cosa adicional a esta práctica será el análisis de estas máquinas bajo sistemas operativos diferentes. Como ya he ido haciendo en anteriores prácticas, miraré los resultados que se obtienen bajo el sistema operativo Windows y luego sobre Linux para ver si hay alguna diferencia o no entre sistemas bajo el mismo sistema. (Hasta ahora se ha visto que las prestaciones de Linux son mayores que las de Windows)
Como vamos a tocar varios componentes del sistema, habrá varios elementos que pueden influir en la medición:
Obviamente, las condiciones de ejecución del benchmark va a afectar al resultado de las pruebas. Es por ello que estas pruebas se realizarán con el sistema en baja carga, en este caso nada más arrancarlo que es cuando menos cosas se pueden estar ejecutando y dejaremos el benchmark solo, no haremos nada durante la ejecución del mismo.

Vamos a definir ahora cada una de las pruebas y explicar el código asociado a cada parte:

OBTENER 20000 NÚMEROS PRIMOS

Como todos sabemos un número primo es aquel que es sólo divisible por él mismo y la unidad. La tarea de encontrar 20000 números primos es complicada porque no están repartidos uniformemente y hay que hacer muchas comprobaciones.
  1. El objetivo de esta parte es obtener el tiempo que tarda en encontrarse los 20000 números primos
  2. La métrica es el tiempo en segundos que obtendré como diferencia de fin-inicio con la función clock() de C.
  3. En este caso los elementos que van a influir sobre la medición son:
  4. Todas las pruebas se van a hacer con el sistema en baja carga, en este caso nada más arrancarlo que es cuando menos cosas se pueden estar ejecutando.
  5. Se realizará una prueba para cada sistema o más de una según sistemas operativos que tengan
  6. Se comentará el resultado obtenido al final
El código para detectar si un número es primo o no es el siguiente: 
    int n=2,i=0,p;
    while(i < primos)
    {
        for(p = 2; n % p != 0; p++);
           if(p == n){
               i++;
           }
        n++;
    }
Nota: La variable contador es la i

MULTIPLICAR 100 VECES MATRICES[300][300]

En este caso lo que se hará es multiplicar 100 veces dos matrices de dimensión [300]*[300] que están inicialmente a 0. No me interesa el tiempo que se pierda en hacer la multiplicación sino el tiempos de realizar la operación en sí.
  1. El objetivo de esta parte es obtener el tiempo que tarda en multiplicar 100 veces 2 matrices de dimensión [300]*[300]
  2. La métrica es el tiempo en segundos que obtendré como diferencia de fin-inicio con la función clock() de C.
  3. En este caso los elementos que van a influir sobre la medición son:
  4. Todas las pruebas se van a hacer con el sistema en baja carga, en este caso nada más arrancarlo que es cuando menos cosas se pueden estar ejecutando.
  5. Se realizará una prueba para cada sistema o más de una según sistemas operativos que tengan
  6. Se comentará el resultado obtenido al final
El código para multiplicar dos matrices 100 veces es el siguiente:
matrices

LECTURA Y ESCRITURA EN MEMORIA RAM

En este caso utilizaremos un vector dinámico de la clase vector de C++ para al principio almacenar (ESCRIBIR) números aleatorios según el tamaño final (5,10,15,20)MB y luego almacenar este resultado en un contenedor para luego ir leyendo (LEER) de ahí lo almacenado. Con este vector se harán las pruebas de memoria por la obtención de memoria dinámica conforme solicitamos más espacio al insertar
  1. El objetivo de esta parte es obtener el tiempo que tarda en escribir y leer vectores de distinto tamaño en memoria
  2. La métrica es el tiempo en segundos que obtendré como diferencia de fin-inicio con la función clock() de C.
  3. En este caso los elementos que van a influir sobre la medición son:
    • Número de procesos que se arrancan en cada sistema operativo
    • Capacidad de memoria RAM
    • Ancho de banda del bus de memoria
    • Ocupación de la memoria en el momento de la prueba
  4. Todas las pruebas se van a hacer con el sistema en baja carga, en este caso nada más arrancarlo que es cuando menos cosas se pueden estar ejecutando.
  5. Se realizará una prueba para cada sistema o más de una según sistemas operativos que tengan
  6. Se comentará el resultado obtenido al final
El código para escribir de forma dinámica y leer en memoria es el siguiente:
memoria

LECTURA Y ESCRITURA EN DISCO DE FICHEROS

En este caso utilizaremos un vector dinámico creado en la prueba anterior para escribir su contenido en u fichero en disco. Se escribirá por tanto un único fichero que al final tendrá (5+10+15+20)=50MB. En esta prueba vamos a medir el tiempo que tarda en escribirse y leerse cada uno de los vectores del contenedor. Al principio mediremos el tiempo de escribirlos para generar el fichero de 50MB y luego el tiempo de leerlos.
  1. El objetivo de esta parte es obtener el tiempo que tarda en escribir y leer vectores de distinto tamaño en disco
  2. La métrica es el tiempo en segundos que obtendré como diferencia de fin-inicio con la función clock() de C.
  3. En este caso los elementos que van a influir sobre la medición son:
    • Número de procesos que se arrancan en cada sistema operativo
    • Ocupación del disco
    • Características técnicas del disco como la latencia (menor-es-mejor) si es SATA o no, capacidad del disco,...
  4. Todas las pruebas se van a hacer con el sistema en baja carga, en este caso nada más arrancarlo que es cuando menos cosas se pueden estar ejecutando.
  5. Se realizará una prueba para cada sistema o más de una según sistemas operativos que tengan
  6. Se comentará el resultado obtenido al final
El código para escribir y leer en disco es el siguiente:
disco

IMPRESIÓN DE CARACTERES POR PANTALLA

En este caso vamos a imprimir 500000 veces el texto "HOLA MUNDO" por pantalla y así veremos qué tarjeta gráfica es más rápida ya que cuando mejor sea esta el tiempo en imprimir será menor.
  1. El objetivo es ver cuánto se tarda en imprimir este texto
  2. La métrica es el tiempo en segundos que utilizando la librería time de C pero en vez de clock() usaré time(NULL) para controlar el tiempo dado que con la otra no funciona demasiado bien para este experimento.
  3. En este caso los elementos que van a influir sobre la medición son:
    • Número de procesos que se arrancan en cada sistema operativo
    • Características técnicas de la tarjeta gráfica como memoria dedicada, procesador, si es integrada o no,...
  4. Todas las pruebas se van a hacer con el sistema en baja carga, en este caso nada más arrancarlo que es cuando menos cosas se pueden estar ejecutando.
  5. Se realizará una prueba para cada sistema o más de una según sistemas operativos que tengan
  6. Se comentará el resultado obtenido al final
El código para escribir por pantalla es el siguiente: 
    for(int i=0;i<500000;i++){
        cerr << "HOLA MUNDO";
    }
Nota: El hecho de que sea cerr en lugar de cout es por el caso de direccionar El hecho de medir el tiempo antes y después de esto es por ver que no van a salir el mismo, dado que una cosa será el tiempo de procesador y otro muy distinto el tiempo de ir escribiendo por pantalla. Es decir, se mandará la orden de imprimir los 500000 en x tiempo pero la impresión de los mismos no será tan rápido.
Nota: Para todos los experimentos cuanto menor sea el tiempo obtenido mejor será la máquina evaluada

Al final de esta práctica se va a presentar una tabla que recogerá los datos y una gráfica donde se presentarán los resultados obtenidos y la reflexión sobre lo obtenido.
Nota: Esta práctica puede plantearse de la forma que yo la presento o dado un tiempo límite ver el número de operaciones que pueden llegar a hacerse.

EQUIPOS DE PRUEBA Y CÓDIGO

En el apartado anterior he explicado cómo voy a tomar el tiempo y en qué va a consistir cada prueba. Partiremos del siguiente código C++ que reune todas las pruebas a realizar y lo ejecutaremos en cada una de las siguientes máquinas:

Sistema 1,2

Sistema 3

Sistema 4

Sistema 5

Sistema 6

Sistema 7 (prácticas ETSIIT)

Nota: En este ordenador no pude instalar un monitor para obtener datos más específicos por no tener permisos de administrador

El código completo es el siguiente (benchmark.cpp):
codigo
Este código se encuentra en la carpeta archivos adjunta al index.html, puede verse aquí, y también está el binario generado en Windows con devcpp4.9.9.2 y en Linux con g++ -o benchmark benchmark.cpp.
Este código se ha probado tanto en Linux como en Windows y MACOSX y funciona correctamente. El único pero es que al tratarse de sistemas de archivos distintos y utilizar comandos diferentes no es posible eliminar el fichero que se genera con la prueba de disco, será el usuario el que tenga que eliminarlo después de la prueba. El motivo es que en Windows se eliminaría con la llamada al sistema del pero para Linux y Mac sería con rm y no hay una orden común.

ANÁLISIS

Una vez hemos compilado el código vamos a ejecutar el benchmark en cada uno de los equipos anteriores obteniendo los siguientes resultados:
SISTEMA 1 SISTEMA 2 SISTEMA 3 SISTEMA 4 SISTEMA 5 SISTEMA 6 SISTEMA 7
CPU44.7546.87528.5230.328.77125.11 180.20
MEMORIA4.7873.393.646.6019.19190.343
DISCO13.8421.9229.7910.3214.5659.5897.29
GRÁFICA23.1555.2220.1218.588.6425.3431
El hecho de que el sistema 5 esté por debajo de las espectativas es porque el sistema no trabaja al 100% dado que está preparado para el nuevo MAcOSX 10.6 Snow Leopard a 64 bits, que no está disponible ahora mismo, mientras que ahora está capado y trabajando con 32 bits en lugar de 64.
La gráfica comparativa viendo estos datos es la siguiente:
gráfica1
De aquí puede verse la importancia de tener un sistema de base dado que en algunas pruebas puede tener un ordenador mejores resultados que otro. Esto puede verse en el caso del MAC (Sistema 5) que en teoría tenía que ser el mejor de todos pero resulta estar en la media por el motivo comentado arriba. Otra posibilidad de ver esto es el caso de que la CPU ofrezca malos resultados pero en cambio se haya colocado una gráfica de última generación y de muy buenos resultados en los test de gráfica. Es por ello que necesitamos considerar un sistema base y comparar los resultados obtenidos con este.

A la vista de los resultados obtenidos, se aprecia cuáles son los 2 peores pero cuesta averiguar cuál es el mejor entre los sistemas 3, 4, 5 y esto se obtendrá realizando la normalización de esta tabla respecto al sistema base.
Como sistema base podría considerar cualquiera de los equipos analizados pero voy a considerar el que peor resultados ha dado a la vista de las pruebas.
Si nos detenemos en los sistemas 1 y 2 que tienen la misma arquitectura pero se ha ejecutado el benchmark bajo sistemas operativos distintos vemos que el sistema 1 ofrece mejores prestaciones que el sistema 2. De nuevo Linux le gana la partida a Windows y podemos decir que una máquina de bajas prestaciones se puede explotar mucho mejor bajo Linux que en Windows debido a las exigencias del sistema operativo y la cantidad de procesos que se están ejecutando constantemente en la máquina que lo que hace es ralentizar la máquina. Hay que decir que entre los sistemas evaluados varios están en Linux y otros en Windows, no cabe la menor duda de que el sistema en Linux obtendría peores mediciones con Windows mirando ese ejemplo.

Vamos a generar la tabla normalizada:
SISTEMA 1 SISTEMA 2 SISTEMA 3 SISTEMA 4 SISTEMA 5 SISTEMA 6 SISTEMA 7
CPU4,02681564246,3183730725,9471947196,2634688911,4403325071
MEMORIA39,820711327,1918571456,1483775852,2920329728,839848489,9188639921
DISCO7,0296242774,4384124099,9376915229,4273255816,6820054951,6329305141
GRÁFICA1,3390928730,56139081,5407554671,6684607118,902439021,2233622731
MEDIA13,054061028,99058091818,4862994117,3337534915,171940473,5538723211
Dado que un sistema puede ser mucho mejor que otro en una medición que en otra he preferido considerar una medida que pondere las 4 mediciones, en este caso la media aunque se podría haber utilizado otras fórmulas más complejas, con el único fin de poder comparar una máquina con otra y obtener unos resultados más fiables.

GRÁFICA

gráfica con media
Se aprecia que el mejor es el sistema 3 ya que tiene un valor medio mayor que el resto. También puede apreciarse más claro el análisis hecho arriba entre el sistema Linux y Windows, es casi 1.5 veces mejor.

CONCLUSIONES

En esta práctica se ha aprendido a evaluar varios sistemas bajo un mismo programa de prueba de CPU, MEMORIA, DISCO y GRÁFICA respecto a un sistema base. En esta práctica se ha visto que la arquitectura hace que un sistema esté por encima de otro cuanto más moderno es, como es natural, pero tambien se ve que no podemos decir que un ordenador es mejor que otro por la descripción del sistema, depende del entorno de trabajo y para lo que esté diseñado. Esto va por los resultados obtenidos del MAC respecto al resto
Con la programación de benchmark hay que tener cuidado con lo que se mide y cómo se mide ya que un sistema diseñado para cálculo intensivo va a a obtener muy buenos resultados para CPU y puede que muy malos para DISCO,es por esto que no podemos pararnos a ver una media concreta, debemos evaluar varios sistemas compararlos y obtener un parámetro que identifique a todas las medidas de forma representativa, como la media aritmética en mi caso, y así poder hacer reflexiones y obtener el resultado final.
Yo veo una gran utilidad en los benchmark para poder evaluar distintos componentes antes de ir a comprarlos (siempre que sean legales con las medidas claro). Estudiando los componentes podremos comprar un sistema mucho mejor que si nos decantamos por la marca o por ciertas características. Un ejemplo de esto es el análisis que le hice a un VAIO VGN-FW21Z que para ser el mejor en teoría ofrecía resultados todavía peores que el ordenador de prácticas, cosa que me impactó mucho y por eso no está entre los datos, la única explicación que le he encontrado es el alto consumo de recursos de Vista, otra explicación no le veo.
DOMINGO LÓPEZ OLLER
Ingeniero Técnico Informática Sistemas
Práctica 6 de Diseño y Evaluación de configuraciones.
Hosted by www.Geocities.ws

1