Sum of product: can we vectorize the following in C++? (using Eigen or other libraries)

Question

UPDATE: the (sparse) three-dimensional matrix v in my question below is symmetric: v(i1,i2,i3) = v(j1,j2,j3) where (j1,j2,j3) is any of the 6 permutations of (i1,i2,i3), i.e.

v(i1,i2,i3) = v(i1,i3,i2) = v(i2,i3,i1) = v(i2,i1,i3) = v(i3,i1,i2) = v(i3,i2,i1).

Moreover, v(i1,i2,i3) != 0 only when i1 != i2 && i1 != i3 && i2 != i3.

E.g. v(i,i,j) = 0, v(i, k, k) = 0, v(k, j, k) = 0, etc...

I thought that with this additional information, I could already get a significant speed-up by doing the following:

• Remark: v contains duplicate values (a triplet (i,j,k) has 6 permutations, and the values of v for these 6 are the same).
• So I defined a more compact matrix uthat contains only non-duplicates of v. The indices of u are (i1,i2,i3) where i1 < i2 < i3. The length of u is equal to the length of v divided by 6.
• I computed the sum by iterating over the new value vector and the new index vectors.

With this, I only got a little speed-up. I realized that instead of iterating N times doing a multiplication each time, I iterated N/6 times doing 6 multiplications each time, and that's pretty much the same as before :(

Hope somebody could come up with a better solution.

--- (Original question) ---

In my program I have an expensive operation that is repeated every iteration.

I have three n-dimensional vectors x1, x2 and x3 that are supposed to change every iteration.

I have four N-dimensional vectors I1, I2, I3 and v that are pre-defined and will not change, where:

• I1, I2 and I3 contain the indices of respectively x1, x2 and x3 (the elements in I_i are between 0 and n-1)
• v is a vector of values.

For example:

We can see v as a (reshaped) sparse three-dimensional matrix, each index k of v corresponds to a triplet (i1,i2,i3) of indices of x1, x2, x3.

I want to compute at each iteration three n-dimensional vectors y1, y2 and y3 defined by:

y1[i1] = sum_{i2,i3} v(i1,i2,i3)*x2(i2)*x3(i3)

y2[i2] = sum_{i1,i3} v(i1,i2,i3)*x1(i1)*x3(i3)

y3[i3] = sum_{i1,i2} v(i1,i2,i3)*x1(i1)*x2(i2)

More precisely what the program does is:

Repeat:

• Compute y1 then update x1 = f(y1)
• Compute y2 then update x2 = f(y2)
• Compute y3 then update x3 = f(y3)

where f is some external function.

I would like to know if there is a C++ library that helps me to do so as fast as possible. Using for loops is just too slow.

Thank you very much for your help!

Update: Looks like it's not easy to get a better solution than the straight-forward for loops. If the vector of indices I1 above is ordered in non-decreasing order, can we compute y1 faster? For example: I1 = [0 0 0 0 1 1 2 2 2 3 3 3 ... n n].

Answer 1

The simple answer is no, at least, not trivially. Your access pattern (e.g. x2(i2)*x3(i3)) does not (at least at compile time) access contiguous memory, but rather has a layer of indirection. Due to this, SIMD instructions are pretty useless, as they work on chunks of memory. What you may want to consider doing is creating a copy of xM sorted according to iM, removing the layer of indirection. This should reduce the number of cache misses in that xM(iM) generates and since it's accessed N times, that may reduce some of the wall time (assuming N is large).

If maximal accuracy is not critical, you may want to consider using a FFT method instead of the convolution (at least, that's how I understood your question. Feel free to correct me if I'm wrong).

Assuming you are doing a convolution and the vectors (a and b, same size as in your question) are large, the result (c) can be calculated naïvely as

// O(n^2)
for(int i = 0; i < c.size(); i++)
    c(i) = a(i) * b.array();

Using the convolution theorem, you could take the Fourier transform of both a and b and perform an element wise multiplication and then take the inverse Fourier transform of the result to get c (will probably differ a little):

// O(n log(n)); note A, B, and C are vectors of complex floating point numbers
fft.fwd(a, A);
fft.fwd(b, B);
C = A.array() * B.array();
fft.inv(C, c);