PROFDINFO.COM

Votre enseignant d'informatique en ligne

Laboratoire - L'ordonnanceur temps réel - Solution

La course au milliard

	
#include <sys/types.h>
#include <process.h>
#include <pthread.h>
#include <sys/neutrino.h>
#include <iostream>

void* A(void* p)
{
	struct sched_param params;
	int policy;
	
	pthread_getschedparam(pthread_self(), &policy, ¶ms);
	params.sched_priority = 12; 
	pthread_setschedparam(pthread_self(), SCHED_RR, ¶ms);
	
	for(unsigned int i=0;i<1000000000;i++);
	std::cout << "A" << std::flush;
}

void* C(void* p)
{
	struct sched_param params;
	int policy;
	
	pthread_getschedparam(pthread_self(), &policy, ¶ms);
	params.sched_priority = 11; 
	params.sched_ss_low_priority = 9;
	params.sched_ss_max_repl = SS_REPL_MAX;
	params.sched_ss_repl_period.tv_sec = 0;
	params.sched_ss_repl_period.tv_nsec = 12000000; //24000000
	params.sched_ss_init_budget.tv_sec = 0;
	params.sched_ss_init_budget.tv_nsec = 8000000;
	
	pthread_setschedparam(pthread_self(), SCHED_SPORADIC, ¶ms);
	
	for(unsigned int i=0;i<1000000000;i++);
	std::cout << "C" << std::flush;
}

void* D(void* p)
{
	struct sched_param params;
	int policy;
	
	pthread_getschedparam(pthread_self(), &policy, ¶ms);
	params.sched_priority = 10; 
	pthread_setschedparam(pthread_self(), SCHED_RR, ¶ms);
	
	for(unsigned int i=0;i<1000000000;i++);
	std::cout << "D" << std::flush;
}

void* B(void* p)
{
	pthread_t id;
	
	struct sched_param params;
	int policy;
	
	pthread_getschedparam(pthread_self(), &policy, ¶ms);
	params.sched_priority = 10; 
	pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶ms);
	
	pthread_create(&id, 0, C, 0);  
	pthread_join(id, 0);
	
	for(unsigned int i=0;i<1000000000;i++);
	std::cout << "B" << std::flush;
}

int main()
{
	pthread_t ida, idb, idd;
	
	pthread_create(&ida, 0, A, 0);  
	pthread_create(&idb, 0, B, 0);  
	pthread_create(&idd, 0, D, 0);  
	
	pthread_join(ida,0);
	pthread_join(idb,0);
	pthread_join(idd,0);
	
	return EXIT_SUCCESS;
}

Le démarrage de processus

 

Fonction
Valeur de retour
Paramètres
Création d'un processus distant (vrai ou faux)
Création d’un nouveau processus (vrai ou faux)
Partage du code source (vrai ou faux)
Copie des données (vrai ou faux)
fork
   
-1, 0 ou pid
aucun
faux
vrai
vrai
vrai
spawn*
   
-1, 0, pid, code de retour
mode(wait,nowait),exécutable, arguments
vrai
vrai
faux
faux
exec*
   
-1 ou rien
exécutable, arguments
faux
faux
faux
faux

Le bonheur d'être parent

  1. Si les deux processus utilisent la même variable locale déclarée au tout début du programme principal est-ce que cela perturbe le bon fonctionnement des processus? Justifiez votre réponse. Non, la variable est dupliquée lors d'un appel à fork.
  2. Quels seront la priorité et l'algorithme d'ordonnancement du processus enfant? Validez votre réponse en utilisant les fonctions pthread_setschedparam et pthread_getschedparam. Même priorité et même algorithme d'ordonnancement que le parent.
  3. Si le processus parent termine son exécution avant le processus enfant, est-ce que cela affecte l'exécution du processus enfant? Non à moins que le parent envoie un signal SIGKILL à l'enfant avant de se terminer.
  4. Quelle modification devez-vous apportez à votre programme afin que les nombres de 1 à 100 s'affichent en ordre croissant? Ajouter un appel à la fonction wait.
  5. Proposez une façon d'échanger des informations entre le processus enfant et le processus parent. Utiliser le système de fichiers (très lent!) ou la communication inter-processus.
Voici le code source utilisé pour répondre aux questions:

#include <sys/types.h>
#include <process.h>
#include <pthread.h>
#include <sys/neutrino.h>
#include <iostream>	  

void AfficherParams(int policy, const sched_param& params)
{
	std::cout << "Policy:";
	switch(policy)
	{
		case SCHED_RR: std::cout << "Round Robin" << std::endl; break;
		case SCHED_FIFO: std::cout << "FIFO" << std::endl; break;
		case SCHED_SPORADIC: std::cout << "Sporadic" << std::endl; break;
		default: std::cout << "Other" << std::endl; break;
	}
	std::cout << "curpriority:" << params.sched_curpriority << std::endl;
	std::cout << "priority:" << params.sched_priority << std::endl;
	std::cout << "ss_low_priority:" << params.sched_ss_low_priority << std::endl;
	std::cout << "ss_max_repl:" << params.sched_ss_max_repl << std::endl;  
	std::cout << "ss_repl_period.tv_sec:" << params.sched_ss_repl_period.tv_sec << std::endl;  
	std::cout << "ss_repl_period.tv_nsec:" << params.sched_ss_repl_period.tv_nsec << std::endl;  
	std::cout << "ss_init_budget.tv_sec:" << params.sched_ss_init_budget.tv_sec << std::endl;
	std::cout << "ss_init_budget.tv_nsec:" << params.sched_ss_init_budget.tv_nsec << std::endl;
}

int main()
{
	struct sched_param params;
	int policy;
	
	pthread_getschedparam(pthread_self(), &policy, ¶ms);
	params.sched_priority = 12; 
	pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶ms);
	pthread_getschedparam(pthread_self(), &policy, ¶ms);
	
	AfficherParams(policy, params);

	pid_t enfant = fork();
	
	if(enfant==0)
	{
		pthread_getschedparam(pthread_self(), &policy, ¶ms);
	    AfficherParams(policy, params);
		
		// processus enfant
		for(long i=1;i<=50;i++)
		   std::cout << i << std::endl;
	}
	else
	{
		wait((int*)0);
		
		// processus parent
		for(long i=51;i<=100;i++)
		   std::cout << i << std::endl;
	}
	
	return EXIT_SUCCESS;
}