QCM en informatique générale avec la correction pour la préparation des concours, des tests, aux examens et aux certifications. Ces questions et réponses sur l’informatique générale comprennent divers sujets. Et sont tirés d’un vrai concours écrit et certaines parties sont tirés d’un entretien orale. Cette méthode d’apprentissage systématique préparera facilement toute personne pour réussir son concours.
 
 

1. Quel est le rôle principal du processeur dans un ordinateur ?

A Stocker les données

B Exécuter les instructions du programme

C Afficher les informations à l’écran

D Connecter l’ordinateur à Internet

2. Le cerveau de tout système informatique est _________?

A CPU

B Mémoire

C Unité de contrôle

D Unité arithmétique et logique – ALU

E Aucune de ces réponses n’est vraie.

3. Quel est le rôle d’un système d’exploitation ?

A Exécuter les applications

B Gérer le matériel et les ressources de l’ordinateur

C Créer des fichiers de données

D Gérer la sécurité du réseau

4. Qu’est-ce qu’une adresse IP ?

A Une unité de mesure de la vitesse de connexion

B Un identifiant unique pour un appareil sur un réseau

C Un protocole de communication utilisé sur Internet

D Une méthode de sécurité pour les réseaux sans fil

5. Quelle est la fonction de la mémoire vive (RAM) dans un ordinateur ?

A Stocker les fichiers à long terme

B Exécuter les applications

C Stocker temporairement les données utilisées par le processeur

D Connecter l’ordinateur à Internet

6. Quelle est la principale fonction d’un pare-feu (firewall) ?

A Crypter les données sensibles

B Bloquer les logiciels malveillants

C Filtrer le trafic réseau pour empêcher les connexions non autorisées

D Gérer les mots de passe des utilisateurs

7. Quel langage de programmation est principalement utilisé pour le développement web côté serveur ?

A Python

B JavaScript

C HTML

D PHP

8. ASCII signifie _______?

A American standard code for information interchange

B All purpose scientific code for information interchange

C American security code for information interchange

D American Scientific code for information interchange

E Aucune de ces réponses n’est vraie.

9. Quel est le type de mémoire le plus rapide ?

A Mémoire cache

B Disque dur (HDD)

C Mémoire flash (SSD)

D Mémoire RAM

10. GUI signifie _______?

A Graph Use Interface

B Graphical Universal Interface

C Graphical User Interface

D Graphical Unique Interface

E Aucune de ces réponses n’est vraie.

11. Quel est le rôle d’un logiciel antivirus ?

A Optimiser la performance de l’ordinateur

B Protéger l’ordinateur contre les logiciels malveillants

C Organiser les fichiers sur l’ordinateur

D Gérer la connexion à Internet

12. Qu’est-ce qu’une base de données relationnelle ?

A Une base de données sans structure

B Une base de données qui organise les données sous forme de tables interconnectées

C Un système de stockage de fichiers non structurés

D Une base de données exclusivement utilisée pour les images

13. Quel est le rôle de HTML dans le développement web ?

A Il gère les bases de données

B Il est utilisé pour les calculs mathématiques dans les pages web

C Il permet d’ajouter des animations aux pages web

D Il structure le contenu d’une page web

14. Un chatbot est un exemple de ____________

A Système expert

B Intelligence artificielle

C Application mobile

D Système de gestion de bases de données

15. Qu’est-ce que le cloud computing ?

A Un logiciel antivirus

B Un type de virus informatique

C L’utilisation de serveurs distants pour stocker et gérer des données

D Un type de disque dur

L’article QCM En Informatique Générale – Partie 1 est apparu en premier sur WayToLearnX.

QCM en informatique générale avec la correction pour la préparation des concours, des tests, aux examens et aux certifications. Ces questions et réponses sur l’informatique générale comprennent divers sujets. Et sont tirés d’un vrai concours écrit et certaines parties sont tirés d’un entretien orale. Cette méthode d’apprentissage systématique préparera facilement toute personne pour réussir son concours.
 
 

1. Toute donnée ou instruction entrée dans la mémoire d’un ordinateur est considérée comme _____?

A Stockage

B Sortie

C Entrée

D Information

E Aucune de ces réponses n’est vraie.

2. Le temps pendant lequel une tâche est traitée par l’ordinateur est appelé _______?

A Temps d’exécution

B Temporisation

C Temps réel

D Temps d’attente

E Aucune de ces réponses n’est vraie.

3. Lequel des circuits suivants est utilisé comme « Périphériques de mémoire » sur les ordinateurs?

A Bascules

B Comparator

C Attenuator

D Aucune de ces réponses n’est vraie.

4. Lequel des énoncés suivants est faux?

A Photoshop est un outil de conception graphique par Adobe

B Linux est un logiciel libre et open source

C Linux est vendu par Microsoft

D Windows XP est un système d’exploitation

E Aucune de ces réponses n’est vraie.

5. Pour indiquer à Excel que nous voulons entré une formule dans une cellule, nous devons commencer par un opérateur tel que _______?

A $

B #

C =

D +

E @

6. Une erreur est aussi appelée _________?

A Bug

B Debug

C Curseur

D Icon

E Aucune de ces réponses n’est vraie.

7. Lequel des éléments suivants n’est pas un package d’application?

A Open Office

B Adobe Pagemaker

C Microsoft Office

D Red Hat Linux

E Aucune de ces réponses n’est vraie.

8. Microsoft Word est un exemple de _________?

A Système d’exploitation

B Dispositif de traitement

C Logiciel applicatif

D Périphérique d’entrée

E Logiciel système

9. La taille du mémoire des ordinateurs mainframe et de technologie avancée s’exprime en _________?

A Octets

B Kilo Octets

C Bits

D Mega Octets

E Aucune de ces réponses n’est vraie.

10. La communication offerte par TCP est _________?

A Full-duplex

B Half-duplex

C Semi-duplex

D Octet par octet

E Aucune de ces réponses n’est vraie.

L’article QCM En Informatique Générale – Partie 2 est apparu en premier sur WayToLearnX.

QCM en informatique générale avec la correction pour la préparation des concours, des tests, aux examens et aux certifications. Ces questions et réponses sur l’informatique générale comprennent divers sujets. Et sont tirés d’un vrai concours écrit et certaines parties sont tirés d’un entretien orale. Cette méthode d’apprentissage systématique préparera facilement toute personne pour réussir son concours.
 
 

1. Quel est le rôle du disque dur (HDD) dans un ordinateur ?

A Exécuter des programmes

B Stocker de manière permanente les données et les programmes

C Augmenter la vitesse de traitement des données

D Gérer les périphériques externes

2. Que signifie l’acronyme « HTTP » ?

A Hyper Text Transfer Protocol

B High Tech Transfer Program

C Hyper Type Transfer Protocol

D High Time Transfer Protocol

3. Qu’est-ce qu’un « virus informatique » ?

A Un programme utile qui protège l’ordinateur

B Un programme qui permet de naviguer sur Internet

C Un programme malveillant qui peut endommager un ordinateur

D Un périphérique externe

4. Quel est l’outil utilisé pour naviguer sur Internet ?

A Un antivirus

B Un navigateur web

C Un moteur de recherche

D Un serveur

E Aucune de ces réponses n’est vraie.

5. Qu’est-ce qu’un fichier « ZIP » ?

A Un programme de traitement de texte

B Un format de fichier compressé

C Un type de virus informatique

D Un périphérique de stockage

E Aucune de ces réponses n’est vraie.

6. Quel est le rôle de la carte mère d’un ordinateur ?

A Gérer la mémoire de l’ordinateur

B Exécuter les programmes

C Connecter et permettre la communication entre les composants matériels

E Gérer l’affichage à l’écran

7. Qu’est-ce que le BIOS dans un ordinateur ?

A Un type de système d’exploitation

B Un logiciel de gestion des fichiers

C Un programme qui permet de configurer les composants matériels avant le démarrage du système d’exploitation

D Un périphérique externe

E Aucune de ces réponses n’est vraie.

8. Que signifie l’acronyme « USB » ?

A Universal Serial Bus

B Unified System Base

C Universal Service Block

D Un System Bus

9. Quel est le rôle d’un « routeur » dans un réseau informatique ?

A Convertir les signaux analogiques en numériques

B Connecter plusieurs ordinateurs à Internet via un réseau local

C Protéger l’ordinateur des virus

D Stocker les données sur le réseau

10. Qu’est-ce qu’un « logiciel open source » ?

A Un logiciel dont le code source est librement accessible et modifiable

B Un logiciel gratuit et sans licence

C Un logiciel payant avec des fonctionnalités avancées

D Un logiciel uniquement disponible en ligne

L’article QCM En Informatique Générale – Partie 3 est apparu en premier sur WayToLearnX.

QCM en informatique générale avec la correction pour la préparation des concours, des tests, aux examens et aux certifications. Ces questions et réponses sur l’informatique générale comprennent divers sujets. Et sont tirés d’un vrai concours écrit et certaines parties sont tirés d’un entretien orale. Cette méthode d’apprentissage systématique préparera facilement toute personne pour réussir son concours.
 
 

1. Qu’est-ce qu’un « système de fichiers » ?

A Un type de virus

B Un système permettant d’organiser, stocker et récupérer des fichiers sur un disque

C Un programme de traitement de texte

D Un outil pour améliorer la sécurité des fichiers

2. Quelle est la principale différence entre un disque dur (HDD) et un disque SSD ?

A Le disque SSD est plus lent que le disque HDD

B Le disque HDD est plus rapide que le disque SSD

C Le disque SSD utilise des puces mémoire pour stocker les données, tandis que le disque HDD utilise des disques magnétiques

D Le disque HDD est plus cher que le disque SSD

3. Qu’est-ce que le « phishing » ?

A Un type de programme antivirus

B Une technique de vol de données personnelles par des faux sites ou emails

C Un type de malware qui dégrade les performances d’un ordinateur

D Un type de logiciel utilisé pour crypter les fichiers

4. Quel protocole est utilisé pour envoyer des emails ?

A FTP

B HTTP

C SMTP

D DNS

5. Qu’est-ce que Python ?

A Un logiciel antivirus

B Un langage de programmation utilisé pour écrire des programmes

C Un système d’exploitation

D Un outil de compression de fichiers

6. Qu’est-ce qu’une « adresse MAC » ?

A Un identifiant unique attribué à un réseau sans fil

B Un identifiant unique attribué à un périphérique réseau, tel qu’une carte réseau

C Un type de malware

D Une adresse email

7. Qu’est-ce qu’une « extension de fichier » ?

A Un type de fichier compressé

B Une partie du nom de fichier qui indique son format ou son type

C Un programme utilisé pour modifier un fichier

D Un type de virus informatique

8. Que fait une « clé USB » ?

A Permet d’afficher des documents sur un écran

B Permet de transférer et stocker des données

C Permet d’accélérer la connexion Internet

D Permet de protéger l’ordinateur contre les virus

9. Qu’est-ce qu’un « logiciel de traitement de texte » ?

A Un programme permettant d’écrire, modifier et imprimer des documents

B Un logiciel permettant de créer des images

C Un programme de gestion de base de données

D Un logiciel de navigation Internet

10. Quel est le rôle de « DNS » (Domain Name System) ?

A Stocker des fichiers à distance

B Traduire les noms de domaine en adresses IP

C Créer des sites web

D Protéger les utilisateurs contre les malwares

L’article QCM En Informatique Générale – Partie 4 est apparu en premier sur WayToLearnX.

QCM en informatique générale avec la correction pour la préparation des concours, des tests, aux examens et aux certifications. Ces questions et réponses sur l’informatique générale comprennent divers sujets. Et sont tirés d’un vrai concours écrit et certaines parties sont tirés d’un entretien orale. Cette méthode d’apprentissage systématique préparera facilement toute personne pour réussir son concours.
 
 

1. Qu’est-ce qu’un « moteur de recherche » ?

A Un logiciel qui protège les données des utilisateurs

B Un programme permettant de naviguer sur Internet

C Un site web permettant de rechercher des informations sur Internet

D Un type de connexion sans fil

2. Que signifie l’acronyme « URL » ?

A Uniform Resource Locator

B Universal Resource Library

C User Resource Locator

D Uniform Reading Locator

3. Quel est l’objectif principal du « cloud computing » ?

A Fournir des services antivirus en ligne

B Offrir une connexion Internet rapide

C Permettre de stocker et de traiter des données sur des serveurs distants

D Créer des logiciels de traitement de texte

4. Quel est le rôle principal d’un « serveur » dans un réseau informatique ?

A Permettre la communication entre deux ordinateurs

B Gérer les connexions Wi-Fi

C Fournir des services, comme l’hébergement de sites web ou de fichiers

D Protéger les données contre les virus

5. Qu’est-ce qu’un « réseau local » (LAN) ?

A Un réseau de télécommunications à l’échelle d’un pays

B Un réseau privé limité à un petit espace géographique, comme une maison ou un bureau

C Un réseau reliant plusieurs pays

D Un réseau qui utilise uniquement le Wi-Fi

6. Qu’est-ce que « Wi-Fi » ?

A Un type de virus informatique

B Une technologie sans fil permettant la connexion à Internet

C Un type de disque dur externe

D Un logiciel de gestion des réseaux

7. Qu’est-ce que le « Big Data » ?

A Un format de fichier compressé

B Des données très volumineuses et complexes que les outils traditionnels ne peuvent pas traiter facilement

C Un type de mémoire de stockage

D Un protocole de communication

8. Qu’est-ce qu’un « cookie » sur Internet ?

A Un logiciel malveillant

B Un petit fichier stocké sur l’ordinateur pour mémoriser les préférences des utilisateurs

C Un type de virus informatique

D Une adresse IP dynamique

9. Quel est le rôle d’un « compresseur de fichiers » ?

A Protéger les fichiers contre les virus

B Réduire la taille d’un fichier pour économiser de l’espace de stockage

C Convertir les fichiers en un autre format

D Créer une copie de sécurité des fichiers

10. Qu’est-ce que le « streaming » ?

A Un type de fichier compressé

B La diffusion en temps réel de contenus audio, vidéo ou autres

C Un système de stockage en ligne

D Une méthode de sécurité pour crypter les fichiers

L’article QCM En Informatique Générale – Partie 5 est apparu en premier sur WayToLearnX.

QCM en informatique générale avec la correction pour la préparation des concours, des tests, aux examens et aux certifications. Ces questions et réponses sur l’informatique générale comprennent divers sujets. Et sont tirés d’un vrai concours écrit et certaines parties sont tirés d’un entretien orale. Cette méthode d’apprentissage systématique préparera facilement toute personne pour réussir son concours.
 
 

1. Quel est l’usage principal de « Linux » ?

A Un navigateur web

B Un système d’exploitation open source

C Un logiciel de traitement de texte

D Un programme de compression de fichiers

2. Que signifie l’acronyme « RAM » ?

A Random Access Memory

B Rapid Application Management

C Read Access Memory

D Read Algorithmic Memory

3. Qu’est-ce qu’un « API » ?

A Une application mobile

B Un logiciel pour coder des programmes

C Un ensemble de règles permettant à des logiciels de communiquer entre eux

D Un périphérique de stockage

4. Qu’est-ce que le « cloud » (nuage) en informatique ?

A Un logiciel de protection contre les virus

B Une technologie permettant de stocker des données et d’utiliser des services via Internet

C Un système d’exploitation

D Un type de connexion réseau câblée

5. Qu’est-ce qu’un « malware » ?

A Un type de programme de sécurité

B Un programme malveillant conçu pour nuire à l’ordinateur ou voler des informations

C Un fichier compressé

D Un outil pour protéger les fichiers contre la corruption

6. Que signifie l’acronyme « IP » dans une adresse IP ?

A Internet Protocol

B Internet Protection

C Internet Package

D Integrated Program

7. Que signifie « HTTP » dans une URL ?

A HyperText Transfer Protocol

B High Transmission Protocol

C Hyper Tool Technology Platform

D High Text Transfer Protocol

8. Qu’est-ce qu’un « firewall » (pare-feu) dans un réseau informatique ?

A Un outil permettant de crypter des données

B Un système de sécurité qui bloque ou filtre les connexions non autorisées

C Un type de serveur web

D Un système d’exploitation

9. Quel est l’objectif principal d’un « algorithme » ?

A Identifier et corriger les erreurs dans le code

B Exécuter des programmes

C Résoudre un problème en suivant une série d’étapes précises

D Stocker des données de manière sécurisée

10. Qu’est-ce qu’un « système de gestion de base de données » (SGBD) ?

A Un système permettant de manipuler et organiser des données

B Un programme de sécurité pour protéger les bases de données

C Un langage de programmation pour coder des bases de données

D Un fichier compressé pour les bases de données

L’article QCM En Informatique Générale – Partie 6 est apparu en premier sur WayToLearnX.

L‘ordonnancement du processus est à la base des systèmes d’exploitation multiprogrammés. En répartissant l’unité centrale entre les processus, le système d’exploitation peut rendre l’ordinateur plus productif. Dans ce chapitre, nous présentons des exercices corrigés sur les concepts de base de l’ordonnancement, l’idée d’allocation de ressources et discutons en détail de l’ordonnancement de l’unité centrale. FCFS, SJF, Round-Robin, Priorité et les autres algorithmes d’ordonnancement devraient être familiers à vous.

Exercice 1: Stratégies d’ordonnancement

1.1) Expliquez pourquoi certains systèmes d’exploitation ont un ou plusieurs processus inactifs.

1.2) Expliquez la différence entre l’ordonnancement préemptif et l’ordonnancement non préemptif.

1.3) Citez un inconvénient de l’ordonnancement préemptif.

1.4) Citez un inconvénient de l’ordonnancement non préemptif.

1.5) Expliquer comment fonctionne l’ordonnancement par queues à plusieurs niveaux (Multilevel Queues).

Il fonctionne avec plusieurs files d’attente. Chaque file d’attente a une priorité différente ou un multiplex temporel. Chaque nouveau processus est inséré dans la file d’attente supérieure, ce qui lui confère la priorité la plus élevée. Pour chaque file d’attente, le système Round Robin est utilisé. Si un processus abandonne volontairement l’unité centrale, il est réinséré dans la même file d’attente. Si un processus a utilisé toute sa tranche de temps, il est inséré dans la file d’attente immédiatement inférieure, avec une priorité plus faible.

1.6) Décrivez ce que signifie « Partage équitable » (fair share).

1.7) Laquelle des méthodes suivantes est la méthode d’ordonnancement équitable ?

A Ordonnancement en fonction des priorités

B Premier arrivé, premier servi (First Come First Served)

C Round Robin avec quantum de temps

D Ordonnancement EDF (Earliest Deadline First: Échéance la plus proche d’abord)

E Partage équitable

1.8) Laquelle des méthodes suivantes est la méthode d’ordonnancement préemptif ?

A Premier arrivé, premier servi

B Round Robin avec quantum de temps

C Partage équitable

D Ordonnancement par queues à plusieurs niveaux (Multilevel Queues)

1.9) Laquelle des méthodes suivantes est la méthode d’ordonnancement non-préemptif ?

A Premier arrivé, premier servi

B Round Robin avec quantum de temps

C Partage équitable

D Ordonnancement par queues à plusieurs niveaux (Multilevel Queues)

Exercice 2: Ordonnancement

+-----------+-----------+----------+
| Processus | Temps CPU | Priorité |
+-----------+-----------+----------+
|     A     |    5 ms   |    15    |
+-----------+-----------+----------+
|     B     |   10 ms   |     5    |
+-----------+-----------+----------+
|     C     |    3 ms   |     4    |
+-----------+-----------+----------+
|     D     |    9 ms   |    12    |
+-----------+-----------+----------+
|     E     |    8 ms   |     7    |
+-----------+-----------+----------+

Cinq processus doivent être traités sur un seul système CPU/core. Tous les processus se trouvent au point temporel 0, dans l’état « prêt ». Les priorités élevées sont caractérisées par des valeurs élevées.

2.1) Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) pour Round Robin (quantum de temps q = 1 ms), FCFS et l’ordonnancement par priorités.

La colonne Priorité du tableau n’est pertinente que pour l’ordonnancement par priorités (Priority-Driven Scheduling) et non pour Round Robin ou FCFS.

2.2) Calculez les durées d’exécution moyennes et les temps d’attente moyens des processus.

• Round Robin (RR): Chaque processus reçoit un quantum de temps fixe (q = 1 ms). Si le processus n’a pas terminé à la fin de son quantum, il est préempté et remis à la fin de la file d’attente. Ce cycle continue jusqu’à ce que tous les processus soient terminés.
• First Come First Served (FCFS): Les processus sont exécutés dans l’ordre de leur arrivée. Le premier processus dans la file d’attente est servi jusqu’à sa terminaison, puis le suivant est exécuté.
• Priority-Driven Scheduling: Chaque processus se voit attribuer une priorité. Les processus avec une priorité plus élevée sont exécutés avant ceux avec une priorité plus basse. Si un processus de priorité plus élevée arrive, il peut préempter le processus en cours.

Le temps CPU est le temps dont le processus a besoin pour accéder au CPU afin de terminer son exécution.

Durée d’exécution = durée de vie = période de temps entre la création et la fin d’un processus = (temps CPU + temps d’attente).

+------------------------------------------+----+----+----+----+----+
| Durée d'exécution                        |  A |  B |  C |  D |  E |
+------------------------------------------+----+----+----+----+----+
| Round Robin                              | 20 | 32 | 13 | 25 | 30 |
+------------------------------------------+----+----+----+----+----+
| FCFS(First Come First Served)            | 5  | 15 | 18 | 24 | 32 |
+------------------------------------------+----+----+----+----+----+
| Ordonnancement par priorités             | 5  | 29 | 32 | 11 | 19 |
+------------------------------------------+----+----+----+----+----+

RR   (20 + 32 + 13 + 25 + 30) / 5  = 24   ms
FCFS (5 + 15 + 18 + 24 + 32)  / 5  = 18,8 ms
PS   (5 + 29 + 32 + 11 + 19)  / 5  = 19,2 ms

Temps d’attente = temps pendant lequel un processus est dans l’état prêt.

Temps d’attente = temps d’exécution – temps CPU.

+------------------------------------------+----+----+----+----+----+
| Temps d'attente                          |  A |  B |  C |  D |  E |
+------------------------------------------+----+----+----+----+----+
| Round Robin                              | 15 | 22 | 10 | 19 | 22 |
+------------------------------------------+----+----+----+----+----+
| FCFS(First Come First Served)            | 0  | 5  | 15 | 18 | 24 |
+------------------------------------------+----+----+----+----+----+
| Ordonnancement en fonction des priorités | 0  | 19 | 29 | 5  | 11 |
+------------------------------------------+----+----+----+----+----+

RR   (15 + 22 + 10 + 19 + 22) / 5 = 17,6 ms
FCFS (0 + 5 + 15 + 18 + 24)   / 5 = 12,4 ms
PS   (0 + 19 + 29 + 5 + 11)   / 5 = 12,8 ms

L’article Exercice Corrigé Ordonnancement Des Processus – Partie 1 est apparu en premier sur WayToLearnX.

L‘ordonnancement du processus est à la base des systèmes d’exploitation multiprogrammés. En répartissant l’unité centrale entre les processus, le système d’exploitation peut rendre l’ordinateur plus productif. Dans ce chapitre, nous présentons des exercices corrigés sur les concepts de base de l’ordonnancement, l’idée d’allocation de ressources et discutons en détail de l’ordonnancement de l’unité centrale. FCFS, SJF, Round-Robin, Priorité et les autres algorithmes d’ordonnancement devraient être familiers à vous.

Exercice 1: First Come First Serve (FCFS)

Rappel: Dans l’ordonnancement FCFS

• Le processus qui arrive en premier dans la file d’attente est le premier à se voir attribuer l’unité centrale.
• En cas d’égalité, le processus dont l’identifiant est le plus petit est exécuté en premier.
• L’ordonnancement est toujours non préemptif par nature.
• Les jobs sont exécutés selon le principe du premier arrivé, premier servi.
• Il s’agit d’un algorithme d’ordonnancement préemptif et non préemptif.
• Facile à comprendre et à implémenter.
• Son implantation est basée sur la file d’attente FIFO.
• Peu performant car le temps d’attente moyen est élevé.

1.1) Considérons les processus suivants avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) pour FCFS, et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+------------------------------------------+
| ID du processus | Temps d'arrivée | Temps de rafale/temps d'exécution du CPU |
+-----------------+-----------------+------------------------------------------+
| P1              | 0               | 2                                        |
+-----------------+-----------------+------------------------------------------+
| P2              | 1               | 3                                        |
+-----------------+-----------------+------------------------------------------+
| P3              | 2               | 5                                        |
+-----------------+-----------------+------------------------------------------+
| P4              | 3               | 4                                        |
+-----------------+-----------------+------------------------------------------+
| P5              | 4               | 6                                        |
+-----------------+-----------------+------------------------------------------+

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

 

Temps moyen de rotation = 2+4+8+11+16/5 = 41/5 = 8.2 
Temps moyen d'attente   = 0+1+3+7+10/5  = 21/5 = 4.2 

1.2) Considérons les processus suivants P1, P2, P3 arrive pour être exécuté dans le même ordre, avec un temps d’arrivée de 0 avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) pour FCFS, et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 0               | 24              |
+-----------------+-----------------+-----------------+
| P2              | 0               | 3               |
+-----------------+-----------------+-----------------+
| P3              | 0               | 5               |
+-----------------+-----------------+-----------------+

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 0               | 24                |
+-----------+-----------------+-------------------+
| P2        | 24              | 27                |
+-----------+-----------------+-------------------+
| P3        | 27              | 30                |
+-----------+-----------------+-------------------+

Temps d'attente total = 0 + 24 + 27 = 51 ms
Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = 51 / 3 
                      = 17 ms
					  
Temps de rotation total = 24 + 27 + 30 = 81 ms
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = 81 / 3 
                        = 27 ms
						
Débit = 3 jobs/30 sec = 0.1 jobs/sec

1.3) Considérons les processus suivants P1, P2, P3, P4 arrive pour être exécuté dans le même ordre, avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) pour FCFS, et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 0               | 8               |
+-----------------+-----------------+-----------------+
| P2              | 1               | 4               |
+-----------------+-----------------+-----------------+
| P3              | 2               | 9               |
+-----------------+-----------------+-----------------+
| P4              | 3               | 5               |
+-----------------+-----------------+-----------------+

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 0               | 8 – 0 = 8         |
+-----------+-----------------+-------------------+
| P2        | 8 – 1 = 7       | 12 – 1 = 11       |
+-----------+-----------------+-------------------+
| P3        | 12 – 2 = 10     | 21 – 2 = 19       |
+-----------+-----------------+-------------------+
| P4        | 21 – 3 = 18     | 26 – 3 = 23       |
+-----------+-----------------+-------------------+

Temps d'attente total = 0 + 7 + 10 + 18 = 35 ms
Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = 35 / 4
                      = 8.75 ms
					  
Temps de rotation total = 8 + 11 + 19 + 23 = 61 ms
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = 61 / 4
                        = 15.25 ms
						
Débit = 4 jobs/26 sec = 0.15385 jobs/sec

Exercice 2: Shortest Job First (SJF)

Rappel: Dans l’ordonnancement SJF

• Les processus qui ont le temps d’exécution le plus court sont ordonnancés en premier.
• Si deux processus ont le même temps de rafale, l’algorithme FCFS est utilisé pour les départager.
• Il s’agit d’un algorithme d’ordonnancement non préemptif et préemptif.
• La meilleure approche pour minimiser le temps d’attente.
• Facile à mettre en œuvre dans les systèmes de traitement par lots où le temps CPU nécessaire est connu à l’avance.
• Impossible à mettre en œuvre dans les systèmes interactifs où le temps CPU requis n’est pas connu.
• Le processeur doit connaître à l’avance la durée du processus.
• Le mode préemptif de SJF est appelé SRTF.

2.1) Considérons les processus suivants P1, P2, P3, P4, P5 arrive pour être exécuté, avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) pour la politique d’ordonnancement SJF non préemptive, et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 3               | 1               |
+-----------------+-----------------+-----------------+
| P2              | 1               | 4               |
+-----------------+-----------------+-----------------+
| P3              | 4               | 2               |
+-----------------+-----------------+-----------------+
| P4              | 0               | 6               |
+-----------------+-----------------+-----------------+
| P5              | 2               | 3               |
+-----------------+-----------------+-----------------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 4 – 1 = 3       | 7 – 3 = 4         |
+-----------+-----------------+-------------------+
| P2        | 15 – 4 = 11     | 16 – 1 = 15       |
+-----------+-----------------+-------------------+
| P3        | 5 – 2 = 3       | 9 – 4 = 5         |
+-----------+-----------------+-------------------+
| P4        | 6 – 6 = 0       | 6 – 0 = 6         |
+-----------+-----------------+-------------------+
| P5        | 10 – 3 = 7      | 12 – 2 = 10       |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (3 + 11 + 3 + 0 + 7) / 5 
                      = 24 / 5
                      = 4.8 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (4 + 15 + 5 + 6 + 10) / 5 
                        = 40 / 5
                        = 8 unités

2.2) Considérons les processus suivants P1, P2, P3, P4, P5 arrive pour être exécuté, avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) pour la politique d’ordonnancement SJF préemptive, et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 3               | 1               |
+-----------------+-----------------+-----------------+
| P2              | 1               | 4               |
+-----------------+-----------------+-----------------+
| P3              | 4               | 2               |
+-----------------+-----------------+-----------------+
| P4              | 0               | 6               |
+-----------------+-----------------+-----------------+
| P5              | 2               | 3               |
+-----------------+-----------------+-----------------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 1 – 1 = 0       | 4 – 3 = 1         |
+-----------+-----------------+-------------------+
| P2        | 5 – 4 = 1       | 6 – 1 = 5         |
+-----------+-----------------+-------------------+
| P3        | 4 – 2 = 2       | 8 – 4 = 4         |
+-----------+-----------------+-------------------+
| P4        | 16 – 6 = 10     | 16 – 0 = 16       |
+-----------+-----------------+-------------------+
| P5        | 9 – 3 = 6       | 11 – 2 = 9        |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (0 + 1 + 2 + 10 + 6) / 5 
                      = 19 / 5
                      = 3.8 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (1 + 5 + 4 + 16 + 9) / 5
                        = 35 / 5
                        = 7 unités

2.3) Considérons les processus suivants P1, P2, P3, P4, P5, P6 arrive pour être exécuté, avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) pour la politique d’ordonnancement SRTF (Shortest Remaining Time First), et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 0               | 7               |
+-----------------+-----------------+-----------------+
| P2              | 1               | 5               |
+-----------------+-----------------+-----------------+
| P3              | 2               | 3               |
+-----------------+-----------------+-----------------+
| P4              | 3               | 1               |
+-----------------+-----------------+-----------------+
| P5              | 4               | 2               |
+-----------------+-----------------+-----------------+
| P6              | 5               | 1               |
+-----------------+-----------------+-----------------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 19 – 7 = 12     | 19 – 0 = 19       |
+-----------+-----------------+-------------------+
| P2        | 12 – 5 = 7      | 13 – 1 = 12       |
+-----------+-----------------+-------------------+
| P3        | 4 – 3 = 1       | 6 – 2 = 4         |
+-----------+-----------------+-------------------+
| P4        | 1 – 1 = 0       | 4 – 3 = 1         |
+-----------+-----------------+-------------------+
| P5        | 5 – 2 = 3       | 9 – 4 = 5         |
+-----------+-----------------+-------------------+
| P6        | 2 – 1 = 1       | 7 – 5 = 2         |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (12 + 7 + 1 + 0 + 3 + 1) / 6
                      = 24 / 6
                      = 4 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (19 + 12 + 4 + 1 + 5 + 2) / 6
                        = 43 / 6
                        = 7.17 unités

2.4) Considérons les processus suivants P1, P2, P3 arrive pour être exécuté, avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) pour la politique d’ordonnancement SRTF (Shortest Remaining Time First), et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 0               | 9               |
+-----------------+-----------------+-----------------+
| P2              | 1               | 4               |
+-----------------+-----------------+-----------------+
| P3              | 2               | 9               |
+-----------------+-----------------+-----------------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 13 – 9 = 4      | 13 – 0 = 13       |
+-----------+-----------------+-------------------+
| P2        | 4 – 4 = 0       | 5 – 1 = 4         |
+-----------+-----------------+-------------------+
| P3        | 20 – 9 = 11     | 22- 2 = 20        |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (4 + 0 + 11) / 3
                      = 15 / 3
                      = 5 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (13 + 4 + 20) / 3
                        = 37 / 3
                        = 12.33 unités

2.5) Considérons les processus suivants P1, P2, P3, P4 arrive pour être exécuté, avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) pour la politique d’ordonnancement SRTF (Shortest Remaining Time First), et calculez le temps d’attente du processus P2.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 0               | 20              |
+-----------------+-----------------+-----------------+
| P2              | 15              | 25              |
+-----------------+-----------------+-----------------+
| P3              | 30              | 10              |
+-----------------+-----------------+-----------------+
| P4              | 45              | 15              |
+-----------------+-----------------+-----------------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

Donc:

Temps moyen d’attente du processus P2 = 55 – 15 = 40 unités

Temps moyen de rotation du processus P2 = 40 – 25 = 15 unités

L’article Exercice Corrigé Ordonnancement Des Processus – Partie 2 est apparu en premier sur WayToLearnX.

L‘ordonnancement du processus est à la base des systèmes d’exploitation multiprogrammés. En répartissant l’unité centrale entre les processus, le système d’exploitation peut rendre l’ordinateur plus productif. Dans ce chapitre, nous présentons des exercices corrigés sur les concepts de base de l’ordonnancement, l’idée d’allocation de ressources et discutons en détail de l’ordonnancement de l’unité centrale. FCFS, SJF, Round-Robin, Priorité et les autres algorithmes d’ordonnancement devraient être familiers à vous.

Exercice 1: Ordonnancement Round Robin

Rappel: Dans l’ordonnancement Round Robin

• L’unité centrale est attribuée au processus sur la base de la méthode FCFS pour une durée déterminée.
• Cette durée fixe est appelée « time quantum » ou « time slice ».
• À l’expiration du quantum de temps, le processus en cours est préempté et envoyé dans la file d’attente des processus prêts.
• Le processeur est alors attribué au processus suivant.
• Il s’agit toujours d’un processus préemptif par nature.

1.1) Considérons les 5 processus suivants avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement Round Robin avec un quantum de temps = 2 unités, et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+------------------------------------------+
| ID du processus | Temps d'arrivée | Temps de rafale/temps d'exécution du CPU |
+-----------------+-----------------+------------------------------------------+
| P1              | 0               | 5                                        |
+-----------------+-----------------+------------------------------------------+
| P2              | 1               | 3                                        |
+-----------------+-----------------+------------------------------------------+
| P3              | 2               | 1                                        |
+-----------------+-----------------+------------------------------------------+
| P4              | 3               | 2                                        |
+-----------------+-----------------+------------------------------------------+
| P5              | 4               | 3                                        |
+-----------------+-----------------+------------------------------------------+

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 13 – 5 = 8      | 13 – 0 = 13       |
+-----------+-----------------+-------------------+
| P2        | 11 – 3 = 8      | 12 – 1 = 11       |
+-----------+-----------------+-------------------+
| P3        | 3 – 1 = 2       | 5 – 2 = 3         |
+-----------+-----------------+-------------------+
| P4        | 6 – 2 = 4       | 9 – 3 = 6         |
+-----------+-----------------+-------------------+
| P5        | 10 – 3 = 7      | 14 – 4 = 10       |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (8 + 8 + 2 + 4 + 7) / 5 
                      = 29 / 5
                      = 5.8 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (13 + 11 + 3 + 6 + 10) / 5 
                        = 43 / 5
                        = 8.6 unités

1.2) Considérons les 6 processus suivants avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement Round Robin avec un quantum de temps = 2 unités, et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 0               | 4               |
+-----------------+-----------------+-----------------+
| P2              | 1               | 5               |
+-----------------+-----------------+-----------------+
| P3              | 2               | 2               |
+-----------------+-----------------+-----------------+
| P4              | 3               | 1               |
+-----------------+-----------------+-----------------+
| P5              | 4               | 6               |
+-----------------+-----------------+-----------------+
| P6              | 6               | 3               |
+-----------------+-----------------+-----------------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 8 – 4 = 4       | 8 – 0 = 8         |
+-----------+-----------------+-------------------+
| P2        | 17 – 5 = 12     | 18 – 1 = 17       |
+-----------+-----------------+-------------------+
| P3        | 4 – 2 = 2       | 6 – 2 = 4         |
+-----------+-----------------+-------------------+
| P4        | 6 – 1 = 5       | 9 – 3 = 6         |
+-----------+-----------------+-------------------+
| P5        | 17 – 6 = 11     | 21 – 4 = 17       |
+-----------+-----------------+-------------------+
| P6        | 13 – 3 = 10     | 19 – 6 = 13       |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (4 + 12 + 2 + 5 + 11 + 10) / 6
                      = 44 / 6
                      = 7.33 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (8 + 17 + 4 + 6 + 17 + 13) / 6
                        = 65 / 6
                        = 10.84 unités

1.3) Considérons les 6 processus suivants avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement Round Robin avec un quantum de temps = 3 unités, et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 5               | 5               |
+-----------------+-----------------+-----------------+
| P2              | 4               | 6               |
+-----------------+-----------------+-----------------+
| P3              | 3               | 7               |
+-----------------+-----------------+-----------------+
| P4              | 1               | 9               |
+-----------------+-----------------+-----------------+
| P5              | 2               | 2               |
+-----------------+-----------------+-----------------+
| P6              | 6               | 3               |
+-----------------+-----------------+-----------------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 27 – 5 = 22     | 32 – 5 = 27       |
+-----------+-----------------+-------------------+
| P2        | 23 – 6 = 17     | 27 – 4 = 23       |
+-----------+-----------------+-------------------+
| P3        | 30 – 7 = 23     | 33 – 3 = 30       |
+-----------+-----------------+-------------------+
| P4        | 29 – 9 = 20     | 30 – 1 = 29       |
+-----------+-----------------+-------------------+
| P5        | 4 – 2 = 2       | 6 – 2 = 4         |
+-----------+-----------------+-------------------+
| P6        | 15 – 3 = 12     | 21 – 6 = 15       |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (22 + 17 + 23 + 20 + 2 + 12) / 6
                      = 96 / 6
                      = 16 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (27 + 23 + 30 + 29 + 4 + 15) / 6 
                        = 128 / 6
                        = 21.33 unités

Exercice 2: Ordonnancement par priorité (Priority Scheduling)

Rappel: Dans l’ordonnancement par priorité

• Parmi tous les processus disponibles, l’unité centrale est attribuée au processus ayant la priorité la plus élevée.
• En cas d’égalité, le processus est départagé par l’ordonnancement FCFS.
• L’ordonnancement par priorité peut être utilisé en mode préemptif ou non préemptif.
• Le temps d’attente pour le processus ayant la priorité la plus élevée sera toujours nul en mode préemptif.
• Le temps d’attente pour le processus ayant la priorité la plus élevée peut ne pas être nul en mode non préemptif.

L’ordonnancement par priorité en mode préemptif et non préemptif se comporte exactement de la même manière dans les conditions suivantes:

• L’heure d’arrivée de tous les processus est la même
• Tous les processus deviennent disponibles

Avantages:

• Il prend en compte la priorité des processus et permet aux processus importants de s’exécuter en premier.
• L’ordonnancement par priorité en mode préemptif est le mieux adapté aux systèmes d’exploitation en temps réel.

Inconvénients:

• Les processus moins prioritaires risquent d’être affamés par l’unité centrale.
• Il n’y a aucune idée du temps de réponse et du temps d’attente.

2.1) Considérons les 5 processus suivants avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement par priorité non préemptive, et calculez le temps d’attente moyen et le temps moyen de rotation. (Le chiffre le plus élevé correspond à une priorité plus importante).

+-----------+-----------------+-----------------+----------+
| Processus | Temps d'arrivée | Temps de rafale | Priorité |
+-----------+-----------------+-----------------+----------+
| P1        | 0               | 4               | 2        |
+-----------+-----------------+-----------------+----------+
| P2        | 1               | 3               | 3        |
+-----------+-----------------+-----------------+----------+
| P3        | 2               | 1               | 4        |
+-----------+-----------------+-----------------+----------+
| P4        | 3               | 5               | 5        |
+-----------+-----------------+-----------------+----------+
| P5        | 4               | 2               | 5        |
+-----------+-----------------+-----------------+----------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 4 – 4 = 0       | 4 – 0 = 4         |
+-----------+-----------------+-------------------+
| P2        | 14 – 3 = 11     | 15 – 1 = 14       |
+-----------+-----------------+-------------------+
| P3        | 10 – 1 = 9      | 12 – 2 = 10       |
+-----------+-----------------+-------------------+
| P4        | 6 – 5 = 1       | 9 – 3 = 6         |
+-----------+-----------------+-------------------+
| P5        | 7 – 2 = 5       | 11 – 4 = 7        |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (0 + 11 + 9 + 1 + 5) / 5
                      = 26 / 5
                      = 5.2 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (4 + 14 + 10 + 6 + 7) / 5
                        = 41 / 5
                        = 8.2 unités

2.2) Considérons les 5 processus suivants avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement par priorité préemptive, et calculez le temps d’attente moyen et le temps moyen de rotation. (Le chiffre le plus élevé correspond à une priorité plus importante).

+-----------+-----------------+-----------------+----------+
| Processus | Temps d'arrivée | Temps de rafale | Priorité |
+-----------+-----------------+-----------------+----------+
| P1        | 0               | 4               | 2        |
+-----------+-----------------+-----------------+----------+
| P2        | 1               | 3               | 3        |
+-----------+-----------------+-----------------+----------+
| P3        | 2               | 1               | 4        |
+-----------+-----------------+-----------------+----------+
| P4        | 3               | 5               | 5        |
+-----------+-----------------+-----------------+----------+
| P5        | 4               | 2               | 5        |
+-----------+-----------------+-----------------+----------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 15 – 4 = 11     | 15 – 0 = 15       |
+-----------+-----------------+-------------------+
| P2        | 11 – 3 = 8      | 12 – 1 = 11       |
+-----------+-----------------+-------------------+
| P3        | 1 – 1 = 0       | 3 – 2 = 1         |
+-----------+-----------------+-------------------+
| P4        | 5 – 5 = 0       | 8 – 3 = 5         |
+-----------+-----------------+-------------------+
| P5        | 6 – 2 = 4       | 10 – 4 = 6        |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (11 + 8 + 0 + 0 + 4) / 5
                      = 23 / 5
                      = 4.6 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (15 + 11 + 1 + 5 + 6) / 5
                        = 38 / 5
                        = 7.6 unités

L’article Exercice Corrigé Ordonnancement Des Processus – Partie 3 est apparu en premier sur WayToLearnX.

L‘ordonnancement du processus est à la base des systèmes d’exploitation multiprogrammés. En répartissant l’unité centrale entre les processus, le système d’exploitation peut rendre l’ordinateur plus productif. Dans ce chapitre, nous présentons des exercices corrigés sur les concepts de base de l’ordonnancement, l’idée d’allocation de ressources et discutons en détail de l’ordonnancement de l’unité centrale. FCFS, SJF, Round-Robin, Priorité et les autres algorithmes d’ordonnancement devraient être familiers à vous.

Exercice 1: Pourcentage d’inactivité du CPU

Considérons trois processus, arrivant tous au temps zéro, avec un temps d’exécution total de 10, 20 et 30 unités respectivement. Chaque processus passe les premiers 20 % de son temps d’exécution à faire des E/S, les 70 % suivants à faire des calculs et les derniers 10 % à refaire des E/S. Le système d’exploitation utilise un algorithme d’ordonnancement basé sur l’algorithme d’ordonnancement Shortest Remaining Time First (SRTF) et planifie un nouveau processus soit lorsque le processus en cours est bloqué sur les E/S, soit lorsque le processus en cours termine sa rafale de calcul. Supposons que toutes les opérations d’E/S puissent se chevaucher autant que possible. Quel est le pourcentage d’inactivité de l’unité centrale (CPU) ?

A 0%

B 10.6%

C 30.0%

D 89.4%

B

D’après la question, nous avons:

Rafale = Temps d’exécution

+--------------+------------------+------------+------------+------------+
|              | Totale du Rafale | Rafale E/S | Rafale CPU | Rafale E/S |
+--------------+------------------+------------+------------+------------+
| Processus P1 | 10               | 2          | 7          | 1          |
+--------------+------------------+------------+------------+------------+
| Processus P2 | 20               | 4          | 14         | 2          |
+--------------+------------------+------------+------------+------------+
| Processus P3 | 30               | 6          | 21         | 3          |
+--------------+------------------+------------+------------+------------+

L’algorithme d’ordonnancement utilisé est celui du SRTF « plus court temps restant en premier ».

Pourcentage de temps d’inactivité de l’unité centrale (CPU)
= (5 / 47) x 100
= 10.638%
L’option correcte est donc (B).

 

Exercice 2: SRTF « plus court temps restant en premier »

Considérons les 4 processus suivants avec un temps de rafale (temps d’exécution). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement SRTF « plus court temps restant en premier », et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------+-----------------+--------------------------------------+
| Processus | Temps d'arrivée |           Temps de rafale            |
|           |                 |------------+------------+------------+
|           |                 | Rafale E/S | Rafale CPU | Rafale E/S |
+-----------+-----------------+------------+------------+------------+
| P1        | 0               | 3          | 2          | 2          |
+-----------+-----------------+------------+------------+------------+
| P2        | 0               | 2          | 4          | 1          |
+-----------+-----------------+------------+------------+------------+
| P3        | 2               | 1          | 3          | 2          |
+-----------+-----------------+------------+------------+------------+
| P4        | 5               | 2          | 2          | 1          |
+-----------+-----------------+------------+------------+------------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 11 – (3+2) = 6  | 11 – 0 = 11       |
+-----------+-----------------+-------------------+
| P2        | 7 – (2+1) = 4   | 7 – 0 = 7         |
+-----------+-----------------+-------------------+
| P3        | 7 – (1+2) = 4   | 9 – 2 = 7         |
+-----------+-----------------+-------------------+
| P4        | 11 – (2+1) = 8  | 16 – 5 = 11       |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (6 + 4 + 4 + 8) / 4
                      = 22 / 4
                      = 5.5 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (11 + 7 + 7 + 11) / 4
                        = 36 / 4
                        = 9 unités

Exercice 3: Ordonnancement par priorité (Priority Scheduling)

Considérons les 3 processus suivants avec un temps de rafale (temps d’exécution). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement par priorité, et calculez le temps d’attente moyen et le temps moyen de rotation. (Un chiffre plus bas signifie une priorité plus élevée).

+-----------+-----------+----------+--------------------------------------+
| Processus | Temps     | Priorité |            Temps de rafale           |
|           | d'arrivée |          |------------+------------+------------+
|           |           |          | Rafale E/S | Rafale CPU | Rafale E/S |
+-----------+-----------+----------+--------------------------------------+
| P1        | 0         | 2        | 1          | 5          | 3          |
+-----------+-----------+----------+--------------------------------------+
| P2        | 2         | 3        | 3          | 3          | 1          |
+-----------+-----------+----------+--------------------------------------+
| P3        | 3         | 1        | 2          | 3          | 1          |
+-----------+-----------+----------+------------+------------+------------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 10 – (1+3) = 6  | 10 – 0 = 10       |
+-----------+-----------------+-------------------+
| P2        | 13 – (3+1) = 9  | 15 – 2 = 13       |
+-----------+-----------------+-------------------+
| P3        | 6 – (2+1) = 3   | 9 – 3 = 6         |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (6 + 9 + 3) / 3
                      = 18 / 3
                      = 6 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (10 + 13 + 6) / 3
                        = 29 / 3
                        = 9.67 unités

Exercice 4:

Un algorithme d’ordonnancement du CPU détermine l’ordre d’exécution des processus programmés. Étant donné que n processus doivent être ordonnancés sur un processeur, combien y a-t-il d’ordonnances différentes possibles ? Donnez une formule en fonction de n.

Exercice 5:

Considérons les 6 processus suivants avec un temps de rafale (temps d’exécution). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle). Si la politique d’ordonnancement du CPU est First Come First Serve (FCFS) et qu’il y a une unité du temps d’attente pour le changement de contexte dans l’ordonnancement des processus, déterminez l’efficacité de l’algorithme.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 0               | 3               |
+-----------------+-----------------+-----------------+
| P2              | 1               | 2               |
+-----------------+-----------------+-----------------+
| P3              | 2               | 1               |
+-----------------+-----------------+-----------------+
| P4              | 3               | 4               |
+-----------------+-----------------+-----------------+
| P5              | 4               | 5               |
+-----------------+-----------------+-----------------+
| P6              | 5               | 2               |
+-----------------+-----------------+-----------------+

Ici, δ représente le temps d’attente pour le changement de contexte.
Maintenant,
Temps inutile / Temps perdu = 6 x δ = 6 x 1 = 6 unités
Temps total = 23 unités
Temps utile = 23 unités – 6 unités = 17 unités

Efficacité (η)
= Temps utile / Total Total
= 17 unités / 23 unités
= 0.7391
= 73.91%

L’article Exercice Corrigé Ordonnancement Des Processus – Partie 4 est apparu en premier sur WayToLearnX.

L‘ordonnancement du processus est à la base des systèmes d’exploitation multiprogrammés. En répartissant l’unité centrale entre les processus, le système d’exploitation peut rendre l’ordinateur plus productif. Dans ce chapitre, nous présentons des exercices corrigés sur les concepts de base de l’ordonnancement, l’idée d’allocation de ressources et discutons en détail de l’ordonnancement de l’unité centrale. FCFS, SJF, Round-Robin, Priorité et les autres algorithmes d’ordonnancement devraient être familiers à vous.

Exercice 1:

Considérons les processus suivants, la durée du temps d’utilisation du CPU (temps de rafale) étant exprimée en millisecondes:

+-----------+-----------------+----------+
| Processus | Temps de rafale | Priorité |
+-----------+-----------------+----------+
| P1        | 10              | 3        |
+-----------+-----------------+----------+
| P2        | 1               | 1        |
+-----------+-----------------+----------+
| P3        | 2               | 3        |
+-----------+-----------------+----------+
| P4        | 1               | 4        |
+-----------+-----------------+----------+
| P5        | 5               | 2        |
+-----------+-----------------+----------+

On suppose que les processus sont arrivés dans l’ordre P1, P2, P3, P4, P5, tous au temps 0.

A. Dessinez quatre diagrammes de Gantt illustrant l’exécution de ces processus en utilisant l’ordonnancement FCFS, SJF, par priorité non préemptive (un numéro de priorité plus petit implique une priorité plus élevée), et RR – Round Robin (quantum = 1).

Les quatre diagrammes de Gantt sont:

B. Quel est le temps d’exécution (ou temps de rotation) de chaque processus pour chacun des algorithmes d’ordonnancement de la question A ?

+-----------+--------+--------+---------+--------------+
| Processus |  FCFS  |   RR   |   SJF   | Par priorité |
+-----------+--------+--------+---------+--------------+
| P1        | 10     | 19     | 19      | 16           |
+-----------+--------+--------+---------+--------------+
| P2        | 11     | 2      | 1       | 1            |
+-----------+--------+--------+---------+--------------+
| P3        | 13     | 7      | 4       | 18           |
+-----------+--------+--------+---------+--------------+
| P4        | 14     | 4      | 2       | 19           |
+-----------+--------+--------+---------+--------------+
| P5        | 19     | 14     | 9       |  6           |
+-----------+--------+--------+---------+--------------+

C. Quel est le temps d’attente de chaque processus pour chacun des algorithmes d’ordonnancement de la question A ?

+-----------+--------+--------+---------+--------------+
| Processus |  FCFS  |   RR   |   SJF   | Par priorité |
+-----------+--------+--------+---------+--------------+
| P1        | 0      | 9      | 9       | 6            |
+-----------+--------+--------+---------+--------------+
| P2        | 10     | 1      | 0       | 0            |
+-----------+--------+--------+---------+--------------+
| P3        | 11     | 5      | 2       | 16           |
+-----------+--------+--------+---------+--------------+
| P4        | 13     | 3      | 1       | 18           |
+-----------+--------+--------+---------+--------------+
| P5        | 14     | 9      | 4       |  1           |
+-----------+--------+--------+---------+--------------+

D. Lequel des ordonnancements de la question A permet d’obtenir le temps d’attente moyen le plus court (sur l’ensemble des processus) ?

Exercice 2:

Supposons que les processus suivants arrivent pour être exécutés aux moments indiqués. Chaque processus s’exécutera pendant la durée indiquée. Pour répondre aux questions, utilisez un ordonnancement non préemptif et basez toutes vos décisions sur les informations dont vous disposez.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 0.0             | 8               |
+-----------------+-----------------+-----------------+
| P2              | 0.4             | 4               |
+-----------------+-----------------+-----------------+
| P3              | 1.0             | 1               |
+-----------------+-----------------+-----------------+

A. Quel est le délai d’exécution moyen (ou temps moyen de rotation) de ces processus avec l’algorithme d’ordonnancement FCFS ?

B. Quel est le délai d’exécution moyen (ou temps moyen de rotation) de ces processus avec l’algorithme d’ordonnancement SJF ?

C. L’algorithme SJF est censé améliorer les performances, mais remarquez que nous avons choisi d’exécuter le processus P1 au temps 0 parce que nous ne savions pas que deux processus plus courts arriveraient bientôt. Calculez le délai d’exécution moyen (ou temps moyen de rotation) si l’unité centrale est laissée inactive pendant la première unité, puis si l’ordonnancement SJF est utilisé. N’oubliez pas que les processus P1 et P2 sont en attente pendant cette période d’inactivité, et que leur temps d’attente peut donc augmenter.

Exercice 3:

Considérons l’algorithme d’ordonnancement par priorité préemptive suivant, basé sur des priorités changeant dynamiquement. Les numéros de priorité les plus grands impliquent une priorité plus élevée. Lorsqu’un processus est en attente de l’unité centrale (dans la file d’attente des processus prêts mais non en cours d’exécution), sa priorité change à un taux α ; lorsqu’il est en cours d’exécution, sa priorité change à un taux β. Tous les processus reçoivent une priorité de 0 lorsqu’ils entrent dans la file d’attente. Les paramètres α et β peuvent être définis de manière à obtenir de nombreux algorithmes d’ordonnancement différents.

A. Quel est l’algorithme qui résulte de β > α > 0 ?

B. Quel est l’algorithme qui résulte de α < β < 0 ?

Exercice 4:

Supposons qu’un algorithme d’ordonnancement (au niveau de l’ordonnancement CPU à court terme) favorise les processus qui ont utilisé le moins de temps processeur récemment. Pourquoi cet algorithme favorise-t-il les programmes liés aux E/S tout en ne laissant pas les programmes liés aux CPU dans un état de starvation permanent ?

Exercice 5:

Expliquez les différences dans le degré de discrimination des algorithmes d’ordonnancement suivants en faveur des processus courts :

A. FCFS
B. RR
C. Queues multiples à rétroaction (Multilevel Feedback Queues)

Exercice 6:

Les questions suivantes se réfèrent à l’ordonnanceur Round Robin basé sur Java.

A. S’il y a actuellement un thread T1 dans la file d’attente de l’ordonnanceur avec une priorité de 4 et un autre thread T2 avec une priorité de 2, est-il possible pour le thread T2 de s’exécuter pendant le quantum de temps de T1 ? Expliquez.

B. Expliquez ce qui se passe si la méthode stop() du thread en cours d’exécution est invoquée pendant son quantum de temps.

C. Expliquez ce qui se passe si l’ordonnanceur sélectionne un thread à exécuter dont la méthode suspend() a été invoquée.

Exercice 7:

Le planificateur UNIX traditionnel impose une relation inverse entre les numéros de priorité et les priorités : plus le numéro est élevé, plus la priorité est faible. Le planificateur recalcule les priorités des processus une fois par seconde en utilisant la fonction suivante :

Priorité = (utilisation récente du CPU / 2) + base

où base = 60 et l’utilisation récente du CPU fait référence à une valeur indiquant à quelle fréquence un processus a utilisé le CPU depuis que les priorités ont été recalculées. Supposons que l’utilisation récente du CPU pour le processus P1 est de 40, pour le processus P2 est de 18, et pour le processus P3 est de 10.

A. Quelles seront les nouvelles priorités pour ces trois processus lorsque les priorités seront recalculées ?

B. Sur la base de ces informations, le planificateur UNIX traditionnel augmente-t-il ou abaisse-t-il la priorité relative d’un processus liés aux CPU ?

L’article Exercice Corrigé Ordonnancement Des Processus – Partie 5 est apparu en premier sur WayToLearnX.

Les exercices pratiques sur les systèmes d’exploitation comportent des exercices théoriques et pratiques. Pour résoudre les exercices pratiques, vous avez besoin d’un shell UNIX. Un shell très populaire est Bash. Le terminal Apple Mac OS X est suffisant pour la plupart des exercices pratiques. L’invite de commande Windows et Windows PowerShell ne sont pas suffisants pour les exercices.

Pour vous préparer, l’idéal est d’installer sur votre système le système d’exploitation Linux. Une installation dans une machine virtuelle est suffisante. Les distributions faciles à utiliser sont, par exemple, Debian, Ubuntu et CentOS. VirtualBox est une solution de virtualisation gratuite.

Vous pouvez également travailler avec un système vivant sur CD, DVD ou lecteur de mémoire flash USB. Dans ce cas, aucune installation locale n’est nécessaire.

Exercice 1: Traitement par lots

1.1) Décrivez l’objectif du traitement par lots.

1.2) Décrivez pourquoi le traitement par lots provoque un effet d’accélération lorsque plusieurs tâches sont exécutées.

1.3) Nommez les conditions préalables qui doivent être remplies pour le traitement par lots avant que l’exécution d’une tâche ne puisse commencer.

1.4) Citez des tâches pour lesquelles le traitement par lots est bien adapté.

1.5) Le traitement par lots est toujours ____________

A interactif

B non interactif

1.6) Citez une application du mode batch, qui est encore populaire aujourd’hui.

1.7) Décrire ce qu’est le spooling.

Exercice 2: Temps partagé

2.1) Décrire l’objectif du partage du temps (time sharing) dans les systèmes d’exploitation.

2.2) Décrire comment le partage du temps répartit le temps de calcul entre les processus.

2.3) Donnez le nom du programme quasi-parallèle ou de l’exécution du processus.

2.4) Décrire l’objectif de l’exécution du programme ou du processus quasi-parallèle.

2.5) Décrire ce qu’est l’ordonnancement (scheduling).

2.6) Décrire ce qu’est le swapping.

2.7) Décrire comment fonctionne la protection de la mémoire.

2.8) Décrire le but de la protection de la mémoire.

Exercice 3: Fichiers et répertoires

3.1) Créez un répertoire MyRep dans votre répertoire personnel.

$ mkdir ~/MyRep

3.2) Naviguez jusqu’au répertoire MyRep et créez à l’intérieur un fichier vide portant le nom File1.txt. N’utilisez pas d’éditeur pour créer le fichier, mais une ligne de commande.

$ cd ~/MyRep && touch File1.txt

3.3) Vérifiez la taille du fichier File1.txt.

$ ls -lh File1.txt

3.4) Modifiez l’heure de modification du fichier File1.txt pour qu’elle corresponde à votre date de naissance.

$ touch -t XXXXYYZZAABB File1.txt

3.5) Créez un nouveau fichier dans l’interpréteur de commandes File2.txt et insérez dans le nouveau fichier un texte dont le contenu ne se limite pas à une seule ligne. N’utilisez pas d’éditeur pour insérer le texte dans le fichier, mais une ligne de commande.

$ echo -e "Ligne1\nLigne2" > File2.txt

3.6) Affichez la première ligne du fichier File2.txt dans l’interpréteur de commandes.

$ head -n 1 File2.txt

3.7) Ajoutez le contenu de File2.txt à File1.txt. N’utilisez pas d’éditeur, mais une commande en ligne.

$ cat File2.txt >> File1.txt

3.8) Créez dans votre répertoire personnel un répertoire portant le nom cours_university.

$ mkdir ~/cours_university

3.9) Copiez les fichiers File1.txt et File2.txt du répertoire MyRep dans le répertoire cours_university.

$ cp ~/MyRep/* ~/cours_university

3.10) Effacer le répertoire MyRep.

$ rm -rf ~/MyRep

L’article Exercice Corrigé Système d’Exploitation Linux – Partie 1 est apparu en premier sur WayToLearnX.

Les exercices pratiques sur les systèmes d’exploitation comportent des exercices théoriques et pratiques. Pour résoudre les exercices pratiques, vous avez besoin d’un shell UNIX. Un shell très populaire est Bash. Le terminal Apple Mac OS X est suffisant pour la plupart des exercices pratiques. L’invite de commande Windows et Windows PowerShell ne sont pas suffisants pour les exercices.

Pour vous préparer, l’idéal est d’installer sur votre système le système d’exploitation Linux. Une installation dans une machine virtuelle est suffisante. Les distributions faciles à utiliser sont, par exemple, Debian, Ubuntu et CentOS. VirtualBox est une solution de virtualisation gratuite.

Vous pouvez également travailler avec un système vivant sur CD, DVD ou lecteur de mémoire flash USB. Dans ce cas, aucune installation locale n’est nécessaire.

Exercice 1: Classifications des systèmes d’exploitation

1.1) À chaque instant, un seul programme peut être exécuté. Quel est le terme technique pour ce mode de fonctionnement ?

1.2) Quelle est la différence entre les systèmes d’exploitation 8 bits, 16 bits, 32 bits et 64 bits ?

1.3) Quels sont les critères essentiels des systèmes d’exploitation en temps réel ?

1.4) Citez les deux types de systèmes d’exploitation en temps réel.

1.5) Citez quatre domaines d’application typiques des systèmes d’exploitation en temps réel et classez chaque domaine d’application dans l’une des catégories de la réponse ci-dessus.

1.6) Décrire la structure d’un nano-noyau (ou nanokernel).

1.7) Décrire la structure d’un noyau monolithique.

1.8) Décrire la structure d’un micro-noyau.

1.9) Décrire la structure d’un noyau hybride.

1.10) Linux implémente un _______________.

A noyau monolithique

B micro-noyau

C noyau hybride

1.11) MacOS X implémente un _______________.

A noyau monolithique

B micro-noyau

C noyau hybride

1.12) Windows NT4/Vista/XP/7/8/10 implémente un _______________.

A noyau monolithique

B micro-noyau

C noyau hybride

1.13) Citez un avantage et un inconvénient des noyaux monolithiques.

1.14) Citez un avantage et un inconvénient des micro-noyaux.

1.15) Citez un avantage et un inconvénient des noyaux hybrides.

Exercice 2: Commandes de base de Linux/UNIX

2.1) Quelle commande permet de consulter les pages de manuel ?

2.2) Quelle commande permet d’afficher le répertoire de travail actuel dans l’interpréteur de commandes ?

2.3) Quelle commande permet de créer un nouveau répertoire ?

2.4) Quelle commande permet de naviguer vers un répertoire ?

2.5) Quelle commande permet d’afficher le contenu d’un répertoire dans l’interpréteur de commandes ?

2.6) Quelle commande permet de créer un fichier vide ?

2.7) Quelle commande permet de déterminer le contenu d’un fichier ?

2.8) Quelle commande permet de concaténer le contenu de fichiers avec d’autres fichiers et peut également être utilisé pour afficher le contenu d’un fichier ?

2.9) Quelle commande permet d’afficher des lignes à partir de la fin d’un fichier dans l’interpréteur de commandes ?

2.10) Quelle commande permet d’afficher les lignes du début d’un fichier dans l’interpréteur de commandes ?

2.11) Quelle commande permet de copier des fichiers ou des répertoires à un autre endroit ?

2.12) Quelle commande permet de déplacer des fichiers ou des répertoires vers un autre emplacement ?

2.13) Quelle commande permet de supprimer des fichiers ou des répertoires ?

2.14) Quelle commande permet de supprimer un répertoire vide ?

2.15) Quelle commande permet d’introduire une chaîne dans le shell?

2.16) Quelle commande permet de modifier les permissions du fichier ou du répertoire ?

2.17) Quelle commande permet de changer le mot de passe d’un utilisateur ?

2.18) Quelle commande permet de mettre fin à une session (et donc au shell) et permet de spécifier la valeur de retour d’un script shell ?

2.19) Quelle commande permet de redémarrer le système ?

2.20) Quelle commande permet d’arrêter le système ?

2.21) Quelle commande permet de créer un nouvel utilisateur ?

2.22) Quelle commande permet de supprimer un utilisateur ?

2.23) Quelle commande permet de modifier un utilisateur ?

2.24) Quelle commande permet d’afficher l’appartenance d’un utilisateur à un groupe ?

2.25) Quelle commande permet de créer un nouveau groupe ?

2.26) Quelle commande permet de supprimer un groupe ?

2.27) Quelle commande permet de modifier un groupe ?

2.28) Quelle commande permet de changer l’utilisateur (ownership) associé à un fichier ou à un répertoire ?

2.29) Quelle commande permet de changer le groupe associé à un fichier ou à un répertoire ?

2.30) Quelle commande permet de créer un lien ?

2.31) Quelle commande permet de rechercher dans un fichier les lignes qui contiennent un motif de recherche ?

2.32) Quelle commande permet d’afficher la liste des processus en cours dans l’interpréteur de commandes ?

2.33) Quelle commande permet de faire passer au premier-plan(foreground) un processus qui s’exécute dans l’arrière-plan(backgrund) de l’interpréteur de commandes ?

2.34) Quelle commande permet de faire passer un processus en arrière-plan de l’interpréteur de commandes ?

2.35) Quelle commande permet de tuer (terminer) un processus ?

2.36) Quelle commande permet de tuer (terminer) un groupe de processus ?

2.37) Quelle commande permet de spécifier la priorité d’un nouveau processus ?

2.38) Quelle commande permet de modifier la priorité d’un processus existant ?

2.39) Quelle commande permet d’afficher l’arbre des processus dans l’interpréteur de commandes ?

L’article Exercice Corrigé Système d’Exploitation Linux – Partie 2 est apparu en premier sur WayToLearnX.