[SYCL][ESIMD] Add test proxy for move constructors

Because copy constructor works as the default fallback for every case with move
constructor disabled or not provided, there is no way for a caller to
differentiate between actual call to move constructor and copy constructor.
Same goes for copy and move assignment operators.

Therefore a test proxy is the only way left to check the move constructor and
the move assignment works as expected.

Signed-off-by: Yuriy Kochetkov <[email protected]>

Author: yuriykoch

sycl/include/sycl/ext/intel/experimental/esimd/detail/simd_obj_impl.hpp

@@ -13,6 +13,7 @@
 #include <sycl/ext/intel/experimental/esimd/detail/intrin.hpp>
 #include <sycl/ext/intel/experimental/esimd/detail/memory_intrin.hpp>
 #include <sycl/ext/intel/experimental/esimd/detail/sycl_util.hpp>
+#include <sycl/ext/intel/experimental/esimd/detail/test_proxy.hpp>
 #include <sycl/ext/intel/experimental/esimd/detail/types.hpp>
 #include <sycl/ext/intel/experimental/esimd/simd_view.hpp>
 
@@ -716,11 +717,17 @@ template <typename Ty, int N, class Derived, class SFINAE> class simd_obj_impl {
   __ESIMD_DEF_SIMD_OBJ_IMPL_OPASSIGN(/, /=, __ESIMD_ARITH_OP_FILTER)
 #undef __ESIMD_ARITH_OP_FILTER
 
+  // Getter for the test proxy member, if enabled
+  __ESIMD_DECLARE_TEST_PROXY_ACCESS
+
 private:
   // The underlying data for this vector.
   vector_type M_data;
 
 protected:
+  // The test proxy if enabled
+  __ESIMD_DECLARE_TEST_PROXY
+
   void set(const vector_type &Val) {
 #ifndef __SYCL_DEVICE_ONLY__
     M_data = Val;

sycl/include/sycl/ext/intel/experimental/esimd/detail/simd_view_impl.hpp

@@ -11,6 +11,7 @@
 #pragma once
 
 #include <sycl/ext/intel/experimental/esimd/detail/intrin.hpp>
+#include <sycl/ext/intel/experimental/esimd/detail/test_proxy.hpp>
 #include <sycl/ext/intel/experimental/esimd/detail/types.hpp>
 
 __SYCL_INLINE_NAMESPACE(cl) {
@@ -303,8 +304,12 @@ class simd_view_impl {
   Derived &operator=(const value_type &Val) { return write(Val); }
 
   /// Move assignment operator.
-  Derived &operator=(Derived &&Other) { return write(Other.read()); }
+  Derived &operator=(Derived &&Other) {
+    __esimd_move_test_proxy(Other);
+    return write(Other.read());
+  }
   simd_view_impl &operator=(simd_view_impl &&Other) {
+    __esimd_move_test_proxy(Other);
     return write(Other.read());
   }
 
@@ -492,10 +497,17 @@ class simd_view_impl {
     return read().all();
   }
 
+public:
+  // Getter for the test proxy member, if enabled
+  __ESIMD_DECLARE_TEST_PROXY_ACCESS
+
 protected:
   // The reference to the base object, which must be a simd object
   BaseTy &M_base;
 
+  // The test proxy if enabled
+  __ESIMD_DECLARE_TEST_PROXY
+
   // The region applied on the base object. Its type could be
   // - region1d_t
   // - region2d_t

sycl/include/sycl/ext/intel/experimental/esimd/detail/test_proxy.hpp

@@ -0,0 +1,106 @@
+//==-------------- test_proxy.hpp - DPC++ Explicit SIMD API ----------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// Test proxy to differentiate move and copy constructor calls
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#ifndef __ESIMD_ENABLE_TEST_PROXY
+
+// No ABI-breaking changes by default
+#define __ESIMD_DECLARE_TEST_PROXY
+#define __ESIMD_DECLARE_TEST_PROXY_ACCESS
+#define __esimd_move_test_proxy(other)
+
+#else
+
+// Declare the class attribute
+//
+// We are using non static data member initialization approach to force
+// the value required. Initialization will take place even if no
+// default/copy/move constructor of the test_proxy class was explcitly
+// called by any of the user-defined constructors of the proxy target
+#define __ESIMD_DECLARE_TEST_PROXY                                             \
+  esimd::detail::test_proxy M_testProxy = esimd::detail::test_proxy();
+
+// Declare the getter to access the proxy from the tests
+#define __ESIMD_DECLARE_TEST_PROXY_ACCESS                                      \
+  const auto &get_test_proxy() const { return M_testProxy; }
+
+// Test proxy will be handled in a proper way by default/implicit move
+// constructors and move operators.
+// Still the user-defined constructors or move operators should explicitly state
+// what to do with each of class atributes, so a proper wrapper required
+#define __esimd_move_test_proxy(other)                                         \
+  do {                                                                         \
+    M_testProxy = std::move(other.M_testProxy);                                \
+  } while (false);
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace ext {
+namespace intel {
+namespace experimental {
+namespace esimd {
+namespace detail {
+
+/// The test_proxy class.
+///
+/// This is a helper class for tests to differentiate between the copy
+/// constructor/assignment and the move constructor/assignment calls,
+/// as the copy constructor works as the default fallback for every case with
+/// move constructor disabled or not provided
+///
+/// The test proxy is enabled only if the __ESIMD_ENABLE_TEST_PROXY macro is
+/// defined.
+/// It is expected for the class with the test proxy (the class under test) to:
+/// - provide the get_test_proxy() method
+/// - properly handle moving the test_proxy member in user-defined move
+///   constructors and user-defined assignment operators
+///
+/// Therefore the following expression is expected to return `true` only if the
+/// move constructor or move operator was called for the instance of the class
+/// under test:
+///   instance.get_test_proxy().was_moved()
+///
+/// \ingroup sycl_esimd
+class test_proxy {
+  // Define the default value to use for every constructor
+  bool m_moved = false;
+
+public:
+  test_proxy() { __esimd_dbg_print(test_proxy()); }
+
+  test_proxy(const test_proxy &) {
+    __esimd_dbg_print(test_proxy(const test_proxy &other));
+  }
+  test_proxy(test_proxy &&) {
+    __esimd_dbg_print(test_proxy(test_proxy && other));
+    m_moved = true;
+  }
+  test_proxy &operator=(const test_proxy &) {
+    __esimd_dbg_print(test_proxy::operator=(const test_proxy &other));
+    return *this;
+  }
+  test_proxy &operator=(test_proxy &&) {
+    __esimd_dbg_print(test_proxy::operator=(test_proxy &&other));
+    m_moved = true;
+    return *this;
+  }
+  bool was_moved() const { return m_moved; }
+};
+
+} // namespace detail
+} // namespace esimd
+} // namespace experimental
+} // namespace intel
+} // namespace ext
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)
+
+#endif // __ESIMD_ENABLE_TEST_PROXY