Commit Graph

7 Commits

Author SHA1 Message Date
Keir Mierle 7492b0d8de Update copyright headers with new year and URL
Since Ceres is moving to using GitHub for issues, and the Google
Code URL in the current copyright header will soon become invalid,
update all the headers.

Change-Id: I1fce70375d1bcf098591f07b4d8f01a5c1e0789c
2015-03-18 05:43:23 +00:00
Sameer Agarwal d61b68aaac Lint cleanups from William Rucklidge
Change-Id: Ia4756ef97e65837d55838ee0b30806a234565bfd
2013-08-16 17:02:56 -07:00
Sameer Agarwal 367b65e17a Multiple dense linear algebra backends.
1. When a LAPACK implementation is present, then
DENSE_QR, DENSE_NORMAL_CHOLESKY and DENSE_SCHUR
can use it for doing dense linear algebra operations.

2. The user can switch dense linear algebra libraries
by setting Solver::Options::dense_linear_algebra_library_type.

3. Solver::Options::sparse_linear_algebra_library is now
Solver::Options::sparse_linear_algebra_library_type to be consistent
with all the other enums in Solver::Options.

4. Updated documentation as well as Solver::Summary::FullReport
to reflect these changes.

Change-Id: I5ab930bc15e90906b648bc399b551e6bd5d6498f
2013-08-13 14:57:03 -07:00
Sameer Agarwal 487250eb27 Minor cleanups.
1. Further BLAS and heap allocation cleanups in  schur_eliminator_impl.h
2. Modularize blas.h using macros.
3. Lint cleanups from William Rucklidge.
4. Small changes to jet.h
5. ResidualBlock now uses blas.h

Performance improvements:

For static and dynamic sized blocks, the peformance is not changed much.

-use_quaternions -ordering user -linear_solver sparse_schur

                                        master         change
problem: 16-22106
gcc                                        3.4            3.3
clang                                      2.8            2.7

problem: 49-7776
gcc                                        1.7            1.7
clang                                      1.4            1.4

problem: 245-198739
gcc                                       80.1           79.6
clang                                     80.6           76.2

problem: 257-65132
gcc                                       12.2           12.0
clang                                     10.4           10.2

problem: 356-226730
gcc                                       99.0           96.8
clang                                     88.9           88.3

problem: 744-543562
gcc                                      361.5          356.2
clang                                    352.7          343.5

problem: 1024-110968
gcc                                       45.9           45.6
clang                                     42.6           42.1

However, performance when using local parameterizations is
significantly improved due to residual_block.cc using blas.h

-use_quaternions -use_local_parameterization -ordering user -linear_solver sparse_schur

                                        master         change
problem: 16-22106
gcc                                        3.6            3.3
clang                                      3.5            2.8

problem: 49-7776
gcc                                        1.8            1.6
clang                                      1.7            1.4

problem: 245-198739
gcc                                       79.7           76.1
clang                                     79.7           73.0

problem: 257-65132
gcc                                       12.8           11.9
clang                                     12.3            9.8

problem: 356-226730
gcc                                      101.9           93.5
clang                                    105.0           86.8

problem: 744-543562
gcc                                      367.9          350.5
clang                                    355.3          323.1

problem: 1024-110968
gcc                                       43.0           40.3
clang                                     41.0           37.5

Change-Id: I6dcf7476ddaa77cb116558d112a9cf1e832f5fc9
2013-04-14 09:33:11 -07:00
Sameer Agarwal dc3a27fa60 Fix MatrixVectorMultiply and incorrect DCHECKS.
(Thanks to Serget Sharybin for reporting this)

Change-Id: I6bbc41667308fc2932871cf25ad07b431f70801f
2013-04-07 09:18:12 -07:00
Sameer Agarwal 520d35ef22 Further BLAS improvements.
1. Switch to Eigen's implementation when all dimensions are fixed.
2. Use lazyProduct for eigen matrix-vector product. This brings
   eigen's performance on iterative_schur closer to what it used
   to be before the last commit. There is however still an
   improvement to be had by using the naive implementation when
   the matrix and vector have dynamic dimensions.

BENCHMARK
                                      HEAD                                       CHANGE

problem-16-22106-pre.txt
gcc-eigen       sparse_schur         0.859    gcc-eigen       sparse_schur        0.853
clang-eigen     sparse_schur         0.848    clang-eigen     sparse_schur        0.850
gcc-blas        sparse_schur         0.956    gcc-blas        sparse_schur        0.865
clang-blas      sparse_schur         0.954    clang-blas      sparse_schur        0.858
gcc-eigen       iterative_schur      4.656    gcc-eigen       iterative_schur     3.271
clang-eigen     iterative_schur      4.664    clang-eigen     iterative_schur     3.307
gcc-blas        iterative_schur      2.598    gcc-blas        iterative_schur     2.620
clang-blas      iterative_schur      2.554    clang-blas      iterative_schur     2.567

problem-49-7776-pre.txt
gcc-eigen       sparse_schur         0.477    gcc-eigen       sparse_schur        0.472
clang-eigen     sparse_schur         0.475    clang-eigen     sparse_schur        0.479
gcc-blas        sparse_schur         0.521    gcc-blas        sparse_schur        0.469
clang-blas      sparse_schur         0.508    clang-blas      sparse_schur        0.471
gcc-eigen       iterative_schur      3.172    gcc-eigen       iterative_schur     2.088
clang-eigen     iterative_schur      3.161    clang-eigen     iterative_schur     2.079
gcc-blas        iterative_schur      1.701    gcc-blas        iterative_schur     1.720
clang-blas      iterative_schur      1.708    clang-blas      iterative_schur     1.694

problem-245-198739-pre.txt
gcc-eigen       sparse_schur        28.092    gcc-eigen       sparse_schur       28.233
clang-eigen     sparse_schur        28.148    clang-eigen     sparse_schur       28.400
gcc-blas        sparse_schur        30.919    gcc-blas        sparse_schur       28.110
clang-blas      sparse_schur        31.001    clang-blas      sparse_schur       28.407
gcc-eigen       iterative_schur     63.095    gcc-eigen       iterative_schur    43.694
clang-eigen     iterative_schur     63.412    clang-eigen     iterative_schur    43.473
gcc-blas        iterative_schur     33.353    gcc-blas        iterative_schur    33.321
clang-blas      iterative_schur     33.276    clang-blas      iterative_schur    33.278

problem-257-65132-pre.txt
gcc-eigen       sparse_schur         3.687    gcc-eigen       sparse_schur        3.629
clang-eigen     sparse_schur         3.669    clang-eigen     sparse_schur        3.652
gcc-blas        sparse_schur         3.947    gcc-blas        sparse_schur        3.673
clang-blas      sparse_schur         3.952    clang-blas      sparse_schur        3.678
gcc-eigen       iterative_schur    121.512    gcc-eigen       iterative_schur    76.833
clang-eigen     iterative_schur    123.547    clang-eigen     iterative_schur    78.763
gcc-blas        iterative_schur     68.334    gcc-blas        iterative_schur    68.612
clang-blas      iterative_schur     67.793    clang-blas      iterative_schur    68.266

Notes:

1. Naive BLAS was a bit worse than eigen on fixed sized matrices. We did not see this
   before because of the different inlining thresholds. Fixing this boosted eigen's
   performance. Also the disparity between gcc and clang has gone away.

2. SPARSE_SCHUR performance remains the same, since it is only testing static sized
   matrices.

3. ITERATIVE_SCHUR performance goes up substantially due to the lazyProduct change,
   but even there, since most of the products are dynamic sized, the naive implementation
   wins handily.

Change-Id: Idc17f35b9c68aaebb1b2e131adf3af8374a85a4c
2013-04-04 18:02:08 -07:00
Sameer Agarwal 296fa9b127 Replace Eigen block operations with small GEMM and GEMV loops.
1. Add Matrix-Matrix and Matrix-Vector multiply functions.
2. Replace Eigen usage in SchurEliminator with these custom
   matrix operations.
3. Save on some memory allocations in ChunkOuterProduct.
4. Replace LDLT with LLT.

As a result on problem-16-22106-pre.txt, the linear solver time
goes down from 1.2s to 0.64s.

Change-Id: I2daa667960e0a1e8834489965a30be31f37fd87f
2013-04-02 18:04:39 -07:00