Un programme qui utilise open_mp pour trouver des nombre premier.

Soyez le premier à donner votre avis sur cette source.

Snippet vu 8 937 fois - Téléchargée 26 fois

Contenu du snippet

Ce programme utilise une technologie particuliere pour integrer le support des threads.
OPEN_MP est base sur un macro language a base de #pragma et aussi sur le compilateur qui doit etre OPEN_MP compatible
le compilateur C/C++ de MS DEV-STUDIO PRO 2005 est 100% compatible.

Pour plus d'info : http://www.openmp.org/drupal/

Source / Exemple :


// OPEN_MP_01.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "windows.h"

#include "stdio.h"
#include "math.h"
#include "stdlib.h"
#include "omp.h"

int main(int argc, char *argv[])
{
	int i, j, limit;
	int start, end;          /* range of numbers to search */
	int number_of_primes=0;  /* number of primes found */
	int number_of_41primes=0;/* number of 4n+1 primes found */
	int number_of_43primes=0;/* number of 4n-1 primes found */
	int prime;               /* is the number prime? */
	int print_primes=0;      /* should each prime be printed? */
	DWORD dwStart, dwStop;
	float fElapsed;

	start = atoi(argv[1]);
	end = atoi(argv[2]);
	if (!(start % 2)) start++;

	if (argc == 4 && atoi(argv[3]) != 0) print_primes = 1;
	printf("Range to check for Primes: %d - %d\n\n",start, end);

	dwStart = GetTickCount();

#pragma omp parallel
	{
		int numPrimes=0;    /* local number of primes found */
		int num41Primes=0;  /* local number of 4n+1 primes found */
		int num43Primes=0;  /* local number of 4n-1 primes found */

#pragma omp for schedule(dynamic,1000)
		for(i = start; i <= end; i += 2) {
			int limit, j, prime;
			limit = (int) sqrt((float)i) + 1;
			prime = 1; /* assume number is prime */
			j = 3;
			while (prime && (j <= limit)) {
				if (i%j == 0) prime = 0;
				j += 2;
			}

			if (prime) {
				if (print_primes) printf("%5d is prime\n",i);
#pragma omp atomic
				number_of_primes++;

				if (i%4 == 1) {
#pragma omp atomic
					number_of_41primes++;
				}

				if (i%4 == 3) {
#pragma omp atomic
					number_of_43primes++;
				}

			}
		} // end for
	} // end parallel region

	dwStop = GetTickCount();
	fElapsed = (float) (((float)dwStop-(float)dwStart) / (float) 1000.0);
	printf("Total Elapsed time :%f Seconds\n",fElapsed);
	printf("\nProgram Done.\n %d primes found\n",number_of_primes);
	printf("\nNumber of 4n+1 primes found: %d\n",number_of_41primes);
	printf("\nNumber of 4n-1 primes found: %d\n",number_of_43primes);
}

Conclusion :


Pour utiliser le code : OpenMP.exe 1 100000
Le programme recherche les nombres premier... OPEN_MP permet a certaine partie du code d'etre automatiquement parallelise...
Donc si vous avez un ordi avec deux processeurs ou mieux un DUAL-CORE alors le programme va creer automatiquement
deux ou plus threads qui executerons par exemple la boucle :


#pragma omp parallel
{
int numPrimes=0; /* local number of primes found */
int num41Primes=0; /* local number of 4n+1 primes found */
int num43Primes=0; /* local number of 4n-1 primes found */

#pragma omp for schedule(dynamic,1000)
for(i = start; i <= end; i += 2) {
int limit, j, prime;
limit = (int) sqrt((float)i) + 1;
prime = 1; /* assume number is prime */
j = 3;
while (prime && (j <= limit)) {
if (i%j == 0) prime = 0;
j += 2;
}

if (prime) {
if (print_primes) printf("%5d is prime\n",i);
#pragma omp atomic
number_of_primes++;

if (i%4 == 1) {
#pragma omp atomic
number_of_41primes++;
}

if (i%4 == 3) {
#pragma omp atomic
number_of_43primes++;
}

}
} // end for
} // end parallel region

Donc je vous laisse deviner comment un programme qui utilise cette techno peut etre utilise pour accelerer une application.

A voir également

Ajouter un commentaire

Commentaires

lynxtyle
Messages postés
79
Date d'inscription
samedi 25 septembre 2004
Statut
Membre
Dernière intervention
31 octobre 2011
2 -
cette source date d'il y a un bail et je n'ai pas trop le temps de la relire mais si je ne me trompe pas, afin d'accélèrer la recherche il divise par tout les premiers trouvé (plutôt que par tout les impair...), donc la directive atomic à pour but d'attendre que chaque thread apporte les derniers premiers trouvé (sinon si un thread prennait trop de retard il se pourrait qu'un thread avec beaucoup d'avance retourne un premier alors qu'il ne l'ait pas car divisible par le premier en court de calcul sur le thread lent...)

tu vas me dire : mais il y a très peut de chance que ça arrive... je te répondrais imagine le cas suivant : tu utilise open_mp sur une grappe, l'un des ordinateurs de la grappe tombe en panne, dans ce cas avec la directive atomic le calculateur s'arrête (tu rajoute un timeout pour relancer les calculs raté sur le reste de la grappe et tu évite ainsi une énorme erreur qui peu couter cher à ton travail de recherche^^)

ici tu ne perd théoriquement pas grand chose en vitesse de calcul car le nombre total de calcul de chaque thread est équivalant donc ils finissent tous un peu près en même temps...

voilà j'espère que ça répond à ta question...


PS : aujourd'hui open_mp est un peu "dépassé" par les calculateurs GPU (cf. NVidia CUDA, ATI Stream et dans la ligné des opens : OpenCL qui va gérer les thread CPU et GPU)
OpenCL intégre d'ailleur OpenMP et à l'avantage d'être compatible avec les cartes NVidia et ATI. Avec la programmation GPU on arrive à des monstres de supercalculateurs pas si cher que ça !
hassansaib
Messages postés
2
Date d'inscription
jeudi 7 avril 2011
Statut
Membre
Dernière intervention
28 avril 2011
-
pour quoi tu a fais la directive atomic
lynxtyle
Messages postés
79
Date d'inscription
samedi 25 septembre 2004
Statut
Membre
Dernière intervention
31 octobre 2011
2 -
vous êtes un peu à côté : c'est pas du multithread à proprement parler... mais du Symmetric MultiProcessing c'est à dire du multithread mais symétrique (pour généraliser tout les thread font le même calcul au même moment mais sur une zone mémoire différente... donc qu'un thread par coeur maxi...)
La différence avec du multithread que procure l'API Windows? un gain plus qu'important de vitesse et une certaine facilité à programmer sur une grappe... rien que ça! Par contre il ne peut pas être utilisé dans bon nombre de cas de multithread : inutile d'espérer l'utiliser pour programmer un serveur multithread... c'est juste bon pour du calcul scientifique... et encore ces calculs doivent répondre à quelques exigences!

Pour finir je dis bravo à SuntzuMaster pour cette source car je dois dire qu'il y a peu de personne qui maîtrise le SMP

Sinon juste un petite remarque : utilise plutot "clock()" (que tu peux pourquoi pas divisé par "CLOCKS_PER_SEC" pour avoir le résultat en seconde) afin de donner le temps processuce d'exécution du programme (l'avantage c'est que tu prend en compte les temps d'allocation etc... ce qui permet d'être plus juste sur le temps réel d'exécution et surtout ça fait des variables en mémoire en moins... je sais je suis un rapia^^)

Enfin pour ce qui souhaite approfondir leur connaissances en SMP intêressez vous en plus de OPENMP à MPI (qui aurai était ici encore plus puissant)
SuntzuMaster
Messages postés
1
Date d'inscription
lundi 6 mars 2006
Statut
Membre
Dernière intervention
24 décembre 2006
-
OPENMP est une techno qui permet d'utiliser des threads sana avoir a connaitre L'API Windows.
Un programme qui utilise OPENMP est compatible avec d'autre plateformes UNIX,...
pour plus d'info openmp.org.
yann_lo_san
Messages postés
1137
Date d'inscription
lundi 17 novembre 2003
Statut
Membre
Dernière intervention
23 janvier 2016
17 -
Apparemment le thread se crée et se ferme tout seul.
Sympa ce code.
A plus.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.