cpu: fix cpp20 build after switching to capture-by-copy

Author: dzarukin

src/cpu/matmul/ref_matmul.cpp

@@ -14,12 +14,13 @@
 * limitations under the License.
 *******************************************************************************/
 
+#include <algorithm>
 #include <assert.h>
 #include <float.h>
 #include <math.h>
 
-#include <algorithm>
 #include "common/c_types_map.hpp"
+#include "common/compiler_workarounds.hpp"
 #include "common/dnnl_thread.hpp"
 #include "common/math_utils.hpp"
 #include "common/type_helpers.hpp"
@@ -261,7 +262,8 @@ status_t ref_matmul_t::execute_ref(const exec_ctx_t &ctx) const {
     dim_t M_chunks = utils::div_up(M, M_chunk_size);
     dim_t N_chunks = utils::div_up(N, N_chunk_size);
     parallel_nd_ext(pd()->nthr_, batch, M_chunks, N_chunks,
-            [=](int ithr, int nthr, dim_t mb, dim_t mc, dim_t nc) {
+            [= WA_THIS_COPY_CAPTURE](
+                    int ithr, int nthr, dim_t mb, dim_t mc, dim_t nc) {
         if (ithr >= pd()->ntasks_) return;
         for_(dim_t m_ = mc * M_chunk_size;
                 m_ < std::min<dim_t>((mc + 1) * M_chunk_size, M);

src/cpu/matmul/ref_matmul_int8.cpp

@@ -19,6 +19,7 @@
 #include <math.h>
 
 #include "common/c_types_map.hpp"
+#include "common/compiler_workarounds.hpp"
 #include "common/dnnl_thread.hpp"
 #include "common/math_utils.hpp"
 #include "common/type_helpers.hpp"
@@ -257,7 +258,8 @@ status_t ref_matmul_int8_t::execute_ref(const exec_ctx_t &ctx) const {
     auto sum_dt = pd()->attr()->post_ops_.get_sum_dt(dst_d.data_type());
 
     // computations
-    parallel_nd(batch, M, N, [=](dim_t mb, dim_t m, dim_t n) {
+    parallel_nd(
+            batch, M, N, [= WA_THIS_COPY_CAPTURE](dim_t mb, dim_t m, dim_t n) {
         dims_t dst_dims_idx;
         // account for M, N dims for index calculations
         const size_t l_offset = mb * M * N + m * N + n;

src/cpu/ref_binary.cpp

@@ -19,6 +19,7 @@
 #include <math.h>
 
 #include "common/c_types_map.hpp"
+#include "common/compiler_workarounds.hpp"
 #include "common/dnnl_thread.hpp"
 #include "common/math_utils.hpp"
 #include "common/nstl.hpp"
@@ -94,7 +95,7 @@ status_t ref_binary_t::execute_ref(const exec_ctx_t &ctx) const {
         }
     }
 
-    parallel_nd(nelems, [=](dim_t i) {
+    parallel_nd(nelems, [= WA_THIS_COPY_CAPTURE](dim_t i) {
         // decomposition for physical offsets
         dims_t dims_src0, dims_src1, dims_src2;
         utils::l_dims_by_l_offset(dims_src0, i, dst_d.dims(), ndims);

src/cpu/ref_convolution.cpp

@@ -15,6 +15,7 @@
 *******************************************************************************/
 
 #include "common/c_types_map.hpp"
+#include "common/compiler_workarounds.hpp"
 #include "common/dnnl_thread.hpp"
 #include "common/dnnl_traits.hpp"
 #include "common/math_utils.hpp"
@@ -187,7 +188,8 @@ status_t ref_convolution_fwd_t::execute_forward(const exec_ctx_t &ctx) const {
     auto sum_dt = pd()->attr()->post_ops_.get_sum_dt(dst_d.data_type());
 
     parallel_nd(G, MB, OC, OD, OH, OW,
-            [=](dim_t g, dim_t mb, dim_t oc, dim_t od, dim_t oh, dim_t ow) {
+            [= WA_THIS_COPY_CAPTURE](
+                    dim_t g, dim_t mb, dim_t oc, dim_t od, dim_t oh, dim_t ow) {
         float acc = 0;
         if (src_d.is_plain() && weights_d.is_plain() && src_ic_stride == 1
                 && weights_kw_stride == 1)

src/cpu/ref_convolution_int8.cpp

@@ -15,6 +15,7 @@
 *******************************************************************************/
 
 #include "common/c_types_map.hpp"
+#include "common/compiler_workarounds.hpp"
 #include "common/dnnl_thread.hpp"
 #include "common/dnnl_traits.hpp"
 #include "common/math_utils.hpp"
@@ -237,7 +238,8 @@ status_t ref_convolution_int8_fwd_t::execute_forward(
     const auto sum_dt = pd()->attr()->post_ops_.get_sum_dt(dst_d.data_type());
 
     parallel_nd(G, MB, OC, OD, OH, OW,
-            [=](dim_t g, dim_t mb, dim_t oc, dim_t od, dim_t oh, dim_t ow) {
+            [= WA_THIS_COPY_CAPTURE](
+                    dim_t g, dim_t mb, dim_t oc, dim_t od, dim_t oh, dim_t ow) {
         int acc = 0;
         if (src_d.is_plain() && weights_d.is_plain() && src_ic_stride == 1
                 && weights_kw_stride == 1)

src/cpu/ref_eltwise.cpp

@@ -17,6 +17,7 @@
 #include <assert.h>
 
 #include "common/c_types_map.hpp"
+#include "common/compiler_workarounds.hpp"
 #include "common/dnnl_thread.hpp"
 #include "common/math_utils.hpp"
 #include "common/type_helpers.hpp"
@@ -62,8 +63,9 @@ status_t ref_eltwise_fwd_t::execute_forward_generic(
     const float beta = pd()->desc()->beta;
     const int ndims = pd()->ndims();
 
-    parallel_nd(
-            MB, C, D, H, W, [=](dim_t n, dim_t c, dim_t d, dim_t h, dim_t w) {
+    parallel_nd(MB, C, D, H, W,
+            [= WA_THIS_COPY_CAPTURE](
+                    dim_t n, dim_t c, dim_t d, dim_t h, dim_t w) {
         auto data_p_off = DATA_OFF(src_d, n, c, d, h, w);
         const float s
                 = io::load_float_value(src_d.data_type(), src, data_p_off);

src/cpu/ref_layer_normalization.cpp

@@ -18,6 +18,7 @@
 #include <math.h>
 
 #include "common/c_types_map.hpp"
+#include "common/compiler_workarounds.hpp"
 #include "common/dnnl_thread.hpp"
 #include "common/type_helpers.hpp"
 
@@ -76,7 +77,7 @@ status_t ref_layer_normalization_fwd_t::execute_forward(
         return status::success;
     }
 
-    parallel_nd(N, [=](dim_t n) {
+    parallel_nd(N, [= WA_THIS_COPY_CAPTURE](dim_t n) {
         const size_t s_off = stat_d.off_l(n);
         auto v_mean = (calculate_stats || skip_mean) ? 0 : mean[s_off];
         auto v_variance = calculate_stats ? 0 : variance[s_off];

src/cpu/ref_reduction.cpp

@@ -17,6 +17,7 @@
 #include <math.h>
 
 #include "common/c_types_map.hpp"
+#include "common/compiler_workarounds.hpp"
 #include "common/dnnl_thread.hpp"
 #include "common/nstl.hpp"
 
@@ -169,7 +170,7 @@ status_t ref_reduction_t::execute_ref(const exec_ctx_t &ctx) const {
         }
     }
 
-    parallel_nd(idle_size, [=](dim_t l_offset) {
+    parallel_nd(idle_size, [= WA_THIS_COPY_CAPTURE](dim_t l_offset) {
         dims_t idle_pos;
         utils::l_dims_by_l_offset(idle_pos, l_offset, dst_mdw.dims(), ndims);
 

src/cpu/ref_softmax.cpp

@@ -19,6 +19,7 @@
 #include <math.h>
 
 #include "common/c_types_map.hpp"
+#include "common/compiler_workarounds.hpp"
 #include "common/dnnl_thread.hpp"
 #include "common/type_helpers.hpp"
 
@@ -78,7 +79,8 @@ status_t ref_softmax_fwd_t::execute_forward_dense(const exec_ctx_t &ctx) const {
 
     const int nthr = pd()->nthr_;
 
-    parallel_nd_ext(nthr, outer_size_, [=](int ithr, int, dim_t ou) {
+    parallel_nd_ext(nthr, outer_size_,
+            [= WA_THIS_COPY_CAPTURE](int ithr, int, dim_t ou) {
         const void *src_data = reinterpret_cast<const char *>(src)
                 + ou * ou_stride * src_dt_size;
         void *dst_data
@@ -251,7 +253,8 @@ status_t ref_softmax_fwd_t::execute_forward_generic(
     const auto axis_size = pd()->axis_size(true);
     const int nthr = pd()->nthr_;
 
-    parallel_nd_ext(nthr, outer_size_, [=](int ithr, int, dim_t ou) {
+    parallel_nd_ext(nthr, outer_size_,
+            [= WA_THIS_COPY_CAPTURE](int ithr, int, dim_t ou) {
         const dim_t thr_shift = ithr * axis_size;
 
         float space_max_val = 0, space_denom_val = 0;
@@ -344,7 +347,7 @@ status_t ref_softmax_bwd_t::execute_backward_dense(
     // previous dimension.
     const auto ou_stride = pd()->axis_size();
 
-    parallel_nd(outer_size_, [=](dim_t ou) {
+    parallel_nd(outer_size_, [= WA_THIS_COPY_CAPTURE](dim_t ou) {
         float sbr = 0;
         size_t off = ou * ou_stride;
         if (pd()->is_softmax()) {
@@ -412,7 +415,8 @@ status_t ref_softmax_bwd_t::execute_backward_generic(
             ctx.zero_pad_output(DNNL_ARG_DIFF_SRC);
     }
 
-    parallel_nd(outer_size_, inner_size_, [=](dim_t ou, dim_t in) {
+    parallel_nd(outer_size_, inner_size_,
+            [= WA_THIS_COPY_CAPTURE](dim_t ou, dim_t in) {
         dim_t ou_in_offset = ou * channels_ * inner_size_ + in;
         float sbr = 0;
         for (int c = 0; c < channels_; ++c) {

src/cpu/simple_layer_normalization.cpp

@@ -18,6 +18,7 @@
 #include <math.h>
 
 #include "common/c_types_map.hpp"
+#include "common/compiler_workarounds.hpp"
 #include "common/dnnl_thread.hpp"
 #include "common/reorder.hpp"
 #include "common/type_helpers.hpp"
@@ -133,7 +134,7 @@ status_t simple_layer_normalization_fwd_t::execute_forward(
     const auto eps = pd()->desc()->layer_norm_epsilon;
     const auto save_stats = pd()->is_training();
 
-    parallel(0, [=](const int ithr, const int nthr) {
+    parallel(0, [= WA_THIS_COPY_CAPTURE](const int ithr, const int nthr) {
         dim_t N_start = 0, N_end = 0;
         balance211(N, nthr, ithr, N_start, N_end);
         const char *const __restrict src_ptr