Replace tuple-style cast with pointer/stride access

It was noted in #1 (closed) that the get operator will not fully vectorize due to the tuple-style cast hidden in getStructMember. The pointers upfront are now cached in attempts to alleviate this. This changes the manner of data access in the AoSoA for arrays:

return getStructMember<I>(_raw_data[idx.s()]);

to:

return static_cast<struct_member_array_type<I> >( data<I>() + idx.s() * _strides[I] );

If this allows vectorization, then it may be well worth the extra arithmetic needed to index into the data block. Furthermore, if loop-invariant hoisting were done well by the compiler, idx.s() * _strides[I] would be hoisted above the inner loop over arrays as a further optimization.

Cacheing pointers and strides also had a nice side effect for future C interfaces - template-free pointer and stride access! A user can now get strides and (un-typed void*) pointers directly through the following interface:

size_t PosX = 0;
double* pos_x = (double*) aosoa.pointer(PosX);
size_t pos_x_stride = aosoa.stride(PosX);

core/unit_test/tstAoSoA.cpp

@@ -73,19 +73,14 @@ BOOST_AUTO_TEST_CASE( aosoa_serial_api_test )
     BOOST_TEST( Cabana::is_aosoa<AoSoA_t>::value );
 
     // Create an AoSoA.
-    std::size_t num_data = 35;
-    AoSoA_t aosoa( num_data );
+    AoSoA_t aosoa;
 
     // Check sizes.
-    BOOST_TEST( aosoa.size() == std::size_t(35) );
-    BOOST_TEST( aosoa.capacity() == std::size_t(40) );
-    BOOST_TEST( aosoa.numSoA() == std::size_t(4) );
-
-    BOOST_TEST( aosoa.arraySize(0) == std::size_t(10) );
-    BOOST_TEST( aosoa.arraySize(1) == std::size_t(10) );
-    BOOST_TEST( aosoa.arraySize(2) == std::size_t(10) );
-    BOOST_TEST( aosoa.arraySize(3) == std::size_t(5) );
+    BOOST_TEST( aosoa.size() == std::size_t(0) );
+    BOOST_TEST( aosoa.capacity() == std::size_t(0) );
+    BOOST_TEST( aosoa.numSoA() == std::size_t(0) );
 
+    // Check member type properties.
     BOOST_TEST( aosoa.rank(0) == std::size_t(3) );
     std::size_t e00 = aosoa.extent(0,0);
     BOOST_TEST( e00 == dim_1 );
@@ -136,6 +131,20 @@ BOOST_AUTO_TEST_CASE( aosoa_serial_api_test )
     std::size_t e43 = aosoa.extent(4,3);
     BOOST_TEST( e43 == std::size_t(0) );
 
+    // Resize
+    std::size_t num_data = 35;
+    aosoa.resize( num_data );
+
+    // Check sizes for the new allocation/size.
+    BOOST_TEST( aosoa.size() == std::size_t(35) );
+    BOOST_TEST( aosoa.capacity() == std::size_t(40) );
+    BOOST_TEST( aosoa.numSoA() == std::size_t(4) );
+
+    BOOST_TEST( aosoa.arraySize(0) == std::size_t(10) );
+    BOOST_TEST( aosoa.arraySize(1) == std::size_t(10) );
+    BOOST_TEST( aosoa.arraySize(2) == std::size_t(10) );
+    BOOST_TEST( aosoa.arraySize(3) == std::size_t(5) );
+
     // Initialize data with the rank accessors.
     float fval = 3.4;
     double dval = 1.23;
@@ -218,11 +227,15 @@ BOOST_AUTO_TEST_CASE( aosoa_raw_data_test )
     // Inner array size.
     const std::size_t array_size = 103;
 
+    // Multi dimensional member sizes.
+    const std::size_t dim_1 = 3;
+    const std::size_t dim_2 = 5;
+
     // Declare data types. Note that this test only uses rank-0 data.
     using DataTypes =
         Cabana::MemberDataTypes<float,
                                 int,
-                                double,
+                                double[dim_1][dim_2],
                                 int,
                                 double
                                 >;
@@ -248,6 +261,12 @@ BOOST_AUTO_TEST_CASE( aosoa_raw_data_test )
     std::size_t st3 = aosoa.stride(3);
     std::size_t st4 = aosoa.stride(4);
 
+    // Member 2 is multidimensional so get its extents.
+    std::size_t m2e0 = aosoa.extent(2,0);
+    std::size_t m2e1 = aosoa.extent(2,1);
+    BOOST_TEST( m2e0 == dim_1 );
+    BOOST_TEST( m2e1 == dim_2 );
+
     // Initialize the data with raw pointer/stride access. Start by looping
     // over the structs. Each struct has a group of contiguous arrays of size
     // array_size for each member.
@@ -260,9 +279,15 @@ BOOST_AUTO_TEST_CASE( aosoa_raw_data_test )
         {
             p0[ s * st0 + i ] = (s + i) * 1.0;
             p1[ s * st1 + i ] = (s + i) * 2;
-            p2[ s * st2 + i ] = (s + i) * 3.0;
             p3[ s * st3 + i ] = (s + i) * 4;
             p4[ s * st4 + i ] = (s + i) * 5.0;
+
+            // Member 2 has some extra dimensions so add those to the
+            // indexing.
+            for ( std::size_t j = 0; j < m2e0; ++j )
+                for ( std::size_t k = 0; k < m2e1; ++k )
+                    p2[ s * st2 + i * m2e0 * m2e1 + j * m2e1 + k ] =
+                        (s + i + j + k) * 3.0;
         }
     }
 
@@ -273,8 +298,12 @@ BOOST_AUTO_TEST_CASE( aosoa_raw_data_test )
         std::size_t i = idx.i();
         BOOST_TEST( aosoa.get<0>(idx) == (s+i)*1.0 );
         BOOST_TEST( aosoa.get<1>(idx) == int((s+i)*2) );
-        BOOST_TEST( aosoa.get<2>(idx) == (s+i)*3.0 );
         BOOST_TEST( aosoa.get<3>(idx) == int((s+i)*4) );
         BOOST_TEST( aosoa.get<4>(idx) == (s+i)*5.0 );
+
+        // Member 2 has some extra dimensions so check those too.
+        for ( std::size_t j = 0; j < dim_1; ++j )
+            for ( std::size_t k = 0; k < dim_2; ++k )
+                BOOST_TEST( aosoa.get<2>(idx,j,k) == (s+i+j+k)*3.0 );
     }
 }