¿Venís de leer la intro, la parte 1, la parte 2 y la parte 3?
El tema
Lo que veníamos viendo es como aprovechar mejor una CPU cada vez más compleja y luego varias pero con la ilusión de usar una sola. Cada una de estas CPU es capaz de ejecutar al sistema operativo, de hecho es probable que por momentos lo estén haciendo. Este enfoque generíco produce un inconveniente, que es que las CPU deben ser capaces de comunicarse entre si y con los dispositivos de almacenaminento y entrada/salida, cuando lo que nos interesa es que ejecuten programas que no son parte de la gestión del sistema operativo y comunicarse entre sí.
Existen varios enfoque que consisten en usar muchas CPUs genéricas simples interconectadas. Entonces en un mismo chip se pueden poner muchos cores pues necesitan menos silicio.
La que uso es la parallella, que es una mini supercomputadora. Mini en términos de que tiene muy pocas CPUs, por ende, bajo rendimiento. Super en la arquitectura, son CPUs simples con un bus de interconexión que no he usado, no necesito comunicar información entre los cores.
Este chip está pensado para experimentar, la versión siguiente de 64 cores y la siguiente de 1024 aparentemente han "desaparecido", DARPA contrató al diseñador y nada más se ha sabido.
Una dificultad que tuve fue el cambio de endiannes, mis programas originales son para x86 y estos cores son ARM, la tienen invertida.
Mientras estaba haciendo las primeras pruebas, no presté suficiente atención a la disipación de calor y pasé un momentó de pánico cuando se freezó, mmh, que raro decir que se freezó cuando en realidad se sobrecalentó y se detuvo.
Con respecto a la dificultad que esperaba en esta etapa respecto a las demás, resultó sorpresivamente sencillo que funcionara.
Para hacer funcionar esto hacen falta dos programas, uno para la CPU y otro para enviar a cada core. Este último programa se fija cual es su core y usa ese número como índice para decidir sobre que parte del set de datos trabajar.
El programa de la CPU principal es:
#include <host_bsp.h>
#include <stdio.h>
int main(int argc, char **argv) {
// Initialize the BSP system
bsp_init("ecore_find.elf", argc, argv);
// Initialize the Epiphany system and load the binary
bsp_begin(16);
// Run the program on the Epiphany cores
ebsp_spmd();
// Finalize
bsp_end();
return 0;
}
La esencia del programa en los cores es:
typedef struct {
uint64_t hashcount;
char init;
char stop;
} Data;
int main(int argc, char * argv[]) {
bsp_begin();
int n = bsp_nprocs();
int p = bsp_pid();
Data data[] = {
{0,';','>'},
{1,'?','B'},
{2,'C','F'},
....
{14,'s','v'},
{15,'w','z'}
};
uint64_t hashcount = data[p].hashcount;
char init = data[p].init;
char stop = data[p].stop;
for (char0 = init; char0 <= stop ; ++char0) {...
En data están los rangos a procesar, con bsp_pid() se obtiene el core actual y se usa como índice en data y el for usa los valores apropiados.
El clock es de 1Ghz, así que tiene un consumo muy bajo, la placa entera consume 5W de los cuales 2 o 3 son del chip multicore.
Código
- https://github.com/cpantel/Forzando-Brutalmente-MD5/tree/master/v6_ebsp
No hay comentarios:
Publicar un comentario