CSC4509 – Algorithmique et communications des applications réparties

Portail informatique

Devoir maison : Étape 4

  • Paralléliser les réquêtes RPC grâce au multithreading (étape optionnelle non évaluée)

Cette étape est réalisable à la suite de la séance 5. Cette étape est optionnelle. Elle ne comptera pas pour l'évaluation du module. Mais si vous voulez faire cette étape et que vous avez besoin d'aide, n'hésitez pas à la demander.

Prérequis pour la réalisation de cette étape :

Les calculs d'une images de Mandelbrot sont facilement parallélisables. Le calcul fait en chaque point est totalement indépendant des autres points. L'application graphique de l'étape 3 du devoir a déjà divisé le calcul de l'image en plusieurs sections. Mais actuellement ces calculs sont fait les uns après les autres. Dans cette nouvelle étape, nous modifions le code pour que les calculs soient faits en parallèle. Pour cela il faut modifier le serveur RPC et l'application graphique (qui est ici notre client RPC).

Parallélisation du serveur RPC

Le code actuel du serveur RPC suit sur les deux phases suivantes à chaque nouvelle réquête:

  • Accepter la connexion du nouveau client ;
  • Recevoir sa requêtes, la traiter, y répondre, et fermer la connexion avec ce client.

Donc actuellement, tant que la seconde phase n'est pas terminée, il n'est pas possible d'accepter de nouveaux clients et de traiter leurs requêtes.

Placer le traitement des requêtes RPC dans un nouveau thread

Créer un nouvelle classe RpcServerRunnable qui implémente Runnable pour y déporter tout le code de la seconde phase.

Terminer les modifications pour que le serveur RPC lance cette seconde phase dans un nouveau thread, et retourne immédiatement sur l'acceptation des nouvelles connexions.

Parallélisation de l'application graphique

Le code actuel de l'application graphique lance les requêtes RPC pour le calcul des sections d'images les une après les autres. Nous le modifions pour que chaque requête soit réalisée dans un thread qui utilise une classe Callable.

Placer l'envoi des requêtes RPC dans un nouveau thread

Pour Paralléliser l'envoi des requêtes de calcul pour chaque section:

  1. Modifiez votre code pour ces requêtes soit réalisées par une classe qui implémente Callable<RpcClient>. Notez que vous n'étes pas obligé d'écrire une classe d'implémentation complète. La méthode RpcClient call() se résume à une seule instruction, donc une classe anonyme ou une expression lambda suffit pour cette modification ;
  2. Utilisez une liste (ArrayList<FutureTask<RpcClient>>) de taches pour préparer l'attente du résultat de chaque thread ;
  3. Utilisez une liste (ArrayList<Thread>) de threads pour lancer les RPC en parallèle ;
  4. Attendez la fin de tous ces threads ;
  5. Récupérez le résultat de tous les threads pour afficher chaque section de l'image de Mandelbrot.

Votre projet est fini, mais des améliorations de ce programme sont envigeables. Votre code actuel parallélise le calcul d'une image de Mandelbrot en envoyant toutes les requêtes sur le même serveur RPC. Il serait pertinent de fournir à l'application graphique une liste de serveurs pour pouvoir envoyer plus de requêtes en parallèle et vraiment accélérer le calcul de ces images.

 


$Date: 2019-04-18 14:48:37 +0200 (jeu. 18 avril 2019) $