Optimisation d'un projet en C

Version imprimable

Voir 40 message(s) de cette discussion en une page

30/01/2007, 17h34
Flophx

Optimisation d'un projet en C

Bonjour à tous, je demande votre aide car j'ai besoin d'optimiser un programme informatique;

J'ai actuellement un programme qui permet de faire des captures d'image issue d'une WebCam. Avec la forme actuelle du programme, j'arrive à environ 10 images par seconde.

Je voudrais pouvoir monter à au moins 20 images par seconde afin d'arriver à reconstituer une vidéo avec ffmpeg.

J'aurais besoin de pistes pour améliorer la capacité de mon programme à récupérer des images

Toute idée st la bienvenue!!
30/01/2007, 17h41
fearyourself

Citation:

Envoyé par Flophx

Bonjour à tous, je demande votre aide car j'ai besoin d'optimiser un programme informatique;

J'ai actuellement un programme qui permet de faire des captures d'image issue d'une WebCam. Avec la forme actuelle du programme, j'arrive à environ 10 images par seconde.

Je voudrais pouvoir monter à au moins 20 images par seconde afin d'arriver à reconstituer une vidéo avec ffmpeg.

J'aurais besoin de pistes pour améliorer la capacité de mon programme à récupérer des images

Toute idée st la bienvenue!!

Il faut déterminer avec un profileur (programme qui regarde le comportement d'un programme) quelles sont les zones de code qui utilisent beaucoup de ressources et se concentrer sur celles-là.

Jc
30/01/2007, 17h44
Thierry Chappuis

Ma première recommandation est d'utiliser un profiler afin de localiser les goulots d'étranglement. Ensuite, tu pourras optimiser de manière ciblée, voir poster des bouts de code provenant d'une fonction particulièrement gourmande en ressources. L'optimisation est un vaste sujet, et il est difficile de répondre comme cela, en toute généralité. Le conseil de débutant que je peux donner pour le moment est: "optimise où c'est nécessaire"

Thierry
30/01/2007, 17h50
Flophx

Bien, alors pour commencer,lequel me recommandez-vous?
30/01/2007, 18h15
souviron34

Tout dépend.

Si ton programme est assez simple, la mniére la plus rapide est de faire des printfs entourant les endroits que tu penses difficiles, et le regarder tourner..

Ensuite, tu peux utiliser gprof (tu compiles avec -pg) ou prof (-p). Là tu as statistiques de temps de passage, de nombres d'appels, etc...
30/01/2007, 18h20
Flophx

Je pense que dans mon cas il me faut qqch de relativement précis, parce que je soupconne l'acquisition de l'image (ca mise en mémoire), puis la création du fichier .ppm comme étant le plus couteux en temps... Et les printf me semble un peu limité non?
30/01/2007, 18h34
souviron34

Encore une fois tout dépend 8-)

ça peut donner une première idée.. Moi en général c'est ce que je fais..

Si là (et je suppose qu'avec ce que tu dis, je suis presque sûr que c'est dans la génération du .ppm) tu ne vois rien d'évident, tu passes à gprof ou prof..

Très rapide aussi... Et la sortie est un fichier te listant l'ensemble des routines avec les pourcentages de temps, d'appels, etc..
30/01/2007, 18h53
Flophx

ok, je vais essayer ca et je vous expédie les résulats merci
30/01/2007, 19h08
Flophx

En fait j'ai des printf qui cadencent début et fin de traitement d'une image(j'avais oublié)... Tel quel, difficile de savoir réellement ce qui prend de la mémoire...même si au bout d'une minute il devrait m'annoncer image 1500, et qu'on se situe vers les 600....

Dans cette partie de code, j'ai une image en mémoire, je recrée 3 tableaux contenant des composante Y,U,V (palette de couleur de ma WC), puis je remplis un fichier ppm avec une double boucle (colonne ligne), et à chaque tour je fais la conversion en RGB24 à partir des composantes des tableaux YUV...
C'est surtout une partie très calculatoire.... et nécessaire!!
A moins de supprimer les tableaux intermédiaires??
30/01/2007, 21h24
Emmanuel Delahaye
Citation:

Envoyé par Flophx

En fait j'ai des printf qui cadencent début et fin de traitement d'une image(j'avais oublié)... <...> C'est surtout une partie très calculatoire.... et nécessaire!!
A moins de supprimer les tableaux intermédiaires??
- Si les tableaux sont inutiles (voir l'algorithme), les supprimer
- Si ils sont utiles, et de taille fixe, les allouer une fois pour toutes au début (statique, dynamique, peu importe).
- Minimiser les copies (surtout de tableaux).
- Eviter les allocations et les réallocations dans les traitements intenses
- Eviter les printf dans les traitements intenses
30/01/2007, 23h39
Flophx

J'ai une question à ajouter: je développe actuellement ce programme sur un PC 3,2 GHz, et 512 Mo de RAM. Il est destiné à être implanté sur une carte munie d'un processeur 100 MHz, avec 16Mo de RAM. L'impact du changement d'environnement sera t-il tel que même bien optimisé, la destinée de mon programme sera vaine??
30/01/2007, 23h53
Emmanuel Delahaye

Citation:

Envoyé par Flophx

J'ai une question à ajouter: je développe actuellement ce programme sur un PC 3,2 GHz, et 512 Mo de RAM. Il est destiné à être implanté sur une carte munie d'un processeur 100 MHz, avec 16Mo de RAM. L'impact du changement d'environnement sera t-il tel que même bien optimisé, la destinée de mon programme sera vaine??

Tu crois vraiment qu'on peut répondre sérieusement à cette question ? On t'a dit de faire du profiling, tu l'as fait ?
31/01/2007, 11h10
souviron34

Citation:

Envoyé par Flophx

puis je remplis un fichier ppm avec une double boucle (colonne ligne)

Est-ce vraiment colonne-ligne ? la boucle intérieure est sur les lignes ou colonnes ? Beaucoup plus lent si elle est sur les lignes .. (sauts dans la mémoire)

Bien, voilà ce que j'ai fait:
j'avais des tableaux intermédiares qui effectivement ne servait à rien, je les ai supprimer, mais sur 1min, j'ai environ gagné 10 images....

sinon, j'ai exécuté gprof, et voici ce qu'il me retourne:

Code:

1
2
3
4
5
6
7
8
9
10
11
 
Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  ms/call  ms/call  name    
100.00      0.06     0.06       10     6.00     6.00  extractPix
  0.00      0.06     0.00        1     0.00    60.00  captureImage
  0.00      0.06     0.00        1     0.00     0.00  closeCam
  0.00      0.06     0.00        1     0.00     0.00  openCam
  0.00      0.06     0.00        1     0.00     0.00  printCap
  0.00      0.06     0.00        1     0.00     0.00  setImage
  0.00      0.06     0.00        1     0.00     0.00  setWin

Code:

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
 
index % time    self  children    called     name
                0.06    0.00      10/10          captureImage [2]
[1]    100.0    0.06    0.00      10         extractPix [1]
-----------------------------------------------
                0.00    0.06       1/1           main [3]
[2]    100.0    0.00    0.06       1         captureImage [2]
                0.06    0.00      10/10          extractPix [1]
-----------------------------------------------
                                                 <spontaneous>
[3]    100.0    0.00    0.06                 main [3]
                0.00    0.06       1/1           captureImage [2]
                0.00    0.00       1/1           openCam [5]
                0.00    0.00       1/1           printCap [6]
                0.00    0.00       1/1           setWin [8]
                0.00    0.00       1/1           setImage [7]
                0.00    0.00       1/1           closeCam [4]
-----------------------------------------------
                0.00    0.00       1/1           main [3]
[4]      0.0    0.00    0.00       1         closeCam [4]
-----------------------------------------------
                0.00    0.00       1/1           main [3]
[5]      0.0    0.00    0.00       1         openCam [5]
-----------------------------------------------
                0.00    0.00       1/1           main [3]
[6]      0.0    0.00    0.00       1         printCap [6]
-----------------------------------------------
                0.00    0.00       1/1           main [3]
[7]      0.0    0.00    0.00       1         setImage [7]
-----------------------------------------------
                0.00    0.00       1/1           main [3]
[8]      0.0    0.00    0.00       1         setWin [8]
-----------------------------------------------

Sans surprise, c'est la fonction qui recoit en paramètr el'image contenue dans le budffer et qui la transforme en PPM qui prend le plus du temps...
Mais là comme ca, ca apporte peu d'eau à mon moulin non?
N'y aurait il pas plus précis pour voir ou se situe le goulot d'étranglement??

31/01/2007, 16h43
souviron34

Citation:

100.00 0.06 0.06 10 6.00 6.00 extractPix
0.00 0.06 0.00 1 0.00 60.00 captureImage

Bon ya quelque chose que je comprends pas trop dans la sortie, mais en gros c'st sur ces 2 routines que ça se passe, ton étranglement, non ??
31/01/2007, 16h51
Flophx

Dans l'exemple donné, j'ai fait un test pour 10 captures.
EN fait, captureimage est appelé dans le main, et fait comme suit:
1) capture l'image
2) passe l'image en paramètre de la fonction extraxpix, qui crée le PPM
Il le fait normalement en continu (while(1))....

Bien, je vous donne le code tel qu'il est au niveau du goulot d'étranglement:

image.c:

Code:

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
 
/*
 * Conversion en format PPM*/
#include <string.h>
#include "image.h"
void extractPix(unsigned char* imgbuffer, int hauteur, int largeur, int num)
{
 
    sprintf(nom_image,"Image_%.05d.ppm", num);
    printf("nom_image = '%s'\n",nom_image);
 
    fp = fopen(nom_image, "w");
 
    if(fp==NULL)
    {
        printf("Impossible d'ouvrir le fichier\n");
        exit(-1);
    }
 
    fprintf(fp, "P6\n%d %d\n255\n",largeur, hauteur);
 
    p=1;
    jDebut=1;
    j = jDebut;
    for(ligne=0;ligne<hauteur;ligne++)   
    {
        if(ligne%2!=0)
            j=jDebut;
        else
            jDebut=j;
        for(colonne=0;colonne<largeur;colonne++)
        {
 
            b = 1.164*(imgbuffer[p]-16)+2.018*(imgbuffer[taille_totale+j]-128);p++;
            g = 1.164*(imgbuffer[p]-16)-0.813*(imgbuffer[taille_totale+j]-128)-0.391*(imgbuffer[5*taille_totale/4+j]
            r = 1.164*(imgbuffer[p]-16)+1.596*(imgbuffer[5*taille_totale/4+j]-128);
 
 
            putc(r, fp);
            putc(g, fp);
            putc(b, fp);
 
            if(colonne%2==0)
                j++;
        }
    }
 
    fflush(fp);
    fclose(fp);
}

et image.h:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <stdio.h>
#include <stdlib.h>
#include "camera.h"
 
FILE* fp;
unsigned int ligne,colonne;
unsigned char  r,g,b;
unsigned char nom_image[17] = "";
unsigned int taille_totale = HEIGHT*WIDTH;
unsigned int j, jDebut;
unsigned int p;
void extractPix(unsigned char* imgbuffer, int hauteur, int largeur, int num);

Si quelqu'un a des idées pour optimiser cette partie, là j'avoue être un poil perdu...

01/02/2007, 12h06
O( N )

Bonjour ;) ,

( Je réalise un logiciel sur le format PPM pour faire du traitement numérique destiné à l'OPEN SOURCE, avec des cours, des explications, des liens, le code et l'exécutable si stable )

Si tu cherche à devélopper dedans, si cela t'intéresse tu peux me MP :mouarf:

Sinon pour ton truc, juste une petite idée comme çà :P

Si tu connais le nombre d 'images que tu génères à chaque fois ! Au lieu de faire un sprintf tu fais pointé 'nom_image sur le tableau de chaines de caractères contenant déjà les noms de fichiers 'Image_00001.ppm' ... .

Voilà @+
01/02/2007, 12h12
Flophx

J'ai pas vraiment compris.... J'initialise un tableau avec "Image_00001".... jusqu'à 30000 (c'est pour une vidéo d'un quart d'heure, 25*60*15=22500, comm eca j'ai un peu de marge), et ensuite à chaque appel de la fonction extraxpix, je pointe la case suivante??

Il y a plusieurs choses faciles à optimiser ::

d'abord remplace ton

Code:

imgbuffer[p]

par
Code:

1 2 3 4 5 unsigned char *buf = imgbuffer ; /* puis dans la boucle utilise : */ *buf...... buf++ ;
tu viens déjà d'éviter n*m (multiplication+addition)

Ensuite tu mets :
Code:

1 2 3 4 int decal=(5*taille_totale/4) ; ...imgbuffer[decal+j]...
tu viens encore d'éviter 2* n*m (multiplication+division)

Et tu peux encore accélerer, si tu disposes de mémoire :
Code:

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 /*tu peux remplacer r,g,b, par un unsigned char *bufferimage */ /* tu alloues à 3 fois la taille de l'image */ unsigned char *bufferimage =NULL, *pos=NULL; (unsigned char *) calloc ( 3*taille_totale, sizeof(unsigned char) ); if ( bufferimage == NULL ) exit(1) ... /* et tu remplaces dans la boucle */ pos = bufferimage ; /* au lieu de */ /* b = ... g = ... r = .... tu mets */ *pos = ....... p++ ; pos++ ; *pos = ... /* tu enleves les 3 putc */ } / une fois sorti de la boucle tu fais un seul : fwrite ou fprintf..
ou bien tu gardes les 3 putc mais tu les mets au moment de l'incrémentation de pos (avant bien sûr 8O ).....

puis

Voir 40 message(s) de cette discussion en une page