Discussion :

[takout]

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 C :

Sélectionner tout - Visualiser dans une fenêtre à part

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];}}   
 
 
  }

[Jerome Briot]

J'ai un peu nettoyé on code :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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 ?

[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.

[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 ?

[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.

[takout]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?