Algorithmique & Programmation (INF 431)
|
|
- Gaspard Germain
- il y a 8 ans
- Total affichages :
Transcription
1 Algorithmique & Programmation () Pottier 4 juin juin / 84
2 Une communication peu coûteuse... Les processus légers : partagent le tas et les variables globales, donc peuvent communiquer de façon potentiellement peu coûteuse. 4 juin / 84
3 ...mais pas simple pour autant Nous allons constater que si plusieurs threads tentent d accéder au même emplacement au même moment, le résultat est souvent imprévisible et/ou indésirable. Donc, la communication par mémoire partagée ne suffit pas pour écrire des programmes concurrents corrects et efficaces ; il faut aussi des mécanismes de synchronisation, c est-à-dire d attente. 4 juin / 84
4 Différents mécanismes de synchronisation Nous avons déjà rencontré un mécanisme de synchronisation, join. Il permet à un thread B d attendre la terminaison d un thread A. Cela permet, par exemple, de transmettre un résultat de A vers B. Il en existe d autres... 4 juin / 84
5 Différents mécanismes de synchronisation Si deux threads stockent des informations dans une table de hash partagée, il faut leur interdire d y accéder au même moment. Il faut donc parfois que l un d eux attende. Les verrous («locks») étudiés aujourd hui servent à cela. 4 juin / 84
6 Différents mécanismes de synchronisation Si A produit un flot de résultats, qu il souhaite transmettre au fur et à mesure qu ils sont produits à B, alors ces threads doivent se coordonner. A doit parfois attendre B, et vice-versa. Les files d attente concurrentes utilisées la semaine dernière en TD et étudiées en détail la semaine prochaine permettent cela. Nous verrons qu elles sont implémentées à l aide de mécanismes plus élémentaires, à savoir verrous et variables de condition. 4 juin / 84
7 Aujourd hui, donc, nous étudions les verrous : à quoi servent-ils? comment fonctionnent-ils? quels présentent-ils? 4 juin / 84
8 Le problème du compteur partagé Imaginons que plusieurs threads souhaitent partager un compteur. 4 juin / 84
9 Le problème du compteur partagé Voici une implémentation ordinaire d un objet «compteur» : class UnsafeCounter { private int count ; void increment () { count++ ; } int get () { return count ; } } Que se passe-t-il si plusieurs threads utilisent simultanément un tel objet? (Démonstration.) 4 juin / 84
10 Que se passe-t-il? Comment expliquer ce comportement? Chacun des deux threads appelle n fois c.increment(). La valeur finale de c ne devrait-elle pas être 2n, quel que soit l ordre dans lequel ces appels sont effectués? Ce raisonnement serait correct si chaque appel était exécuté de façon atomique, c est-à-dire sans interférence de la part de l autre thread. Or, ce n est pas le cas... 4 juin / 84
11 increment n est pas atomique L instruction count++ ; est une version abrégée de : count = count + 1 ; qui signifie en fait : this. count = this. count + 1 ; qui signifie en fait : int tmp = this. count ; tmp = tmp + 1 ; this. count = tmp ; On reconnaît une lecture en mémoire («load»), suivie d une addition, suivie d une écriture en mémoire («store»). 4 juin / 84
12 increment n est pas atomique Supposons que deux threads A et B appellent c.increment() au même moment. L objet c est partagé. L emplacement en mémoire nommé c.count est le même du point de vue de A et du point de vue de B. La variable tmp est locale, donc non partagée. Chaque thread a la sienne. Le code exécuté est donc, grosso modo : // thread A // thread B int tmpa = this. count ; int tmpb = this. count ; tmpa = tmpa + 1 ; tmpb = tmpb + 1 ; this. count = tmpa ; this. countb = tmp ; où chaque thread progresse à sa vitesse propre. 4 juin / 84
13 increment n est pas atomique Comment ce code est-il exécuté par la machine? Si la machine a un seul processeur, il y a partage du temps, donc entrelacement arbitraire des instructions de A et des instructions de B. Si la machine a plusieurs processeurs, A et B s exécutent réellement en même temps, et et la mémoire traite les ordres de lecture et d écriture émis par A et B dans un ordre un entrelacement imprévisible. (En fait, c est encore pire, voir plus loin.) 4 juin / 84
14 Un entrelacement possible // thread A // thread B int tmpa = this. count ; int tmpb = this. count ; tmpa = tmpa + 1 ; tmpb = tmpb + 1 ; this. count = tmpa ; this. count = tmpb ; Quoiqu il en soit, le scénario suivant (entre autres) est possible : A lit c.count et initialise tmpa à 0 ; B lit c.count et initialise tmpb à 0 ; A et B incrémentent tmpa et tmpb ; A écrit 1 dans c.count ; B écrit 1 dans c.count. À la fin, le compteur vaut 1 alors que c.increment a été appelé deux fois. Aïe! 4 juin / 84
15 increment n est pas atomique D autres scénarios peuvent se produire : par exemple, on peut voir diminuer la valeur du compteur. Dans tous les cas, le problème provient du fait que B modifie le compteur à un instant où A a déjà pu observer le compteur mais pas encore le modifier. On dit qu il y a interférence entre les threads A et B. 4 juin / 84
16 Interférence Il y a interférence ou conflit («race condition») si et seulement si : il existe un entrelacement des instructions qui fait que... deux threads accèdent au même instant à un même emplacement en mémoire, et au moins l un d eux tente d écrire à cet emplacement. Deux lectures simultanées ne constituent donc pas une race condition. 4 juin / 84
17 Thou shalt not race Nous poserons ce principe : Un programme qui présente une race condition est incorrect. 4 juin / 84
18 Thou shalt not race Deux raisons principales justifient ce principe : pour comprendre le comportement d un programme qui présente une race condition, il faudrait au minimum étudier tous les entrelacements possibles des instructions des différents threads ; cela ne suffirait même pas, car certains comportements des machines modernes ne sont expliqués par aucun entrelacement... 4 juin / 84
19 Un comportement inattendu Soient x et done des variables globales, donc partagées. Le code suivant présente une race condition sur la variable partagée done. On suppose qu initialement x vaut 0 et done vaut false. L instruction assert peut-elle échouer? // thread A // thread B x = 42 ; while (!done ) { } done = true ; assert ( x == 42) ; Sur certaines machines (par exemple ARM), oui. B voit que done vaut true mais trouve une valeur autre que 42 dans x. Cela n est expliqué par aucun entrelacement. Comme disent Boehm et Adve, «You Don t Know Jack about Shared Variables or Memory Models». 4 juin / 84
20 Mais que fait ARM? Le processeur A a demandé à la mémoire d écrire d abord 42 dans x, puis true dans done. Or, le processeur B a lu true dans done mais pas 42 dans x. La mémoire n a pas respecté l ordre des écritures. En fait, il y a une mémoire interne au processeur A, une autre interne au processeur B, des échanges de messages entre elles, et ces messages ne circulent pas dans l ordre, pour des raisons d efficacité. Ce n est pas un bug du processeur! 4 juin / 84
21 Et que fait Intel? Les processeurs Intel garantissent que «les messages d écriture circulent dans l ordre», donc si B voit que done vaut true, il voit aussi que x vaut 42. Cela n empêche pas que, à un instant donné, A peut savoir que done vaut true tandis que B croit encore que done vaut false, parce que le message n a pas encore été reçu. On dit que ARM, Intel,... offrent des «modèles mémoire faiblement cohérents». 4 juin / 84
22 Et que dit Java? En ce qui concerne le comportement de la mémoire en présence de race, le standard Java est extrêmement complexe. (Démonstration.) Le compilateur Java change while (!done) boolean d = done ; while (!d) ;. ; en Mes collègues débattent toujours s il a tort ou raison! Déclarer que done est volatile impose un comportement «cohérent» et fait disparaître le problème. 4 juin / 84
23 Thou shalt not race Revenons sur Terre. Pour nous, une règle simple suffit : Un programme qui présente une race condition est incorrect. On doit synchroniser les threads pour éviter toute race condition. Le comportement des programmes est alors beaucoup plus facile à analyser et à prédire, car, en l absence de race, le fait que la mémoire est «faiblement cohérente» ne se voit pas. 4 juin / 84
24 Comment faire un compteur partagé? Notre objet UnsafeCounter ne doit pas être utilisé simultanément par plusieurs threads : cela conduit à une race condition. Il y a race condition sur count parce que plusieurs threads y accèdent (en lecture et en écriture) au même moment. 4 juin / 84
25 Comment faire un compteur partagé? On pourrait songer à ajouter un booléen ready dont la valeur indique s il est permis ou non d accéder à count. Mais cela ne ferait que déplacer le problème : il y aurait alors une race condition sur ready. Mais alors, comment implémenter correctement un compteur partagé? 4 juin / 84
26 Plusieurs solutions Dans la suite, nous allons découvrir deux réponses à ce problème : l une à base d instructions évoluées, l autre, plus générale, à base de verrous. Les deux idées sont liées : l implémentation des verrous utilise (plusieurs techniques dont) des instructions évoluées. 4 juin / 84
27 Avec l aide de la machine Et si la machine nous proposait une instruction toute faite pour lire la valeur du compteur puis y écrire une nouvelle valeur, le tout de façon atomique? 4 juin / 84
28 Avec l aide de la machine De nombreux processeurs proposent des instructions qui combinent une lecture et une écriture au même emplacement. L une de ces instructions est compareandset. Voyons quelle forme elle prend du point de vue d un programmeur Java... 4 juin / 84
29 L instruction compareandset Java fournit une classe AtomicInteger : public class AtomicInteger { public AtomicInteger ( int initialvalue) ; public int get () ; public void set ( int newvalue) ; public boolean compareandset ( int expectedvalue, int newvalue) ; } Un tel objet contient un champ de type int, consultable et modifiable grâce aux méthodes get et set. Il propose de plus une méthode compareandset... 4 juin / 84
30 L instruction compareandset L expression ai.compareandset(expectedvalue, newvalue) : 1 lit la valeur stockée dans l objet ai ; 2 compare cette valeur à expectedvalue ; 3 si cette comparaison réussit, écrit dans ai la valeur newvalue ; 4 renvoie le résultat de la comparaison (qui indique donc si l écriture a eu lieu) ; 5 le tout de façon atomique, c est-à-dire sans qu un autre thread puisse modifier ai pendant ce temps. 4 juin / 84
31 Comment utiliser compareandset? La classe AtomicInteger fournit aussi une méthode getandincrement, dont l effet est analogue à celui de l instruction count++. getandincrement est implémentée à l aide de compareandset. Comment?... 4 juin / 84
32 Comment utiliser compareandset? On va vouloir utiliser compareandset... public int getandincrement () { compareandset (?,?) ; } Mais il faut d abord déterminer l ancienne valeur et calculer la nouvelle... 4 juin / 84
33 Comment utiliser compareandset? Pour cela, on appelle d abord get : public int getandincrement () { int n = get() ; compareandset ( n, n + 1) ; } Mais compareandset peut échouer. Il faut examiner son résultat... 4 juin / 84
34 Comment utiliser compareandset? Si compareandset réussit, tout va bien! Aucune interférence n a eu lieu. public int getandincrement () { } int n = get() ; if ( compareandset (n, n + 1)) return n ; //?? Mais que faire dans le cas contraire? 4 juin / 84
35 Comment utiliser compareandset? Il faut réessayer jusqu à ce que compareandset réussisse. public int getandincrement () { while ( true ) { int n = get() ; if ( compareandset (n, n + 1)) return n ; } } C est une attente active (à éviter en principe, sauf si elle dure peu). 4 juin / 84
36 Comment utiliser compareandset? En résumé, get permet d observer la valeur du compteur, compareandset permet de la modifier, à condition que notre observation n ait pas été invalidée entre-temps ; la boucle permet d attendre que compareandset réussisse. 4 juin / 84
37 Faut-il utiliser compareandset? L utilisation de compareandset ne constitue pas une race condition. Elle est «autorisée». compareandset résout le problème du compteur partagé. Cependant, elle ne résout pas (directement) le problème plus général de l exclusion... 4 juin / 84
38 Peut-on partager une pile? Imaginons que nous souhaitions partager une pile («stack») entre plusieurs threads. 4 juin / 84
39 Une pile traditionnelle Traditionnellement, on peut implémenter une pile à l aide d une liste chaînée de cellules immuables : class StackCell <X> { final X data ; final StackCell <X> next ; StackCell ( X data, StackCell <X> next ) {... } } 4 juin / 84
40 Une pile traditionnelle L objet «pile» contient un pointeur top vers la tête de la liste : class Stack <X> { private StackCell <X> top ; void push ( X x) { top = new StackCell <X> (x, top) ; } X pop () { if ( top == null ) return null ; X data = top. data ; top = top. next ; return data ; } } Si deux threads appellent s.push(...) ou s.pop() au même moment, que se passe-t-il?... 4 juin / 84
41 Peut-on partager une pile? D abord, il y a une race condition sur le champ s.top. Donc, le programme est incorrect. Si cela ne vous convainc pas, étudiez quelques scénarios possibles : deux appels simultanés à push peuvent n empiler qu un seul objet! un objet est perdu. deux appels simultanés à pop peuvent ne dépiler qu un seul objet! un objet est dupliqué. etc. 4 juin / 84
42 Quel est le problème? La racine du problème, en ce qui concerne push par exemple, est que l instruction : top = new StackCell <X> (x, top) ; n est pas atomique. Elle signifie en fait : StackCell <X> oldcell = top ; StackCell <X> newcell = new StackCell <X> (x, oldcell) ; top = newcell ; Cette séquence d instructions est sujette à interférence. 4 juin / 84
43 Quel est le problème? Ici, on retrouve le motif simple (lecture-calcul-écriture) de la méthode UnsafeCounter.increment. Le problème peut donc à nouveau être résolu à l aide de l instruction compareandset. (Exercice! On utilisera la classe AtomicReference fournie par Java.) 4 juin / 84
44 Quel est le problème? Cependant, en général, on peut souhaiter exécuter une séquence d instructions plus longue, constituée de plus d une lecture et/ou plus d une écriture, de façon atomique (sans interférence). C est le cas si on souhaite partager, par exemple : une table de hash dotée de méthodes put et get ; un arbre binaire de recherche doté de méthodes put et get ; etc. 4 juin / 84
45 Spécifier ce que l on attend On aimerait déclarer quelles séquences d instructions, appelées «sections critiques», doivent être exécutées sans interférence. atomic {... } On pourrait écrire : void push ( X x) { atomic { top = new StackCell <X> (x, top) ; } } X pop () { atomic {... } } C est un peu simpliste/simplifié, mais c est l idée. 4 juin / 84
46 Spécifier ce que l on attend On pourrait alors exprimer la propriété que l on attend : Jamais deux threads ne sont engagés chacun dans une section critique. Cette propriété est appelée exclusion. 4 juin / 84
47 Implémenter l exclusion Pour réaliser l exclusion, l idée est simple : si un thread B arrive à l entrée d une section critique, et si un thread A se trouve déjà dans une section critique, alors B doit attendre jusqu à ce que A en sorte. Un mécanisme de synchronisation est donc nécessaire. Les verrous constituent un tel mécanisme. 4 juin / 84
48 Les verrous Habituellement, les verrous servent à la fois à : délimiter les sections critiques, donc spécifier ce que l on attend ; implémenter l attente à l entrée d une section critique. 4 juin / 84
49 Les verrous Il existe trois opérations sur les verrous : 1 création d un nouveau verrou l ; 2 verrouillage («acquisition») d un verrou existant l ; 3 déverrouillage («libération») d un verrou l préalablement verrouillé. 4 juin / 84
50 Les verrous en Java En Java, un verrou est un objet (alloué dans le tas, comme tout objet). Java fournit une interface Lock : public interface Lock { void lock () ; void unlock () ; } Il en existe plusieurs implémentations, dont celle-ci : public class ReentrantLock implements Lock {... } On peut donc créer autant de verrous qu on le souhaite : Lock l = new ReentrantLock () ; 4 juin / 84
51 Les verrous Un verrou a deux états possibles : il est soit déverrouillé («libre»), soit verrouillé («pris»). L opération de verrouillage, lock, est bloquante : si un thread B tente d acquérir un verrou, et si un thread A a déjà pris ce verrou, alors B doit attendre jusqu à ce que A libère ce verrou. C est donc une opération de synchronisation. Un verrou ne peut pas être «pris» simultanément par plusieurs threads. 4 juin / 84
52 Les verrous Un verrou peut être implémenté par attente active, à l aide de compareandset. (Exercice!) Il peut également être implémenté via un appel système : le thread qui appelle lock est suspendu jusqu à ce que le verrou soit libre. On combine en général ces deux mécanismes. Le programmeur Java n a pas à savoir comment les verrous sont implémentés. 4 juin / 84
53 Délimiter une section critique On voit que, pour délimiter une section critique, il suffit : d acquérir un verrou à l entrée de la section critique, de libérer ce verrou à la sortie de la section critique. 4 juin / 84
54 Délimiter une section critique en Java Si lock est un verrou, on écrira donc : lock. lock() ; try { // SECTION CRITIQUE } finally { lock. unlock() ; } try/finally garantit que le verrou sera libéré même si le code situé dans la section critique lance une exception. Ceci correspond à l hypothétique mot-clef atomic de tout-à-l heure. 4 juin / 84
55 Quel(s) verrou(s) utiliser? Il reste une chose à préciser. Quel verrou faut-il utiliser pour délimiter une section critique? Si s est une pile, il faut interdire à deux threads d exécuter s.pop ou s.push au même moment. Cependant, si s1 et s2 sont deux piles distinctes, mieux vaut autoriser s1.pop et s2.push à être exécutés simultanément. 4 juin / 84
56 Quel(s) verrou(s) utiliser? En termes plus généraux, deux sections de code : qui peuvent interférer entre elles doivent être contrôlées par un même verrou ; qui ne peuvent pas interférer entre elles peuvent être contrôlées par des verrous distincts. 4 juin / 84
57 Quel(s) verrou(s) utiliser? Ici, il semble naturel que chaque pile partagée ait son propre verrou. 4 juin / 84
58 Une pile partagée en Java On associe à chaque objet de classe SafeStack un verrou distinct : class SafeStack <X> { private final Lock lock = new ReentrantLock () ; private StackCell <X> top ; void push (X x) { lock. lock() ; // take the lock try { top = new StackCell <X> (x, top) ; } finally { lock. unlock() ; // release the lock } } X pop () {... } // also takes and releases the lock } Le corps des méthodes push et pop forme une section critique. 4 juin / 84
59 Une pile partagée en Java Un objet s de classe SafeStack peut être utilisé sans danger par plusieurs threads simultanément. Au plus un thread à la fois pourra exécuter un appel à s.push ou s.pop ; les autres devront attendre. Deux objets distincts s1 et s2 de classe SafeStack peuvent être utilisés simultanément par deux threads sans qu aucune attente soit nécessaire. 4 juin / 84
60 Une pile partagée en Java Le fait que la classe SafeStack est «thread-safe» (ou «synchronized») doit être indiqué dans sa documentation. On oublie trop souvent de préciser si l accès concurrent à un objet est permis ou non. Dans la documentation de Java, c est parfois précisé (voir par exemple StringBuilder versus StringBuffer), parfois non. 4 juin / 84
61 Le mot-clef synchronized Pour alléger l emploi des verrous, Java propose trois idées : tout objet o est aussi un verrou ; une section critique protégée par l objet o s écrit : synchronized ( o) { // SECTION CRITIQUE } si on souhaite que le corps d une méthode constitue une section critique protégée par this, alors il suffit d écrire synchronized dans l en-tête de la méthode. Cela correspond à l hypothétique mot-clef atomic de tout-à-l heure ; mais il faut préciser quel verrou on prend (ici, o). 4 juin / 84
62 Une pile partagée, avec synchronized L objet this joue le rôle de verrou. class SafeStack <X> { private StackCell <X> top ; synchronized void push ( X x) { top = new StackCell <X> (x, top) ; } synchronized X pop () {... } } Ce verrou est pris puis rendu par push, et de même par pop. 4 juin / 84
63 Deux règles simples Le programmeur doit respecter deux règles simples : tout accès à un champ partagé modifiable doit être protégé par un verrou ; les accès à un même champ doivent être protégés par un même verrou. Les champs non modifiables (final) n ont pas besoin d être protégés. Ces règles suffisent à garantir l absence de race condition. 4 juin / 84
64 et invariants Si une structure de données partagée possède un invariant : par exemple, «ceci est un arbre binaire de recherche équilibré», alors : lorsqu on acquiert le verrou, on peut supposer l invariant satisfait ; on peut alors briser (temporairement) l invariant, sans crainte qu un autre thread puisse observer cette violation ; lorsqu on relâche le verrou, on doit démontrer que l invariant est à nouveau satisfait. 4 juin / 84
65 Une grande latitude Le programmeur reste libre de décider (et doit savoir!) : quelles structures de données sont partagées ; quels verrous protègent quelles structures ; quel invariant est (éventuellement) associé à chaque verrou. 4 juin / 84
66 Violations d atomicité Malheureusement, l absence de race ne suffit pas! Ce code obéit à nos règles et ne présente donc aucune race condition : class BuggyCounter { private int count ; synchronized int get () { return count ; } synchronized void set ( int newcnt ) { count = newcnt ; } void increment () { set ( get () + 1) ; } } Est-il correct?... 4 juin / 84
67 Violations d atomicité Ce code ne se comporte pas de façon satisfaisante, parce que la méthode increment n est pas atomique. Entre l instant où on observe la valeur actuelle de count et l instant où on modifie count, d autres threads peuvent agir. L absence de race n est donc pas une condition suffisante pour que le programme soit correct. 4 juin / 84
68 Violations d atomicité Pour corriger ce code, on doit déclarer que increment est synchronized. Cela ne provoquera pas de blocage, car les verrous de Java sont ré-entrants : un même thread peut prendre plusieurs fois un même verrou. 4 juin / 84
69 Interblocage Autre danger : puisque l opération lock est bloquante, il y a risque de blocage éternel («deadlock»). Un thread A pourrait attendre un verrou détenu par un thread B qui ne le libérera jamais, parce qu il attend lui-même un verrou détenu par un thread C qui... Les threads ainsi bloqués forment un cycle : A attend B qui attend C qui qui attend A. Chacun attend un verrou que le suivant possède. Ce danger est bien réel! (Démonstration.) 4 juin / 84
70 Interblocage Pour éviter ce danger, on peut adopter une règle simple : chaque thread doit détenir au plus un verrou à la fois ; ou bien une règle moins restrictive mais plus complexe : pour un ordre partiel fixé sur les verrous, un thread qui acquiert plusieurs verrous doit les acquérir dans l ordre. On voit que l exemple précédent ne respecte aucune de ces règles. 4 juin / 84
71 Interblocage Le danger ne provient pas seulement de l opération lock mais de toutes les opérations bloquantes, dont par exemple join. Une règle prudente est qu il ne faut pas effectuer un appel bloquant lorsque l on a pris un verrou. Plus généralement, une section critique doit être de durée aussi courte que possible. 4 juin / 84
72 Dernier danger : l inefficacité. Questions d efficacité Prendre et relâcher un verrou a un coût en soi («lock overhead»). De plus, deux pièges nous sont tendus : goulots d étranglement séquentiels : de nombreux threads attendent pour prendre à tour de rôle un même verrou ; «huit peintres et un seul pot de peinture» compétition («contention») : plus les threads qui tentent de prendre un même verrou au même moment sont nombreux, plus cette opération est lente. «après vous, cher confrère ; je n en ferai rien» (Démonstrations.) 4 juin / 84
73 Questions d efficacité Il est souvent difficile de comprendre pourquoi un programme concurrent est efficace ou inefficace en pratique. Les comportements sont difficiles à reproduire et influencés par les observations! De plus, les performances peuvent dépendre : de la configuration de la machine (nombre de processeurs, taille et disposition des caches, etc.) ; de sa charge (pour un serveur, nombre de requêtes reçues par seconde, etc.). 4 juin / 84
74 Que retenir? La mémoire partagée pouvait sembler porteuse de promesses. On voit maintenant qu elle n a rien de miraculeux. Pour utiliser de façon cohérente la mémoire partagée, l exclusion est nécessaire, et est obtenue via des mécanismes de synchronisation, dont les verrous sont un exemple. 4 juin / 84
75 Que retenir? Les sont multiples : synchroniser trop peu conduit à des comportements incohérents ; synchroniser trop ou trop grossièrement conduit à une inefficacité, voire à un interblocage. 4 juin / 84
J2SE Threads, 1ère partie Principe Cycle de vie Création Synchronisation
J2SE Threads, 1ère partie Principe Cycle de vie Création Synchronisation Cycle Ingénierie 2e année SIGL Dernière mise à jour : 19/10/2006 Christophe Porteneuve Threads Principes Cycle de vie Création java.lang.thread
Plus en détailCours de Systèmes d Exploitation
Licence d informatique Synchronisation et Communication inter-processus Hafid Bourzoufi Université de Valenciennes - ISTV Introduction Les processus concurrents s exécutant dans le système d exploitation
Plus en détailINTRODUCTION AUX SYSTEMES D EXPLOITATION. TD2 Exclusion mutuelle / Sémaphores
INTRODUCTION AUX SYSTEMES D EXPLOITATION TD2 Exclusion mutuelle / Sémaphores Exclusion mutuelle / Sémaphores - 0.1 - S O M M A I R E 1. GENERALITES SUR LES SEMAPHORES... 1 1.1. PRESENTATION... 1 1.2. UN
Plus en détailProblèmes liés à la concurrence
ENS Cachan Problématique Difficile de gérer la concurrence : Pas toujours facile d avoir des fonctions réentrantes. Risque de race condition : ex : x :=x+1 x :=x+1 On voudrait des blocs d instructions
Plus en détailExclusion Mutuelle. Arnaud Labourel Courriel : arnaud.labourel@lif.univ-mrs.fr. Université de Provence. 9 février 2011
Arnaud Labourel Courriel : arnaud.labourel@lif.univ-mrs.fr Université de Provence 9 février 2011 Arnaud Labourel (Université de Provence) Exclusion Mutuelle 9 février 2011 1 / 53 Contexte Epistémologique
Plus en détailThreads. Threads. USTL http://www.lifl.fr/ routier 1
Threads USTL http://www.lifl.fr/ routier 1 Rappels - Définitions un Process est un programme qui tourne et dispose de ses propres ressources mémoire. OS multi-tâche plusieurs process en concurrence un
Plus en détailIntroduction à la programmation concurrente
Introduction à la programmation concurrente Moniteurs Yann Thoma Reconfigurable and Embedded Digital Systems Institute Haute Ecole d Ingénierie et de Gestion du Canton de Vaud This work is licensed under
Plus en détailLOG4430 : Architecture et conception avancée
LOG4430 : Architecture et conception avancée Abdou Maiga Patrons pour la conception d applications distribuées Département de génie informatique et de génie logiciel École Polytechnique de Montréal Guéhéneuc,
Plus en détail4. Outils pour la synchronisation F. Boyer, Laboratoire Lig Fabienne.Boyer@imag.fr
4. Outils pour la synchronisation F. Boyer, Laboratoire Lig Fabienne.Boyer@imag.fr Le problème Insuffisance des solutions de base (verrous) Les solutions de plus haut niveau Les Sémaphores Les Moniteurs
Plus en détailProgrammation d Applications Concurrentes et Distribuées (INF431)
Programmation d Applications Concurrentes et Distribuées (INF431) Julien Cervelle Albert Cohen Eric Goubault Francesco Zappa Nardelli François Pottier Samuel Mimram Benjamin Werner 1er janvier 2015 2 Table
Plus en détailBases de données et sites WEB Licence d informatique LI345
Bases de données et sites WEB Licence d informatique LI345 Anne Doucet Anne.Doucet@lip6.fr http://www-bd.lip6.fr/ens/li345-2013/index.php/lescours 1 Contenu Transactions en pratique Modèle relationnel-objet
Plus en détailCours 1 : La compilation
/38 Interprétation des programmes Cours 1 : La compilation Yann Régis-Gianas yrg@pps.univ-paris-diderot.fr PPS - Université Denis Diderot Paris 7 2/38 Qu est-ce que la compilation? Vous avez tous déjà
Plus en détailUn ordonnanceur stupide
Un ordonnanceur simple Université Paris Sud L objet des exercices qui suivent est de créer un ordonanceur implantant l algorithme du tourniquet ( round-robin scheduler ). La technique utilisée pour élire
Plus en détailCours de Base de Données Cours n.12
Cours de Base de Données Cours n.12 Gestion des transactions : contrôle de concurrence Elisabetta De Maria - http://www.i3s.unice.fr/ edemaria/ UFR Sciences et Laboratoire I3S, CNRS 2013-2014 Université
Plus en détailLes processus légers : threads. Système L3, 2014-2015 1/31
Les processus légers : threads Système L3, 2014-2015 1/31 Les threads Les threads sont des processus légers exécutés à l intérieur d un processus L exécution des threads est concurrente Il existe toujours
Plus en détailLicence Bio Informatique Année 2004-2005. Premiers pas. Exercice 1 Hello World parce qu il faut bien commencer par quelque chose...
Université Paris 7 Programmation Objet Licence Bio Informatique Année 2004-2005 TD n 1 - Correction Premiers pas Exercice 1 Hello World parce qu il faut bien commencer par quelque chose... 1. Enregistrez
Plus en détailExercices INF5171 : série #3 (Automne 2012)
Exercices INF5171 : série #3 (Automne 2012) 1. Un moniteur pour gérer des ressources Le moniteur MPD 1 présente une première version d'un moniteur, exprimé en pseudo-mpd, pour gérer des ressources le nombre
Plus en détailGestion des transactions et accès concurrents dans les bases de données relationnelles
Gestion des transactions et accès concurrents dans les bases de données relationnelles Bernard ESPINASSE Professeur à Aix-Marseille Université (AMU) Ecole Polytechnique Universitaire de Marseille Fev.
Plus en détailCours 1 : Qu est-ce que la programmation?
1/65 Introduction à la programmation Cours 1 : Qu est-ce que la programmation? Yann Régis-Gianas yrg@pps.univ-paris-diderot.fr Université Paris Diderot Paris 7 2/65 1. Sortez un appareil qui peut se rendre
Plus en détailIntroduction : les processus. Introduction : les threads. Plan
IN328 Programmation distribuée avec Java et J2EE 2 - Threads en Java Introduction : les processus Un processus est un ensemble d instructions à exécuter, un espace mémoire réservé et éventuellement d autres
Plus en détailExceptions. 1 Entrées/sorties. Objectif. Manipuler les exceptions ;
CNAM NFP121 TP 10 19/11/2013 (Séance 5) Objectif Manipuler les exceptions ; 1 Entrées/sorties Exercice 1 : Lire un entier à partir du clavier Ajouter une méthode readint(string message) dans la classe
Plus en détailCours Bases de données 2ème année IUT
Cours Bases de données 2ème année IUT Cours 12 : Concurrence d accès Anne Vilnat http://www.limsi.fr/individu/anne/cours Plan 1 Accès concurrents Définitions Verrous Collisions Niveaux de cohérence Blocage
Plus en détailÉcole Polytechnique de Montréal. Département de Génie Informatique et Génie Logiciel. Cours INF2610. Contrôle périodique.
École Polytechnique de Montréal Département de Génie Informatique et Génie Logiciel Cours INF2610 Contrôle périodique Automne 2013 Date : 11 octobre 2013 de 18h à 20h Professeur : Boucheneb Hanifa Documentation
Plus en détailLes transactions 1/46. I même en cas de panne logicielle ou matérielle. I Concept de transaction. I Gestion de la concurrence : les solutions
1/46 2/46 Pourquoi? Anne-Cécile Caron Master MAGE - SGBD 1er trimestre 2014-2015 Le concept de transaction va permettre de définir des processus garantissant que l état de la base est toujours cohérent
Plus en détailProgrammer en JAVA. par Tama (tama@via.ecp.fr( tama@via.ecp.fr)
Programmer en JAVA par Tama (tama@via.ecp.fr( tama@via.ecp.fr) Plan 1. Présentation de Java 2. Les bases du langage 3. Concepts avancés 4. Documentation 5. Index des mots-clés 6. Les erreurs fréquentes
Plus en détailProjet gestion d'objets dupliqués
Projet gestion d'objets dupliqués Daniel Hagimont Daniel.Hagimont@enseeiht.fr 1 Projet Service de gestion d'objets dupliqués Mise en cohérence lors de la prise d'un verrou sur un objet Pas de verrous imbriqués
Plus en détailTests de performance du matériel
3 Tests de performance du matériel Après toute la théorie du dernier chapitre, vous vous demandez certainement quelles sont les performances réelles de votre propre système. En fait, il y a plusieurs raisons
Plus en détailConventions d écriture et outils de mise au point
Logiciel de base Première année par alternance Responsable : Christophe Rippert Christophe.Rippert@Grenoble-INP.fr Introduction Conventions d écriture et outils de mise au point On va utiliser dans cette
Plus en détail4. Outils pour la synchronisation F. Boyer, Laboratoire Sardes Fabienne.Boyer@imag.fr
4. Outils pour la synchronisation F. Boyer, Laboratoire Sardes Fabienne.Boyer@imag.fr Le problème Insuffisance des solutions de base (verrous) Les solutions de plus haut niveau Les Sémaphores Les Moniteurs
Plus en détailINTRODUCTION À LA PROGRAMMATION CONCURRENTE
INTRODUCTION À LA PROGRAMMATION CONCURRENTE POLYCOPIÉ DU COURS PCO1 Prof. Claude Evéquoz Prof. Yann Thoma HEIG-VD 2009 Table des matières Table des matières 2 1 Introduction à la programmation concurrente
Plus en détailJulien MATHEVET Alexandre BOISSY GSID 4. Rapport RE09. Load Balancing et migration
Julien MATHEVET Alexandre BOISSY GSID 4 Rapport Load Balancing et migration Printemps 2001 SOMMAIRE INTRODUCTION... 3 SYNTHESE CONCERNANT LE LOAD BALANCING ET LA MIGRATION... 4 POURQUOI FAIRE DU LOAD BALANCING?...
Plus en détailUtilisation d objets : String et ArrayList
Chapitre 6 Utilisation d objets : String et ArrayList Dans ce chapitre, nous allons aborder l utilisation d objets de deux classes prédéfinies de Java d usage très courant. La première, nous l utilisons
Plus en détailTP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile
TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile Dans ce TP, vous apprendrez à définir le type abstrait Pile, à le programmer en Java à l aide d une interface
Plus en détailCours 2: Exclusion Mutuelle entre processus (lourds, ou légers -- threads)
Cours 2: Exclusion Mutuelle entre processus (lourds, ou légers -- threads) Concurrence entre processus & Problème d Exclusion Mutuelle 1. Introduction 2. Solutions avec attente active, dites Sans Arbitrage
Plus en détailMétriques de performance pour les algorithmes et programmes parallèles
Métriques de performance pour les algorithmes et programmes parallèles 11 18 nov. 2002 Cette section est basée tout d abord sur la référence suivante (manuel suggéré mais non obligatoire) : R. Miller and
Plus en détailLes arbres binaires de recherche
Institut Galilée Année 2010-2011 Algorithmique et arbres L2 TD 6 Les arbres binaires de recherche Type en C des arbres binaires (également utilisé pour les ABR) : typedef struct noeud_s { struct noeud_s
Plus en détailNFP 121. Java et les Threads. Présentation : Thierry Escalarasse Mai 2007
NFP 121 Java et les Threads Présentation : Thierry Escalarasse Mai 2007 Plan du cour Présentation de la notion de Threads La classe Thread L interface Runnable Les états d un thread La Synchronisation
Plus en détail03/04/2007. Tâche 1 Tâche 2 Tâche 3. Système Unix. Time sharing
3/4/27 Programmation Avancée Multimédia Multithreading Benoît Piranda Équipe SISAR Université de Marne La Vallée Besoin Programmes à traitements simultanés Réseau Réseau Afficher une animation en temps
Plus en détailTp 1 correction. Structures de données (IF2)
Tp 1 correction Structures de données (IF2) Remarque générale : compilez et exécutez le code au-fur-et-à mesure de son écriture. Il est plus facile de corriger une petite portion de code délimitée que
Plus en détailArgument-fetching dataflow machine de G.R. Gao et J.B. Dennis (McGill, 1988) = machine dataflow sans flux de données
EARTH et Threaded-C: Éléments clés du manuel de références de Threaded-C Bref historique de EARTH et Threaded-C Ancêtres de l architecture EARTH: Slide 1 Machine à flux de données statique de J.B. Dennis
Plus en détailVIII- Circuits séquentiels. Mémoires
1 VIII- Circuits séquentiels. Mémoires Maintenant le temps va intervenir. Nous avions déjà indiqué que la traversée d une porte ne se faisait pas instantanément et qu il fallait en tenir compte, notamment
Plus en détailIntroduction à MATLAB R
Introduction à MATLAB R Romain Tavenard 10 septembre 2009 MATLAB R est un environnement de calcul numérique propriétaire orienté vers le calcul matriciel. Il se compose d un langage de programmation, d
Plus en détailChapitre 4 : Exclusion mutuelle
Chapitre 4 : Exclusion mutuelle Pierre Gançarski Juillet 2004 Ce support de cours comporte un certain nombre d erreurs : je décline toute responsabilité quant à leurs conséquences sur le déroulement des
Plus en détailPremiers Pas en Programmation Objet : les Classes et les Objets
Chapitre 2 Premiers Pas en Programmation Objet : les Classes et les Objets Dans la première partie de ce cours, nous avons appris à manipuler des objets de type simple : entiers, doubles, caractères, booléens.
Plus en détailNotion de thread (1/2)
Notion de thread (1/2) La machine virtuelle java (JVM) permet d'exécuter plusieurs traitements en parallèle (en pratique, ils s'exécutent par tranche et en alternance sur le processeur). Ces traitements
Plus en détailManuel d utilisation 26 juin 2011. 1 Tâche à effectuer : écrire un algorithme 2
éducalgo Manuel d utilisation 26 juin 2011 Table des matières 1 Tâche à effectuer : écrire un algorithme 2 2 Comment écrire un algorithme? 3 2.1 Avec quoi écrit-on? Avec les boutons d écriture........
Plus en détailTraduction des Langages : Le Compilateur Micro Java
BARABZAN Jean-René OUAHAB Karim TUCITO David 2A IMA Traduction des Langages : Le Compilateur Micro Java µ Page 1 Introduction Le but de ce projet est d écrire en JAVA un compilateur Micro-Java générant
Plus en détailIV- Comment fonctionne un ordinateur?
1 IV- Comment fonctionne un ordinateur? L ordinateur est une alliance du hardware (le matériel) et du software (les logiciels). Jusqu à présent, nous avons surtout vu l aspect «matériel», avec les interactions
Plus en détailET 24 : Modèle de comportement d un système Boucles de programmation avec Labview.
ET 24 : Modèle de comportement d un système Boucles de programmation avec Labview. Sciences et Technologies de l Industrie et du Développement Durable Formation des enseignants parcours : ET24 Modèle de
Plus en détailGrandes lignes ASTRÉE. Logiciels critiques. Outils de certification classiques. Inspection manuelle. Definition. Test
Grandes lignes Analyseur Statique de logiciels Temps RÉel Embarqués École Polytechnique École Normale Supérieure Mercredi 18 juillet 2005 1 Présentation d 2 Cadre théorique de l interprétation abstraite
Plus en détailLa JVM. La machine virtuelle Java. La JVM. La JVM
La machine virtuelle Java Historique et rappels Organisation mémoire de la JVM Le garbage collector Le bytecode, la machine à pile. Les threads Suivi, tracé, optimisation d un programme Java JVM embarquées
Plus en détailCorrigés des premiers exercices sur les classes
Corrigés des premiers exercices sur les classes Exercice 2.1.1 utilisation d une classe Voici le texte d une classe représentant de façon sommaire un compte bancaire et les opérations bancaires courantes.
Plus en détailCours 1: Java et les objets
Ressources Les interface homme-machine et le langage Java DUT première année Henri Garreta, Faculté des Sciences (Luminy) Cyril Pain-Barre & Sébastien Nedjar, IUT d Aix-Marseille (Aix) Cours 1: infodoc.iut.univ-aix.fr/~ihm/
Plus en détailArchitecture des ordinateurs TD1 - Portes logiques et premiers circuits
Architecture des ordinateurs TD1 - Portes logiques et premiers circuits 1 Rappel : un peu de logique Exercice 1.1 Remplir la table de vérité suivante : a b a + b ab a + b ab a b 0 0 0 1 1 0 1 1 Exercice
Plus en détailIntroduction à Java. Matthieu Herrb CNRS-LAAS. Mars 2014. http://homepages.laas.fr/matthieu/cours/java/java.pdf
Introduction à Java Matthieu Herrb CNRS-LAAS http://homepages.laas.fr/matthieu/cours/java/java.pdf Mars 2014 Plan 1 Concepts 2 Éléments du langage 3 Classes et objets 4 Packages 2/28 Histoire et motivations
Plus en détailInfo0604 Programmation multi-threadée. Cours 5. Programmation multi-threadée en Java
Info0604 Programmation multi-threadée Cours 5 Programmation multi-threadée en Java Pierre Delisle Université de Reims Champagne-Ardenne Département de Mathématiques et Informatique 18 février 2015 Plan
Plus en détailIntroduction à la Programmation Parallèle: MPI
Introduction à la Programmation Parallèle: MPI Frédéric Gava et Gaétan Hains L.A.C.L Laboratoire d Algorithmique, Complexité et Logique Cours du M2 SSI option PSSR Plan 1 Modèle de programmation 2 3 4
Plus en détailOrdonnancement temps réel
Ordonnancement temps réel Laurent.Pautet@enst.fr Version 1.5 Problématique de l ordonnancement temps réel En fonctionnement normal, respecter les contraintes temporelles spécifiées par toutes les tâches
Plus en détailRéplication des données
Réplication des données Christelle Pierkot FMIN 306 : Gestion de données distribuées Année 2009-2010 Echange d information distribuée Grâce à un serveur central Une seule copie cohérente Accès à distance
Plus en détailInitiation. àl algorithmique et à la programmation. en C
Initiation àl algorithmique et à la programmation en C Initiation àl algorithmique et à la programmation en C Cours avec 129 exercices corrigés Illustration de couverture : alwyncooper - istock.com Dunod,
Plus en détailArchitecture des ordinateurs
Architecture des ordinateurs Cours 4 5 novembre 2012 Archi 1/22 Micro-architecture Archi 2/22 Intro Comment assembler les différents circuits vus dans les cours précédents pour fabriquer un processeur?
Plus en détailAuto-évaluation Programmation en Java
Auto-évaluation Programmation en Java Document: f0883test.fm 22/01/2013 ABIS Training & Consulting P.O. Box 220 B-3000 Leuven Belgium TRAINING & CONSULTING INTRODUCTION AUTO-ÉVALUATION PROGRAMMATION EN
Plus en détailGPA770 Microélectronique appliquée Exercices série A
GPA770 Microélectronique appliquée Exercices série A 1. Effectuez les calculs suivants sur des nombres binaires en complément à avec une représentation de 8 bits. Est-ce qu il y a débordement en complément
Plus en détailContrôle de versions et travail collaboratif. Organisation du travail collaboratif. Organisation du travail collaboratif
Contrôle de versions et travail Problématique Benoit Darties ESIREM ITR4 benoit.darties@u-bourgogne.fr Problème de la gestion de versions Problème de l'accès concurrent à un fichier Exemple : Création
Plus en détailCorrigé des exercices sur les références
Corrigé des exercices sur les références Exercice 3.1.1 dessin Pour cet exercice, vous allez dessiner des structures de données au moyen de petits schémas analogues à ceux du cours, comportant la pile
Plus en détailTemps Réel. Jérôme Pouiller <j.pouiller@sysmic.org> Septembre 2011
Temps Réel Jérôme Pouiller Septembre 2011 Sommaire Problèmatique Le monotâche Le multitâches L ordonnanement Le partage de ressources Problèmatiques des OS temps réels J. Pouiller
Plus en détailGénie Logiciel avec Ada. 4 février 2013
Génie Logiciel 4 février 2013 Plan I. Généralités II. Structures linéaires III. Exceptions IV. Structures arborescentes V. Dictionnaires I. Principes II. Notions propres à la POO I. Principes Chapitre
Plus en détailSynchro et Threads Java TM
Synchro et Threads Java TM NICOD JEAN-MARC Master 2 Informatique Université de Franche-Comté UFR des Sciences et Techniques septembre 2008 NICOD JEAN-MARC Synchro et Threads avec Java TM 1 / 32 Sommaire
Plus en détailCours de Programmation Impérative: Zones de mémoires et pointeurs
Cours de Programmation Impérative: Zones de mémoires et pointeurs Julien David A101 - david@lipn.univ-paris13.fr Julien David (A101 - david@lipn.univ-paris13.fr) 1 / 1 Z`o n`e s `d`e m`é m`o i r`e Julien
Plus en détailImplémentation des SGBD
Implémentation des SGBD Structure générale des applications Application utilisateur accédant à des données d'une base Les programmes sous-jacents contiennent du code SQL Exécution : pendant l'exécution
Plus en détail2. Comprendre les définitions de classes
Conception objet en Java avec BlueJ une approche interactive 2. Comprendre les définitions de classes Analyser le contenu des classes David J. Barnes, Michael Kölling version française: Patrice Moreaux
Plus en détailUne introduction à la technologie EJB (2/3)
Une introduction à la technologie EJB (2/3) 1 Les singletons des EJB 3.1 1.1 Synchronisation gérée manuellement Depuis la version 3.1, des EJB Statless à instance unique sont maintenant disponibles : ce
Plus en détailCEG4566/CSI4541 Conception de systèmes temps réel
CEG4566/CSI4541 Conception de systèmes temps réel Chapitre 6 Vivacité, sécurité (Safety), fiabilité et tolérance aux fautes dans les systèmes en temps réel 6.1 Introduction générale aux notions de sécurité
Plus en détailTD2 Programmation concurrentielle
TD2 Programmation concurrentielle Développement Logiciel (L2-S4) Lundi 10 février 2014 Exercice 1 (Au bar...) Trois clients se trouvent au bar. Il est tard, ils sont fatigués, et ils s endorment sur le
Plus en détailINITIATION AU LANGAGE JAVA
INITIATION AU LANGAGE JAVA I. Présentation 1.1 Historique : Au début des années 90, Sun travaillait sur un projet visant à concevoir des logiciels simples et performants exécutés dans des PDA (Personnal
Plus en détailJava Licence Professionnelle CISII, 2009-10
Java Licence Professionnelle CISII, 2009-10 Cours 4 : Programmation structurée (c) http://www.loria.fr/~tabbone/cours.html 1 Principe - Les méthodes sont structurées en blocs par les structures de la programmation
Plus en détailTable des matières PRESENTATION DU LANGAGE DS2 ET DE SES APPLICATIONS. Introduction
PRESENTATION DU LANGAGE DS2 ET DE SES APPLICATIONS Depuis SAS 9.2 TS2M3, SAS propose un nouveau langage de programmation permettant de créer et gérer des tables SAS : le DS2 («Data Step 2»). Ces nouveautés
Plus en détailCette application développée en C# va récupérer un certain nombre d informations en ligne fournies par la ville de Paris :
Développement d un client REST, l application Vélib 1. Présentation L application présentée permet de visualiser les disponibilités des vélos et des emplacements de parking à la disposition des parisiens
Plus en détailCours d initiation à la programmation en C++ Johann Cuenin
Cours d initiation à la programmation en C++ Johann Cuenin 11 octobre 2014 2 Table des matières 1 Introduction 5 2 Bases de la programmation en C++ 7 3 Les types composés 9 3.1 Les tableaux.............................
Plus en détailRecherche dans un tableau
Chapitre 3 Recherche dans un tableau 3.1 Introduction 3.1.1 Tranche On appelle tranche de tableau, la donnée d'un tableau t et de deux indices a et b. On note cette tranche t.(a..b). Exemple 3.1 : 3 6
Plus en détailCours Programmation Système
Cours Programmation Système Filière SMI Semestre S6 El Mostafa DAOUDI Département de Mathématiques et d Informatique, Faculté des Sciences Université Mohammed Premier Oujda m.daoudi@fso.ump.ma Février
Plus en détailIN 102 - Cours 1. 1 Informatique, calculateurs. 2 Un premier programme en C
IN 102 - Cours 1 Qu on le veuille ou non, les systèmes informatisés sont désormais omniprésents. Même si ne vous destinez pas à l informatique, vous avez de très grandes chances d y être confrontés en
Plus en détailConception des systèmes répartis
Conception des systèmes répartis Principes et concepts Gérard Padiou Département Informatique et Mathématiques appliquées ENSEEIHT Octobre 2012 Gérard Padiou Conception des systèmes répartis 1 / 37 plan
Plus en détailSolutions du chapitre 4
Solutions du chapitre 4 Structures de contrôle: première partie 4.9 Identifiez et corrigez les erreurs (il peut y en avoir plus d une par segment de code) de chacune des proposition suivantes: a) if (
Plus en détailSGBDR. Systèmes de Gestion de Bases de Données (Relationnelles)
SGBDR Systèmes de Gestion de Bases de Données (Relationnelles) Plan Approches Les tâches du SGBD Les transactions Approche 1 Systèmes traditionnels basés sur des fichiers Application 1 Gestion clients
Plus en détailCompilation (INF 564)
Présentation du cours Le processeur MIPS Programmation du MIPS 1 Compilation (INF 564) Introduction & architecture MIPS François Pottier 10 décembre 2014 Présentation du cours Le processeur MIPS Programmation
Plus en détailProjet d informatique M1BI : Compression et décompression de texte. 1 Généralités sur la compression/décompression de texte
Projet d informatique M1BI : Compression et décompression de texte Le but de ce projet est de coder un programme réalisant de la compression et décompression de texte. On se proposera de coder deux algorithmes
Plus en détailBases de programmation. Cours 5. Structurer les données
Bases de programmation. Cours 5. Structurer les données Pierre Boudes 1 er décembre 2014 This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License. Types char et
Plus en détailCours intensif Java. 1er cours: de C à Java. Enrica DUCHI LIAFA, Paris 7. Septembre 2009. Enrica.Duchi@liafa.jussieu.fr
. Cours intensif Java 1er cours: de C à Java Septembre 2009 Enrica DUCHI LIAFA, Paris 7 Enrica.Duchi@liafa.jussieu.fr LANGAGES DE PROGRAMMATION Pour exécuter un algorithme sur un ordinateur il faut le
Plus en détailTP : Gestion d une image au format PGM
TP : Gestion d une image au format PGM Objectif : L objectif du sujet est de créer une classe de manipulation d images au format PGM (Portable GreyMap), et de programmer des opérations relativement simples
Plus en détailÉléments d informatique Cours 3 La programmation structurée en langage C L instruction de contrôle if
Éléments d informatique Cours 3 La programmation structurée en langage C L instruction de contrôle if Pierre Boudes 28 septembre 2011 This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike
Plus en détailTD n o 8 - Domain Name System (DNS)
IUT Montpellier - Architecture (DU) V. Poupet TD n o 8 - Domain Name System (DNS) Dans ce TD nous allons nous intéresser au fonctionnement du Domain Name System (DNS), puis pour illustrer son fonctionnement,
Plus en détailLes structures de données. Rajae El Ouazzani
Les structures de données Rajae El Ouazzani Les arbres 2 1- Définition de l arborescence Une arborescence est une collection de nœuds reliés entre eux par des arcs. La collection peut être vide, cad l
Plus en détail1 de 46. Algorithmique. Trouver et Trier. Florent Hivert. Mél : Florent.Hivert@lri.fr Page personnelle : http://www.lri.fr/ hivert
1 de 46 Algorithmique Trouver et Trier Florent Hivert Mél : Florent.Hivert@lri.fr Page personnelle : http://www.lri.fr/ hivert 2 de 46 Algorithmes et structures de données La plupart des bons algorithmes
Plus en détailAlgorithmique et Programmation, IMA
Algorithmique et Programmation, IMA Cours 2 : C Premier Niveau / Algorithmique Université Lille 1 - Polytech Lille Notations, identificateurs Variables et Types de base Expressions Constantes Instructions
Plus en détail1 Architecture du cœur ARM Cortex M3. Le cœur ARM Cortex M3 sera présenté en classe à partir des éléments suivants :
GIF-3002 SMI et Architecture du microprocesseur Ce cours discute de l impact du design du microprocesseur sur le système entier. Il présente d abord l architecture du cœur ARM Cortex M3. Ensuite, le cours
Plus en détailModule BDR Master d Informatique (SAR)
Module BDR Master d Informatique (SAR) Cours 9- Transactions réparties Anne Doucet Anne.Doucet@lip6.fr Transactions réparties Gestion de transactions Transactions dans un système réparti Protocoles de
Plus en détailStructure fonctionnelle d un SGBD
Fichiers et Disques Structure fonctionnelle d un SGBD Requetes Optimiseur de requetes Operateurs relationnels Methodes d acces Gestion de tampon Gestion de disque BD 1 Fichiers et Disques Lecture : Transfert
Plus en détailAnnée Universitaire 2009/2010 Session 2 de Printemps
Année Universitaire 2009/2010 Session 2 de Printemps DISVE Licence PARCOURS : CSB4 & CSB6 UE : INF 159, Bases de données Épreuve : INF 159 EX Date : Mardi 22 juin 2010 Heure : 8 heures 30 Durée : 1 heure
Plus en détailUne introduction à Java
Une introduction à Java IFT 287 (Semaine 1) UNIVERSITÉ DE SHERBROOKE 1 Java - Historique Développé par Sun Microsystems en 1994 Inventeur James Gosling (canadien!) Objectif langage sûr (fortement typé)
Plus en détail