Yotta

Projet tutoré :
Librairie de calcul distribué

Guillaume Abadie
Thierry Cantenot

De quoi allons-nous vous parler ?

Dossier d'initialisation
Travail distribué et parallélisé
Architecture répondant à un besoin
Dossier bilan
Des threads
Et des processus !!!

Calcul distribué

Un projet

Yotta = 10^24

3 mois de dev

~500 commits (Git)

Deux produits principaux

Librairie statique C
Daemon Python

Inspiration

OpenCL

Travail au long des jours

Oui mais un projet coordonné !

Oups !... L'habitude ...

Toute ressemblance avec des enseignements existant

ou ayant existé ne serait que pure coïncidence.

Application & Daemon

Librairie statique C

Orienté objet
Standard POSIX
Compatible Linux & Mac OS
Full 64 bits
Support IPv4 et IPv6
~14000 lignes de code (88% du code)
~1300 lignes de makefile (8% du code)
+120 fichiers de code

Daemon Python

Un daemon par ordinateur esclave
Utilisation de la librairie réseau Twisted
Tests avec Pytest
Prêt à l'emploi

 > sudo pip install twisted
 > git clone git@github.com/gabadie/yotta.git yotta
 > python yotta/src_daemon/daemon.py --port 5000

~600 lignes de code (4% du code)

Dictate

Communication Master - Daemon

Récupération des infos du daemon
Envoi du binaire au daemon
Démarrage de l'exécutable chez le client
Récupération des erreurs du daemon

Protocole indépendant de la version

Déploiement

Whisper

Communication Master - Slave

Lancement des commandes de massive dispatch
Push de zones mémoires
Fetch de zones mémoires (FETCH REQUEST, FETCH ANSWER)
Arrêt d'un processus esclave

Vers l'infini et l'au-delà ...

Lancement d'une commande

void
hello_world(foo_t const * bar);

int
main()
{
    // [...]

    foo_t bar;
    bar.what = ever;

    yotta_context_massive(&context, hello_world, sizeof(bar), &bar);

    // [...]
}

Problème : les adresses de fonctions
sont incompatibles entre processus ...
(Une chance sur 2^64 que cela fonctionne)

(si ça marche, jouez au loto)

Adresses de fonctions relatives

Ajoutez y du Git !...

(Mais pas de SVN ...)

Transferts mémoires

Blocs mémoires

Exemple de transferts

void
hello_world(yotta_addr_t master_ptr)
{
    foo_t bar;
    yotta_sync_t fetch_done;
    yotta_sync_t push_done;

    yotta_fetch_package(master_ptr, sizeof(bar), &bar, &fetch_done);
    yotta_sync_wait(&fetch_done);

    bar.what = ever;

    yotta_push_package(master_ptr, sizeof(bar), &bar, &push_done);
    yotta_sync_wait(&push_done);
}

Spaghetti de threads ....

(Mais ceci n'est pas de la cuisine ...)

(La communauté italienne remarquera que nous n'avons pas écrit "spaghettis" (avec un "s"))

Thread dispatching

void
hello_world(foo_t * bar);

void
main()
{
    // [...]

    foo_t bar;
    bar.what = ever;

    yotta_dispatch(hello_world, &bar);

    // [...]
}

Problème : Démarre les threads dans le processus courant...

Calcul de masse

Calcul de masse distribué

Démo

Bilan d'un développement système

Incrémentations indispensables
Cycle en V inutilisable
Assertions dynamiques primordiales
Spécifications OCL inutiles
Tests unitaires progressifs indispensables
Modèles du concept, protocole (etc ...) inutiles
Diagrammes UML très utiles
Aucune paperasse de chef de projet
Discussion régulière

Bref ...

Merci à tous !

Merci à Lionel Brunie de nous avoir offert une occasion dans

la 4IF de faire quelque chose qui nous plait, essentiel pour le

moral des troupes mis à rude épreuve par notre formation.