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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
| /* il faut modifier un peu la fonction pour que ca marche */
void eratosthene(std::vector<char> & potentials, size_t begin, size_t end,
size_t toTest )
{
size_t index;
/* on peut s'éviter le test sur le modulo si l'on est sur que l'index
* "begin" est bel et bien un multiple de toTest...
* cette condition est vérifiée dans main, et nous allons donc "prendre
* le risque" de faire confiance à la fonction appelante :D
*/
for(index = begin; index < end; index+=toTest )
{
if(potentials[index] && index!= toTest )
potentials[index]= 0x0;
}
}
}
int main()
{
std::vector<char> potentials(MAX,0x1);
size_t square = sqrt(MAX);
for(size_t result = 0; result < MAX;result+=2)
{
potentials[result] = 0x0;
}
potentials[2] = 0x1;
size_t size = potential.size();
size_t divided = size / 4; // partons du principe de 4 threads ;)
/* Seuls les indices supérieurs à 2 et inférieurs à la racine carrée de MAX
* nous intéressent, testons donc toutes les valeurs comprises entre 2 et
* sqrt(MAX)
*/
for(size_t index = 2;index < square; ++index)
{
/* la directive pragma vient sans doute ici
* mais je te laisse le soin de trouver comment faire pour que les threads
* ne soient lancés qu'une fois ;)
*/
for(int th = 0; th <4; ++ th)
{
/* en première approximation, chaque thread travaille sur une
* part égale des valeurs à tester
*/
size_t begin = th * divided;
/* assurons nous que begin est bel et bien un multiple de l'index
* à tester
begin -= begin % modulo;
size_t end = (th+1) * divided;
if(potential[index]==0x1)
eratosthene(potentials, begin, end, index);
}
}
/*...*/
} |
