bonjour

j'aurais aimé savoir si pour résoudre ça :

je devais genre enlever la boucle et mettre plusieurs "parbegin" ? (instruction marquant le début d'opérations en parallèle)

ou est-ce que je mets les 3 actions dans un seul parbegin ?

(est-ce que vous voyez de quoi je parle ?)

Je ne sias pas comment il veut que tu l'ecrive. Mais il veut qu'un processus fasse les read, qu'un processus fassent le calcul et qu'un autre fasse les writes.

oui oui ça j'ai bien compris
donc la boucle je la garde, c'est ça ?

bah c'est un genre de producer/consumer qu'il cherche. Du coup, j'ai aucune idee de la syntaxe qu'il veut.

C'est du pseudo code ? Je suppose queread(t[i])modifiet[i]. Trois boucle (une par tache) et deux compteurs global devraient le faire. Pour une solution plus compliqué, voir le pattern producteur-consommateur.

Le 14 septembre 2016 à 22:41:25 godrik a écrit :
bah c'est un genre de producer/consumer qu'il cherche. Du coup, j'ai aucune idee de la syntaxe qu'il veut.

producer consumer ??

Le 14 septembre 2016 à 22:51:47 CodeArtisan a écrit :
C'est du pseudo code ? Je suppose queread(t[i])modifiet[i]. Trois boucle (une par tache) et deux compteurs global devraient le faire. Pour une solution plus compliqué, voir le pattern producteur-consommateur.

oui tout à fait
ah pas bête en effet merci !

Producteur-consommateur est une technique de programmation concurrente où un ou plusieurs producteurs enfilent des objets sur une file d'attente (souvent de type PEPS mais pas forcement) et où un ou plusieurs consommateurs défilent cette dernière. En plus de la communication, la file d'attente joue aussi un rôle d'abstraction: Un producteur ne se soucie pas du rôle et du nombre de consommateurs. De même pour les consommateurs vis a vis du producteur. Si il y a une chaîne de producteurs/consommateurs comme c'est le cas présent, on parle alors d'un tube (pipeline). La technique permet aussi la séparation des charges pour une meilleur scalabilité: On analyse les étapes les plus lentes, les plus lourdes du tube et on y augmente le nombre de producteurs/consommateurs (meilleur granularité).

Le 15 septembre 2016 à 14:17:08 CodeArtisan a écrit :
Producteur-consommateur est une technique de programmation concurrente où un ou plusieurs producteurs enfilent des objets sur une file d'attente (souvent de type PEPS mais pas forcement) et où un ou plusieurs consommateurs défilent cette dernière. En plus de la communication, la file d'attente joue aussi un rôle d'abstraction: Un producteur ne se soucie pas du rôle et du nombre de consommateurs. De même pour les consommateurs vis a vis du producteur. Si il y a une chaîne de producteurs/consommateurs comme c'est le cas présent, on parle alors d'un tube (pipeline). La technique permet aussi la séparation des charges pour une meilleur scalabilité: On analyse les étapes les plus lentes, les plus lourdes du tube et on y augmente le nombre de producteurs/consommateurs (meilleur granularité).

merci ! j'ai pas tout compris mais on nous demande un truc un peu encore "simple" je pense (on débute en multi threading), j'ai lu aussi un peu l'article wikipedia et je suis pas tout :
https://fr.wikipedia.org/wiki/Probl%C3%A8me_des_producteurs_et_des_consommateurs

c'est quoi "verrouiller" et "déverrouiller" ??

https://en.wikipedia.org/wiki/Lock_%28computer_science%29

ok doncj 'ai fait la tactique des 3 boucles ça me semblait + simple parc eque le truc produteur/conso j'ai compris ce que c'est mais dans un truc à 3 processus j'arrive pas àl e concevor en fait

dites-moi comment vous trouvez ça

programme :
begin
I = 1;
parbegin
	while <= 15 do
		begin
			read(T[I]);
			I := I+1;

		end
	while <= 15 do
		begin
			T[I] := T[I]*5
			I := I+1;
		end
	while <= 15 do
		begin
			write(T[I]);
			I := I+1;
		end
parend

end

Je saurais pas dire si c'est ce que ton prof attends,
mais je vois un problème au niveau de I, tu ne le remets jamais à 0 .
t'incrémente encore plus à chaque boucle, 1 - 16 > 16 - 32 -> 32 - 48 (quoique je ne suis pas sur du while il commence à 0 ou 1?)

Encore une fois, ca m'a l'air d'etre un probleme de syntaxe plus qu'autre chose.
Tu veux aussi que le I du processus 2 soit toujours inferieur au I du processus 1. Traditionnellement, on aurait chaque boucle qui a son propre I: I1, I2, I3 et processus 1 passerait periodiquement I1 au processus 2 dans un tube (ou autre) pour permettre la synchro.

oui oui pardon j'ai oublié de remettre I à 1 en effet
ah oui godrik jvois

il me faut donc 3 compteurs ? genre comme ça ?

programme :

I = 1;
J = 1;
K = 1;

parbegin
	while I <= 15 do
		begin
			read(T[I]);
			I := I+1;

		end

	while J <= 15 do
		begin
			T[J] := T[J]*5
			J := J+1;
		end

	while K <= 15 do
		begin
			write(T[K]);
			K := K+1;
		end
parend

Assure toi que J ne devance pas I et que K ne devance pas J.

Le 18 septembre 2016 à 22:28:28 CodeArtisan a écrit :
Assure toi que J ne devance pas I et que K ne devance pas J.

ah putain trop tard jlai rendu ouais le prof m'a fait cette réflexion, merci quand même (pas grave c'est facultatif)