User Tools

Site Tools


in204:tds:sujets:td8:part2

This is an old revision of the document!


Section critique

TD8

Références

Question n°1

Nous supposons que nous avons deux fonctions, une première fonction calcule la valeur maximale d’un tableau numérique :

void array_find_max(const std::vector<int>& theArray, int* theMaxValue)
!{
	int result = theArray[0];
	for (int i = 1; i < (int)theArray.size(); i++)
	{
		if (theArray[i] > result)
			result = theArray[i];
	}
	*theMaxValue = result;
}

la seconde fonction modifie le tableau en multipliant chaque valeur numérique du tableau par 2 :

void array_multiply_by(std::vector<int>& theArray, int theValue)
{
	for (int i = 1; i < theArray.size(); i++)
		theArray[i] *= theValue;
}

Ecrire chacune des fonctions.

Question 2

Nous souhaitons exécuter en parallèle les deux fonctions.

Exécuter plusieurs fois ces fonctions sur un tableau de grande taille que vous créez soit de manière aléatoire soit de manière cycliques. Ci-dessous quelques exemples de fonctions générant des tableaux de taille n et ayant comme valeur des nombres entre 0 et theMaxValue.

void initialize_array(std::vector<int>& theArray, int theSize,
	int theMaxValue)
{
	theArray.clear();
	int step = theMaxValue / 3;
	theArray[0] = 0;
	for (int i = 1; i < theSize; i++)
			theArray[i] = (theArray[i-1] + step) % (theMaxValue + 1);
}

Ou

void initialize_random_array(std::vector<int>& theArray, int theSize,
	int theMaxValue)
{
	theArray.clear();
	for (int i = 0; i < theSize; i++)
		theArray[i] = std::rand() % (theMaxValue + 1);
}

Expliquer pourquoi les résultats ne sont pas toujours cohérents ? ie. que la valeur maximale retournée est supérieure à la valeur maximale du tableau spécifiée au montant de sa création.

Question n°3

Il faut utiliser un verrou qui permet à une méthode de se garantir l’exclusivité de l’usage du tableau. Pour ce faire, nous pouvons utiliser un objet std::mutex qui encapsule un mécanisme d’exclusion mutuelle. L’objet std::unique_lock permet d’obtenir un accès exclusif sur un object std::mutex. Quand nous écrivons le code suivant :

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::unique_lock
 
std::mutex mtx;           // mutex fournissant le mécanisme d’exclusion mutuelle.
 
void my_function (int n, char c) {
	// section critique, tant que l'objet lck existe, personne ne pourra
	// accéder à mtx.
	std::unique_lock<std::mutex> lck(mtx);
	// Code s'exécutant.
}

Question n°3.1

Modifier les fonctions

int array_find_max(std::vector<int>& theArray, int* theMaxValue)

et

void array_multiply_by(std::vector<int>& theArray, int theValue)

pour implanter le mécanisme d’exclusion mutuelle propose.

Question n°3.2

Exécuter le code et vérifier que les résultats sont dorénavant cohérents.

in204/tds/sujets/td8/part2.1573487148.txt.gz · Last modified: 2019/11/11 15:45 by bmonsuez