why is valarray so slow?
<p>Excuse me for my question for the valarray again. I am trying to use it since it is much like the matlab while operating the vector &amp; matrices. I first did some performance check and found that valarray cannot achieve the performance declared as in the book c++ programming language by stroustrup.</p>

<p>The test program actually did 5M multiplication of doubles. I thought that c=a*b would at least be comparable to the for loop double type element multiplication, but I am totally wrong. Tried on several computers and vc6.0 and vs2008.</p>

<p>By the way, I tested on matlab using the following code:</p>

<pre><code>len=5*1024*1024;
a=rand(len,1);b=rand(len,1);c=zeros(len,1);
tic;c=a.*b;toc;
</code></pre>

<p>and the result is 46ms. This time is not high precision, only works as a reference.</p>

<p>The code is:</p>

<pre><code>#include &lt;iostream&gt;
#include &lt;valarray&gt;
#include &lt;iostream&gt;
#include "windows.h"

using namespace std ;
SYSTEMTIME stime;
LARGE_INTEGER sys_freq;

double gettime_hp();

int main()
{
    enum { N = 5*1024*1024 };
    valarray&lt;double&gt; a(N), b(N), c(N) ;
    QueryPerformanceFrequency(&amp;sys_freq);   
    int i,j;
    for(  j=0 ; j&lt;8 ; ++j )
    {
        for(  i=0 ; i&lt;N ; ++i ) 
        {
            a[i]=rand();
            b[i]=rand();
        }

        double* a1 = &amp;a[0], *b1 = &amp;b[0], *c1 = &amp;c[0] ;
        double dtime=gettime_hp();
        for(  i=0 ; i&lt;N ; ++i ) c1[i] = a1[i] * b1[i] ;
        dtime=gettime_hp()-dtime;
        cout &lt;&lt; "double operator* " &lt;&lt; dtime &lt;&lt; " ms\n" ;

        dtime=gettime_hp();
        c = a*b ;
        dtime=gettime_hp()-dtime;
        cout &lt;&lt; "valarray operator* " &lt;&lt; dtime &lt;&lt; " ms\n" ;

        dtime=gettime_hp();
        for(  i=0 ; i&lt;N ; ++i ) c[i] = a[i] * b[i] ;
        dtime=gettime_hp()-dtime;
        cout &lt;&lt; "valarray[i] operator* " &lt;&lt; dtime&lt;&lt; " ms\n" ;

        cout &lt;&lt; "------------------------------------------------------\n" ;
    }
}

double gettime_hp()
{
    LARGE_INTEGER tick;
    extern LARGE_INTEGER sys_freq;
    QueryPerformanceCounter(&amp;tick);
    return (double)tick.QuadPart*1000.0/sys_freq.QuadPart;
}
</code></pre>

<p>The running results: (release mode with maximal speed optimization)</p>

<pre><code>double operator* 52.3019 ms
valarray operator* 128.338 ms
valarray[i] operator* 43.1801 ms
------------------------------------------------------
double operator* 43.4036 ms
valarray operator* 145.533 ms
valarray[i] operator* 44.9121 ms
------------------------------------------------------
double operator* 43.2619 ms
valarray operator* 158.681 ms
valarray[i] operator* 43.4871 ms
------------------------------------------------------
double operator* 42.7317 ms
valarray operator* 173.164 ms
valarray[i] operator* 80.1004 ms
------------------------------------------------------
double operator* 43.2236 ms
valarray operator* 158.004 ms
valarray[i] operator* 44.3813 ms
------------------------------------------------------
</code></pre>

<p>debugging mode with same optimization:</p>

<pre><code>double operator* 41.8123 ms
valarray operator* 201.484 ms
valarray[i] operator* 41.5452 ms
------------------------------------------------------
double operator* 40.2238 ms
valarray operator* 215.351 ms
valarray[i] operator* 40.2076 ms
------------------------------------------------------
double operator* 40.5859 ms
valarray operator* 232.007 ms
valarray[i] operator* 40.8803 ms
------------------------------------------------------
double operator* 40.9734 ms
valarray operator* 234.325 ms
valarray[i] operator* 40.9711 ms
------------------------------------------------------
double operator* 41.1977 ms
valarray operator* 234.409 ms
valarray[i] operator* 41.1429 ms
------------------------------------------------------
double operator* 39.7754 ms
valarray operator* 234.26 ms
valarray[i] operator* 39.6338 ms
------------------------------------------------------
</code></pre>
