begin process at 2013 05 20 04:55:19
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Système

 > UN PROGRAMME QUI UTILISE OPEN_MP POUR TROUVER DES NOMBRE PREMIER.

UN PROGRAMME QUI UTILISE OPEN_MP POUR TROUVER DES NOMBRE PREMIER.


 Information sur la source

Note :
10 / 10 - par 1 personne
10,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Système Classé sous :openmp, thread Niveau :Expert Date de création :21/12/2006 Vu :8 002

Auteur : SuntzuMaster

Ecrire un message privé
Commentaire sur cette source (6)
Ajouter un commentaire et/ou une note

 Description

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

  • // 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);
  • }
// 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++;
}

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

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

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





 Sources du même auteur

Source avec Zip UTILISATION DES THREADS WINDOWS.

 Sources de la même categorie

Source avec Zip Source avec une capture OBTENIR DANS UN FICHIER LE CONTENU D'UN DOSSIER WINDOWS par pgl10
Source avec Zip Source avec une capture INFORMATION PROCESSEUR (CPUID) par Devils_Tiger
Source avec Zip Source avec une capture LECTURE TEMPÉRATURE PROCESSEUR par Devils_Tiger
Source avec Zip Source avec une capture LECTURE FRÉQUENCE PROCESSEUR par Devils_Tiger
Source avec Zip DETECTEUR EJP par idpro

 Sources en rapport avec celle ci

Source avec Zip CHAT EN MODE CONSOLE AVEC API WINDOWS par Pylouq
Source avec Zip Source avec une capture SOKOBAN EN C POUR DÉBUTANT (VERSION AMÉLIORÉE BASÉE SUR LE T... par eustatika
Source avec Zip MINICHAT MULTI-CLIENT par wisar
Source avec Zip Source avec une capture [C++] HASH FINDER - CALCULATEUR DE HASH par ordiman85
Source avec Zip Source avec une capture ALGO DE PATHFINDING AVEC PETIT JEU par kts_system

Commentaires et avis

Commentaire de NairodDorian le 23/12/2006 15:45:36

Bonjour,

Quelle est la différence entre la techno OMP et l'utilisation des fonctions MultiThread de l'API Windows ?

Cordialement,

Commentaire de yann_lo_san le 23/12/2006 16:15:14

Apparemment le thread se crée et se ferme tout seul.
Sympa ce code.
A plus.

Commentaire de SuntzuMaster le 24/12/2006 21:29:52

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.

Commentaire de lynxtyle le 30/12/2007 05:46:10 10/10

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)

Commentaire de hassansaib le 28/04/2011 17:34:17

pour quoi tu a fais la directive atomic

Commentaire de lynxtyle le 29/04/2011 16:31:35

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 !

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

Thread dans une dll [ par angel ] Est-il possible de créer un thread dans une dll ? Controler une ListBox avec un thread [ par header ] Apres avoir creer et appeler ma fct thread j'aimerai controler une listbox.(ou un autre controle)Comment je dois faire ???Comment attacher une variabl Pointeur sur methodes avec parametre [ par Kinamstrong ] Salut a toi,Je cherche à savoir comment marche les pointeurs sur les methodes avec parametres.Qu'est ce qui va differencier deux meme methodes en cour Lancer une thread intraclasse [ par rudyg ] Salut tout le monde,depuis une methode de classe, je souhaite lancer une thread faisant appel a une AUTRE methode de la meme classe.Ex:void kernel::La Thread [ par Vince007 ] Bonjour, je vous laisse se message pour savoir si qqu'un qui connait bien les thread et les sémaphores sous Linux pourrait m'indiquer la méthode de co thread et librairies [ par galamor ] salut, je débute sur visual C++j'aimerai savoir si quelqu'un pourrait me dire où trouver des informations précises et/ou des exemples sur l'utilisatio terminer un thread [ par galamor ] salut,j'aimerai savoir quels sont les moyens les plus utilisés (traduire : les plus performants et les plus simples) pour dire à une thread de s'arrét J'veux dire qqch amon programme...HELP !!! [ par lutin ] Oui en fait, j'aimerais savoir si qqun peux m'aider dans l'utilisation des messages windows.J'explique : je crée une fenetre qui lance un threaddans m Thread?!? [ par couriousous ] Hello!Ma question est bête mais je la pose:Quesque c'est un Thread (une sorte processus pour avoir + de temp processeur) et comment en créer un en C++ multitache [ par nigloudouille ] Je souhaite faire du multitaches sous MFC afin que mon programme ne reste pas bloqué pendant un calcul. j'ai bien réussi à créer une nouvelle thread d


Nos sponsors


Sondage...

CalendriCode

Mai 2013
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Photothèque

A découvrir



 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 5,507 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales