Des temps de calcul très (trop ?) semblables

clock(), CLOCKS_PER_SEC

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

Bonjour tout le monde,

Je dois écrire un programme qui lance un certain nombre de processus ; chacun effectue un calcul. Un processus-fils sur deux est lancé en priorité minimale et je dois déterminer le temps de calcul des processus à l'aide de clock()/CLOCKS_PER_SEC.

Le programme que j'ai écrit compile, s'exécute et normalement fait bien ce qu'il doit faire.

Le problème

Cependant j'ai lancé 20 processus et je trouve que les temps de calcul que j'ai trouvés sont très semblables (0.32 secondes environ). Ils ne fluctuent pas beaucoup, alors qu'un processus sur 2 est en priorité minimale…

Est-ce normal ? Vous trouverez ci-dessous mon échantillon de tests puis mon code-source. Peut-être que la priorité est mal fixée ? Merci d'avance et bonne continuation. :)

Echantillon de tests (temps de calcul des processus)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
Temps de calcul du processus-enfant n°5 : 0.318211
Temps de calcul du processus-enfant n°7 : 0.318444
Temps de calcul du processus-enfant n°9 : 0.317554
Temps de calcul du processus-enfant n°3 : 0.320884
Temps de calcul du processus-enfant n°11 : 0.318025
Temps de calcul du processus-enfant n°15 : 0.318039
Temps de calcul du processus-enfant n°13 : 0.318177
Temps de calcul du processus-enfant n°17 : 0.318919
Temps de calcul du processus-enfant n°19 : 0.319498
Temps de calcul du processus-enfant n°1 : 0.324576
Temps de calcul du processus-enfant n°6 : 0.319116
Temps de calcul du processus-enfant n°20 : 0.320785
Temps de calcul du processus-enfant n°18 : 0.319459
Temps de calcul du processus-enfant n°14 : 0.319256
Temps de calcul du processus-enfant n°12 : 0.319121
Temps de calcul du processus-enfant n°8 : 0.319391
Temps de calcul du processus-enfant n°16 : 0.320895
Temps de calcul du processus-enfant n°2 : 0.322697
Temps de calcul du processus-enfant n°10 : 0.322456
Temps de calcul du processus-enfant n°4 : 0.323175

Code-source

 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
#include <time.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/resource.h>

int main(int argc, char* argv[]) {
    const int NUMBER_OF_CHILD_PROCESSES = 20;
    for(int i = 1; i <= NUMBER_OF_CHILD_PROCESSES; i++) {
        if(fork() == 0) {
            // Odd child processes are set to PRIORITY_MIN
            if(i%2 == 1) {
                if(setpriority(PRIO_PROCESS, 0, PRIO_MIN) == -1) {
                    perror("Priority");
                    exit(EXIT_FAILURE);
                }
            }

            // All the child processes do the following calculations ( *=999)
            int number_of_calculations = 100000000, operand = 999999;
            double time_beginning = clock();
            while(number_of_calculations--) {
                operand *= 999;
            }
            double time_end = clock();

            // All the child processes display the calculations' time
            printf("Temps de calcul du processus-enfant n°%i : %lf\n", i, (time_end - time_beginning)/CLOCKS_PER_SEC);
            return EXIT_SUCCESS;
        }
        wait();
    }

    return EXIT_SUCCESS;
}

Édité par The-Aloha-Protocol

Université de Bretagne-Sud <3

+0 -0
Staff

Cette réponse a aidé l'auteur du sujet

Salut,

Cependant j'ai lancé 20 processus et je trouve que les temps de calcul que j'ai trouvés sont très semblables (0.32 secondes environ). Ils ne fluctuent pas beaucoup, alors qu'un processus sur 2 est en priorité minimale…

Lern-X

C'est tout à fait normal, le rôle de la fonction clock() est de retourner, de manière approximative, le temps d'utilisation du processeur par un programme. Or, si tu baisses la priorité d'un processus, tu vas simplement faire en sorte d'espacer son utilisation du processeur (parce que les autres processus passeront avant lui), mais globalement, le temps d'utilisation sera le même (puisqu'il effectue la même chose que les autres).

Sinon, juste pour dire :

1
2
// Even child processes are set to PRIORITY_MIN
if(i%2 == 1) {

Si le reste de la division entière est un, c'est que le nombre est impair. ;)

+3 -0
Auteur du sujet

Donc si j'ai bien compris, clock retourne le temps d'exécution du programme (exécution réalisée par le processeur), depuis le début du programme.

Donc en effet, dans mon cas en faisant la soustraction des 2 clock, j'obtiens bien le temps de calcul et d'après toi, celui-ci est approximativement le même quelque soit le processus-enfant. En effet ça semble logique !

Et quand tu parles d'espacer l'utilisation d'un processus grâce à setpriority, tu veux dire par là juste que les processus-enfants à priorité haute vont être exécutés avant les processus-enfants à priorité basse, ce qui n'influence en rien le temps d'exécution de chacun des processus-enfants (quelle que soit leur priorité), puisqu'ils font la même chose.

Voilà c'est pour être sûr ?

Université de Bretagne-Sud <3

+0 -0
Staff

Cette réponse a aidé l'auteur du sujet

Donc si j'ai bien compris, clock retourne le temps d'exécution du programme (exécution réalisée par le processeur), depuis le début du programme.

Lern-X

Ce n'est pas véritablement le temps d'exécution (celui-là, tu l'obtiendras en secondes à l'aide de la fonction time() ou en milli/micro/nanosecondes à l'aide d'une fonction plus précise propre au système comme clock_gettime() sous unixoïdes), mais le temps pendant lequel le processus a utilisé le processeur (si le programme attend des données en entrée par exemple, il n'utilise pas le processeur, mais « s'exécute » toujours).

Donc en effet, dans mon cas en faisant la soustraction des 2 clock, j'obtiens bien le temps de calcul et d'après toi, celui-ci est approximativement le même quelque soit le processus-enfant. En effet ça semble logique !

Lern-X

C'est tout à fait ça, le temps est sensiblement le même puisqu'ils font la même chose.

Et quand tu parles d'espacer l'utilisation d'un processus grâce à setpriority, tu veux dire par là juste que les processus-enfants à priorité haute vont être exécutés avant les processus-enfants à priorité basse, ce qui n'influence en rien le temps d'exécution de chacun des processus-enfants (quelle que soit leur priorité), puisqu'ils font la même chose.

Lern-X

Exact, la priorité influence la fréquence à laquelle un processus a accès au processeur, mais pas le temps de calcul.

Édité par Taurre

+1 -0
Auteur du sujet

Merci beaucoup !

Edit : pourquoi les premiers processus exécutés sont les processus impairs, alors qu'ils ont justement reçu le setpriority(..., PRIO_MIN) (priorité minimale) ?

Édité par The-Aloha-Protocol

Université de Bretagne-Sud <3

+0 -0

On me corrigera peut être mais ne te fie pas trop à l'affichage, mes expériences de calcul numérique avec OpenMP et MPI m'ont montré que ca ne vaut rien. C'est le système qui gère ca comme il a envie de manière par forcement cohérente.

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte