Discussion :

[manelisg]

Bonjour les amis, et voilà une autre débutante qui a besoin de votre aide. j'ai une méthode dans une classe que je veux quelle s'exécute en parallèle a un nombre prédéfins de fois cette méthode va être déclencher chaque 5mn

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
for (int i= 1; i<=6 ; i++)
{
	ant_pkt ant_pkt(sourc, dest , 0, i );
	int type = ant_pkt.get_type();
	int t=(unsigned int)time(0);
	do
	{
	
		printf("debut\n");
		n=rtable_.calc_next(k, parent, que);
		wait_on_queue(type, k , n, 1);
		printf("parcours \n");
		cross_the_link(k, n);
		int t_1 = (unsigned int)time(0);
		t_k_n = (unsigned int)difftime(t_1, t);
		ant_pkt.delete_memory(n);
		ant_pkt.add_memory(n,t_k_n);
		parent=k;
		k = n;
	}while (k != dest);

	ant_pkt.affichage_du_memoire();
	ant_pkt.become_backward_ant();
	type = ant_pkt.get_type();
	int initialtt = t_k_n ;
	for(int i=ant_pkt.get_size_list()-2;i>=0;i--)
	{
		update_traffic(ant_pkt, i, initialtt);
		update_table(ant_pkt,i);
	}
}

Voilà mon code qui s'exécute séquentielle mais ce que je cherche une exécution parallèle. j'ai jamais utilisés les threads et j'ai besoin de quelque guide et du code simple pour implémenter ca. J'utilise visiual studio 2008 sous windows XP. Merci d'avance pour chaque information. Sil vous plait aidez moi.

[Charlemagne]

OpenMP: c'est pas ce que je préfère (TBB...), mais c'est simple et efficace.
N'oublie pas de donner l'option de compilation correspondante à ton compilo (VC2005=/openmp)
Les gains en vitesse sont là si chaque thread est suffisamment long (typiquement au moins 100 000 instructions)

Faut écrire qqch du genre devant ta boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
#pragma omp parallel for schedule(dynamic,1)
for (int i= 1; i<=6 ; i++)

PS: Je suis pas sûr de répondre à ta question. Je sais pas comment tu veux mélanger le multi-threading et le démarrage toutes les 5m,

[Fabllot]

Bonjour,

Une autre solution est d'utiliser des bibliothèques (Qt, SDL, ...) qui proposent des classes et/ou structures qui gèrent les threads, ou alors d'utiliser directement les fonctions systèmes (voir l'api windows)...

Cela permet de bien contrôler le calcul parallèle...

Et un petit conseil dans ton code: évite d'utiliser le même nom de variable pour plusieurs variables différentes et utilisées en même temps...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
for (int i= 1; i<=6 ; i++)
{
	// [...] 
	for(int i=ant_pkt.get_size_list()-2;i>=0;i--)
	{
		update_traffic(ant_pkt, i, initialtt);
		update_table(ant_pkt,i);
	}
}

Es-tu sûr que les "i" de la seconde boucle "for" ont les bonnes valeurs ?
Quand tu as plusieurs boucles imbriquée, change les noms des indices : il y a 26 lettres dans l'alphabet!!!

[méphistopheles]

Pour l'avoir testé, je peux attester que boost::tread, une fois passé les premières difficultés du "tout raii" est vraiment simple et robuste.

En plus, un thread n'étant rien qu'une instanciation de classe, on n'a pas de problèmes de "conflits de threads non terminés" (du moment qu'on fait appel à des mutexes pour la comunication extra-thread).

Par contre, j'avoue ne jamais l'avoir testé sur windows, l'installation est peut-être plus compliquée dessus.



bonne chance

[manelisg]

merci pour votre aide. désolé pour la fautes des boucles intégrés j'ai pas fais attention . Pour la programmation parallèle je trouve que visual studio 2008 intègre openmp. Donc je choisi de travailer avec. Mais ce que je demande si vous savez si openmp implémente des threads simples ou non car déja quelques foncions de cette programmation parallèle sont des threads et merci d'avance

[manelisg]

Après une bonne lecture du msdn je vois que les api windows sont performant. donc je vais utilisé les api windows pour l'implémentation des threads car la création n'est pas totalement parallèle. En faite pas le même principe.


Maintenant j'ai implémenté mes threads avec leurs fonctions. Mais je dois gérer le partage de ressource.

En faite la fonction a traiter par les threads contient des appels a des procedure d'autres classe. Il ya 2 procédure non pas de la même classe qui accède à la même ressource. Une pour consulter et une pour ecrie. Bien sur l'écriture est prioritaire.

Est ce que c possible de d'implémenter cela et avec quel objet: mutex ou section critique? Pouvez vous m'aider svp c urgent.

[Fabllot]

Est ce que c possible de d'implémenter cela et avec quel objet: mutex ou section critique?

Oui, c'est possible... Une section critique étant le code entre mutex (lock / unlock) je dirais ... les deux !
Regarde aussi les sémaphores... Car dans ton cas, on peut faire lire plusieurs thread en même temps, mais un seul doit écriture, sans aucun autre lise à se moment là... Regarde du coté des algorithmes qui utilisent des sémaphores/mutex tu trouveras pas mal de choses...

Pouvez vous m'aider svp c urgent.

Commentaire inutile... Tout est urgent, mon job le premier !

[JolyLoic]

Oui, c'est possible... Une section critique étant le code entre mutex (lock / unlock) je dirais ... les deux !

Dans le vocable spécifique à windows, une section critique est en fait une sorte de mutex avec un faible overhead, mais confiné au sein d'un seul processus.

[manelisg]

Merci pour votre réponse c'est intéressant. Voila pour mon travail j'ai trouvé que les mutex sont suffisantes pour gérer les ressources de la fonction lire ma_table car deja cette fonction contient des ecritures dans des listes. Mais a part ca mes threads effectue un mise à jour dans ma_table. c'est à dire que chaque threads fais une lecture puis une ecriture dans ma table. et je ne sais pas que dois je utiliser pour gérer ca. il ya personne qui peut m'aider avec un grand merci
voici mon code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
DWORD antnet::forward_ant(ant_pkt *ant_pk)
{
	
	do
	{
		printf("debut\n");
		 dwWaitResult = WaitForSingleObject( 
            ghMutex,    // handle to mutex
            INFINITE);  // no time-out interval
 
        switch (dwWaitResult) 
        {
            // The thread got ownership of the mutex
            case WAIT_OBJECT_0: 
                __try { 
                           ant_pk->ant_next = rtable_.calc_next(ant_pk->ant_k, ant_pk->ant_parent, que);
						} 

                __finally { 
                    // Release ownership of the mutex object
                    if (! ReleaseMutex(ghMutex)) 
                    { 
                        // Handle error.
                    } 
                } 
                break; 
        }
		
		
	}while (ant_pk->ant_k != ant_pk->ant_dest);
	for(int i=ant_pkt->get_size_list()-2;i>=0;i--)
	{
		
						update_traffic(*ant_pkt, i, initialtt);
						update_table(*ant_pkt,i);
			
       
	}

les 2 bout de code en gras sont les concernés par la gestion d'accés à la ressource