1. Énoncé du problème : Nous avons un processeur à 100 MHz, un programme d'arrière-plan utilisant 30% du temps CPU, et des tâches périodiques toutes les 10 µs (10 microsecondes, car 10 ps semble une erreur probable, on prendra 10 µs). Nous devons calculer divers paramètres liés à l'exécution des tâches. 2. Données importantes : - Fréquence processeur $f = 100\ \text{MHz} = 100 \times 10^6\ \text{cycles/s}$ - Temps par cycle $T_c = \frac{1}{f} = \frac{1}{100 \times 10^6} = 10^{-8} \text{s} = 10 \text{ns}$ - Tâches toutes les 10 µs = $10 \times 10^{-6} \text{s} = 10^{-5} \text{s}$ - Programme d'arrière-plan prend 30% du temps CPU - Sauvegarde contexte = 45 cycles - Récupération contexte = 21 cycles - Traitement vecteur tâche = 30 cycles - Macro-instruction = 4 cycles 3. Calculs : **1. Temps nécessaire pour l'exécution d'une tâche** Le nombre total de cycles par tâche est la somme des cycles de sauvegarde, récupération et traitement : $$\text{Cycles par tâche} = 45 + 21 + 30 = 96$$ Le temps par tâche est donc : $$t_{t\^ache} = 96 \times T_c = 96 \times 10^{-8} = 9.6 \times 10^{-7} \text{s} = 0.96 \ \mu s$$ **2. Nombre d'instructions par tâche** Chaque instruction prend 4 cycles, donc : $$\text{Nombre d'instructions} = \frac{\text{cycles de traitement}}{\text{cycles par instruction}} = \frac{30}{4} = 7.5$$ On peut arrondir à 7 ou 8 instructions par tâche. **3. Nombre maximal d'instructions disponibles dans la fonction de traitement des tâches** Le temps total disponible par tâche est l'intervalle entre tâches moins le temps du programme d'arrière-plan (30% du temps CPU). Le temps total par tâche est $10 \ \mu s$. Le temps CPU disponible pour la tâche est donc 70% de $10 \ \mu s$ : $$t_{disponible} = 0.7 \times 10 \times 10^{-6} = 7 \times 10^{-6} \text{s}$$ Le nombre maximal de cycles disponibles est : $$N_{cycles} = \frac{t_{disponible}}{T_c} = \frac{7 \times 10^{-6}}{10^{-8}} = 700$$ Le nombre maximal d'instructions est : $$N_{instr} = \frac{N_{cycles}}{4} = \frac{700}{4} = 175$$ **4. Avec un autre programme d'arrière-plan prenant aussi 30% du temps (total 60%)** Le temps CPU disponible est 40% de $10 \ \mu s$ : $$t_{disponible} = 0.4 \times 10 \times 10^{-6} = 4 \times 10^{-6} \text{s}$$ Nombre de cycles disponibles : $$N_{cycles} = \frac{4 \times 10^{-6}}{10^{-8}} = 400$$ Nombre maximal d'instructions : $$N_{instr} = \frac{400}{4} = 100$$ **5. Avec 60 instructions par tâche et 60% du temps CPU utilisé par programmes d'arrière-plan, nombre maximum de tâches par seconde** Temps CPU disponible par tâche : $$t_{disponible} = 0.4 \times 10 \times 10^{-6} = 4 \times 10^{-6} \text{s}$$ Temps d'exécution par tâche (60 instructions × 4 cycles/instruction × $T_c$) : $$t_{t\^ache} = 60 \times 4 \times 10^{-8} = 2.4 \times 10^{-6} \text{s}$$ Nombre maximal de tâches par seconde : $$N_{t\^aches} = \frac{1}{t_{t\^ache}} = \frac{1}{2.4 \times 10^{-6}} \approx 416,666$$ Mais il faut vérifier que les tâches arrivent toutes les 10 µs, donc le nombre maximal est limité par la fréquence d'arrivée : $$N_{max} = \frac{1}{10 \times 10^{-6}} = 100,000$$ Donc le nombre maximal de tâches possibles est $100,000$ par seconde. **6. Temps d'exécution du programme d'arrière-plan $C_p = 30 \ \mu s$ exécuté en boucle infinie, nombre d'instructions du programme d'arrière-plan** Nombre de cycles pour $C_p$ : $$N_{cycles} = \frac{30 \times 10^{-6}}{10^{-8}} = 3000$$ Nombre d'instructions : $$N_{instr} = \frac{3000}{4} = 750$$ --- **Résumé final :** 1. Temps par tâche = $0.96 \ \mu s$ 2. Instructions par tâche = 7.5 (environ 7 ou 8) 3. Max instructions disponibles (30% arrière-plan) = 175 4. Max instructions disponibles (60% arrière-plan) = 100 5. Max tâches par seconde (60 instructions, 60% arrière-plan) = 100,000 6. Instructions programme arrière-plan (30 µs) = 750