Using dot() in the Kernel Definition

[RoyiAvital]

I am trying to have a convolution operation using StaticKernels.jl.

A simple try out is:

using StaticKernels;

vA = [1, 2, 3, 4, 5];
vB = [4, 5, 6];
vC = view(vB, length(vB):-1:1);

vK = Kernel{(0:(length(vB) - 1), )}(@inline vW -> dot(vW, vC));
map(vK, extend(vA, StaticKernels.ExtensionConstant(0)));

Yet I get the error: ERROR: MethodError: no method matching iterate(::StaticKernels.Window{Int64, 1, (0:2,), Kernel{(0:2,), var"#27#28"}, StaticKernels.ExtensionArray{Int64, 1, Vector{Int64}, StaticKernels.ExtensionConstant{Int64}}}).

Yet this works:

vK = @kernel w -> w[0] * vB[3] + w[1] * vB[2] + w[2] * vB[1];
map(vK, extend(vA, StaticKernels.ExtensionConstant(0)));

What's the difference? I guess I'm missing something about the structure of the kernel.

[RoyiAvital]

@stev47 , Any chance to have some tips on this?

[RoyiAvital]

But this is the most regular array. Does it expect a matrix?

[stev47]

vW in the kernel function is not an array, but a Window object which acts similar as a view on a part of vA but with static sizing for performance reasons. The window allows for efficient static indexing, iterate however is more tricky to get right. If you write Tuple(vW) you explicitly index everything and then you can use the tuple object to do your operations as usual. Note that you might want vC to be a StaticArray for performance.

[RoyiAvital]

OK, so how would you recommend having high performance dot?

Would explicit loop be efficient and fast in the context of the kernel?
If have the values of vC is there a macro which just can be expended into vC[1] * vW[1] + vC[2] * vW[2] + ... + vC[n] * vW[n]?

[stev47]

Look at my first answer (wrapping with Tuple), then look at my second answer (making vC a StaticArray) and combine them. That should give good performance.

As already said: loops with iterate are tricky. Tuple(vW) will do exactly that index expansion you are suggesting.

[RoyiAvital]

I am not familiar with the internals.
Just thought that maybe Tuple() is generating an overhead.
Hence there might be a more efficient way.

Will do as suggested.