À quel point Eigen est-il plus rapide pour les petites matrices de taille fixe?

Question

J'utilise Julia pour l'instant mais j'ai une fonction critique de performance qui nécessite une énorme quantité d'opérations matricielles répétées sur de petites matrices de taille fixe (3 dimensions ou 4 dimensions). Il semble que toutes les opérations matricielles dans Julia soient traitées par un back-end BLAS et LAPACK. Il apparaît également qu'il y a beaucoup d'allocation de mémoire dans certaines de ces fonctions.

Il existe une bibliothèque julia pour small matrices qui propose des accélérations impressionnantes pour les matrices 3x3, mais n'a pas été mise à jour depuis 3 ans. Je pense réécrire ma fonction critique de performance en Eigen

Je sais que Eigen prétend être vraiment bon pour les matrices de taille fixe, mais j'essaie toujours de juger si je devrais réécrire cette fonction dans Eigen ou non. Les performances benchmarks sont pour des matrices de taille dynamique. Est-ce que quelqu'un a des données pour suggérer quelle performance on obtient des matrices de taille fixe? Les types d'opérations que je fais sont la matrice matrice x, la matrice x le vecteur, les solutions linéaires définies positives.

Answer 1

Si vous voulez des opérations rapides pour les petites matrices, je recommande fortement FixedSizeArrays. Par exemple:

using FixedSizeArrays 

function foo(A, b, n) 
    s = 0.0 
    for i = 1:n 
     s += sum(A*b) 
    end 
    s 
end 

function foo2(A, b, n) 
    c = A*b 
    s = 0.0 
    for i = 1:n 
     A_mul_B!(c, A, b) 
     s += sum(c) 
    end 
    s 
end 

A = rand(3,3) 
b = rand(3) 
Af = Mat(A) 
bf = Vec(b) 

foo(A, b, 1) 
foo2(A, b, 1) 
foo(Af, bf, 1) 
@time 1 

@time foo(A, b, 10^6) 
@time foo2(A, b, 10^6) 
@time foo(Af, bf, 10^6) 

Résultats:

julia> include("/tmp/foo.jl") 
    0.000005 seconds (148 allocations: 10.151 KB) 
    0.325433 seconds (2.00 M allocations: 106.812 MB, 9.07% gc time) 
    0.144793 seconds (8 allocations: 304 bytes) 
    0.012683 seconds (6 allocations: 192 bytes) 

foo2 essaie d'être intelligent et d'éviter l'allocation de mémoire, mais il est tout simplement époustouflés par la mise en œuvre naïve lors de l'utilisation FixedSizeArrays.