Kokkos::complex<T> behaves slightly differently from std::complex<T>

[bjoo]

Just came accross this issue today. In some cases I want to set the real and imaginary parts of a Kokkos::complex separately. This works in the intuitive way e.g.

Kokkos::complex f;
f.real() = 3.0;
f.imag() = 4.0;

However, when I tried to switch over to std::complex this no longer worked. Apparently
now the only way to do this is:

std::complex f;
f.real(3.0);
f.imag(4.0);

When I tried this with Kokkos::complex it didn't work:

/global/homes/b/bjoo/MG/mg_proto_vec/test/kokkos/./kokkos_vectype.h(222): error: no instance >of overloaded function "Kokkos::complex::imag [with RealType=REAL={REAL64=?{double}}]" matches the argument list
argument types are: (double)
object type is: MG::MyComplex
adata[i].imag( adata[i].imag() - sign*bdata[i].real() );
^
/global/homes/b/bjoo/MG/mg_proto_vec/kokkos/core/src/Kokkos_Complex.hpp(221): note: this >candidate was rejected because mismatch in count of arguments
KOKKOS_INLINE_FUNCTION const RealType imag () const volatile {

(here MG::MyComplex is aliased to Kokkos::Complex using using)

Ultimately this may not matter as folks should use Kokkos::complex, but it may trip up users migrating form std::complex . For what its worth, I prefer the Kokkos version as I can do things like

a.real() += b.imag();

[mhoemmen]

Hi @bjoo ! Would you like to submit a pull request (against Kokkos' develop branch) in order to fix this? Also, is the requested feature standard with C++11? Does it work with GCC 4.8.4?

[ibaned]

Here is a relevant page of C++ documentation with annotations about how things change over standards.
I suspect the way they did it this way (getters and setters) is that there is no guarantee that std::complex internally actually just contains two members of type T, it may be using some other weird encoding. That said, the getters are constexpr since C++11, so it can't be that weird.

[ibaned]

Just added these functions, tested them, and got them approved into Kokkos develop. Record time!

[bjoo]

Thank you very much Dan. I will change my code to use these new versions. As I mentioned, to be honest, I preferred the existing Kokkos::complex<> implementation. Writing f.real() += y.imag(); seems more natural to me than the new std::complex way of : f.real( f.real() + y.imag() ); which looses the feeling of ‘+=‘-ness. Regarding your earlier other point: I do currently rely on having real and imaginary part be contiguous especially in the case of arrays, e.g. for the following: Kokkos::complex<T> array[N]; const T* storage = reinterpret_cast<const T*>(&array[0]); // ‘storage’ should be 2*N values of T Right now this appears to work (at least with Kokkos::complex<>) and this is useful at least on CPUs with vectors, since it turns out that the compilers I’ve had experiences with are not super great at vectorizing over complex numbers and very simple (but nonportable) intrinsics specializations can help here (3-4x speed improvement and not a lot of extra work, so worth not leaving on the table — tho it is nonportable). Ultimately I will need Kokkos::complex<> also for GPUs. The only reason I wanted to swap in std::complex was to see if the compiler recognized it and did a better job vectorizing it than it did with Kokkos::complex. (BTW: It didn’t, the code with Kokkos::complex<> was actually a little faster) Thanks again and best wishes, B

…

On Aug 2, 2017, at 7:58 AM, Dan Ibanez ***@***.***> wrote: Just added these functions, tested them, and got them approved into Kokkos develop. Record time! — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub, or mute the thread.

-------------------------------------------------------------------------------------- Dr Balint Joo High Performance Computational Scientist Jefferson Lab 12000 Jefferson Ave, Suite 3, MS 12B2, Room F217, Newport News, VA 23606, USA Tel: +1-757-269-5339, Fax: +1-757-269-5427 email: bjoo@jlab.org -------------------------------------------------------------------------------------

[mhoemmen]

@bjoo Kokkos::complex<T> is just a struct { T real_; T imag_; };. It only exists because std::complex doesn't (currently) work on GPUs and doesn't have the required volatile overloads for use as a Kokkos::parallel_{reduce,scan} reduction result.

If you're worried about vectorization on CPUs, you might like to try the built-in C99 types double _Complex or float _Complex. Their syntax is a little bit different, though. I wrote Kokkos::complex because Tpetra had already committed well before my time to use std::complex, so I needed a drop-in replacement.