Multitche objets Modlisation objet des paradigmes multitches Shebli

Multitâche & objets Modélisation objet des paradigmes multitâches © Shebli Anvar Institut de recherches sur les lois fondamentales de l’Univers Irfu/Sédi/Lilas CEA Saclay – 91191 Gif-sur-Yvette – France Shebli. Anvar@cea. fr

2 Communication inter-objets n n n Un objet est une instance de classe La classe encapsule sa structure interne La classe spécifie une interface à base d’opérations Communication inter-objets appels d’opérations données échangées = paramètres

3 Collaboration entre instances Messages serveur[0] choix. Serveur client calcul batch manager batch Instances (objets) serveur[1] serveur[2]

4 Abstraction des classes Les messages sont traduits en opérations Client * client 1 manager Manager +calcul () #choix. Serveur () Rôles manager 1 serveur * Serveur +batch ()

5 Objets actifs Les objets actifs sont les instances en traits gras UML 1. 4) ou avec doubles barres (UML 2) ou avec le stéréotype « active » Un « objet actif » est un objet qui encapsule son (ses) propre(s) fil(s) d’exécution serveur[0] choix. Serveur client calcul batch manager batch serveur[1] serveur[2]

6 Abstraction des classes objets actifs UML: aucune hypothèse sur le modèle d’exécution ni l’implémentation d’un objet actif Client * client 1 manager Manager +calcul () #choix. Serveur () «active» manager 1 serveur * Serveur +batch ()

7 Notions à transposer n Tâche (Thread) ¨ ¨ n Création, lancement Endormissement, suspension Arrêt, destruction Attente d’arrêt (join) Mutex Création, destruction ¨ Types (simple, récursif…) ¨ Prise et rendu de jeton ¨ Rendu automatique ¨ n Condition Association avec Mutex ¨ Attente et notification ¨ Timeout ¨ n Sémaphore ¨ ¨ n Binaire, à compte Conditions initiales Prise et rendu de jetons Timeout Communication Asynchrone (file d’attente) ¨ Synchronisation différée ¨ À distance ¨ Broadcast ¨

8 La notion d’objet actif n Fusion entre objet et tâche ¨ Modèle d’exécution n monotâche n multitâche (une par opération) ¨ Appel d’opération asynchrone ¨ Appel d’opération à distance n En pratique: ¨ La classe dérive d’une classe « Thread » (ou implémente une interface ad hoc comme l’interface Runnable en Java) ¨ Met en œuvre une file d’attente de requêtes d’exécution

9 Exemple de classe Thread « abstract » Thread « C+ + » prio = _prio; stack. Size = _stack. Size; # prio: int # stack. Size: int « create » + Thread (_prio: int, _stack. Size: int) « destroy » + Thread() + start() + join() {virtual} # run() Questions Pourquoi la méthode run() doit être: - protected ? - virtuelle ?

10 Classe Mutex Appel bloquant si mutex vide Le problème du rendu de jeton lors des exceptions : try { . . . mutex. lock(); . . . mutex. unlock(); . . . Survenue de l’exception } catch(std: : exception& e) jeton non rendu {. . . } Mutex + lock() + unlock() mutex 1 Lock « create » + Lock(Mutex m) « destroy » + Lock()

11 Classe Mutex Appel bloquant si mutex vide Le problème du rendu de jeton lors des exceptions : try { . . . Lock lock(mutex); . . . // Quel code ? . . . } rendu normal ? catch(std: : exception& e) {. . . rendu exception ? } Mutex + lock() + unlock() mutex 1 Lock « create » + Lock(Mutex m) « destroy » + Lock()

12 tâche A void wait. For. Stop( volatile int* p. Command, Mutex* mtx, Condition* cnd ) { Lock lock(mutex); while (*p. Command != STOP) { cnd->wait(); } } tâche B Une condition s’utilise avec un mutex void do. Stop( volatile int* p. Command, Mutex* mtx, Condition* cnd ) { Lock lock(mutex); *p. Command = STOP; cnd->notify(); }

13 Classe Condition Mutex lock() unlock() mutex 1 Condition Dans le modèle objet, le mutex ou la condition s’utilisent à l’intérieur de l’objet (encapsulation) : ce sont les méthodes de la classe qui les utilisent. wait(timeout : Integer) notify() notify. All() Condition « create » Condition(Mutex m) wait() lock() unlock() on sait d’avance si le mutex sera associé à une condition ou pas. wait() wait(timeout : Integer) notify() notify. All()

14 Classe Semaphore # counter : Integer # max. Count : Integer Semaphore(init. Val : Integer, max. Val : Integer) take(timeout_ms : Integer) give() flush() Condition not. Empty « create » Condition(Mutex m) 1 wait() wait(timeout : Integer) notify() notify. All() Un sémaphore est un compteur de jetons Lorsqu’il est vide, la demande de jeton bloque la tâche Déblocage : une autre tâche fournit un jeton Mécanisme de blocage déblocage ? Condition

15 Appel d’opération synchrone : Server : Client crunch (param) result Client: : run(Server* server) { int param = 10; double result = server->crunch(param); }

16 Appel d’opération asynchrone : Server : Client crunch (param) result

17 Décomposition de l’appel asynchrone server: Server : Client req. Fifo: Request. Fifo req_crunch (param) push(req) req: Req. Server pop() req crunch (req. param) result set. Result(result) wait. Return() result

18 Appel d’opération asynchrone Client: : run(Server* server) : Server : Client { Req. Server* req = server->req_crunch(10); // requête. . . . // Autres. . . . instructions double result = req->wait. Return(); // // Attente result } result Server: : req_crunch(int param) { ; // Création req. Fifo. push(new Req. Server(param)); // Création req } crunch (param) result Server: : run() { while(true) { req. Fifo. pop() ; Req. Serv* req = =req. Fifo. pop(); double result == crunch(req. param); ; double ; req->set. Result(result); } }

19 Mise en œuvre de l’objet actif Thread Request. Fifo not. Empty + push(Request) + pop() : Request # run() req. Fifo Active. Object 1 1 * requests Exec. Request Server +crunch(param : Integer) : Real +req_crunch(param : Integer): Req. Server # run() Condition « use » Semaphore 1 executed Req. Server param 19 : Integer result : Real + wait. Return() : Real + set. Result(result : Real)

20 Décomposition de l’appel asynchrone server: Server : Client req. Fifo: Request. Fifo (1 req_crunch (param) push(req) req: Req. Server pop() req crunch (req. param) result set. Result(result) wait. Return() result

21 Décomposition de l’appel asynchrone server: Server : Client req. Fifo: Request. Fifo req_crunch (param) push(req) req: Req. Server pop() req execute(server) crunch (req. param) result wait. Return() result

22 Mise en œuvre de l’objet actif Thread Request. Fifo not. Empty + push(Request) + pop() : Request # run() req. Fifo Active. Object 1 1 * requests Exec. Request Server +crunch(param : Integer) : Real +req_crunch(param : Integer): Req. Server # run() Condition « use » Semaphore 1 executed Req. Server param 22 : Integer result : Real + wait. Return() : Real + set. Result(result : Real)

23 Mise en œuvre de l’objet actif Request. Fifo Thread + push(Request) + pop() : Request # run() req. Fifo Active. Object # run() not. Empty « use » Condition 1 1 * requests Exec. Request Semaphore 1 executed + execute(o: Active. Object) Server +crunch(param : Integer) : Real +req_crunch(param : Integer): Req. Server « use » Req. Server param : Integer result : Real + wait. Return() : Real + execute(o: Active. Object)