systèmes embarqués temps réel - université de nantes · 2020. 2. 3. · • l’apple a6 est un...
TRANSCRIPT
Systèmes Embarqués Temps Réel
David Delfieu
August 24, 2018
2
Contents
1 Définitions générales 51.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.1 Les aspects matériels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.1.2 Les différents choix de puces dans l’embarqué . . . . . . . . . . . . . . . . . . . 8
1.2 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.2.1 Architecture Materielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.2.2 Architecture Logicielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3 Programmation Synchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111.3.1 Code C, programmation Synchrone sur un micro-contrôleur . . . . . . . . . . . . 141.3.2 Aspect recherche et developpement autour du “synchrone” . . . . . . . . . . . . 15
1.4 Programmation Asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.4.1 Ordonnancement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161.4.2 Les différent états d’une tâche . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.5 LINUX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171.5.1 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2 Programmation multi-tâche 192.1 Les Processus Unix System V . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.1.1 Création d’un processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.1.2 Création de plusieurs processus . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.1.3 Boucle de création de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2 La communication entre processus Unix . . . . . . . . . . . . . . . . . . . . . . . . . . 242.2.1 Les pipes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242.2.2 Les pipes “non nommés” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252.2.3 Les sémaphores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.3 Les Threads Posix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282.3.1 Création de thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292.3.2 Protéger une variable globale accédèe par plusieurs thread, à l’aide d’un sémaphore 312.3.3 Tableau de threads et passage de paramètre . . . . . . . . . . . . . . . . . . . . 33
3 Système embarqué temps réel 353.1 La cible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.1.1 Boot de la cible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3
3.1.2 Configurer le boot : U-Boot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.2 La carte d’entrée-sortie : VMOD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.2.1 VMOD_IO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373.2.2 Les ports d’Entrées-sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3 Drivers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393.3.1 Driver caractère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393.3.2 Installation de Drivers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393.3.3 Drivers de nos cartes d’ES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403.3.4 Installation du driver de la MTTL . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4 ANNEXES 434.1 Connectivité IP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.1.1 Le protocole IP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.1.2 Les 7 couches du modèle OSI . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.1.3 Le réseau Internet : 4 couches . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444.1.4 Applications NFS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464.1.5 Applications ftp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474.1.6 Applications http . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4
Chapter 1
Définitions générales
1.1 Introduction
Les Systèmes Temps Réel (STR) on été introduits avec le système de guidage de l’alunisseur desmissions Apollo. Aujourd’hui on trouve ces systèmes dans les objets les plus courant : régulateurde vitesse, voitures autonômes smartphones, consoles de jeux, électroménager, GPS. Mais ces sys-tèmes sont évidement présent dans l’avionique avec les systèmes de contrôle de vol et de guidage oudans le médical et surtout dans l’automobile dans lesquelles on peut trouver plusieurs centaines demicrocontrôleur ! Dans ces derniers domaines, la sureté de fonctionnement, la robustesse et la qualitédes informations produites sont des critères déterminants de conception qui priment par rapport à laperformance pure.
D’un point de vue matériel un STR est composé de micro1 de mémoires de périphériques de sapropre alimentation.
Definition 1.1.1 Les caractéristiques d’un Système Embarqué Temps réel sont en priorité la suretéde fonctionnement (CEM, robustesse, redondance), des temps d’exécution de tâche qui doivent êtresdéterministes (où au pire, bornés), une consommation énergétique qui doit être est la plus faible possiblepar rapport au service rendu et un encombrement du programme limité.
1.1.1 Les aspects matériels
Il y a deux grandes catégories matérielles de STR : les cartes électroniques et les racks. Les cartesélectroniques sont généralement des petits systèmes qui embarquent des microcontroleurs voir desmicroprocesseurs. Les racks portent eux, des cartes à microprocesseurs ou des System-on-Chip (SoC).
Les Principaux microprocesseurs de l’embarqué
Smartphones
1On désigne par micro, tout composant comportant une unité de calcul : Microprocesseur, Microcontrôleur, DSP,FPGA, SoC
5
• L’Apple A6 est un système mono-coeur conçu conjointement par P.A. Semi et Intrinsity etfabriqué par Samsung. L’entreprise affirme qu’il est jusqu’à deux fois plus rapide et jusqu’à deuxfois plus performant au niveau graphique que l’Apple A5. Il est intégré pour la première foisdans l’iPhone 5, dévoilé le 12 septembre 2012.
• La puce A7 utilise l’architecture 64 bits ARMv8 basée sur un processeur bi-cœur et une unitégraphique intégrée (GPU). La micro-architecture ARMv8 double le nombre de registres du A7comparé au A6. Le SoC A7 inclut plus de 1 milliard de transistors sur une puce de 102 mm2.
• Galaxy S6. Il dispose d’un processeur Exynos 7420. Samsung conçoit et fabrique ce circuitintégré. Cette puce est gravée en 14 nm2 et gère les instructions 64 bits6. La puce contient 8cœurs : elle est constituée d’une partie comprenant 4 cœurs ARM à 2,1 GHz et 4 cœurs ARM à1,5 GHz2.
• Galaxy S7 : Pour les États-Unis, Le S7 et S7 Edge se doteront du Snapdragon 820 de Qualcomm.Pour l’Asie de l’Ouest, ce sera le Exynos G930FD et dans le reste du monde, le Exynos 8890(tous deux produits par Samsung).
Autres Systèmes Embarqués GPS, radars mobiles, robots, ... Autant de STR sont des systèmesembarqués qui contiennent soit des microprocesseurs spécifiques, soit des “System on Chip”.
Microprocesseurs :
• Intel Medfield, intel ATOM, intel Core2Duo, Intel i3, i5, i7.
• PowerPC (anciennement Apple, IBM, Freescale).
• AMD Geode, AMD Fusion G-series.
System on Chip (SoC) : Les SoC sont des composants dont le design de base est souventachété (cas des coeurs ARM) puis personalisés. C’est le cas d’Apple et Samsung qui achètent descoeurs à ARM puis les particularisent. Pour apple, c’est ensuite Samsung qui les réalise !! Pour lesSoc plus petits : FPGA et CPLD, il existe des logiciels qui permettent d’implanter ou de définir desarchitectures processeurs.
Les Principaux microcontrôleurs de l’embarqué
Microcontroleurs La dernière catégorie à puce relève des systèmes basés à partir de micro-contrôleurs: Les automobiles embarquent aujourd’hui entre 30 (entrée de gamme) et 250 micro-contrôleur(modèlesde luxe) : une par fonction, comme le lève-vitre ou l’essuie-glace mais aussi pour les fonctions de sécu-rité comme l’ABS ou l’airbag.
• ATmega*** (ATMEL),
• PIC (Microchip),
6
• M68HC*** (Motorola),
• ST10F*** (ST-Microelectronics)
Microcontroleurs dédiés au Traitement du signal
• Texas Instrument : C5000,C6000
• freescale ;
• Microchip : dsPIC30F et dsPIC33F
• Qualcomm
Figure 1.1: carte micro : microP, microC, DSP, FPGA
Les systèmes sur étagères : "Rack"
Quand il n’y a pas de problème de consommation et ni d’espace que l’on exige une grande puissance decalcul ainsi qu’une très grande tolérance aux pannes, une forte sureté de fonctionnement et que de plus,ni le poids ni les dimensions on peut trouver des systèmes sur étagère. On trouves ces équipementsdans le transport : les avions, trains, bateaux, centreaux de communication.
Figure 1.2: système de Rack
Les systèmes "rackables" diffèrent par leur format :
• Carte PC/104, taille standard : 90,17 x 95,89 mm ;
• Carte compact PCI ;
7
Figure 1.3: Un rack 5U
Figure 1.4: Un Rack 3U
• Carte Europe ;
• Carte bus VME.
Les caractéristiques du système vu en TP sont :
• Rack 3U et 5U ;
• Alimentation propre ;
• Carte bab740 : Microprocesseur de type PPC ;
• 1 carte d’E/S ;
• format VME ;
1.1.2 Les différents choix de puces dans l’embarquéLe marché des semi-conducteurs pesait 341 milliards en 2015 dont 90 milliards pour les micro. Etl’electonique représente 25 % du cout d’une automobile ! 10% d’un avion. Dans ce marché, les “PC”représente à peine 3,5 milliards de dollars (80% intel, 10% AMD, 10 % autres), tandis que les cartesvidéos, consoles, téléphones représente environ 4 milliards de micro : ARM = 80%: (Apple et Samsung)90 % des micro pour l’embarqué utilisent autre chose que Windows.
1.2 Architecture
1.2.1 Architecture Materielle
1.2.2 Architecture LogicielleUn SETR est un système bouclé multi-tâches dont le temps de réponse est adéquat avec la dynamiquede son environnement. Un exécutif temps réel est un système d’exploitation minimal ajusté au hard-ware auquel il est destiné. Seuls les drivers justes nécessaires sont inclus dans l’exécutif. De même,
8
Entités Caractéristiques AvantagesPORT d’E/S Configuration d’E/S Accés direct
aux actionneurset aux switch
CAN Conversion AN signaux numériquesCommunications Port SPI, UART pas de périphériques externes
I2C, bus CANTimers et PWM Tempo signaux périodiques mise en oeuvre facile
Codage boucle, tableaux, EfficaceInterruptions
Table 1.1: Les micro-contrôleurs
Table 1.2: Data Signal Processor
Entités Caractéristiques AvantagesFiltres logiciels MAC gain Hard
Interfaces Codecs Ports Séries rapides gain HardGros débits DMA Moins d’attente
Accés données programme Architecture Harvard Exécution rapide
Table 1.3: Les micro-contrôleurs de traitement du signal
Table 1.4: Microprocesseur
Besoin micro et petit Moyen/Gros Embarqué critiqueRAM 100ko < x < 4Mo 4Mo < x < 64mo Go - To
FLASH 100ko < x < 4Mo 8Mo < 16Mo Go - ToProc. Dragon Ball : 68K MIPS Pentium
Mcore Hitashi SH PowerPCColdfire X86 CrusoeARM
Carac. MMU optionnelle Carte mère PCI,VME, ...Appli. PDA, Portable Routeur Commutateur tél.
Caméra numérique Stockage réseaux Serveur centralImprimante réseaux Gros routeur
Table 1.5: Les microprocesseurs
9
CPUCAN CNA
FPGAMémoire
Capteurs Actionneurs
Environnement Exterieur
Timer
PWM
UART
In
Interface utilisateurPC Hôte
seuls les services systèmes nécessaires sont dans l’exécutif. Ce système multi-tâches est ordonnancépar un exécutif temps réel. Les tâches et l’exécutif sont compilées dans le même exécutable appellée :image. Un SETR aura un temps de réponse adéquat si la somme du temps d’acquisition, de traitementet d’application de la commande est inférieure à la période d’échantillonage de l’information. Pourcela il faut que l’exécutif soit déterministe et préemptif. Une application de contrôle commande estgénéralement décomposée en tâches.
Definition 1.2.1 Une tâche correspond à une fonctionnalité logicielle et matérielle comportant peud’interactions avec les autres tâches et dont la granularité définie une complexité permettant une im-plémentation rapide.
Exemple
Par exemple prenons le cas d’une régulation en courant d’une Machine à Courant Continu (MCC). Ondésire pouvoir par une saisie de consigne en courant, maintenir constant un certain courant quelquesoit la charge appliquée sur l’axe de la MCC., On peut décomposer cette application en trois tâches :
• Une tâche d’acquisition de la consigne ;
• Une tâche d’échantillonnage lecture du courant ;
• Une tâche de calcul et d’application du correcteur ;
Nous allons maintenant traiter cet exemple au travers de deux axes méthodologiques différents :Synchrone et Asynchrone.
10
1.3 Programmation SynchroneUne programmation “synchrone” partage une application en tâches qui sont lancées de façon synchronespar rapport à des évènements correspondant généralement à des interruptions.
Programme Principal
SPIT Timer......
IT Timer
IT Externe
SPIT IT Externe......
SPIT CAN......
IT CAN
Programmation SYNCHRONE
Exemple
Pour implémenter l’exemple, on découpe l’appllication en plusieurs tâches :
• Programme principal qui initialise les différents périphériques et le timer, puis il ne fait rien (oupas grand chose) ;
• La tâche d’acquisition de consigne : durée 30 µs, appelée toutes les secondes ;
• La tâche d’acquisition du courant : durée : 30 µs, appelée toutes les 200 µs;
• La tâche de calcul et d’application du correcteur : durée : 100 µs, appelée toutes les 200 µs;
Chaque tâche est lancée de façon synchrone avec un évènement d’interruption dans un sous-programme d’interruption. On peut aussi envisager d’effectuer plusieurs sous-taches dans un pro-gramme d’interruption à condition que ces sous-tâches ne soient pas bloquantes.
Lecture Consigne
Lecture Courant IM
Calcul Correcteur
Tâche en traitement
Déroulement de tâches en Programmation Synchrone
100 μs
30 μs
30 μs
Tg=200 μs
100 μs
30 μs
100 μs
30 μs
100 μs
30 μs
100 μs
30 μs
100 μs
30 μs
100 μs
30 μs
100 μs
30 μs
100 μs
30 μs
100 μs
30 μs
30 μs TLc= 1 s
TIM=200 μs
TCC=200 μs
Figure 1.5: Exemple d’ordonancement préemptif
11
Le code suivant, est un exemple de programmation synchrone en assembleur pour un micropro-cesseur 68000. On y remarque le programme principal et les sous-programmes d’interruption.
ORG $0FF0000LEA PILE(PC),A7
INITPIA CLR.B CRB Le Port B commande les TimersMOVE.B #$1F,DDRBMOVE.B #4,CRBCLR.B CRAMOVE.B #7,DDRAMOVE.B #4,CRAPEA IT3(PC)MOVE #27,-(A7)MOVE #5,-(A7)TRAP #13ADDQ.L #8,A7PEA IT2(PC)MOVE #26,-(A7)MOVE #5,-(A7)TRAP #13ADDQ.L #8,A7
************** LES initialisation des 3 TIMERS *********************** CPT0 de U1 : periode de hachage PWM : 125 us f = 1 Mhz
MOVE.B #$14,CRWMOVE.B #125,CPT0MOVE.B #$16,CWMOVE.B #125,CT0MOVE.B #$96,CW 10 01 | 011 0 generation du signal convstMOVE.B #125,CT2CLR.B ORA * aiguillage du multiplexeur analogique
************** * Les activations des IT et Timers **********************MOVE.B #5,CRA IT3MOVE.B #5,CRAx IT2MOVE.B #11,ORB * mise en route de G10,G20 et G22
LOOP BRA LOOP La Boucle InfinieTRAP #0
**************** IT Num 2 : Le Calcul du correcteur ***********************IT2 MOVE.L #IREF,D0 Temps Execution = 60 us
ASL #1,D0 D0 = 2 * IREFSUB.L D2,D0 D0 = 2IREF - 5IMn = EPSnMOVE.L D0,D3 D3 = EPSnADD.L D4,D3 D3 = In = In-1 + EPSn D4 = In-1MOVE.L D3,D5 D5 = InMOVE.L D3,D4 D4 = In-1 <- In pour le prochain calculASL #3,D0 D0 = 8 * EPSnADD.L D5,D0 D0 = 8 EPSn + InMULS #5,D0DIVS #18,D0 D0 = Vn = 100(8*EPSn+In)/360=5(8EPSn+In)/18MOVE.L #3500,D6 D0 <- 100 * E (=35v)SUB D0,D6 D0 <- 100 * E - 100 * VmDIVS #112,D6 D0 <- (100 * E - 100 * Vm)/112
12
MOVE.L #10500,D7 D1 <- 100 * VmADD D0,D7 D1 <- 300 * E + 100 * VmDIVS #112,D7 D1 <- (300 * E + 100 * Vm)/112MOVE.B #$52,CRW Temps IT2 = 25 usMOVE.B D6,CPT1MOVE.B #$92,CRWMOVE.B D7,CPT2MOVE.B ORAx,D7RTE
************** IT Num 3 : Echantillonage du courant **********************IT3 MOVE CAN,D3
CMPI.B #1,D1 Temps IT3 = 22 ou 14 usBNE PASDL Pas De Lecture si D1=1 : variable semaphoreCLR.L D2MOVE D3,D2 D2 = IMn : Mise a jour du courant mesureLSL #4,D2ASR #4,D2
PASDL BCHG #0,D1FIN MOVE.B ORA,D3
RTE
DS.L 100PILE DS.L 1
END
13
1.3.1 Code C, programmation Synchrone sur un micro-contrôleurLe code suivant, est un exemple de programmation synchrone en C pour un microcontroleur ATMega8.On y remarque le programme principal (main) et les sous-programmes d’interruption (ISR).
#include <avr/io.h>...void sleep(int dzs){for(int i=0;i<10*dzs;i++) _delay_ms(10);}
void cligne(void) {for (int i=0;i<7;i++) {
PORTD |= (1<<MALAXEUR_M);sleep(5);PORTD = PORTD & 0b11110111 ;sleep(5);}}
ISR(INT0_vect){int i,local=PORTD;cli();for (i=0;i<7;i++) {PORTD=0xFF; sleep(1);PORTD=0;sleep(1);}PORTD=local;sei();}
ISR(TIMER0_OVF_vect){PORTD = PORTD^0x40;TCNT0=0; }
void transition(int condition) {int capteur=0;if (condition == TEMPO) { cligne();}else do {capteur = PINC;capteur = capteur & condition;
} while(capteur != condition);}
void etape0(void){ PORTD=(1<<STATION_ARRETEE);}void etape1(void) {PORTB=(1<<POSITION_ATTENTE);PORTD=0;}void etape2(void){PORTD=(1<<VANNE_C);PORTB=0;TIMSK|=(1<<TOIE0);}...
int main(void){
DDRC = 0x00; // port C en entreeDDRB = 0x01; // PB0 en sortieDDRD = 0b1111011; // port D en sortie, PD2 en entreeGICR |= (1<<INT0); // en particulier INT0 valideMCUCR |= (1<<ISC01) | (1<<ISC00);TCNT0= 0; // valeur initiale du compteurTCCR0 = 5; // facteur de predivision de clk/IOsei(); // Toutes les ITs sont possiblesdo {
etape0();transition(DEPART_CYCLE);etape1();transition(TREMIE_VIDE+MALAXEUR_VIDE);etape2();transition(POIDS_ATTEINT);
...} while(1);return(1);
}
14
Au niveau des avantages, la programmation est très efficace car prôche du hard. Sa structure estminimale donc très performante. Il n’y a pas d’exécutif donc pas d’ordonnancement et le comportementest de ce fait déterministe.
Par contre, il est difficile de faire évoluer le système. Si l’on veut rajouter une tâche, on doit avoirune source d’interruption supplémentaire. De plus, le temps d’exécution de la nouvelle tâche doit être“compatible” avec les autres temps d’exécutions.
Dans l’exemple : On a une periode globale de 100µs. A ces instants on a au plus : 3 tâches avec100 + 30 + 30 = 160µs. Le temps dexécution le plus grand est donc de 40µs.
Sur une architecture synchrone les coûts de développement sont très importants : La programma-tion de ces systèmes nécessite une maîtrise complète de la partie hardware. En effet, Ces systèmesintimement liés au hardware sont généralement développés au moins en partie en assembleur et enC ce qui augmente encore les coûts de développements et de maintenance. La lisibilité du code estsouvent faible (assembleur, code très lié au hard) et le code n’est pas portable.
1.3.2 Aspect recherche et developpement autour du “synchrone”Des langages spécifiques dit “synchrones” ont été développés dans des laboratoires de recherche. Ilsrestent cantonnés à des programmes de recherche et développement des très grandes entreprises commeAirbus ou Boing mais restent très peu utilisés dans le reste de l’industrie.
Definition 1.3.1 Langages Synchrones : Esterel, Lustre, Statecharts Ce sont des langages à hautniveau d’abstraction dont les instructions de bases manipulent des évènements. Ils sont qualifiés de"synchrones" car ces évènements jouent le rôle de marqueurs temporels. Ils sous-entendent la présenced’une horloge d’échantillonnage temporel permettant de les synchroniser.
1.4 Programmation Asynchrone
La programmation asynchrone implique l’utilisation d’un système d’exploitation (SE ou OS en Anglais).Un système d’exploitation permet, de gérer les tâches de l’application : Il décide de lancer lestâches, il attend leur comptes rendus d’exécution, les interrompt pour ne lancer d’autres : On parled’ordonnancement. L’OS gère, de plus, tous les éléments physiques ou logiciels du système tel quela mémoire, les entrées sorties du système et la communication avec l’exterieur. La gestion de pé-riphérique est faite à l’aide de driver. Les tâches peuvent être implémentés (en C sous Unix/LINUX)par des processus ou des threads.
Le style asynchrone de conception d’une application offre une structure souple : On peut ajouterou supprimer des tâches de façon simple. Le code est lisible (langage haut niveau tyoe C) et détachédu hard, la maintenance est donc plus aisée et le code est portable sur d’autres système ou processeurs.La communication avec le hard se fait via des drivers. Et suivant les drivers portés dans le noyau onva pouvoir faire des tâches de très haut niveau : Protocole TCP/IP, telnet, serveur http, ...
Quant aux inconvénients : L’image intègre un mini système d’exploitation (qlqs Mo) en plus del’application et cet OS rend le système moins performant à cause des changements de contextes (cffigure 1.5.1). De plus, le comportement temporel n’est pas forcement déterministe. Une tâche moinsurgente peut s’exécuter avant une autre qui est plus urgente ! Du déterminisme temporel peut être
15
réablit ou forcé pour un nombre restreint de tâches de haute priorité. Pour atteindre un même niveaude déterminisme en asynchrone qu’en synchrone : il faut un processeur beaucoup plus puissant doncplus consommateur d’énergie électrique et plus de mémoire.
1.4.1 OrdonnancementLe rôle principal d’un OS est d’ordonnancer les tâches. Généralement les OS ont une politique qui essaiede servir de façon plus ou moins équitable l’ensemble des tâches. Pour cela est définit un intervalle detemps très court : ordre de la milliseconde, appelé quantum. Chaque expiration de quantum, provoquel’interruption de la tâche en cours et l’election par l’OS d’une nouvelle tâche ce qui donnera, commele quatum est petit, l’impression que toutes les tâches s’exécutent en même temps. Cette impressionsera d’autant plus importante que le nombre de coeur est important. En effet, sur une architecturemuti-coeur, les tâches seront en plus distribuées sur les différents coeurs.
Une tâche dispose d’un quantum de temps. Au bout de ce quatum elle est preemptée par l’OS.Elle peut se terminer avant l’expiration du quantum, par une fin naturelle ou être bloquée par unedemande d’une entrée-sortie bloquante. Le quantum permet d’assurer une redistribution régulière desressources CPU . Dans la figure suivante, toutes les tâches évoluent de concert.
Lecture Consigne
Lecture Courant
Calcul Correcteur
Tâche en traitement
Election d'une nouvelle tâche à éxecuter : Surcoût temporel
Figure 1.6: Exemple d’ordonancement préemptif
Exemple d’ordonnancement :
1.4.2 Les différent états d’une tâche• Activer : La tâche entre dans un processus électif : File d’attente des tâches "Prêtes";
• Démarrer : Le tâche en tête de la FA "Prête" est élue, elle a 100% du CPU ;
• Arrêter : Le tâche est interrompue, elle a terminée son quantum de temps ;
16
Bloquée
Non planifiée
Tâche en traitement
Tâche Prête
Activer Terminer
Démarrer
Suspendre
Suspendre
Terminer
Arrêter
Continuer
Les Différents états d'une tâche
• Suspendre : Le tâche a demandé une ressource non encore disponible ou s’est endormi elle-même(sleep) ;
• Continuer : La ressource demandée est maintenant disponible ou le sommeil est terminé, le tâcherentre à nouveau dans la FA "Prête".
• Terminer : Le tâche s’arrête définitivement par l’appel à exit ou return. Elle peut aussi recevoirun signal de fin émis par une tâche en traitement.
1.5 LINUX
1.5.1 HistoriquePourquoi LINUX ? Linus Thorvald introduit un OS multitâches comparable à UNIX sur des ordinateursPC vers mla fin des années 80.
• LINUX est dérive d’UNIX, un OS fiable du marché ;
• LINUX est libre : le source est disponible sans royalties à reverser ;
• LINUX est foisonnant : de nombreux contributeurs, développeurs le font évoleur et fournissentune aide rapide ;
• Les versions stables de linux sont FIABLES ;
• LINUX offre une connectivité IP en standard.
LINUX : sur quel système ?
• Linux est décliné sur un grand nombre d’architecture :Pentium x86, PowerPC, ARM, MIPS, 68000, Coldfire,...
17
• Taille du noyau est modeste 500ko (au minimum) à plusieurs dizaine de mégaoctets;
• Différentes distributions sont proposées suivant le domaine :routeur IP, PDA, portable, ...
• Chargement de modules dynamiques : optimisation taille noyau ;
• Migration aisée de linux à Linux Embarqués.
Historique
• 1991 : la première version de Linux est développé par Linus Torvalds;
• 1999 : Présentation à Linux World d’un système compact PCI sous linux ;
• 2000 : Embedded Linux Consortium : centralise des solutions Linux embarqués ;
• Aujourd’hui : des solutions libres ou commerciales sont concurrentes.
• Solutions libres :
– RTLinux,– RTAI.
• Solutions propriétaires:
– VxWorks,– pSOS,– QNX.
18
Chapter 2
Programmation multi-tâche
Deux mécanismes de programmation C sous Unix, permettent d’implémenter la notion de tâche, lesprocessus et les threads. Ces deux mécanismes apparaissent aussi dans d’autres langages et d’autressystèmes d’exploitations. On trouve les notions de processus ou de thread en Java par exemple souswindows. Si les processus/threads Linux correspondent à ceux d’UNIX, ceux de Windows ne corre-spondent pas tout à fait. Un standard définit ce qu’est un processus ou un thread. Le standard desprocessus Unix se nomme les processus Unix System V. Celui des threads se nomme les thread Posix.
2.1 Les Processus Unix System V
Un processus est une implémentation en langage C de la notion de tâche. Un processus est une entitépossédant :Un contexte d’exécution :
• Un ensemble sauvegardé de valeurs des registres du processeur ;
• une zone mémoire associé au code exécutable ;
• une zone de mémoire dynamique privé ;
• une zone pour la pile.
Un environnement d’exécution :
• Les fichiers ouverts,
• sa priorité d’exécution,
• un processus est identifié par un numéro : PID.
• ...
19
PIDPPID
Desc. FichiersZone de pileZone de data
Zone programme
PIDPPID
Desc. FichiersZone de pileZone de data
Zone programme
fork()
père fils
même programmemême valeurs des variables (valeurs d'avant le fork)
MAIS ces codes coexistent à une adresse différenteet les variables appartiennent à des espaces mémoires différents
Duplication
Figure 2.1: fork
2.1.1 Création d’un processusLa primitive fork() (cf la figure 2.1) fait partie du paquettage standard "stdio.h"
• Duplication quasi-complète du patrimoine du père ;
• Le "fils" se distingue par :
– La valeur retournée par l’appel système fork() : 0 pour le fils et le pid du fils chez le pere– son PID ;– son PPID ;– sa zone programme, data et pile ;– ses propres descripteurs de fichiers ouverts.
2.1.2 Création de plusieurs processusUn père, un fils
main() {int i,PID,res;PID=fork();if (!PID) { /* Chez le fils */
for(i=0;i<iteration;i++)printf("je suis le fils, iter num %d \n",i);
printf("je suis le fils, j’ai fini\n");exit(i);
20
}else { /* chez le pere */
for(i=0;i<iteration;i++)printf("\t Je suis le pere, iter num %d \n",i);
res=wait(&CR);printf("\t fils est termine, res= %d \n",res);
}}
Voir le code : processus.c
Definition 2.1.1 Un processus fils se termine par la primitive exit qui permet de renvoyer un entierau père. Ce père récupère cet entier par l’appel à la procédure wait qui est un appel système bloquant.
2.1.3 Boucle de création de processus#include <stdio.h>#include <sys/types.h>#include <sys/ipc.h>#define repos 10000#define iteration 20extern void exit(int);extern int fork();extern int getpid();extern void usleep();extern int wait(int *);
void travaille(int i){printf("\t\t\t\t Je m’appelle %d et je fournit le travail suivant :",getpid());for(int j=0;j<i+5;j++) printf(".");printf("\n");
}
int main(){
int i,tab[nbfils],CR,PID,res;
printf("\n\n\nJe suis le pere et je m’appelle %d\n",getpid());/*CREATION des fils */
for(i=0;i<nbfils;i++) {if ((tab[i]=fork())==0) {travaille(i);exit(i);}else printf("Je suis le pere, je viens de creer un fils qui s’appelle %d \n",tab[i]);
}
21
/*Le PERE travaille */travaille(iteration);
printf("Je suis le pere j’ai fini, j’attends la terminaison de mes fils \n");for (int j=0;j<10;j++) {
res=wait(&CR);printf("\n \t \t \t \t Le fils %d est termine, il s’appelait %d ",CR>>8,res);}printf("\n\n-------------------------- fin ----------------------------\n\n");
}
Dans les résultats d’exécution ci-dessous, on remarque la création des 5 fils qui s’intercale avec lesexécutions des fils. Le fils 3212 commence son travail avant que le fils 3214 soit créé. On remarqueaussi la synchronisation exit-wait qui se fait lors de la treminaison des fils. Le fils 3216 finit sont travailbien après les autres, alors que les fils 3214, 3213 et 3212 se sont déjà synchronisés avec le père.
Je suis le pere et je m’appelle 3211Je suis le pere, je viens de creer un fils qui s’appelle 3212Je suis le pere, je viens de creer un fils qui s’appelle 3213Je m’appelle 3212 et je fournit le travail suivant :.....Je m’appelle 3213 et je fournit le travail suivant :......
Je suis le pere, je viens de creer un fils qui s’appelle 3214Je suis le pere, je viens de creer un fils qui s’appelle 3215Je m’appelle 3214 et je fournit le travail suivant :.......Je m’appelle 3215 et je fournit le travail suivant :........
Je suis le pere, je viens de creer un fils qui s’appelle 3216Je m’appelle 3211 et je fournit le travail suivant :.........................
Je suis le pere j’ai fini, j’attends la terminaison de mes fils
Le fils 2 est terminé, il s’appelait 3214Le fils 1 est terminé, il s’appelait 3213Le fils 0 est terminé, il s’appelait 3212
Je m’appelle 3216 et je fournit le travail suivant :.........Le fils 3 est terminé, il s’appelait 3215Le fils 4 est terminé, il s’appelait 3216
-------------------------- fin ----------------------------
Définition incorrecte d’un ensemble de processus
int main(){
int i,CR,PID,res;int tab[nbfils];
22
printf("\n\n\nJe suis le pere et je m’appelle %d\n",getpid());
for(i=0;i<5;i++) {tab[i]=fork();
}if (tab[i]==0) {printf("fils");travaille(i);exit(i);}else printf("\n pere");
printf("Je suis le pere j’ai fini, j’attends la terminaison de mes fils \n");for (int j=0;j<10;j++) {
res=wait(&CR);printf("\n \t \t \t \t Le fils %d est terminé, il s’appelait %d ",CR>>8,res);}printf("\n\n-------------------------- fin ----------------------------\n\n");
}
Ce code est incorrect : On a une explosion inattendue du nombre de fils : Ce code produit environ30 processus. En effet, les fils produisent a leur tour des fils qui produisent des fils,. . . Comme dans lepremier code il faut absolument que le if (tab[i]=fork()==0) ait bien lieu dans la boucle du for.
Gestion de processus et mesure du temps d’exécution
• gcc fils.c -o file
• chmod 777 file
• ./file
• file & ;
• time ./file
• ps -aC;
• kill -9 777 3214;
Les deux premiers items servent à compiler et produire un exécutable, donner les droits d’exécution.Les trois items suivant servent à lancer le programme exécutable : de façon simple d’abord, le &
provoque le lancement du programme en arrière plan, c’est à dire que l’on va bénéficier encore duterminal.
La comande time La commande time lance le programme et évaluant son temps d’exécution. Ellerenvoie toutefois une information plus riche : le temps total écoulé, le temps du programme utilisateur,le temps système :
• Elapsed time : temps réel complet de l’exécution de la commande
23
• User time : temps CPU utilisé uniquement par le programme utilisateur
• Sys time : temps utilisé uniquement par le système pour gérer l’exécution de tous les jobs pendantl’exécution du processus
Elapsed time = Temps du programme utilisateur + temps système + temps utilisé par les autrestâches
La commande ps : Processus state donne les processus du système et différentes informations(PID, temps d’écution, nom ou commande correspond au processus ...). Tandis que la commande kill-9 associée à un PID permet de tuer un processus.
2.2 La communication entre processus Unix
Les processus peuvent communiquer à travers deux outils de communication : Les pipes et les Sockets.Nous allons étudier les pipes.
Processus Producteur
Processus Consomateur
TUBE
Figure 2.2: Information circulant dans un pipe
Principe
2.2.1 Les pipes
Un pipe est un mécanisme qui transporte une information ou une donnée dans un seul sens à la fois(cf fig. 2.2). Le producteur producteur envoie des données qui circulent dans un tuyau “virtuel” versle processus consomateur. On le nomme pipe ou tuyau en français, car les informations ne peuventpas se doubler. Une info A émise arrivera avant l’info B émise après A. C’est un mécanisme First InFirst Out.
Les processus peuvent changer de rôle, celui qui était consomateur peut devenir producteur etl’autre peux devenir consommateur, à condition aussi que les processus modifient leur usage du pipe.Par contre on ne peux pas avoir les deux processus producteurs ou les deux processus consomateursen même temps. Dès lors qu’une communication est établie, un pipe fonctionne à sens unique.
Ce qui est singulier dans le pipe est que l’information disparaît après lecture. C’est pour cela quel’on utilise le vocable de producteur/consomateur. Le producteur produit de l’information qui seraretirée du pipe par le consommateur.
Il existe deux catégories de pipes :
24
• Les pipes “non nommés” utilisables entre processus parents qui partagent le même environ-nement. Comme ces processus partagent le même environnement ils peuvent se transmettre lescaractéristiques des pipes sans difficulté.
• Les pipes “nommés” employés pour les communications entre processus sans liens de parenté. Ilss’apparentent à des fichiers en mémoire. Le fonctionnement est sensiblement le même. Ce sontdes fichiers d’un type spécial à usage interne pour la communication entre processus. Le processusConsommateur, lorsqu’il se met en attente de lecture d’une information que le Producteur doitlui transmettre à travers le pipe, se synchronise sur ce dernier. Il reçoit, de plus, un message quipeut être utilisé pour diriger ses actions.
2.2.2 Les pipes “non nommés”Si un pipe est nommé, il peut donc être partagé entre un père et sa toute descendance. Soit p le nomdu pipe :
• p[0] : sortie du pipe, c’est par la que l’on retire de l’information
• p[1] : entrée du pipe c’est par la que l’on dépose de l’information
Pour comprendre leur fonctionnement, en voici un exemple réduit à sa plus simple expression.On crée un pipe par la fonction pipe() puis un processus fils par fork(). Ce fils hérite de toutl’environnement du père donc du pipe et de ses caractéristiques. Dans un pipe, p[0] représente lasortie du pipe et p[1] l’entrée du pipe. Dans les deux processsus, un doit être le producteur et l’autrele consommateur. Le producteur ferme le pipe en lecture par close(p[0]), pour lui le pipe ne peut doncplus servir qu’en écriture. Celle-ci se fait par la fonction write() qui comprend trois arguments :
• La structure d’écriture p[1] du pipe
• La chaîne à transmettre
• Le nombre de caractères de la chaine.
Si il a terminé sa production le producteur peut fermer p[1].Le deuxième fils créé, le consommateur, est employé pour lire les informations envoyées par le
producteur. Ce consommateur ferme le pipe en ecriture par close(p[1]), pour lui le pipe ne peut doncplus servir qu’en lecture. Celle-ci se fait par la fonction read() qui comprend trois arguments :
• La structure de lecture p[0] du pipe
• La chaîne qui receptionne l’information
• Le nombre de caractères que le consommateur désire recevoir.
Si il a terminé sa production le consommateur peut fermer p[0].
25
#include <stdio.h>#include <sys/signal.h>main() {
int fils1, fils2, m, n, p[2], count; char buf[6];pipe(p);/* creation premier fils : Le producteur */
if ((fils1=fork())== 0){char c;close (p[0]);fprintf(stdout,"(%d) est le Producteur: \n",getpid());do {
scanf("%c",&c);write(p[1],&c,1);
} while (c!=’T’);close(p[1]);fprintf(stdout,"fin production \n");exit(2);
}
/* creation du deuxieme fils : Le consommateur */else if ((fils2=fork())==0){
fprintf(stdout,"fils2 (%d) : lit ds pipe\n",getpid());close (p[1]);do{
count = read(p[0],lu,1);printf("\t \t \t \t LU : %c\n",*lu);
}while (*lu != ’T’);fprintf(stdout,"fin de consommation \n");exit(3);
}else{
fprintf(stdout,"processus pere %d\n",getpid());close(p[0]);close(p[1]);fprintf(stdout, "wait fils : %d\n",wait(&m));fprintf(stdout, "wait fils : %d\n",wait(&n));fprintf(stdout, "fin du pere\n");exit(0);
}}
26
2.2.3 Les sémaphoresDefinition 2.2.1 (Semaphore) Un sémaphore est un object permettant à N processus ou thread(tâche) d’accéder à une même région de code ou a une ressource critique
Pour cela un sémaphore est un objet qui permet les actions suivantes :
• L’initialisation
• Le processus de réservation : semP
• Le processus de libération : semV
Code de SemP:
Masquer toutes les ITs;S--;if (S<0) {Tache_courante --> File_Attente(S);reordonnancement();}Demasquer toutes les ITs;
Code de SemV :
Masquer toutes les ITs;S++;if (S<=0) {
Debloquer(Premier(File_Attente(S)));reordonnancement();
}Demasquer toutes les ITs;
Exemple deux imprimeurs veulent accéder à une unique imprimante. L’imprimante est représentéepar un affichage sur une ligne d’écran.
#include <stdio.h>#include <sys/types.h>#include <sys/ipc.h>#include <sys/sem.h>#include <sys/shm.h>#include "semaphore.h"#define NB_IMPRIMEURS 40#define NB 200
extern void exit(int);extern void usleep();
27
extern int getpid();extern int fork();extern void sleep();extern int wait();
int ecran; /*semaphore */
void imprime() {sem_P(ecran);for (int i=0;i<NB;i++)
printf("Je suis suis %d, Je realise une impression %d\n",getpid(),i);sem_V(ecran);
}
int main(){ int i,tab[NB_IMPRIMEURS];
sem_init(); //initialisation de(s) semaphore(s)
ecran=sem_creer(1);
printf(" Creation des imprimeurs \n");for(i=0;i<NB_IMPRIMEURS;i++) {
tab[i]=fork();if (tab[i]==0) {
imprime();exit(1);
}}sleep(1);
for(i=0;i<NB_IMPRIMEURS;i++) wait(NULL); //on attend la terminaison des voiture, elle vont disparaitre des quais.printf(" Toutes les impressions sont finies \n");sem_detruire();printf(" destruction des semaphores \n");return(1);
}
2.3 Les Threads PosixPOSIX définit une norme : IEEE 1003. Cette norme porte sur les interfaces de communication deslogiciels : les API. Une API : Application Programming Interface permet de définir la manière dont on
28
peux utilser un logiciel pu composant informatique. C’est donc un ensemble de fonction typée (décritesdans un *.h) qui indique comment on peut interagir avec le composant. Les threads implémentent lanorme POSIX. Ceux sont des processus légers car ils ont été créés par un processus père avec qui ilspartagent avec lui le même espace mémoire.
Ils ont les caractéristiques suivantes :
• Ils peuvent avoir des variables communes (globales) et des variables locales ;
• Ils partagent les mêmes fichiers et les mêmes ressources ;
• Ils ont leur propre pile d’exécution ;
• Ils sont ordonnancés ;
Voir le code : API "pthread.h"
2.3.1 Création de threadint pthread_create(pthread_t *thread,
const pthread_attr_t *attr,void *(*start_routine)(void *),void *arg);
• thread : identifiant, descripteur du thread ;
• attr : attribut de création ;
• start_routine : fonction constituant le corps du thread ;
• arg : argument de la fonction.
void pthread_exit(void *value_ptr) ;
int pthread_join(pthread_t thread,void **value_ptr) ;
value_ptr : valeur de retour au père. thread : identifiantVoir le code : thread2.cDeux threads qui partagent et modifient une même variable globale peuvent provoquer un com-
portement non déterministe de l’application.
#include <stdio.h>#include <unistd.h>#include <stdlib.h>#include <string.h>#include <pthread.h>#define NBITER 11000
29
unsigned int globale=0;
void *ligne1(void *arg);void *ligne2(void *arg);
int main(){int res;pthread_t l1, l2;char c;
//***************************************************************************res=pthread_create(&l1, NULL, ligne1, NULL);
//***************************************************************************if (res == -1) {
perror(" erreur de creation du thread\n");exit (EXIT_FAILURE);
}//***************************************************************************
res=pthread_create(&l2, NULL, ligne2, NULL);//***************************************************************************
if (res == -1) {perror(" erreur de creation du thread\n");exit (EXIT_FAILURE);
}
printf("attente des fils\n");pthread_join(l1,NULL);pthread_join(l2,NULL);printf("Fin du père, valeur finale de la variable globale = %d\n",globale);exit(EXIT_SUCCESS);
}
void *ligne1(void *arg) {for(int i=0;i<NBITER;i++) {
globale=globale+1;}printf("Fin du fils1\n");pthread_exit(NULL);
}
void *ligne2(void *arg) {for(int i=0;i<NBITER;i++) {
30
globale=globale+10;}printf("Fin du fils2\n");pthread_exit(NULL);
}
2.3.2 Protéger une variable globale accédèe par plusieurs thread, à l’aided’un sémaphore
Pour assurer un accès atomique à une variable globale on va s’assurer que l’on ne sera pas interrompulorsque l’on modifie la variable. L’usage d’un sémaphore va premettre :
1. Eviter une élection par l’ordonnanceur dans une région.
2. Eviter toute interruption.
3. Masquer les interruptions en début de région et les démasquer en fin de région
#include <stdio.h>#include <unistd.h>#include <stdlib.h>#include <string.h>#include <pthread.h>#include "semaphore.h"#define NBITER 11000
unsigned int globale=0;
int ecran;
void *ligne1(void *arg);void *ligne2(void *arg);
int main(){int res;pthread_t l1, l2;char c;
sem_init();ecran=sem_creer(1);
//***************************************************************************res=pthread_create(&l1, NULL, ligne1, NULL);
//***************************************************************************
31
if (res == -1) {perror(" erreur de creation du thread\n");exit (EXIT_FAILURE);
}//***************************************************************************
res=pthread_create(&l2, NULL, ligne2, NULL);//***************************************************************************
if (res == -1) {perror(" erreur de creation du thread\n");exit (EXIT_FAILURE);
}
printf("attente des fils\n");pthread_join(l1,NULL);pthread_join(l2,NULL);sem_detruire();printf("Fin du père, valeur finale de la variable globale = %d\n",globale);exit(EXIT_SUCCESS);
}
void *ligne1(void *arg) {for(int i=0;i<NBITER;i++) {
sem_P(ecran);globale=globale+1;sem_V(ecran);
}printf("Fin du fils1\n");pthread_exit(NULL);
}
void *ligne2(void *arg) {for(int i=0;i<NBITER;i++) {
sem_P(ecran);globale=globale+10;sem_V(ecran);
}printf("Fin du fils2\n");pthread_exit(NULL);
}
32
2.3.3 Tableau de threads et passage de paramètreBoucle de création de thread. On va faire un travail à chaque thread qui est différent grâce à la variablei. On utilise un sémaphore pour que chaque thread écrive sur une seule et même ligne.
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/time.h>
#include "semaphore.h"
#define N 5 // nombre de threads
int ligne;
void *imprime(void *k){
int p=(int) k+5,j=0;
sem_P(ligne);
for(j=1;j<=p;j++) printf("%d ",j);
sem_V(ligne);
printf("\n");
return(NULL);
}
int main(){
int i;
pthread_t pt[N];
sem_init();
ligne=sem_creer(1);
for(i=0;i<N;i++){
pthread_create(&pt[i],NULL,imprime,(void *)(size_t) i);
}
for(i=N;i>0;i--) pthread_join(pt[i],NULL);
sem_detruire();
return 0;
}
• ligne verrouille l’accés à la mise à jour de la variable globale
• Si ligne est déverrouillé, il devient alors verrouillé par un autre thread et est possédé par lethread appelant semP
• Si le sémaphore est déjà verrouillé par un autre thread, semP suspend le thread appellant jusqu’àce que ligne soit déverrouillé.
33
34
Chapter 3
Système embarqué temps réel
3.1 La cible
La cible est un rack 5U ou 3A relié au PC par le réseau et par une liaison série. On y accède par sonadresse IP. Dans ce rack, on peut y ficher 3 à 5 cartes, dont une est la carte processseurs et les autresdes cartes d’entrées-sorties. On doit tout d’abord booter la cible comme on le ferait pour un PC.
3.1.1 Boot de la cibleRemarque 3.1.1 Boot Le boot c’est l’amorçage d’un système hardware par un programme appelébootloader. Le bootloader va chercher sur un périphérique (Disque Dur, Clef USB ou le réseau) unexécutif qui s’installera en mémoire vive et appellera lui-même des programmes applicatifs.
Remarque 3.1.2 bootloader et MBR Le bootloader d’un PC est un programme placé dans le MasterBoot Record (MBR) qui réalise le boot. Le MBR est la zone d’amoçage d’un PC. Elle contient la tabledes partitions (les 4 partitions primaires) du disque dur et le bootloader dont le but est de charger lesystème d’exploitation.
3.1.2 Configurer le boot : U-BootRemarque 3.1.3 U-Boot U-Boot est un bootloader (logiciel libre), permettant de loader un exécutiflinux par le réseau (Ethernet). U-Boot implémente le protocole TFTP. U-Boot fonctionne sur descentaines de cartes mère et a été développé pour la très grande majorité des processeurs existant :PowerPC, ARM, XScale, MIPS, Coldfire, NIOS, Microblaze, et x86.
Proposition 3.1.1 TFTP Trivial File Tranfer Protocol : ce protocole permet de faire des transfertde fichiers d’une machine à une autre. Il est basé sur l’architecture Client Serveur.
Commande de U-Boot : printenv
printenv : Cette commande affiche l’ensemble des variables de l’environnement.
35
=> printenv
baudrate=9600
bootdelay=5
stdin=serial
stdout=serial
netmask=255.255.255.0
ipaddr=172.22.64.170
serverip=172.22.64.172
Environment size: 992/16380 bytes
=> printenv ipaddr netmask
ipaddr=172.22.64.170
netmask=255.255.255.0
=>
Commande de U-Boot : setenv
setenv : Cette commande permet de définir une variable ou de supprimer une variable.usage :
=> setenv nom valeurpermet de definir la variable nom avec valeur=> setenv nompermet de supprimer la variable valeur
Autre exemple :=> setenv cons_opts console=tty0 console=ttyS0,${baudrate}=> printenv cons_optscons_opts=console=tty0 console=ttyS0,${baudrate}
Commande de U-Boot : saveenv
Permet de sauvegarder de façon persistante dans la mémoire flash, toutes les valeurs des variablespositionnées par la commande setenv.
=> saveenvSaving Enviroment to Flash...Writing to Flash... done
=>
Commande de U-Boot : tftpboot
tfypboot : boote l’image par le réseau suivant les variables définies par setenv. Elle va chercher l’imagesur $serverip
=> help tftpboottftpboot [loadAddress] [bootfilename]
36
3.2 La carte d’entrée-sortie : VMODSpécifications générales
• On a une carte porteuse VMOD_IO : proposant 4 emplacements en mezzanine pour des cartesfilles ;
• Cette carte porteuse réalise l’interface avec le Bus VME ;
3.2.1 VMOD_IOSur les 4 emplacements on a :
1. deux cartes VMOD_TTL ;
2. une carte VMOD_12E816 : carte d’entrée Convertisseur analogique-numérique ;
3. une carte VMOD_12a4 : carte de sortie Convertisseur numérique-analogique ;
3.2.2 Les ports d’Entrées-sortiesLes Ports A, B et C
VMOD_TTL
Les 3 ports A, B et C :Cette carte sur un bus VME via une interface de type MODULbus+ propose 2 ports 8 bits et un
port 4 bits.
• 20 entreées-sorties TTL optocouplées ;
• Les 3 ports sont configurables en entrée ou en sortie.
• Chaque bit du port peut fournir un courant max de 48 mA il est de type collecteur ouvert ;
• A chaque port doit être alimenté.
• Fonction secondaire timer (Zilog Z8536) sur les ports B et C.
37
VMOD_TTL
VMOD_TTL2O ES TTL
VMOD_12E8/1612 Entrees Analogiques
16 bits
VMOD12A44 sorties Analogiques
PORT APORT B
PORT C
Vcc/Gnd
38
3.3 DriversDefinition 3.3.1 Driver Un Driver (module) est un programme écrit généralement en Assembleurpermettant de lire et d’écrire sur un périphérique ou de réaliser des actions appellées "services". Unmodule fournit des services ou utilise des services d’autres modules.
Le cas des drivers linux :
• Statique : Les modules sont rajoutés dans la partie "File System" et compilé avec le noyau. Ilsera présent même si le périphérique n’est plus utilisable
• Dynamique : On alors un "module chargeable", les modules/drivers ne sont chargés QUE lorsqueun programme en a besoin.
Il existe différents types de pilotes suivant le périphérique à contrôler:
• les pilotes en mode caractèreEx : ports séries et parallèles
• les pilotes en mode blocEx : Disque dur.
• les pilotes réseaux
3.3.1 Driver caractèreAvec ce matériel de TP, on n’utilisera que des pilotes en mode caractère. Ces pilotes sont accessiblesà travers des fichiers spéciaux appelés également noeuds (nodes). Ces fichiers sont localisés sur lerépertoire /dev et sont caractérisés par deux valeurs numériques :
• Le MAJEUR (MAJOR) qui identifie le pilote
• Le MINEUR (MINOR) qui représente une sous-adresse en cas de présence de plusieurs pé-riphériques identiques, contrôlés par un même pilote.
3.3.2 Installation de DriversLe fichier /etc/rc.sysinit permet de réaliser des installations des drivers/modules spécifiques.
• La commande depmod� a :Elle établit la liste des dépendances de modules en lisant pour tous les modules les servicesexportés ou importés.
• La commande insmod programme simple permettant d’insérer un module dans le noyau sanss’occuper de dépendances éventuellement non satisfaites.
• La commande modprobe programme simple permettant d’insérer un module dans le noyau.modprobe charge un module et les modules qui en dépendent.
• rmmod décharge un module
39
3.3.3 Drivers de nos cartes d’ES#depmod � a#insmod copy_universe#modprobe universe #modprobe vme_mod log = 4 level = 3#modprobe modvme#modprobe � v modat0
3.3.4 Installation du driver de la MTTL#modprobe mttl.o io = 62, 0, 0, 0x3000a800, 0xa0, 0xd
• 62 : major number : celui de la carte MTTL
• 0 : num. carte VMODIO sur bus VME 2 [0, 15]
• 0 : minor number emplacement de MTTL sur VMODIO 2 [0, 3]
• 0x3000a800 adr physique carte VMODIO sur bus VME
• 0xa0 : adresse du vecteur d’IT
• 0x0d : 0000 1101
1101 : 1: Opto, 1: C en sortie, 0: B en entrée, 1: A en sortie
Drivers de nos cartes d’ESInstallation des deux cartes TTL :
#insmod mttl � v io = 62, 0, 0, 0x3000a800, 0xa0, 0xd 62, 0, 0, 0x3000a800, 0xa0, 0xd
Exemple simple de Driver Linux
Ecriture du driver hello.c:
#include <linux/module.h>#include <linux/kernel.h>
int init_module(void){
printk("Driver chargé n");return 0;
}
40
void cleanup_module(void){
printk("Driver déchargé \n");}
Compilation et utilisation de Driver Linux
Ce code constitue la base d’un module chargeable. Si on le compile par:
$gcc -Wall -c hello.c -o hello.o -D__KERNEL__-I /usr/include/linux/ -O2
on pourra insérer dynamiquement le module par la commande insmod:
$insmod hello.o
Ce qui provoque le chargement du module (voir lsmod) et l’apparition du message dans les traces dunoyau.
Chargement du module :
[exemple]# lsmodModule Size Used byhello 184 0 (unused)3c509 5972 1 (autoclean)vfat 9116 0 (unused)fat 30048 0 [vfat][exemple]# dmesg | tail -1Module chargé
De même si on décharge le module par rmmod on obtient:
[exemple]# rmmod hello S[exemple]# dmesg | tail -1Module déchargé
41
42
Chapter 4
ANNEXES
4.1 Connectivité IPDefinition 4.1.1 Connectivité IP La connectivité IP permet de raccorder tout système électroniqueau réseau internet. Elle met en oeuvre une suite de protocole que l’on doit embarquer sur le système.
Avantages :
• Contrôler à distance les SETR ;
• usage d’interfaces graphiques modernes et banalisées : navigateur web ;
• Evolution du télécontrôle : RS232 et terminal V T100.
4.1.1 Le protocole IPDefinition 4.1.2 Protocole IP Protocole basé sur le modèle OSI à 7 couches.
Definition 4.1.3 Modèles OSI Ensemble de couches. Une couche crée un niveau d’abstraction enraffinant un service de base pour donner des services plus élaborés au niveau supérieur.
4.1.2 Les 7 couches du modèle OSI1. Couche physique : transmettre des bits ;
2. Couche liaison : transmettre des trames, détection et correction d’erreurs ;
3. Couche réseau : routage et acheminement des données, constitutions de paquets de trames,gestion de la congestion du réseau ;
4. Couche Transport : gestion du dialogue entre 2 noeuds (sockets, pipe, ....), mode connecté (TCP)ou non (UDP).
5. Couche session : structuration du dialogue (client-serveur) ;
43
6. Couche représentation : représentation des données format, compression, cryptage,...
7. Couche Application : Interface shell, webmail, firefox, ...
4.1.3 Le réseau Internet : 4 couches1. Couche médium : transmettre des trames de bits (couche 1 et 2) : Ethernet, GSM, Courant
porteur,...
2. Couche IP : routage et Acheminement des données (couche 3)
3. Couche TCP (ou UDP) : gestion du dialogue entre 2 noeuds mode connecté (TCP) ou non (UDP)(couche 4);
4. Couche Application : de structuration du dialogue jusqu’a l’interface (couche 5,6,7).
Architecture Internet
Client FTP
TCP
IP
Médium
Serveur FTP
TCP
IP
Médium
Protocole ftp
Protocole TCP
Protocole IP
trames propres au médium
Figure 4.1: Réseaux 4 couches
Adressage
1. Chaque ordinateur ou système embarqué est repéré par une adresse IP unique sur 32 bist.
2. Notation décimale : 172.22.64.173 : 4 octets (255 < x < 0)
3. ADRESSE IP : id réseau + id machine
4. 1 octet : id Réseau
5. dernier octet : 255 broadcast, 1 : Gateway
44
Protocole IP
1. version IPv4 : 4 bits d’entête
2. 8 bits : priorité, préférences sur la qualité
3. 2 octets : Longueur totale
4. 4 octets : identification, drapeaux,..
5. 1 octet durée de vie : nombre de routeurs traversés
6. 1 octet de protocole : 6 -> TCP, 17 UDP,...
7. header checksum
8. 20 octets maximum pour le message
9. adresse IP source et destination
10. options
Protocole TCP et UDP
1. Utilise IP comme service réseau
2. TCP procure un service de transport en mode connecté sécurisé (demande de ré-emission siechec)
• Connexion par handshake ;
• Transfert de données ;
• acquitement ;
• fermeture des connexions;
• exemple : chat, telnet, ftp
3. UDP procure un service de transport en mode non connecté et non sécurisé.
• Adresse materielle de la machine appellée
• adresse IP
• numéro du port
• exemple : mail
45
L’API Socket
LES SOCKETS IMPLEMENTENT LES PROTOCOLES TCP ET UDP
1. Elles permettent d’échanger des octets entre une application cliente et une application serveur.
2. Les données passent en clair dans le réseau.
3. SSL : est une nouvelle API basée sur les sockets pour échanger des données sécurisées.
Applications telnet et rlogin
Elles utilisent TCP
1. telnet est une appli client/serveur en mode connecté.
2. rlogin ne fonctionne qu’entre 2 machine UNIX. telnet est faisable sous windows
3. Un daemon serveur doit tourner sur la machine appellée.
4.1.4 Applications NFS1. Permet de rendre transparente l’utilisation de fichiers répartis sur différentes machines.
2. NFS utilise UDP, les nouvelles versions utilisent TCP.
3. Est particulièrement utile pour les SETR diskless
Montage NFS
NFS
• NFS (Network File System) permet de partager des fichiers entre ordinateurs sous un environ-nement Linux et/ou Unix (des implémentations existent pour Macintosh et MS Windows).
• Il existe plusieurs version de NFS : NSF 1 et 2 son obsolètes et NFS 3 : Non sécurisé et NFS 4.
• Usage : Partage d’un répertoire (projet).
• Basée sur la notion de point de montage
Point de Montage
En linux tout est fichier ou répertoire (Noeud).
Definition 4.1.4 Point de montage Sous linux : Un disque dur, un lecteur de CDROM ou une clefUSB correspondent à un répertoire. Ces éléments physiques doivent être montés et démontés aprèsusage. Le montage correspond à la création d’un lien entre l’élément physique et le répertoire.
• mount � t iso9660 /dev/cdrom/media/cdrom
• umount /media/cdrom
46
Montage NFS
C’est un système client� serveur.• Le client importe des fichiers.
• Le serveur exporte ses fichiers.Principe
• Installation sur le serveur : Dans /etc/exports/public ⇤ (rw, no_root_squash, sync)#exportfs � a#/etc/init.d/nfs_kernel_server restart
• Le Client :
• mount � t nfs 172.22.64.175 : /public /mnt � o nolock
• umount/mnt
4.1.5 Applications ftp1. Permet de faire des transfert de fichiers ;
2. nécessite une connexion par login et mot de passe.
3. il existe des serveurs anonymous, le mot de passe est alors son email.
• ftp 172.22.64.173• login passwd• put file• mget file.*• bye
4.1.6 Applications http1. Protocole de communicatoin et d’échange de documents sur le web
2. Est écrit en utilisant l’API SOCKET
3. Tous les navigateurs sont des applications client/serveur basé sur l’API Socket.
1. Protocole de communicatoin et d’échange de documents sur le web
2. Est écrit en utilisant l’API SOCKET
3. Tous les navigateurs sont des applications client/serveur basé sur l’API Socket.
47
Travaux Dirigés SETR
Polytech’Nantes, GE4 - 1h30
David Delfieu
On cherche à programmer de façon simplifiée le fonctionnement d’une usine (voir l’illustration)réalisant un mélange de 2 produits C et S. Le produit final B sera obtenu en suivant les phasessuivantes :
• Approvisionner BAC1 et BAC2 avec les produit S et C en agissant sur les vannes V A1 et V A2
de façon à maintenir constamment les niveaux dans chacun des bacs autours d’un niveau moyenfixé.
• Lorsque les niveaux de BAC1 et BAC2 oscillent autour de leur valeur moyenne, BAC3 estapprovisionné avec un mélange composé de C et S composé de 16 kg de S et 8kg de C, enagissant sur les vannes de vidages V D1 et V D2. Pendant cet approvisionnement la vanne V D3
est fermée.
• BAC3 est alors vidé de 15 kg dans une autre bac (non modélisé dans l’exercice) par la vanneV D3 et le cycle recommence.
N1
n1
BAC1
S
VA1
C
BAC2
N2
n2
BAC3
P M
VD1
VD3
VD2
VA2
Figure 1: Illustration
D’autres part pour modéliser le problème, les entrés-sorties auront les caractéristiques suivantes :
• Les vannes V A1,V A2,V D1,V D2,V D3 peuvent êtres ouvertes ou fermées par les procéduresouvrir avec comme paramètre le nom de la vanne : ouvrir(V D1); fermer(V D2);
1
• On peux se mettre en attente des signaux N1,n1,N2,n2,P ,M par la procédure atit : atit(P); N1
(resp N2) signale que le niveau max du bac 1 est atteint, n1 (resp n2) signale que le niveau mindu bac 1 est atteint.
• Le poids du mélange dans BAC3 est mesuré par un capteur qui délivre le signal P à chaquefois que le mélange augmente de 100g et M à chaque fois que le mélange atteint diminue de100g.
1 Modélisation préliminaire
Initialement tous les bacs sont vides, les vannes sont fermées. On demande proposer une programma-tion progressive de cette application : Modéliser le fonctionnement des tâches BAC1, BAC2, BAC3
en utilisant une structure d’algorithme en utilisant les appels :
• ouvrir(V ), fermer(V )
• atit(S1)
• L’attente (de type "l’un ou l’autre") de deux signaux S1 et S2 : atit(S1||S2),
• L’attente (de type "l’un et l’autre") de deux signaux S1 et S2 : atit(S1&&S2),
les primitives :
• Boucle, Fin Boucle
• Tant Que, Fin Tant Que
• Si Alors... Sinon... F in Si, ...
2 Codage
Vous coderez cette modélisation en suivant les consignes suivantes :
• Les actions de fermeture et d’ouverture de vannes seront modélisées par un printf :
printf("\n\t\t\t\t\t\t�ouverture�Vanne�Vidange�2�");
• Les attentes de signaux de capteurs modélisées par la procédure atit(N1) seront modélisées parla mise en sommeil du processus (sleep);
• on utilisera les déclarations globales :
pthread_t B1 ,B2 ,B3;int N1 , n1 , N2 , n2 , P, M;
• La tâche sera d’abord défini par :
void *BAC3(void){ ... }
• Le main va ensuite créer et lancer ces 3 thread qui géreront les 3 bacs par l’instruction :
pthread_create (&B3 ,NULL , BAC3 , NULL);
2
• Puis le main agira comme générateur de signaux sur les capteurs avec la structure
while (1) {printf("\nTapez�1�->�N1 ,�2�->�n1 ,�3�->�N2");printf("4�->�n2 ,�5�->�P,�M�->�6�:�");fflush(stdin);scanf("%i" ,&i);switch(i) {
case 1 : N1=1; n1=0; printf("\n->�N1");break;.....
3
3 Solution
3.1 Première partieTâche BAC(i)
BoucleOuvrir(VA(i));atit(N(i));fermer(VA(i));atit(n(i));
Fin boucle;fin BAC(i);
Tâche BAC3atit(N1 && N2);PA=0;PB=0;Boucle
ouvrir(VD1);Tant Que (PA < 160) Faire
atit(P);PA++;
Fin Tant Que;fermer(VD1);ouvrir(VD2);poids=0;Tant Que (PB < 80) Faire
atit(P);PB++;
Fin Tant Que;fermer(VD2);ouvrir(VD3);Pour Pt=0 à 150 par pas de 1
Faire atit(M);fermer(VD3);PA=PA-100;PB=PB-50;
Fin BoucleFin BAC3;
4
Commande de moteur multithread
Polytech’Nantes - Dept GE.
Le but de ce TP sera l’implémentation d’une application temps réel embarquée multithreadée qui commande unmoteur pas à pas.
1 Préambule
Télécharger le fichier "squelette.c" sur madoc. Faire Control A control C pour copier le programme. Sous l’éditeurkate enregistrer votre programme avec un nom (nom d’un des binômes) sous le répertoire RTAI-JANZ/sourcesC/
Connectique : Brancher PA0,PA1,PA2,PA3 sur les 4 bobines du MPP . Connectez l’alimentation (5V ) sur le MPP
ainsi que sur V A de la carte d’ES. Connectez la masse du MPP et de la carte d’ES.
Ouvrir un terminal (icône en bas à droite). En créant 2 onglets vous en obtenez 3 avec l’onglet de départ, changerleurs titres: compil, ftp et telnet. On a alors 3 onglets :Onglet compil :
$ cd RTAI-JANZ/sourcesC$ PATH=$PATH:. // instruction nécessaire une fois lors de la création du shell// Attention le premier dollar constitue le prompt du shell$ chmod 777 compil$ compil monfichier // sans extention !!
Onglet ftp :
L’onglet $ftp$ sert à envoyer votre exécutable sur la cible :$ cd RTAI-JANZ/sourcesC$ ftp 172.22.64.17*
login : taper root> put monfichier// Attention aprés 900 secondes d’inactivité il faut quitter avec "bye" et retaper ftp 172....
172.22.64.17⇤ est l’adresse IP de votre cible.
Onglet telnet :
$ telnet 172.22.64.17*login : taper root puis la barre espace
# PATH=$PATH:. // instruction nécessaire une fois lors de la création du shell// Attention le premier dièse constitue le prompt du shell# chmod 777 monfichier# monfichier
2 Ennoncé
1. Ecrire un programme permettant de faire clignoter la led numéro zéro toutes les secondes à l’aide de la fonctionusleep() (microseconde).
1
2. Ecrire une fonction menu() qui interroge l’utilisateur sur le Sens, et la Vitesse (tant que la touche ’q’ pour quittern’a pas été choisie).
MenuTapez S pour définir le sensTapez V pour définir la vitesseTapez Q pour Quitter
Ce menu met à jour les variables globales S, V .
3. Ecrire une fonction tourner() qui utilisent les valeurs S, V pour faire tourner le moteur.
4. En vous inspirant des fonctions père et fils présentes dans "squelette.c", créer une application multithread :
* Le main utilise le menu précédent pour initialiser dans un premier temps des variables globales : V itesse etSens (seulement), qui seront utilisées par le fils.
* Puis le père, affiche en mode boucle infinie, un autre menu qui agit maintenant sur les interactions ’+’, ’-’(variation de la vitesse) ou ’q’ (pour quitter).
* Le père contrôle uniquement la vitesse, tandis que le fils réagit sur la commande du moteur. Pendant larotation du moteur gérée par le fils, le père, peut changer accéléérer la rotation du moteur en tapant par ’+’et ’-’ pour décélerer ou bien ’q’ pour arrêter.
* Le fils, lui, tourne désormais en boucle infinie, jusqu’à la frappe de la touche ’q’ détectée par le père transmiseau fils par la variable globale Q. Si le fils détecte que Q a été mis à un alors il s’arrête (pthread_exit). Lepère fait un pthread_join et se termine alors aussi.
3 Conclusion
En conclusion, chercher sur internet, un exemple d’application multithreadée : application de contrôle commande,calcul scientifique parallèle, . . . Vous donnerez pour cet exemple, une description du cahier des charges et une idée dupartitionnement en tâches (1 page).
3.1 Compte rendu
De plus, dans votre code, pour chaque sous-programme vous donnerez les informations en commentaires suivant :
/*--------------------------------------------------------------Fonction : nom de la fonction et des paramêtres avec leur types ;Entrées : Paramêtres en entrée de la fonction ;Sorties : paramêtres modifiés ou de sortie ;Variables globales utilisées ;Sous-programmes appelés ;Fonctionnement : description rapide/sommaire du fonctionnement.---------------------------------------------------------------*/
Ce qui est intéressant :
• Résultats d’exécution et analyse des résultats
• Copie d’écran, photos (gifs animés) des montages, de l’oscilloscope.
• Limiter le code : se concentrer sur les points clefs du code : Le code complet doit être relégué en annexe.
Ce qui N’EST PAS intéressant :
• La reprise de l’énnoncé
• Copié collé internet
2
TP SETR 2
Commande et Calcul Parallèle
D. Delfieu
August 24, 2018
Le but est d’insérer des threads de calcul à la commande de moteurs pas à pas réalisée lors du premier TP .
La conjecture
1de Syracuse
Lothar Collatz (1910-1990) était un mathématicien allemand. En 1937, il énonce la conjecture de Collatz connue égalementsous le nom de conjecture de Syracuse :
La suite de Syracuse de n
0importe quel entier strictement positif atteint 1
La suite dite de Syracuse se définit de la façon suivante :
8<
:
Un+1 = Un2 Si Un est pair
Un+1 = 3 Un + 1 Si Un est impair
U0 = N
Exemple : Syracuse(15) = 15 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1
1 Comprendre
1. Calculer la suite de Syracuse pour Un=17.
2. Coder en C la fonction syracuse_rec à l’aide de l’algo récursif suivant qui calcule une suite pour l’entier Un :
Syracuse(Un) begin
Afficher Un ;si Un == 1 alors
retourner 1fin
si (Un est impair) alors
retourner Syracuse(3 ⇤ Un + 1)fin
sinon
retourner Syracuse(Un/2)fin
end
Passage de paramètres à un main :On peut passer un ou plusieurs paramètres à un éxécutable :
# syracuse_rec 1500
Calcule par exemple la suite de syracuse du nombre 1500. Pour cela on passera au main, le nombre de paramêtre nbparamet le tableau des paramêtres param:
1Une conjoncture est une proposition non encore démontrée. Un théoréme est une conjoncture qui a été démontrée.
1
int main(int nbparam, char * param[]) {
long long int Un=(long long int) atoi(param[1]); /* transforme chaîne car. en int et forçage 64 bits */
syracuse(Un);
}
3. Coder en C la fonction syracuse_iter, à l’aide d’une boucle, qui calcule une suite pour l’entier Un :
4. Coder en C les fonctions NSyracuses_Iter et NSyracuses_Rec qui calculent toutes les suites de Syracuse de 0 à unnombre n, passé en paramètre.
#time NSyracuses_Iter 100000
#time NSyracuses_Rec 100000
a Au niveau des structures algorithmiques de contrôles : Comparer les fonctions itérative et récursive.
b Comparer, à l’aide de la commande time, les temps d’exécution des 2 versions pour de grands nombres. Vousdonnerez un tableau des temps d’exécutions.
2 Mise en parallèle d’une commande moteur et d’un calcul de suites de Syra-
cuse
• Reprendre sous la forme d’un thread la commande du moteur pas à pas. Ce thread commande en pas entier, à vitesserapide prédéterminé, dans un sens fixé, et en boucle infinie le moteur pas à pas.
• Insérer l’appel de fonction NSyracuses (iter ou rec) dans un thread pSyracuses.
• Créer un main qui parallélise ces deux threads et tester l’influence du calcul sur la commande du moteur avec de trésgrandes valeurs de N .
3 Parallèlisation du calcul des suites de Syracuse
On veux paralléliser le calcul des suites de tous les entiers compris entre 0 à nbsuites (saisi par l’utilisateur, nbsuites > 50).On veux donc calculer nbSuites suites de Syracuse en partageant ce calcul entre plusieurs threads. Pour cela, le main
récupère dans son premier paramètre la valeur nbSuites, constituant le nombre de suites à calculer pour chaque thread. Lavariable nbThread est défini à l’aide d’un #define. Modifier la fonction pSyracuses de façon à ce que en fonction d’un indice ielle calcule :
• Pour i = 0 elle calcule de bi = 50 à bs = bi+ nbsuites,
• Pour i = 1 elle calcule de bi = 50 + nbsuites à bs = bi+ nbsuites,
• Pour i = 2 elle calcule de bi = 50 + 2 ⇤ nbsuites à bs = bi+ 2 ⇤ nbsuites,
• . . .
Création de mutiples threads
• Compléter la fonction lesthreads() qui fait la création de nbThread threads. Ces threads vont produire chacun nbSuitessuites. On utilisera donc la boucle de création de threads suivante :
pthread_t ???; <---- variable ou tableau ?
for(i=0;i<N;i++)
pthread_create (???, NULL , pSyracuses , (void *)&i);
• Comparer les temps d’exécutions entre le calcul parallèle et non parallèle.
2
Parallélisation
Re-introduire la commande du moteur pas à pas et tester l’influence du calcul sur la commande de l’augmentation de nbThreadet nbSuites. Quel est le paramètre qui agit le plus sur la commande ?
3