Problème de vitesse d'execution d'un code C

Version imprimable

Bonjour à tous,

J'ai interfacé un code C avec Matlab, pour augmenter la vitesse d’exécution de Matlab. Mon souci c'est que lorsque j’exécute mon code C (compilé avec gcc) il met 10 secondes environs mais lorsque j’exécute ce même programme sous Matlab il met plus de 5 minutes.
J'ai l’impression que la fonction mex de matlab n'optimise pas bien mon code et de plus j'ai le warning suivant :

 You are using gcc version "4.6.3-1ubuntu5)".  The version
         currently supported with MEX is "4.3.4".
         For a list of currently supported compilers see: 
         http://www.mathworks.com/support/com...rrent_release/

Est ce normale ou c'est moi qui est mal codé quelque chose ?
Voici un exemple sur la manière dont je m'y prend pour faire l'interface :

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include "mex.h"
#include <stdio.h>
#include <stdlib.h>
 
typedef int Bool;
#define False 0
#define True  1
 
 
    /*#######################************ Programme C copie d'une matrice ***********************####################*/
void copie(double **x,double **res, unsigned int row, unsigned int col)
{  
        register unsigned int i1,j1;
 
       for(i1=0;i1<row;++i1)
       {
         for(j1=0;j1<col;++j1)
         {
         res[i1][j1]=x[i1][j1];
         }
       }
 
}
 
 
/* nrhs nombre de parametre d'entre
  nlhs nombre de parametre de sortie
  prhs tableau de pointeur d'un element en entre
  plhs tableau de pointeur de sortie
*/
 
 
 
void mexFunction( int nlhs, mxArray *plhs[],  int nrhs, const mxArray *prhs[] ) {
 
    double *x,*res, **I;
    double **Icopie;
    unsigned int nrow, ncol;
    register unsigned int i, j;
 
    nrow = mxGetM(prhs[0]);
    ncol = mxGetN(prhs[0]);
 
    x = mxGetPr(prhs[0]);       
    I = mxMalloc(nrow * sizeof(double *));
 
    /* changement de representation en memoire des matrices matlab */
 
    for (i = 0; i < nrow; ++i)
       { I[i] = mxMalloc(ncol * sizeof(double)); }
 
    for(i=0;i<nrow;++i){
        for(j=0;j<ncol;++j)
            {I[i][j] = x[j*nrow+i];}}
 
      Icopie = mxMalloc(nrow * sizeof(double *));
 
     for (i = 0; i < nrow; ++i)
       { Icopie[i] = mxMalloc(ncol * sizeof(double)); }    
 
 
      plhs[0] = mxCreateDoubleMatrix(nrow, ncol, mxREAL);  
      res= mxGetPr(plhs[0]); 
 
      /* appel de la fonction C */
      copie(I,Icopie,nrow,ncol) ; 
 
      /*resultat */
 
        for(j=0;j<ncol;++j){
        for(i=0;i<nrow;++i)     
        {res[j*nrow+i]=Icopie[i][j];}}   
 
 
  }

J'ai un peu nettoyé on code :

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
51
52
53
54
55
56
57
58
59
60
61
#include "mex.h"
 
/*#######################************ Programme C copie d'une matrice ***********************####################*/
void copie(double **x, double **res, size_t row, size_t col) {
 
    size_t i1, j1;
 
    for(i1=0;i1<row;++i1)
        for(j1=0;j1<col;++j1)
            res[i1][j1] = x[i1][j1];
 
}
 
void mexFunction( int nlhs, mxArray *plhs[],  int nrhs, const mxArray *prhs[] ) {
 
    double *x, *res, **I;
    double **Icopie;
    size_t i, j, nrow, ncol;
 
    nrow = mxGetM(prhs[0]);
    ncol = mxGetN(prhs[0]);
 
    x = mxGetPr(prhs[0]);
    I = mxMalloc(nrow * sizeof(double *));
 
    /* changement de representation en memoire des matrices matlab */
 
    for (i = 0; i < nrow; ++i)
        I[i] = mxMalloc(ncol * sizeof(double));
 
    for(i=0;i<nrow;++i)
        for(j=0;j<ncol;++j)
            I[i][j] = x[j*nrow+i];
 
    Icopie = mxMalloc(nrow * sizeof(double *));
 
    for (i = 0; i < nrow; ++i)
        Icopie[i] = mxMalloc(ncol * sizeof(double));
 
    plhs[0] = mxCreateDoubleMatrix(nrow, ncol, mxREAL);
    res= mxGetPr(plhs[0]);
 
    /* appel de la fonction C */
    copie(I, Icopie, nrow, ncol) ;
 
    /*resultat */
 
    for(j=0;j<ncol;++j)
        for(i=0;i<nrow;++i)
            res[j*nrow+i] = Icopie[i][j];    /*réfléchir */
 
    /* liberation memoire */
    for (i = 0; i < nrow; ++i) {
        mxFree(I[i]);
        mxFree(Icopie[i]);
    }
 
    mxFree(I);
    mxFree(Icopie);
 
}

(je n'ai pas mis les détections des échecs d'allocation avec mxMalloc)

Par contre, je ne comprends pas ce que tu cherches à faire avec toutes ces copies :koi:

A quel code C as-tu comparé ce fichier MEX ?
Quelle est la taille de la matrice que tu passes en entrée du fichier MEX ?

29/05/2012, 14h00
takout

en fait ce que je veux faire c'est un fichier mex qui va prendre en entré une matrice. Puis va mettre cette matrice en paramètre d'une fonction C (ici pour illustrer c'est copie la fonction) et me sortir le résultat de ma fonction dans matlab.
Mon souci c'est que lorsque je fais l'interface (de la manière décrite dans mon code) sur un autre programme, ma fonction C est plus rapide que le fichier Mexfile.
Dans ce programme les matrices ont une taille de 839x839 au minimum.
30/05/2012, 07h57
takout

Bonjour à tous,

Je souhaiterai savoir si possible comment fais t-on pour déterminer la partie d'un code C contenu dans un mex-files qui met le plus de temps à s’exécuter ?
30/05/2012, 09h50
Jerome Briot

Comme tu sembles être sous Linux, il est possible d'inspecter un code C avec Gprof.
Malheureusement, il faut un exécutable, ce qui n'est pas le cas du fichier MEX.

Une méthodologie simple consiste à optimiser le code C en dehors de MATLAB puis à l'inclure dans le fichier MEX.
Le surplus de temps d'exécution vient donc finalement du fichier MEX.
On peut alors chercher à optimiser le MEX.

Ok d'accord, je vois.

Je me suis rendu compte que mon programme matlab à planter pour une matrice. Pourtant en dehors du Mex-files avec cette matrice mon code C fonctionne. Je pense que mon souci doit être dans le Mex-files.
J'ai tenté de débugger le mex-file dans matlab à l'aide de gdb et j'ai eu le message d'erreur suivant.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 < M A T L A B (R) > Copyright 1984-2010 The MathWorks, Inc. Version 7.12.0.635 (R2011a) 64-bit (glnxa64) March 18, 2011 To get started, type one of these: helpwin, helpdesk, or demo. For product information, visit www.mathworks.com. >> lpe [New Thread 0x7fffca3a9700 (LWP 4185)] [New Thread 0x7fffc9067700 (LWP 4186)] Program received signal SIGUSR1, User defined signal 1. 0x00007ffff53b6d84 in pthread_cond_wait@@GLIBC_2.3.2 () from /lib/x86_64-linux-gnu/libpthread.so.0 (gdb)
Je ne sais pas ce que cela signifie et je ne connais pas la ligne où se situe mon erreur. Pouvez vous m'aider svp ?

30/05/2012, 10h30
Jerome Briot

Entre le caractère 'c' et appuie sur la touche Entré du clavier après l'invite (gdb)

ok c'est fait.
j'ai trouvé une erreur puis je l'ai débuggé mais j'ai obtenu après le message suivant :

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
 
 
                                                               < M A T L A B (R) >
                                                     Copyright 1984-2010 The MathWorks, Inc.
                                                   Version 7.12.0.635 (R2011a) 64-bit (glnxa64)
                                                                  March 18, 2011
 
 
  To get started, type one of these: helpwin, helpdesk, or demo.
  For product information, visit www.mathworks.com.
 
>> lpe
[New Thread 0x7fffca3a9700 (LWP 5303)]
[New Thread 0x7fffc9067700 (LWP 5304)]
 
Program received signal SIGUSR1, User defined signal 1.
0x00007ffff53b6d84 in pthread_cond_wait@@GLIBC_2.3.2 () from /lib/x86_64-linux-gnu/libpthread.so.0
(gdb) c
Continuing.
 
MEX FILE: /home/Documents/taff/détection_de_contour/watershed/watershed.mexa64 entry point located at address 0xc3dfc4fa
Add breakpoints at the debugger prompt and issue a "continue" to resume 
execution of MATLAB.
 
 
Program received signal SIGUSR1, User defined signal 1.
0x00007ffff53b6d84 in pthread_cond_wait@@GLIBC_2.3.2 () from /lib/x86_64-linux-gnu/libpthread.so.0
(gdb) c
Continuing.
>>

qu'est ce que sa signifie? Pourquoi il m'est demandé de mettre un point d'arrêt ?

30/05/2012, 11h28
takout

J'ai mi un point d'arrêt le programme semble fonctionner.
Cependant j'ai toujours un problème avec la vitesse d'execution, le code C hors du Mex-file tourne 3 fois plus vite. Comment fait-vous pour optimiser le mex-file ? je suppose que mon souci vient de là car à chaque appel du mex file j'effectue une copie de la matrice en entré de matlab et une copie de la matrice en sortie de ma fonction C.

Tu n'es pas obligé de copier ton image en entré et en sortie dans certaine condition.
Si tu vectorises ta fonction en C et que tu la prototype pour prendre en entré un double* et pour qu'elle retourne un double* tu peux alors utilisé les fonction mxGetPr pour obtenir ta matrice (sous la forme de double*)
pour faire la liaison entre ta variable mxArray et ta matrice de sortie tu utilise mxSetPr
comme ça adieu les copies.

Après je ne suis pas sur que ce soit ton mex-file qui prenne du temps.
pour vérifier cela tu peux obtenir les temps avec les fonctions tic et toc de MATLAB.
Code:

1 2 3 4 5 6 7 8 9 10 mxArray* toc[1]; double* temps; mexEvalString("tic;");// appel la fonction tic de matlab dans ton mexfile /* inclure ici le code dont tu souhaite obtenir le temps d'exécution */ mexCallMATLAB(1,toc,0,NULL,"toc");// appel de la fonction toc on récupère //le temps d'exécution temps=mxGetPr(toc[0]); printf("\n temps d'éxécution : %f ",temps[0]); mxDestroyArray(toc[0]);// libération de la mémoire.(attention : libère toc[0] mais aussi temps)
Le temps que tu obtiens n'est pas le temps réel d'exécution (car tu les temps d'appel des fonction MATLAB sont comptabilisé) mais ça te donne une bonne idée d'où tu passes le plus de temps

08/06/2012, 10h51
Jerome Briot

Citation:

Envoyé par gpcbitnik38

Si tu vectorises ta fonction en C

Sauf que takout voulait justement conserver son code C tel quel avec les indices x[i][j] : Fichier .m compilé en MEX