Does armadillo library slow down the execution of matrix operations?

Question

I've converted a MATLAB code to C++ to speed it up, using the Armadillo library to handle matrix operations in C++, but surprisingly it is 10 times slower than the MATLAB code!

So I test the Armadillo library to see if it's the cause. The below code is a simple test code that initializes two matrices, adds them together and saves the result to a new matrix. One section of code uses the Armadillo library and other one doesn't. The section using Armadillo is too slow (notice the elapsed times).

Does it really slow down the execution (though it is supposed to speed it up) or am I missing some thing?

      #include<iostream>
      #include<math.h>
      #include<chrono>
      #include<armadillo>
      #include<time.h>
      #include<conio.h>
     using namespace std;
     using namespace arma;
     int main()
       {   
        srand((unsigned int)time(NULL));
        auto start = std::chrono::high_resolution_clock::now();
        double a[100][100];
        double b[100][100];
        double c[100][100];
        for (int i = 0; i < 100; i++)
           {
             for (int j = 0; j < 100; j++)
                {   
                 a[i][j] = rand() % 10;
                 b[i][j] = rand() % 10;
                 c[i][j] = a[i][j] + b[i][j];
                 }
            }

        auto finish = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> elapsed = finish - start;
        std::cout << "Elapsed time: " << elapsed.count() << " s\n";
        auto start1 = std::chrono::high_resolution_clock::now();
        mat a1= randi<mat>(100, 100, distr_param(1, 10));
        mat b1= randi<mat>(100, 100, distr_param(1, 10));
        mat c1=zeros(100,100);
        c1 = a1 + b1;
        auto finish1 = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> elapsed1 = finish1 - start1;
        std::cout << "Elapsed time: " << elapsed1.count() << " s\n";
        return 0;


    }

        }

Here is the answer I get:

Elapsed time: 0.00217959 s
Elapsed time: 0.00946147 s

As you see, Armadillo is significantly slower! Is it better not to use the Armadillo library?

Answer 1

You're comparing statically-defined arrays which live on the stack:

    double a[100][100];
    double b[100][100];
    double c[100][100];

to heap allocated arrays:

    mat a1= randi<mat>(100, 100, distr_param(1, 10));
    mat b1= randi<mat>(100, 100, distr_param(1, 10));
    mat c1=zeros(100,100);

Of course, stack-allocated variables are more constrained but have faster access than heap allocated variables. Additionally, this loop:

             a[i][j] = rand() % 10;
             b[i][j] = rand() % 10;
             c[i][j] = a[i][j] + b[i][j];

doesn't actually need a and b if those are not returned from the function, so as @Kirill mentions in the comments some compilers will just completely remote those arrays and put it all into c.

(also make sure you're compiling correctly. Use higher optimization level flags like -O3, make sure it's not in debug mode, etc.)

So there's a few morals to this story. First of all, using stack-allocated arrays is awesome. You should do it whenever possible. But secondly, you shouldn't expect MATLAB vs Armadillo to be very different if all of the time is spent in MATLAB operations since MATLAB is essentially a library for calling things like Armadillo. Writing out the MATLAB code as a for loop will be slow, but its vectorized operations are very optimized and many times implicitly multithreaded. While you don't give MATLAB code here to actually show what's going on, that implicit multithreading could be the distinguishing factor in the timings. Of course, you can always multithread and parallelize your own code in C and get it just as good, but the advantage of vectorized programming languages like MATLAB is that the hard work on simple functions has already been done for you.

So what this is really saying is that MATLAB vectorization is fine/good when dealing with operations on the heap, or if you want to write out more complicated loops then you should try to use static arrays whenever possible and only go to heap-allocated array operations when necessary. Unfortunately, when working in something like MATLAB/Python/R your operations are with heap-allocated variables which is why they focus so much on vectorization and large array operations. Using C or Fortran gives you the choice between heap vs stack that these languages don't have, while libraries like Armadillo add on the MATLAB-like functionality. From the other direction, something like Julia does have libraries like StaticArrays.jl to utilize static arrays (and parallelism), so that's one option to both have the flexibility to mix the designs while staying in a higher level language. But no matter where you look, optimized vectorized heap operations will likely end up the same speed as MATLAB: it's the more complicated operations and loops which you would have to write yourself that make the speed difference.

Answer 2

Have you tried initialising c1 to memory?

c1=zeros(100,100);

I think it doesn't allocate the memory to the variable until you fill it.

The result when I run your code:

Elapsed time: 0.0002079 s Elapsed time: 0.0003315 s

Difference not as bad... I'm no expert but maybe the way your armadillo is installed?