Pire rendement à l'aide d'Eigen que d'utiliser ma propre classe

Un couple de semaines, j'ai posé une question sur les performances de la multiplication de matrices.

M'a dit que, pour améliorer les performances de mon programme je dois utiliser spécialisées de la matrice des classes plutôt que de ma propre classe.

StackOverflow utilisateurs recommandé:

  • uBLAS
  • PROPRES
  • BLAS

J'ai d'abord voulu utiliser uBLAS cependant la lecture la documentation il s'est avéré que cette bibliothèque ne prend pas en charge multiplication matrice-matrice.

Après tout, j'ai décidé d'utiliser EIGEN bibliothèque. Donc j'ai échangé ma classe matrix pour Eigen::MatrixXd - cependant il s'est avéré que mon application fonctionne même plus lent qu'avant.
L'heure avant d'utiliser EIGEN a été de 68 secondes, et après avoir échangé ma classe matrix pour PROPRES de la matrice de programme s'exécute 87 secondes.

Parties de programme qui prend le plus de temps ressemble à ça

TemplateClusterBase* TemplateClusterBase::TransformTemplateOne( vector<Eigen::MatrixXd*>& pointVector, Eigen::MatrixXd& rotation ,Eigen::MatrixXd& scale,Eigen::MatrixXd& translation )
{   
    for (int i=0;i<pointVector.size();i++ )
    {
        //Eigen::MatrixXd outcome =
        Eigen::MatrixXd outcome = (rotation*scale)* (*pointVector[i])  + translation;
        //delete  prototypePointVector[i];      //((rotation*scale)* (*prototypePointVector[i])  + translation).ConvertToPoint();
        MatrixHelper::SetX(*prototypePointVector[i],MatrixHelper::GetX(outcome));
        MatrixHelper::SetY(*prototypePointVector[i],MatrixHelper::GetY(outcome));
        //assosiatedPointIndexVector[i]    = prototypePointVector[i]->associatedTemplateIndex = i;
    }

    return this;
}

et

Eigen::MatrixXd AlgorithmPointBased::UpdateTranslationMatrix( int clusterIndex )
{
    double membershipSum = 0,outcome = 0;
    double currentPower = 0;
    Eigen::MatrixXd outcomePoint = Eigen::MatrixXd(2,1);
    outcomePoint << 0,0;
    Eigen::MatrixXd templatePoint;
    for (int i=0;i< imageDataVector.size();i++)
    {
        currentPower =0; 
        membershipSum += currentPower = pow(membershipMatrix[clusterIndex][i],m);
        outcomePoint.noalias() +=  (*imageDataVector[i] - (prototypeVector[clusterIndex]->rotationMatrix*prototypeVector[clusterIndex]->scalingMatrix* ( *templateCluster->templatePointVector[prototypeVector[clusterIndex]->assosiatedPointIndexVector[i]]) ))*currentPower ;
    }

    outcomePoint.noalias() = outcomePoint/=membershipSum;
    return outcomePoint; //.ConvertToMatrix();
}

Comme Vous pouvez le voir, ces fonctions effectue beaucoup d'opérations matricielles. C'est pourquoi je pensais à l'aide de Eigen permettrait d'accélérer ma demande. Malheureusement (comme je l'ai mentionné ci-dessus), le programme fonctionne plus lent.

Est-il un moyen d'accélérer ces fonctions?

Peut-être que si j'ai utilisé DirectX opérations matricielles, je voudrais obtenir de meilleures performances ?? (toutefois, j'ai un ordinateur portable avec graphique intégré de la carte).

"j'ai d'abord voulu utiliser uBLAS cependant la lecture de la documentation, il s'est avéré que cette bibliothèque ne prend pas en charge multiplication matrice-matrice.", Hein? La page exacte est lié à apparaître les éléments suivants comme étant valide les opérations de produit (où A, B, et C matrix sont les types): C = prod(A, B); C = prec_prod(A, B); C = element_prod(A, B); axpy_prod(A, B, C, true); axpy_prod(A, B, C, false); Alors qu'est-ce que vous voulez qu'il ne le fait pas..?
boost.org/doc/libs/1_46_1/libs/numeric/ublas/doc/blas.htm. Le modèle gmm est général multiplication matrice-matrice.
J'ai aussi trouvé Propres lent. J'ai juste utilisé pour le calcul sur chaque pixel dans une image, dans VS2010 Express avec le Débogage activé, et il a été unusably lent (> 50 * code personnalisé). Je me rends compte qu'il vaudrait mieux dans un communiqué de construire, mais je ne peux même pas faire de débogage avec ceux des temps de chargement. Réfléchir à deux fois avant de l'utiliser pour quoi que ce soit à distance critique pour les performances!
La Performance de Eigen est BEAUCOUP mieux dans les versions release que dans les versions de débogage. Vous avez raison que la vitesse dans le debug est incroyablement lent.
visual studio C++ de la performance en général, est épouvantablement lent dans les versions debug; tous les types de conteneurs standard ne la vérification des limites (et de l'exécution elle-même insère boundschecking même pour les matières premières, tableaux). Si c'est un problème, vous pouvez définir NDEBUG qui désactive ces contrôles; bien sûr, qui permet de rendre votre code plus difficile à déboguer (toujours mieux que de sortir car il ne sera pas en ligne, comme beaucoup).

OriginalL'auteur george | 2011-05-31