[SYCL][ESIMD] Enable verification for 32 simd vector length (intel#758)

Author: vasilytric

SYCL/ESIMD/api/functional/ctors/ctor_array_core.cpp

@@ -32,11 +32,16 @@ int main(int, char **) {
 
   bool passed = true;
 
+<<<<<<< HEAD
   const auto types = get_tested_types<tested_types::core>();
   const auto dims = get_all_dimensions();
   const auto contexts =
       unnamed_type_pack<ctors::initializer, ctors::var_decl,
                         ctors::rval_in_expr, ctors::const_ref>::generate();
+=======
+  const auto types = get_tested_types<tested_types::all>();
+  const auto dims = get_all_dimensions();
+>>>>>>> 7ff842b8f ([SYCL][ESIMD] Enable verification for 32 simd vector length (#758))
 
   passed &= for_all_combinations<ctors::run_test>(types, dims, contexts, queue);
 

SYCL/ESIMD/api/functional/ctors/ctor_fill_core.cpp

@@ -35,6 +35,7 @@ int main(int, char **) {
   // invocation contexts, base and step values accumulating the result in
   // boolean flag.
 
+<<<<<<< HEAD
   {
     // Validate basic functionality works for every invocation context
     const auto types = named_type_pack<char, int>::generate("char", "int");
@@ -144,6 +145,118 @@ int main(int, char **) {
       }
     }
   }
+=======
+  const auto two_dims = values_pack<1, 8>();
+  const auto char_int_types = named_type_pack<char, int>({"char", "int"});
+
+  // Run for specific combinations of types, vector length, base and step values
+  // and invocation contexts.
+  // The first init_val value it's a base value and the second init_val value
+  // it's a step value.
+  passed &=
+      ctors::run_verification<ctors::initializer, ctors::init_val::min_half,
+                              ctors::init_val::zero>(queue, two_dims,
+                                                     char_int_types);
+
+  passed &= ctors::run_verification<ctors::initializer, ctors::init_val::zero,
+                                    ctors::init_val::positive>(queue, two_dims,
+                                                               char_int_types);
+  passed &=
+      ctors::run_verification<ctors::initializer, ctors::init_val::min_half,
+                              ctors::init_val::positive>(queue, two_dims,
+                                                         char_int_types);
+
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::min_half,
+                                    ctors::init_val::zero>(queue, two_dims,
+                                                           char_int_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::zero,
+                                    ctors::init_val::positive>(queue, two_dims,
+                                                               char_int_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::min_half,
+                                    ctors::init_val::positive>(queue, two_dims,
+                                                               char_int_types);
+
+  passed &=
+      ctors::run_verification<ctors::rval_in_express, ctors::init_val::min_half,
+                              ctors::init_val::zero>(queue, two_dims,
+                                                     char_int_types);
+  passed &=
+      ctors::run_verification<ctors::rval_in_express, ctors::init_val::zero,
+                              ctors::init_val::positive>(queue, two_dims,
+                                                         char_int_types);
+  passed &=
+      ctors::run_verification<ctors::rval_in_express, ctors::init_val::min_half,
+                              ctors::init_val::positive>(queue, two_dims,
+                                                         char_int_types);
+
+  passed &= ctors::run_verification<ctors::const_ref, ctors::init_val::min_half,
+                                    ctors::init_val::zero>(queue, two_dims,
+                                                           char_int_types);
+  passed &= ctors::run_verification<ctors::const_ref, ctors::init_val::zero,
+                                    ctors::init_val::positive>(queue, two_dims,
+                                                               char_int_types);
+  passed &= ctors::run_verification<ctors::const_ref, ctors::init_val::min_half,
+                                    ctors::init_val::positive>(queue, two_dims,
+                                                               char_int_types);
+
+  const auto all_dims = get_all_dimensions();
+  const auto all_types = get_tested_types<tested_types::all>();
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::min,
+                                    ctors::init_val::zero>(queue, all_dims,
+                                                           all_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::max_half,
+                                    ctors::init_val::zero>(queue, all_dims,
+                                                           all_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::zero,
+                                    ctors::init_val::positive>(queue, all_dims,
+                                                               all_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::max_half,
+                                    ctors::init_val::positive>(queue, all_dims,
+                                                               all_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::zero,
+                                    ctors::init_val::negative>(queue, all_dims,
+                                                               all_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::max_half,
+                                    ctors::init_val::negative>(queue, all_dims,
+                                                               all_types);
+
+  const auto single_dim = values_pack<8>();
+  const auto uint_types = get_tested_types<tested_types::uint>();
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::min,
+                                    ctors::init_val::positive>(
+      queue, single_dim, uint_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::min,
+                                    ctors::init_val::negative>(
+      queue, single_dim, uint_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::max,
+                                    ctors::init_val::positive>(
+      queue, single_dim, uint_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::max,
+                                    ctors::init_val::negative>(
+      queue, single_dim, uint_types);
+
+  const auto sint_types = get_tested_types<tested_types::sint>();
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::min,
+                                    ctors::init_val::positive>(
+      queue, single_dim, uint_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::max,
+                                    ctors::init_val::negative>(
+      queue, single_dim, uint_types);
+
+  const auto fp_types = get_tested_types<tested_types::fp>();
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::neg_inf,
+                                    ctors::init_val::max>(queue, single_dim,
+                                                          fp_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::max,
+                                    ctors::init_val::neg_inf>(queue, single_dim,
+                                                              fp_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::nan,
+                                    ctors::init_val::negative>(
+      queue, single_dim, fp_types);
+  passed &= ctors::run_verification<ctors::var_dec, ctors::init_val::negative,
+                                    ctors::init_val::nan>(queue, single_dim,
+                                                          fp_types);
+>>>>>>> 7ff842b8f ([SYCL][ESIMD] Enable verification for 32 simd vector length (#758))
 
   std::cout << (passed ? "=== Test passed\n" : "=== Test FAILED\n");
   return passed ? 0 : 1;

SYCL/ESIMD/api/functional/ctors/ctor_move.cpp

@@ -21,12 +21,6 @@
 // source simd instance. It is expected for a new simd instance to store
 // bitwise same data as the one passed as the source simd constructor.
 
-// The following issues for simd<T,32> observed:
-// - freeze with T in {char, unsigned char, singned char};
-// - runtime failure with T in {short, unsigned short}.
-// TODO Remove once the freeze is fixed
-#define SKIP_VECTOR_LEN_32
-
 // The test proxy is used to verify the move constructor was called actually.
 #define __ESIMD_ENABLE_TEST_PROXY
 
@@ -222,11 +216,7 @@ template <typename DataT, int NumElems, typename TestCaseT> class run_test {
 int main(int, char **) {
   bool passed = true;
   const auto types = get_tested_types<tested_types::all>();
-#ifdef SKIP_VECTOR_LEN_32
-  const auto dims = values_pack<1, 8, 16>();
-#else
   const auto dims = get_all_dimensions();
-#endif
 
   sycl::queue queue(esimd_test::ESIMDSelector{},
                     esimd_test::createExceptionHandler());

SYCL/ESIMD/api/functional/ctors/ctor_vector_core.cpp

@@ -41,11 +41,16 @@ int main(int, char **) {
 
   bool passed = true;
 
+<<<<<<< HEAD
   const auto types = get_tested_types<tested_types::core>();
   const auto dims = get_all_dimensions();
   const auto contexts =
       unnamed_type_pack<ctors::initializer, ctors::var_decl,
                         ctors::rval_in_expr, ctors::const_ref>::generate();
+=======
+  const auto types = get_tested_types<tested_types::all>();
+  const auto dims = get_all_dimensions();
+>>>>>>> 7ff842b8f ([SYCL][ESIMD] Enable verification for 32 simd vector length (#758))
 
   // Run test for all combinations possible
   passed &= for_all_combinations<ctors::run_test>(types, dims, contexts, queue);