IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

MATLAB Discussion :

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


Sujet :

MATLAB

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éclairé
    Profil pro
    Inscrit en
    Janvier 2011
    Messages
    421
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2011
    Messages : 421
    Par défaut Problème de vitesse d'execution d'un code C
    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];}}   
     
     
      }

  2. #2
    Rédacteur/Modérateur

    Avatar de Jerome Briot
    Homme Profil pro
    Freelance mécatronique - Conseil, conception et formation
    Inscrit en
    Novembre 2006
    Messages
    20 317
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Freelance mécatronique - Conseil, conception et formation

    Informations forums :
    Inscription : Novembre 2006
    Messages : 20 317
    Par défaut
    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 ?

  3. #3
    Membre éclairé
    Profil pro
    Inscrit en
    Janvier 2011
    Messages
    421
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2011
    Messages : 421
    Par défaut
    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.

  4. #4
    Membre éclairé
    Profil pro
    Inscrit en
    Janvier 2011
    Messages
    421
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2011
    Messages : 421
    Par défaut
    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 ?

  5. #5
    Rédacteur/Modérateur

    Avatar de Jerome Briot
    Homme Profil pro
    Freelance mécatronique - Conseil, conception et formation
    Inscrit en
    Novembre 2006
    Messages
    20 317
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Freelance mécatronique - Conseil, conception et formation

    Informations forums :
    Inscription : Novembre 2006
    Messages : 20 317
    Par défaut
    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.

  6. #6
    Membre éclairé
    Profil pro
    Inscrit en
    Janvier 2011
    Messages
    421
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2011
    Messages : 421
    Par défaut
    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 ?

Discussions similaires

  1. probléme d'affichage et execution code
    Par coye dans le forum Windows Forms
    Réponses: 4
    Dernier message: 16/04/2009, 23h19
  2. Problème execution avec IDE codes::blocks
    Par tom31 dans le forum Code::Blocks
    Réponses: 2
    Dernier message: 28/10/2008, 21h54
  3. [P-03] Problème de vitesse d'execution
    Par moilou2 dans le forum Powerpoint
    Réponses: 6
    Dernier message: 26/10/2008, 16h07
  4. Réponses: 8
    Dernier message: 23/07/2007, 19h44
  5. Problème de vitesse d'execution
    Par Samyhijodelaluna dans le forum MFC
    Réponses: 31
    Dernier message: 17/05/2006, 11h41

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo