Un dispositif extérieur déclenche une interruption toutes les millisecondes. La prise en compte de cette interruption par le système entraîne l'exécution du programme suivant:

{ programme sous IT horloge }
cpt_mes := ( cpt_mes + 1 ) mod 1000;
si cpt_mes = 0 alors
	cpt_sec := ( cpt_sec + 1 ) mod 60;
	si cpt_sec = 0 alors
		cpt_min := ( cpt_min + 1 ) mod 60;
		si cpt_min = 0 alors
			cpt_h := ( cpt_h + 1 ) mod 24;
			si cpt_h = 0 alors cpt_j := cpt_j + 1;
			finsi;
		finsi;
	finsi;
finsi;

A- Dé1finir la fonction système qui délivre dans un tableau de 5 entiers la date exacte, à la milliseconde près, au moment de l'appel. On prendra garde au fait que l'interruption d'horloge peut survenir pendant l'exécution de cette fonction.

B- Dans le cas d'un système en monoprogrammation, comment vous proposeriez-vous d'utiliser cette fonction système pour optimiser la durée d'exécution d'un programme?

C- Dans le cas d'un système en multiprogrammation, qu'est-ce qui empêche d'utiliser cette fonction pour aider à optimiser la durée d'exécution d'un programme?

L'interruption d'horloge pouvant intervenir à tout moment, si elle est prise en compte pendant l'appel de la fonction système, certains des entiers transmis seront relatifs au temps précédant l'interruption, d'autres à celui qui le suit, et il y aura incohérence dans les données. Pour éviter que l'interruption soit prise en compte pendant l'exécution de la fonction, il suffit de masquer les interruptions au début et de les démasquer à la fin. Si on ne veut pas perdre d'interruption d'horloge, il faut que la durée de ce masquage soit assez bref. Étant donné que cette exécution est plus simple que le programme de prise en compte de l'interruption elle-même, on peut penser que ce sera bien le cas, sinon la machine passerait son temps à mettre à jour les compteurs de l'horloge!

fonction temps ( var t: tableau [1..5] de entier);
début
	masquer_IT_horloge;
	t [1] := cpt_mes;
	t [2] := cpt_sec;
	t [3] := cpt_min;
	t [4] := cpt_h;
	t [5] := cpt_j;
	démasquer_IT_horloge;
fin;

Cette fonction permet donc de connaître à tout moment l'heure exacte. Si on l'appelle à différents endroits d'un programme, on peut alors, par différence, calculer le temps écoulé entre deux appels successifs. En monoprogrammation, le programme étant seul en mémoire, ce temps est donc la durée d'exécution (temps Unité Centrale et temps d'entrées-sorties) du programme. En faisant de telles mesures, il est donc possible de savoir quelles parties du programme prennent le plus de temps, et essayer d'optimiser ces parties.

Dans le cas d'un système en multiprogrammation, un processus passe successivement dans trois états: prêt, élu, bloqué. La mesure de durée obtenue par différence entre deux appels à la fonction temps, mesure en fait le temps pendant lequel le processus a utilisé l'unité centrale, et le temps d'attente des entrées-sorties (bloqué), mais aussi le temps pendant lequel il a été en attente du processeur attribué à un autre processus. Ce dernier temps, imprévisible et sans lien avec le comportement du programme, doit pouvoir être éliminé des mesures, si on désire les utiliser pour savoir les endroits du programme qui sont les plus coûteux. Les mesures importantes pour optimiser la durée d'exécution d'un programme sont en fait le temps virtuel, représentant le temps pendant lequel le processus a été actif, et le temps pendant lequel le processus est resté bloqué. Ceux-ci peuvent être mesurés par le système chaque fois qu'il change l'état du processus suivant le graphe ci-dessus.