Vous êtes sur la page 1sur 12

S Y S T EME D ’ E X P L O I T A T I O N

Projet 3

Le Processeur Et Les Systèmes


D’Exploitation
Index :
- Définir et décrire un processeur.

- Les architectures actuelles des processeurs.

- Définir l'opération d'ordonnancement de processus et ces types

- Pour chaque système d'exploitation décrire :

 L'ordonnancement de processus utilisé.

 Expliquer avec des exemples.

 Les avantages et les inconvénients

D’après :
-Merzougui Hanine.

-Boudersa Oumnia.

- G 03 (17).

Sous La Supervision Du :
.Mme Saadi Leila
1. Définir et décrire un processeur :

C’est un circuit électronique cadencé au rythme d'une horloge interne, grâce à un


cristal de quartz qui, soumit à un courant électrique, envoie des impulsions, appelées «
top ». La fréquence d'horloge (appelée également cycle, correspondant au nombre
d'impulsions par seconde, s'exprime en Hertz (Hz). Ainsi, un ordinateur à 200 MHz
possède une horloge envoyant 200 000 000 de battements par seconde. La fréquence
d'horloge est généralement un multiple de la fréquence du système (FSB, Front-Side
Bus), c'est-à-dire un multiple de la fréquence de la carte mère.

A chaque top d'horloge le processeur exécute une action, correspondant à une instruction ou une partie
d'instruction. L'indicateur appelé CPI (Cycles Par Instruction) permet de représenter le nombre moyen de cycles
d'horloge nécessaire à l'exécution d'une instruction sur un microprocesseur. La puissance du processeur peut
ainsi être caractérisée par le nombre d'instructions qu'il est capable de traiter par seconde. L'unité utilisée est le
MIPS (Millions d'Instructions Par Seconde) correspondant à la fréquence du processeur que divise le CPI.

Le processeur exécute 3 fonctions de base : recevoir des données d'entrée, traiter ces données et fournir des
données de sortie, et la plupart des entrées apparaîtront immédiatement à l'écran tout cela se fait en une
fraction de seconde. Il existe également d'autres types de processeurs qui peuvent être installés sur le système,
mais chaque processeur contient plusieurs fonctionnalités importantes. Voici les principaux :

Le séquenceur : ou unité de contrôle, se charge de gérer le processeur. Il peut décoder les instructions, choisir
les registres à utiliser, gérer les interruptions ou initialiser les registres au démarrage. Il fait appel à l'unité
d'entrée-sortie pour communiquer avec la mémoire ou les périphériques.

L'horloge : doit fournir un signal régulier pour synchroniser tout le fonctionnement du processeur. Elle
est présente dans les processeurs synchrones mais absente des processeurs asynchrones et des
processeurs auto synchrones. EXEMPLE : si un processeur a une horloge de 2 Gigahertz, il peut avoir
jusqu'à 2 milliards de cycles par seconde, donc plus la fréquence d'horloge est élevée, le plus le temps
d'exécution sera bas, ce qui signifie un processeur plus rapide.

Les registres : sont des petites mémoires internes très rapides, pouvant être accédées facilement. Un plus grand
nombre de registres permettra au processeur d'être plus indépendant de la mémoire. La taille des registres
dépend de l'architecture, mais est généralement de quelques octets et correspond au nombre de bit de
l'architecture (un processeur 8 bits aura des registres d'un octet).

Le cache: c'est la mémoire auxiliaire d'un processeur où le plus accédé qui sera traité est identifié puis
stocké, le processeur a accédé à cette mémoire et est capable d'exécuter l'action plus rapidement car elle
est plus facilement disponible, c'est un facteur plus important qui a un impact direct sur la vitesse du
processeur, le plus il y a de cache, plus la capacité est rapide, ce qui se traduit par une vitesse plus rapide

Il existe plusieurs types de processeurs mais Les deux


principaux constructeurs de processeurs
actuellement sont AMD et Intel.

Intel a été créé en 1968 et c’est actuellement le


premier constructeur mondial de processeurs. AMD a
été fondé en 1969 en Californie, c’est le deuxième
constructeur mondial de processeurs.
Le processeur intel Celeron :

Premier constructeur de microprocesseurs au monde, Intel détient près de 80 % du


marché CPU et équipe la majorité des Pc portables et de bureau,

ainsi que tous les Macs d’Apple en processeurs, grâce à une offre
complète et diversifiée. Parmi ses gammes les plus connues, l’on
compte l’Intel Atom, l’Intel Pentium, l’Intel Core i3, l’Intel Core i5,
l’Intel Core i7, l’Intel Core i9, l’Intel Xeon… et l’Intel Celeron .

Le terme “Celeron” fait référence à une gamme de processeurs


équipant les ordinateurs bon marché, développée par la société Intel.

L’Intel Celeron a été créé en 1998 pour faire face à la concurrence d’autres fabricants alors positionnés sur les
microprocesseurs d’entrée de gamme, à l’image d’AMD et de Curix, à l’époque.

Processeur peu puissant, le Celeron a donc davantage été conçu dans un souci d’économie que de performance,
pour répondre à une demande croissante d’ordinateurs à prix abordables. Il est intégré aussi bien dans des Pc
portables que dans des Pc de bureau.

1. Les architectures actuelles des processeurs :


L'architecture x86 est l'architecture des processeurs CISC de Intel et AMD notamment.
X86 est une architecture CISC. Le nombre d’instruction est un facteur important comme tous les architectures
CISC avec toutes les autres instructions. De plus, comme les instructions sont complexes en CISC, elles peuvent
prendre>1 pour se terminer, alors que dans RISC, elles devraient être en un seul cycle. Les principales
différences se trouvent ici :
+------------------------------+------------------------------+
| CISC | RISC |
+------------------------------+------------------------------+
| Emphases on hardware | Emphases on software |
| . | |
| Includes multi-clock | Single-clock, |
| complex instructions | reduced instruction only |
| . | |
| Memory-to-memory: | Register to register: |
| "LOAD" and "STORE" | "LOAD" and "STORE" |
| incorporated in instruction | are independent instructions |
| . | |
| Small code sizes, | Low cycles per second, |
| high cycles per second | large code sizes |
| . | |
| Transistors used for storing | Spends more transistors |
| complex instructions | on memory registers |
+------------------------------+------------------------------+
x86-64, ou x64, est une extension du jeu d'instructions x86 d'Intel, introduite par la société AMD avec la
gamme AMD64. Intel utilisera cette extension en l'appelant initialement EM64T renommé aujourd'hui en Intel
64.
-Cette extension permet la gestion des nombres sur 64 bits, avec pour corollaire un adressage mémoire
possible bien au-delà de la limite des 4 Go.
· -À cela s'ajoute le doublement (de 8 à 16) du nombre de registres généralistes et vectoriels (SSE).
Le jeu d'instruction de l'architecture AMD x86-64 est une extension de l'architecture Intel IA-32 (x86-32). Les
caractéristiques principales de l'architecture AMD64 sont le support de registres généraux de 64 bits, de
l'arithmétique des entiers et des opérations logiques 64 bits ainsi que des adresses virtuelles 64 bits. Les
créateurs ont profité de l'opportunité d'une nouvelle architecture pour proposer d'autres améliorations, incluant
principalement :
Support complet des entiers 64 bits : tous les registres généraux (GPRs : General Purpose Registers) passent de
32 à 64 bits et toutes les opérations logiques et arithmétiques, de la mémoire vers les registres et des registres
vers la mémoire, etc. sont disponibles nativement pour les entiers 64 bits. Les push (empilement) et
les pop (dépilement) sur la pile sont toujours d'une largeur de 8 octets (64 bits), de même que les pointeurs.

Registres supplémentaires : le nombre des registres généraux est doublé pour atteindre 16. Il y a par conséquent
moins besoin de sauvegarder les registres, de les restaurer et plus généralement de les manipuler ; la plupart
des arguments de la plupart des fonctions peut de même être passée par les registres plutôt que sur la pile. À
titre de comparaison l'architecture PowerPC 970 dispose de 32 GPRs. La taille et le nombre de registres est en
effet un des points faible du x86. Avec des applications optimisées, on peut attendre un gain de performances,
notamment pour les programmes disposant de nombreuses boucles.
Registres XMM supplémentaires : de
manière similaire, le nombre de
registres XMM (utilisés pour les
instructions SIMD) est aussi
augmenté de 8 à 16.
Espace mémoire virtuelle plus
grand : les modèles de processeurs
implémentant actuellement
l'architecture AMD64 peuvent
adresser jusqu'à
256 tébioctets d'adresse mémoire
virtuelle (248 octets). Cette limite
peut être étendue dans de futures
implémentations à
16 exbioctets (264 octets). Ceci peut
être comparé aux 4 gibioctets pour
les architectures x86 32 bits.
Espace mémoire vive plus grand : les
modèles de processeurs
implémentant actuellement l'architecture AMD64 peuvent adresser 1 tébioctet d'adresses mémoire vive. Cette
limite peut être étendue dans de futures implémentations à 4 pébioctets (252 octets) (limités par le format des
entrées de la table de page). En legacy mode (mode compatible x86), l'extension PAE (Physical Address
Extension) est supportée, comme sur les processeurs x86 32 bits les plus courant, autorisant l'accès à un
maximum de 64 gibioctets.
Accès aux données relatives au pointeur d'instruction : les instructions peuvent désormais référencer les données
relativement au pointeur d'instruction (registre RIP). Ceci permet de générer du code indépendant de la position
du programme en mémoire (PIC, ou Position Independent Code) plus efficace ; ceci est souvent utilisé dans les
bibliothèques partagées ou les codes chargés à l'exécution.
Instructions SSE : l'architecture originale AMD64 a adopté les instructions SSE et SSE2 au sein du cœur du
processeur. Les instructions SSE3 ont été ajoutées en avril 2005. SSE2 remplace le jeu d'instructions x87 de
80 bits de précision, incluant le choix d'opérations mathématiques flottantes en 32 ou 64 bits. Ceci permet des
opérations en virgule flottante compatibles avec les autres CPUs modernes. Les instructions SSE et SSE2 ont
aussi été étendues pour supporter les huit nouveaux registres XMM. SSE et SSE2 sont disponibles en 32 bits sur
les processeurs x86 modernes ; cependant s'ils sont utilisés par des programmes 32 bits, ces derniers ne
pourront fonctionner que sur des processeurs supportant ces instructions. Ceci n’est pas un problème pour des
programmes 64 bits, du fait que tous les
processeurs AMD64 supportent ces jeux
d'instructions. Utiliser les instructions SSE et
SSE2 au lieu des x87 ne réduit alors pas le
nombre de plates-formes sur lesquelles les
programmes pourront fonctionner. Du fait
que les instructions SSE et SSE2 sont
généralement plus rapides et fournissent
les mêmes fonctionnalités que les
jeux MMX et 3DNow !, ces derniers sont
considérés comme dépassés sur AMD64.
No-Execute bit : le bit 'NX' (bit 63 des
entrées de la table des pages) permet au
système d'exploitation de spécifier quelles
pages d'adresse mémoire virtuelle peuvent
contenir du code exécutable et quelles
pages ne le peuvent pas. Une tentative
d'exécuter du code d'une page identifiée
comme ‘no execute’ provoquera une
violation d'accès mémoire, identique à celle
générée lors d'une tentative d'écriture sur
une page en mode « lecture seule ». Ceci
devrait rendre plus difficile pour un code
malicieux de prendre le contrôle du
système via les attaques par « buffer
overrun » ou liées à des problèmes de
vérification des tampons mémoire. Une
fonctionnalité identique était déjà
disponible sur les processeurs x86 depuis
le 80286 à l'aide d'un attribut des
descripteurs de segment, mais ne peut alors s'appliquer qu'à
un segment entier. L'adressage par segment est considéré
comme obsolète depuis longtemps et tous les systèmes
d'exploitation actuels pour PC ne l'utilisent effectivement
pas, en plaçant l'adresse de base de chacun d'entre eux à 0 et
sa taille à 4 gigaoctets. AMD a été le premier vendeur de la
famille x86 à supporter l'accès non exécutable en mode
d'adressage linéaire. Cette fonctionnalité est aussi disponible
en mode ‘legacy’ sur les processeurs AMD64, ainsi que les
processeurs Intel x86 récents, avec l'utilisation du mode PAE.
Suppression de fonctionnalités anciennes : un certain nombre
de fonctionnalités de programmation système de
l'architecture x86 non utilisées dans les systèmes
d'exploitation modernes ne sont plus disponibles sur AMD64
en « long mode ». Ceci inclut l'adressage mémoire segmenté
(bien que les segments FS et GS subsistent, pour la compatibilité avec le code Windows), le mécanisme de
changement de tâches (task switch) et le Mode virtuel 8086. Ces fonctionnalités subsistent en « legacy mode »,
pour permettre à ces processeurs d'exécuter complètement les codes 32 et 16 bits sans modification. Si, dans le
futur, ne devrait plus subsister de code 32 bits utilisant ces fonctionnalités, leur support pourrait être supprimé
des
processeurs pour améliorer la conception des processeurs et économiser sur les coûts de production. Ces
fonctionnalités pourraient de plus être émulées par le système d'exploitation pour préserver la compatibilité
avec les applications « legacy ».

2. Définition l'opération d'ordonnancement de processus et ces types :

Définition : La fonction d'ordonnancement gère le partage du processeur entre les différents processus en
attente pour s'exécuter, c'est-à-dire entre les différents processus qui sont dans l'état prêt. L'opération
d'élection consiste à allouer le processeur à un processus. L’ordonnanceur (scheduler en anglais) est un
programme du SE qui s'occupe de choisir, selon une politique (ou algorithme) d'ordonnancement donnée, un
processus parmi les processus prêts pour lui affecter le processeur.

L’ordonnancement règle les transitions d’un état à un autre des différents processus. Cet ordonnancement a
pour objectifs de :

-Maximiser l’utilisation du processeur ; - Avoir un bon rendement ;

- Être équitable entre les différents processus ;

- Présenter un temps de réponse acceptable ; -Assurer certaines priorités.

La figure schématise le fonctionnement d'une machine


multiprocessus. Plusieurs processus sont présents en mémoire
centrale. P1 est élu et s'exécute sur le processeur. P2 et P4
sont dans l'état bloqué car ils attentent tous les deux une fin
d'entrée/sortie avec le disque. Les processus P3, P5 et P6
quant à eux sont dans l'état prêt : ils pourraient s'exécuter (ils
ont à leur disposition toutes les ressource s nécessaires) mais
ils ne le peuvent pas car le processeur est occupé par P1.
Lorsque P1 quittera le processeur parce qu'il a terminé son
exécution, les trois processus P3, P5 et P6 auront tous les trois
le droit d'obtenir le processeur. Mais le processeur ne peut
être alloué qu'à un seul processus à la fois : il faudra donc
choisir entre P3, P5 et P6 : c'est le rôle de l’ordonnancement qui élira un des trois processus.

Les types d'ordonnancement de processus :

La figure reprend le graphe d'états tel qu'il a été vu à la leçon précédente concernant les processus. Une
transition a été cependant ajoutée entre l'état élu et l'état prêt : c'est la transition de préemption. La
préemption correspond à une opération de réquisition du processeur, c'est-à-dire que le processeur est retiré au
processus élu alors que celui-ci dispose de toutes les ressources nécessaires à la poursuite de son exécution.
Cette réquisition porte le nom de préemption.

Selon si l'opération de réquisition du processeur est autorisée ou non, l'ordonnancement sera qualifié
d'ordonnancement préemptif ou non préemptif :

● Si l'ordonnancement est non préemptif, la transition de l'état élu vers l'état prêt est interdite : un processus
quitte le processeur s’il a terminé son exécution ou s’il se bloque. In processus ne perd le processeur que quand
il relâche volontairement le processeur (ex : primitive de synchronisation bloquante)
● Si l'ordonnancement est préemptif, la transition de l'état élu vers l'état prêt est autorisée : un processus quitte
le processeur s’il a terminé son exécution, s’il se bloque ou si le processeur est réquisitionné. Un processus peut
perdre involontairement le processeur (réquisition)

Ordonnancement de processus Partage en temps processeur entre activités parallèles.

L’Ordonnancement préemptif : un processus peut


être interrompu en tout point – y compris le pire !

if (condition) {

// Je fais quelque chose

// Condition peut ne plus être vérifiée ! }

Aucune décision ne doit prendre en compte le


temps (réel)

Ordonnancement sous le système Unix :

Les opérations relatives à l’ordonnancement sont réalisées par le système Unix à chaque fois qu'un processus
s'apprête à passer du mode système au mode utilisateur, donc à la suite de l'occurrence soit d'une interruption,
d'un appel système ou d'une trappe. La politique
d'ordonnancement du système Unix est une politique à
multiples niveaux de priorité avec quantum de temps. Le
noyau recalcule la priorité d'un processus quand il passe du
mode noyau au mode utilisateur. Dans une première
approche, ce calcul permet une extinction de priorité des
processus qui s'exécutent de manière à permettre l'exécution
de tous les processus et à éviter les problèmes de famine

La priorité de chaque processus est codée dans l'entrée de la


table des processus qui lui correspond. La plage des priorités
des processus est partitionnée en deux sous-ensembles.
Chaque ensemble contient plusieurs niveaux de priorités et à
chaque niveau de priorité est associé une file d'attente

Algorithmes d'ordonnancement mis en œuvre


L'algorithme mis en œuvre s'appuie sur la routine d'interruption horloge qui fait régulièrement passer le
processus en mode noyau. Plus précisément : ● A chaque interruption horloge, le système incrémente d’une
unité la valeur du champ "utilisation du processeur" pour le processus élu.● Toutes les secondes c'est-à-dire
toutes les 50 à 100 interruptions horloge, la valeur du champ
"utilisation du processeur" pour tous les processus est divisée par
deux. Puis la priorité des processus est recalculée selon la formule
suivante : priorité du processus = Utilisation du processeur /2 +
(priorité de base du niveau utilisateur) Du fait de ce recalculé des
priorités ; les processus se déplacent dans les files de priorité

Un exemple de mise en œuvre On considère trois processus A, B et


C qui ont chacun une priorité initiale de 60. La priorité de base du
niveau utilisateur est également la priorité 60. L'interruption
horloge se déclenche 60 fois par seconde. A l'instant 0, le processus
A est élu. Chaque seconde, l'interruption horloge survient et le
champ "utilisation du processeur " (compte UC sur la figure 10) est
incrémenté de une unité. Au bout de 60 secondes (instant t = 1), la
priorité des processus est recalculée. Du fait que les processus B et C ne se sont pas encore exécutés leur
priorité est inchangée (le compte UC est nul pour ces processus). La priorité du processus A par contre baisse et
devient égale à 75 (60 + 30/2). C'est donc le processus B qui est à présent élu. A l'instant 2, de nouveau les
priorités sont recalculées. Le compte UC du processus C étant toujours nul, la priorité de ce processus n'est pas
modifiée. Les priorités du processus A et B par contre évoluent et deviennent respectivement égales à 67 pour le
processus A (60 + 15/2) et à 75 pour le processus B. On voit à présent que le processus A a une priorité qui
remonte du fait qu'il n'a pas pu utiliser l'unité centrale.

Les inconvénients :

 Il offre une interface utilisateur hostile.


 Les utilisateurs doivent comprendre toutes les fonctionnalités principales.
 Il offre une richesse en services publics qui peut être écrasante.
 Il offre des commandes cryptiques qui peuvent être difficiles à comprendre.
 Il vous permet de personnaliser les commandes pour les dialectes locaux.
 Il nécessite une entrée de précision pour être utile.

Ordonnancement sous le système Windows :

L’algorithme d’ordonnancement de Windows est semblable à celui du VAX/VMS : il est basé sur une priorité qui
peut changer au cours de l’exécution des processus. Windows ordonne des threads, sans se préoccuper de
savoir à quel processus ils appartiennent. On n’utilise pas un ordonnanceur autonome : quand un thread ne peut
plus continuer à s’exécuter, il se met en mode superviseur pour exécuter la routine d’ordonnancement. S’il
signale un objet (UP sur un sémaphore, par exemple), il vérifie s’il n’a pas ainsi réveillé un thread plus prioritaire
auquel il doit céder sa place. Si le quantum est expiré et que le thread est sélectionné à nouveau, on lui attribue
un nouveau quantum.

Deux autres situations exigent l’exécution de la routine d’ordonnancement :

– Une entrée/sortie vient d’être complétée

– Un timeout vient d’expirer (ce qui va en général réveiller un thread)

Un appel SetPriorityClass fixe la priorité de base pour tout le thread d’un processus. Les valeurs possibles sont
(en ordre décroissant de priorité) : realtime, high, above normal, normal, below normal et idle. Un appel
SetThreadPriority permet de fixer la priorité d’un thread par rapport aux autres du même processus. Les valeurs
permises sont : time critical, highest, above normal, normal, below normal, lowest et idle. Selon la combinaison de
ces deux attributs, on attribue à un thread une valeur de priorité entre 0 et 31, qu’on appelle priorité de base. En
plus, chaque thread a une priorité courante qui varie dynamiquement : elle peut être plus haute que la priorité
de base. À chaque valeur de priorité une file d’attente est associée et Windows parcourt ces files de manière
classique. Chaque file est traitée par l’algorithme du tourniquet. L’ordonnancement des threads se fait sans tenir
compte du processus auquel il appartient. Le tableau des priorités est divisé en trois segments :

– Temps réel (16 à 31) : priorité fixe, chaque niveau géré par un tourniquet

– Utilisateur (1 à 15) :

- Les processus migrent d’un niveau à l’autre en -Favorise les processus interactifs (ex. E/S clavier,
fonction de la consommation de leur souris, écran…)
quantum, et du type d’E/S qu’ils effectuent.
– Thread 0 (0)

Seul le SE peut manipuler le segment temps réel. Le thread 0 n’est exécuté que lorsqu’il n’y a aucun autre
thread : il initialise à zéro les pages de mémoire. S’il n’y a vraiment rien à faire, un thread idle s’exécute.

C’est la priorité courante d’un thread qui est considérée pour l’ordonnancement. La priorité courante d’un
thread utilisateur, qui est initialement la priorité de base, peut être augmentée dans certaines circonstances :

– Le thread vient d’être libéré d’une attente d’entrée/sortie (ex. +1 pour disque, +6 pour clavier, +8 pour carte
son)

– Le thread vient d’être libéré d’une attente sur un sémaphore (ex +2 pour thread d’un processus en premier
plan et +1 pour les autres)

Lorsqu’un thread a expiré son quantum, se priorité descend de 1 jusqu’ à ce qu’il revienne à sa priorité de base.

Pour éviter les inversions de priorité, Windows utilise la technique suivante :

– Quand un thread n’a pas été exécuté depuis un – Un thread non prioritaire mais qui détient un
temps qui dépasse un seuil pré spécifié, il passe à la sémaphore aura donc la chance de le débloquer
priorité 15 pour deux quanta pour redonner le contrôle à un thread plus
prioritaire en attente sur ce sémaphore

Sur un système à N processeurs

 les N-1 processus les plus prioritaires ont Finalement, Un thread associe à une fenêtre qui
chacun un processeur vient d’être activée reçoit un plus gros quantum
 tous les autres processus se partagent le (typiquement 3 X quantum normal).
dernier processeur

Avantages Inconvénients

-Support pour tout le matériel. -Attaques virales.


-Facilité d'utilisation. -La plupart des logiciels sont payés.
-Support logiciel. -Redémarrer un système.
-Bureau et écran tactile. -Prix élevé.
-Ressources informatiques élevées.
-Mauvais support technique.

Ordonnancement sous le système Android :

Preemptive multitasking was first implemented in the late 1960s. In those days spirits were brave, the stakes

were high, men were real men, women were real women, and small furry creatures from Alpha Centauri were

real small furry creatures from Alpha Centauri. (Douglas Adams, The Hitchhiker’s Guide to the Galaxy). Although

many dared to do mighty deeds, it was sadly a different era. There was but just one CPU, multi-core processors

didn’t exist and the idea that the operating system needed to take into account the amount of energy available

was but a twinkle in some clever engineer’s eye.


Zoom forward several decades and we live in an age where mobile phones have more computing power than

NASA used to go to the moon, processors are multi-core, and the scheduler now needs to consider battery life.

In 2014 ARM released a new piece of tech for the Linux kernel called Intelligent Power Allocation (IPA). Keeping a

SoC at its nominal operating temperatures is essential for fanless designs (like your smartphone or tablet). The

busier a processor gets, the more heat it generates. In a hexa-core or octa-core processor you will find high

performance “big” cores (like the Cortex-A72 or the Cortex-A57), and energy efficient “LITTLE” cores (like the

Cortex-A53 or soon the Cortex-A35), plus there is the GPU. These three different parts of the SoC can be

controlled independently and by controlling them in unison a better power allocation scheme can be created.

This means that if the CPU is generating too much heat then the scheduler might favor the LITTLE cores to

reduce the power used. If the GPU is being used a lot, but the CPU isn’t, then there is room in the thermal

budget to let the GPU run at full speed, since the CPU isn’t using all of its allocation.

ARM’s patches were duly accepted into the mainstream Linux kernel and the benefits can be quite

substantial. According to ARM’s tests, using IPA can increase the performance of a SoC by as much as 36%. The

reason the performance goes up is because the SoC is being tuned dynamically and every bit of the thermal

budget is used. This means that the CPU or the GPU is able to run at maximum speed whenever the thermal

budget allows.

That was 2014. In 2015 and on into 2016 ARM has started working with the Linux community on the next phase,

called Energy Aware Scheduling (EAS). The EAS project is trying to solve a long-standing design limitation of the

two key Linux power-management subsystems (CPUFreq and CPUIdle), namely they don’t coordinate their

decisions with the scheduler.

In fact it is a little worse than that, the scheduler,

CPUFreq and CPUIdle subsystems work in isolation, at

different time scales and often at cross-purposes with

each other. As the scheduler tries to balance the load

across all CPUs, the CPUFreq and CPUIdle subsystems

are trying to save power by scaling down the

frequency of the CPUs or idling them.


The idea behind EAS is to integrate the CPUFreq (i.e. DVFS), CPUIdle and the IPA subsystems. The new design will

be based on measurable energy model data rather than magic tunables; will support future CPU topologies

(including per core/per cluster Dynamic Voltage & Frequency Scaling); and will be maintained in the main Linux

kernel.

What this means in real terms is that if a new task is

waiting for some CPU time then the ESA might assign the

task to a core that is actually active rather than using

an idle core, this then means that the other idle cores

don’t need to be spun-up, which takes power. Previously,

when the scheduler was working only for max

performance then it might have opted to place the

incoming task onto a idle CPU core, as it is free and unloaded, thus giving the best performance.

Initial testing has shown that energy usage can be much lower when compared to the current mainline Linux

kernel while maintaining the same level of performance. In fact, under some loads the performance can actually

increase slightly.

This is on going work. The first generation of EAS is expected during 2016, but after that ARM and Linaro have

plans for a second generation implementation with even tighter iteration.

Advantages Disadvantages

 Millions of apps  Apps run in the background

 Third-party apps also supported  Low specification mobiles run slow

 Sharing of internet among devices  Android is not good at virus protection

 Expandable memory

 Run many apps at the same time

 Large community support

 Android is Open source

 Cloud storage
Resources:

 Wikipedia
 Univ-lille1.fr/˜sedoglav/OS/
 universite de Rouan/T .Paquet/ Architectures des microprocesseurs/Master1
 kiatoo.com
 https://fr.wikipedia.org/
 https://perso.liris.cnrs.fr/
 https://rmdiscala.developpez.com/
 https://web.maths.unsw.edu.au/
 https://www.clicours.com/
 https://slideplayer.fr/
 http://deptinfo.cnam.fr/
 https://www.lrde.epita.fr/
 http://www.azillionmonkeys.com/
 http://www.azillionmonkeys.com/
 https://levelup.gitconnected.com/
 https://cs.stanford.edu/
 https://commons.wikimedia.org/
 https://support.microsoft.com/
 https://forums.commentcamarche.net/
 https://www.androidauthority.com/
 ProcessusEtOrdonnancement.pdf
 SEL-CM.pdf
 chap8.pdf
 transparents-systeme.pdf
 mps.pdf

Vous aimerez peut-être aussi