Estoy construyendo un grupo de 12 Raspberry Pi 2s. ¿Alguien puede explicar cómo medir el rendimiento de un clúster Raspberry Pi?

Ashwin, el trabajo no es tan simple como lo indican algunas de las respuestas aquí. Se requiere una cantidad significativa de optimización antes de realizar la medición para obtener los mejores resultados. La optimización necesaria depende de su aplicación específica.

Prueba el siguiente código:
#! / usr / bin / env python2.7
# script de Alex Eames http://RasPi.tv/?p=7684
tiempo de importación
de llamada de importación de subproceso
de subprocesos Importar subprocesos

cmd = “python /home/pi/presort.py”

hilo_proceso def (i):
imprimir “Hilo:% d”% i
start_time = time.time ()
llamada ([cmd], shell = True)
end_time = time.time ()
elapsed_time = end_time – start_time
print “El hilo% s tomó% .2f segundos”% (i, elapsed_time)

how_many = int (raw_input (“¿Cuántos hilos? \ n>”))

para i en rango (how_many):
t = Hilo (target = process_thread, args = (i,))
t.start ()
Todo lo que hace es preguntarle cuántos hilos desea ( how_many ) y luego llamar al script de preselección how_many veces, ejecutando cada uno en un hilo diferente. No es a prueba de balas (no hay verificación de errores en la entrada). Hace lo que debe hacer.

Luego, para medir el uso, utilice:

git clone https://github.com/raspitv/pi2test/
cd pi2test
python Pi2test.py

Los mejores deseos.

Creo que Matthew Lai estaba siendo sarcástico con su medida multiplicativa: el mundo real no funciona de esa manera si se tiene en cuenta que agregar más núcleos nunca escala el rendimiento como se predijo. (@ver Mejora del rendimiento del sistema multinúcleo utilizando cómputo paralelo con MATLAB)

En todo caso, para ayudarlo, ¿necesitamos más información que solo medir el rendimiento del clúster? Necesitará una serie de puntos de referencia que definan con precisión su aplicación de clústeres : entero, punto flotante, E / S, consumo de energía, latencia, etc.

Pero recuerde que los puntos de referencia son solo … puntos de referencia.

Creo que la otra respuesta del Sr. Lai está un poco equivocada debido a la configuración, la conmutación y otros retrasos de red encontrados en los sistemas de clúster.

Algunos pensamientos básicos. La gente de Cray Research, Inc. descubrió que la capacidad de los sistemas de múltiples CPU (un predecesor de múltiples núcleos) indicaba que, en general, a medida que aumentaban, descubrieron que el aumento máximo en el rendimiento indicaba que un sistema de 2 CPU alcanzaba el máximo en aproximadamente el 178% de una CPU y un sistema de 4 CPU a aprox. 256% de una CPU. Había tres límites integrados en el sistema:

1) Gastos generales de configuración del trabajo y programación de la CPU
2) Retrasos en el acceso a la memoria debido a conflictos y demoras de recuperación y almacenamiento
3) Diferentes longitudes de tiempo de cálculo de las porciones de subtrabajo

No hace falta decir que es para un sistema estrechamente acoplado (multi-core). Tendrá algunos retrasos de red adicionales en lo siguiente:

1) Distribución de los datos a la memoria integrada de cada RPi-2
2) Distribución de los códigos ejecutables a la memoria integrada de cada RPi-2
3) Comunicación entre computadoras entre las 12 unidades en su red
4) Recolectar e informar la salida final a un dispositivo de salida / almacenamiento.

Entonces, mira tu diseño. ¡Debería ser divertido! Mis referencias son el uso general y el diseño de los sistemas de CPU múltiple Cray X-MP y el sistema Cray 2. Tenga en cuenta que el Cray X-MP tenía 4 a 4 CPU como máximo y el sistema Cray 2 tenía un máximo de 4 CPU con un procesador de primer plano (distribución y recolección de trabajos). (Hubo un 8 CPU Cray 2 que fue a CCC cuando el Sr. Cray dejó la empresa.

En cuanto al tiempo, correría con 1 RPi-2, 2 RPI-2, 4 RPi-2 y 8 RPi-2 para ver los multiplicadores. … Esto debería darle una compensación en costo / valor a medida que aumenta.

Espero que esto ayude un poco.

¡Disfrutar!

PD. Aquí hay un comienzo en algunos tipos de referencia: http://en.wikipedia.org/wiki/NAS

¡Es muy fácil y ni siquiera necesitas 12 Pi!

Simplemente mida el rendimiento en uno y multiplíquelo por 12, ya que todos serán iguales.

Existen muchas medidas de rendimiento, y casi todas dependen de la aplicación que esté ejecutando. Algunos escalan muy bien (como 12 Pi, todos ejecutan lo suyo y no se comunican en absoluto), y algunos escalan muy mal (calculando hashes iterativos, ya que cada iteración depende del resultado del anterior). La mayoría de las aplicaciones están en algún punto intermedio.

Simplemente cronometra la aplicación que quieras ejecutar en ella. No existe una medida “objetiva” de rendimiento.

Cuando los configure, asegúrese de instalar GNU Parallel. Esto le brinda una forma sencilla de ejecutar comandos en todos los núcleos de cada máquina y en todas las máquinas.