← Toutes les ressources pour les enseignants

Imprimer la fiche de l’élève Voir le corrigé

Corrigé pour l’enseignant

Ordonnancement, cœurs et événements

Recueillez quatre types d’indices : prédiction de l’état pertinent ; comportement dans des cas variés, y compris aux limites ; explication fondée sur la trace et l’état ; correction justifiée d’un écart. Évaluez chacun comme en développement, avec soutien ou autonome, sur papier ou selon la procédure approuvée de votre école. Réussir un défi prouve un comportement de la machine, pas la paternité du code ni une maîtrise complète. Acceptez les programmes équivalents corrects : le corrigé public est un modèle, pas l’unique réponse possible.

Matériel pédagogique public. Les solutions sont des exemples ; des programmes équivalents corrects peuvent aussi réussir les vérifications réelles.

25. Ordonnancement coopératif

Faites alterner des tâches et distinguez la politique d’exécution des instructions du processeur.

Ouvrir cette leçon →

1. Prévoir et tracer

Avant d’exécuter le programme d’essai, prévoyez sa sortie et tracez les trois premières instructions exécutées. Suivez les registres, les indicateurs ou la mémoire pertinents, selon le besoin. Avancez ensuite pas à pas pour comparer.

LOAD 1
CALL taskA
CALL taskB
HALT
taskA: PRINT
SLEEP 500
RETURN
taskB: LOAD 101
PRINT
RETURN

Ajouter les entrées à la file: Aucune

Initialiser la mémoire: Tous les octets sont initialement nuls

Corrigé de la prédiction d’essai

Sortie: 1, 101

Instruction	PC avant	PC après	R0 avant	R0 après	État pertinent	Sortie
LOAD	0	1	0	1	`{"registers":[1,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Aucune
CALL	1	4	1	1	`{"registers":[1,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[],"callStack":[2],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Aucune
PRINT	4	5	1	1	`{"registers":[1,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[],"callStack":[2],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	1

2. Construire et vérifier

Lisez un nombre de tours de 0 à 3. Faites commencer le compteur de la tâche A à 0 et celui de B à 100. À chaque tour, appelez A pour augmenter et afficher son compteur, puis B pour augmenter et afficher le sien.

Types d’instructions requis: INPUT, LOOP, CALL, RETURN

Exemple de solution du défi

INPUT
COPY R0 R3
LOAD 0 R1
LOAD 100 R2
LOOP R3
CALL taskA
CALL taskB
RETURN
HALT
taskA: LOAD R1
ADD 1
COPY R0 R1
PRINT
SLEEP 0
RETURN
taskB: LOAD R2
ADD 1
COPY R0 R2
PRINT
SLEEP 0
RETURN

Cas réels du vérificateur

Cas 1

Entrée: 0
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: Aucune

Cas 2

Entrée: 1
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: 1, 101

Cas 3

Entrée: 3
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: 1, 101, 2, 102, 3, 103

3. Expliquer la machine

L’alternance CALL/RETURN équivaut-elle à la préemption matérielle ?

Raisonnement et note pédagogique

Non. C’est un modèle de répartiteur coopératif ; la politique et le quantum de l’ordonnanceur relèvent de la simulation des systèmes explicitement identifiée.

26. Répartir le travail entre des cœurs

Divisez des travaux indépendants et combinez leurs résultats.

Ouvrir cette leçon →

1. Prévoir et tracer

STORE 1 0
STORE 2 1
STORE 3 2
STORE 4 3
LOAD [0]
MUL R0
COPY R0 R1
LOAD [2]
MUL R0
ADD R1
PRINT
HALT

Ajouter les entrées à la file: Aucune

Initialiser la mémoire: 0: 1, 1: 2, 2: 3, 3: 4

Corrigé de la prédiction d’essai

Sortie: 10

Instruction	PC avant	PC après	État pertinent	Sortie
STORE	0	1	`{"registers":[0,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[0]}`	Aucune
STORE	1	2	`{"registers":[0,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[1]}`	Aucune
STORE	2	3	`{"registers":[0,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[2]}`	Aucune

2. Construire et vérifier

Quatre valeurs de travaux sont préparées en mémoire 0 à 3. Le traitement pair calcule valeur[0]² + valeur[2]² ; le traitement impair calcule valeur[1]² + valeur[3]². Appelez les deux. Affichez le total pair, le total impair et le total combiné, dans cet ordre.

Types d’instructions requis: CALL, MUL, LOAD, ADD

Exemple de solution du défi

CALL evenWorker
PRINT
CALL oddWorker
PRINT
LOAD R1
ADD R2
PRINT
HALT
evenWorker: LOAD [0]
MUL R0
COPY R0 R1
LOAD [2]
MUL R0
ADD R1
COPY R0 R1
RETURN
oddWorker: LOAD [1]
MUL R0
COPY R0 R2
LOAD [3]
MUL R0
ADD R2
COPY R0 R2
RETURN

Cas réels du vérificateur

Cas 1

Entrée: Aucune
Mémoire initiale: 0: 1, 1: 2, 2: 3, 3: 4
Sortie attendue: 10, 20, 30
Lectures mémoire requises: 0, 1, 2, 3

Cas 2

Entrée: Aucune
Mémoire initiale: 0: 0, 1: 4, 2: 5, 3: 1
Sortie attendue: 25, 17, 42
Lectures mémoire requises: 0, 1, 2, 3

Cas 3

Entrée: Aucune
Mémoire initiale: 0: 10, 1: 1, 2: 2, 3: 3
Sortie attendue: 104, 10, 114
Lectures mémoire requises: 0, 1, 2, 3

3. Expliquer la machine

Calculer successivement les totaux de deux traitements prouve-t-il une exécution parallèle ?

Raisonnement et note pédagogique

Non. Cela vérifie la décomposition et la combinaison. Les voies indépendantes de machines virtuelles démontrent des états distincts dans la simulation, sans promesse de vitesse matérielle.

27. Interruptions et gestionnaires

Traitez un événement et restaurez la valeur du programme interrompu.

Ouvrir cette leçon →

1. Prévoir et tracer

STORE 4 240
LOAD 17
CALL handler
PRINT
LOAD [241]
PRINT
HALT
handler: PUSH
LOAD [240]
ADD 1
STORE 241
POP
RETURN

Ajouter les entrées à la file: Aucune

Initialiser la mémoire: Tous les octets sont initialement nuls

Corrigé de la prédiction d’essai

Sortie: 17, 5

Instruction	PC avant	PC après	R0 avant	R0 après	État pertinent	Sortie
STORE	0	1	0	0	`{"registers":[0,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[240]}`	Aucune
LOAD	1	2	0	17	`{"registers":[17,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Aucune
CALL	2	7	17	17	`{"registers":[17,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[],"callStack":[3],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Aucune

2. Construire et vérifier

Lisez un entier du programme principal, puis un octet d’événement. Enregistrez l’événement à l’adresse 240. Appelez un gestionnaire qui écrit événement + 1 dans l’octet mémoire 241 en préservant R0 avec PUSH et POP. Affichez la valeur principale restaurée, puis le résultat enregistré de l’événement.

Types d’instructions requis: INPUT, PUSH, POP, CALL, STORE

Exemple de solution du défi

INPUT
COPY R0 R1
INPUT
STORE 240
LOAD R1
CALL handler
PRINT
LOAD [241]
PRINT
HALT
handler: PUSH
LOAD [240]
ADD 1
STORE 241
POP
RETURN

Cas réels du vérificateur

Cas 1

Entrée: 17, 4
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: 17, 5
Mémoire finale attendue: 240: 4, 241: 5
Lectures mémoire requises: 240, 241

Cas 2

Entrée: -8, 0
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: -8, 1
Mémoire finale attendue: 240: 0, 241: 1
Lectures mémoire requises: 240, 241

Cas 3

Entrée: 33, 255
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: 33, 0
Mémoire finale attendue: 240: 255, 241: 0
Lectures mémoire requises: 240, 241

3. Expliquer la machine

Que doit restaurer un gestionnaire avant la reprise du programme principal ?

Raisonnement et note pédagogique

La valeur ou l’état principal encore nécessaire à son appelant ; les compteurs d’événements peuvent changer volontairement. Après l’augmentation de 255 à 256, l’octet enregistré devient 0.