examples: purged tag and dt shortcuts

Some examples define 'tag' and 'df' shortcuts to improve code
readability. This detail is misleading when looking at annotated
examples code that only shows code snippets.

Author: vpirogov

examples/bnorm_u8_via_binary_postops.cpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2020-2022 Intel Corporation
+* Copyright 2020-2025 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -46,9 +46,6 @@
 
 using namespace dnnl;
 
-using tag = memory::format_tag;
-using dt = memory::data_type;
-
 void bnorm_u8_via_binary_postops(dnnl::engine::kind engine_kind) {
 
     // Create execution dnnl::engine.
@@ -102,12 +99,18 @@ void bnorm_u8_via_binary_postops(dnnl::engine::kind engine_kind) {
             oscale_data.begin(), oscale_data.end(), []() { return 0.5f; });
 
     // Create descriptors.
-    auto src_md = memory::desc(src_dims, dt::u8, tag::nhwc);
-    auto mean_md = memory::desc(params_dims, dt::f32, tag::nhwc);
-    auto variance_md = memory::desc(params_dims, dt::f32, tag::nhwc);
-    auto scale_md = memory::desc(params_dims, dt::f32, tag::nhwc);
-    auto shift_md = memory::desc(params_dims, dt::f32, tag::nhwc);
-    auto oscale_md = memory::desc(params_dims, dt::f32, tag::nhwc);
+    auto src_md = memory::desc(
+            src_dims, memory::data_type::u8, memory::format_tag::nhwc);
+    auto mean_md = memory::desc(
+            params_dims, memory::data_type::f32, memory::format_tag::nhwc);
+    auto variance_md = memory::desc(
+            params_dims, memory::data_type::f32, memory::format_tag::nhwc);
+    auto scale_md = memory::desc(
+            params_dims, memory::data_type::f32, memory::format_tag::nhwc);
+    auto shift_md = memory::desc(
+            params_dims, memory::data_type::f32, memory::format_tag::nhwc);
+    auto oscale_md = memory::desc(
+            params_dims, memory::data_type::f32, memory::format_tag::nhwc);
 
     // Create src memory objects.
     auto src_mem = memory(src_md, engine);

examples/cnn_inference_f32.cpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2018-2024 Intel Corporation
+* Copyright 2018-2025 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -33,9 +33,6 @@
 using namespace dnnl;
 
 void simple_net_int8(engine::kind engine_kind) {
-    using tag = memory::format_tag;
-    using dt = memory::data_type;
-
     auto eng = engine(engine_kind, 0);
     stream s(eng);
 
@@ -89,12 +86,18 @@ void simple_net_int8(engine::kind engine_kind) {
     /// The user data will be in its original 32-bit floating point format.
     /// @snippet cnn_inference_int8.cpp Allocate buffers
     //[Allocate buffers]
-    auto user_src_memory = memory({{conv_src_tz}, dt::f32, tag::nchw}, eng);
+    auto user_src_memory = memory(
+            {{conv_src_tz}, memory::data_type::f32, memory::format_tag::nchw},
+            eng);
     write_to_dnnl_memory(user_src.data(), user_src_memory);
     auto user_weights_memory
-            = memory({{conv_weights_tz}, dt::f32, tag::oihw}, eng);
+            = memory({{conv_weights_tz}, memory::data_type::f32,
+                             memory::format_tag::oihw},
+                    eng);
     write_to_dnnl_memory(conv_weights.data(), user_weights_memory);
-    auto user_bias_memory = memory({{conv_bias_tz}, dt::f32, tag::x}, eng);
+    auto user_bias_memory = memory(
+            {{conv_bias_tz}, memory::data_type::f32, memory::format_tag::x},
+            eng);
     write_to_dnnl_memory(conv_bias.data(), user_bias_memory);
     //[Allocate buffers]
 
@@ -112,10 +115,14 @@ void simple_net_int8(engine::kind engine_kind) {
     ///  > Bias does not support quantization.
     /// @snippet cnn_inference_int8.cpp Create convolution memory descriptors
     //[Create convolution memory descriptors]
-    auto conv_src_md = memory::desc({conv_src_tz}, dt::u8, tag::any);
-    auto conv_bias_md = memory::desc({conv_bias_tz}, dt::f32, tag::any);
-    auto conv_weights_md = memory::desc({conv_weights_tz}, dt::s8, tag::any);
-    auto conv_dst_md = memory::desc({conv_dst_tz}, dt::u8, tag::any);
+    auto conv_src_md = memory::desc(
+            {conv_src_tz}, memory::data_type::u8, memory::format_tag::any);
+    auto conv_bias_md = memory::desc(
+            {conv_bias_tz}, memory::data_type::f32, memory::format_tag::any);
+    auto conv_weights_md = memory::desc(
+            {conv_weights_tz}, memory::data_type::s8, memory::format_tag::any);
+    auto conv_dst_md = memory::desc(
+            {conv_dst_tz}, memory::data_type::u8, memory::format_tag::any);
     //[Create convolution memory descriptors]
 
     /// Configuring int8-specific parameters in an int8 primitive is done
@@ -129,7 +136,8 @@ void simple_net_int8(engine::kind engine_kind) {
     conv_attr.set_scales_mask(DNNL_ARG_DST, dst_mask);
 
     // Prepare dst scales
-    auto dst_scale_md = memory::desc({1}, dt::f32, tag::x);
+    auto dst_scale_md
+            = memory::desc({1}, memory::data_type::f32, memory::format_tag::x);
     auto dst_scale_memory = memory(dst_scale_md, eng);
     write_to_dnnl_memory(dst_scales.data(), dst_scale_memory);
     //[Configure scaling]
@@ -194,7 +202,8 @@ void simple_net_int8(engine::kind engine_kind) {
     auto conv_src_memory = memory(conv_prim_desc.src_desc(), eng);
     primitive_attr src_attr;
     src_attr.set_scales_mask(DNNL_ARG_DST, src_mask);
-    auto src_scale_md = memory::desc({1}, dt::f32, tag::x);
+    auto src_scale_md
+            = memory::desc({1}, memory::data_type::f32, memory::format_tag::x);
     auto src_scale_memory = memory(src_scale_md, eng);
     write_to_dnnl_memory(src_scales.data(), src_scale_memory);
     auto src_reorder_pd
@@ -208,7 +217,8 @@ void simple_net_int8(engine::kind engine_kind) {
     auto conv_weights_memory = memory(conv_prim_desc.weights_desc(), eng);
     primitive_attr weight_attr;
     weight_attr.set_scales_mask(DNNL_ARG_DST, weight_mask);
-    auto wei_scale_md = memory::desc({1}, dt::f32, tag::x);
+    auto wei_scale_md
+            = memory::desc({1}, memory::data_type::f32, memory::format_tag::x);
     auto wei_scale_memory = memory(wei_scale_md, eng);
     write_to_dnnl_memory(weight_scales.data(), wei_scale_memory);
     auto weight_reorder_pd
@@ -251,7 +261,9 @@ void simple_net_int8(engine::kind engine_kind) {
     /// computation output data.
     /// @snippet cnn_inference_int8.cpp Dequantize the result
     ///[Dequantize the result]
-    auto user_dst_memory = memory({{conv_dst_tz}, dt::f32, tag::nchw}, eng);
+    auto user_dst_memory = memory(
+            {{conv_dst_tz}, memory::data_type::f32, memory::format_tag::nchw},
+            eng);
     write_to_dnnl_memory(user_dst.data(), user_dst_memory);
     primitive_attr dst_attr;
     dst_attr.set_scales_mask(DNNL_ARG_SRC, dst_mask);

examples/cnn_inference_int8.cpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2019-2022 Intel Corporation
+* Copyright 2019-2025 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -38,9 +38,6 @@
 using namespace dnnl;
 
 void simple_net(engine::kind engine_kind) {
-    using tag = memory::format_tag;
-    using dt = memory::data_type;
-
     auto eng = engine(engine_kind, 0);
     stream s(eng);
 
@@ -79,27 +76,36 @@ void simple_net(engine::kind engine_kind) {
         conv_bias[i] = sinf((float)i);
 
     // create memory for user data
-    auto conv_user_src_memory
-            = memory({{conv_src_tz}, dt::f32, tag::nchw}, eng);
+    auto conv_user_src_memory = memory(
+            {{conv_src_tz}, memory::data_type::f32, memory::format_tag::nchw},
+            eng);
     write_to_dnnl_memory(net_src.data(), conv_user_src_memory);
 
     auto conv_user_weights_memory
-            = memory({{conv_weights_tz}, dt::f32, tag::oihw}, eng);
+            = memory({{conv_weights_tz}, memory::data_type::f32,
+                             memory::format_tag::oihw},
+                    eng);
     write_to_dnnl_memory(conv_weights.data(), conv_user_weights_memory);
 
-    auto conv_user_bias_memory = memory({{conv_bias_tz}, dt::f32, tag::x}, eng);
+    auto conv_user_bias_memory = memory(
+            {{conv_bias_tz}, memory::data_type::f32, memory::format_tag::x},
+            eng);
     write_to_dnnl_memory(conv_bias.data(), conv_user_bias_memory);
 
     // create memory descriptors for bfloat16 convolution data w/ no specified
     // format tag(`any`)
     // tag `any` lets a primitive(convolution in this case)
     // chose the memory format preferred for best performance.
-    auto conv_src_md = memory::desc({conv_src_tz}, dt::bf16, tag::any);
-    auto conv_weights_md = memory::desc({conv_weights_tz}, dt::bf16, tag::any);
-    auto conv_dst_md = memory::desc({conv_dst_tz}, dt::bf16, tag::any);
+    auto conv_src_md = memory::desc(
+            {conv_src_tz}, memory::data_type::bf16, memory::format_tag::any);
+    auto conv_weights_md = memory::desc({conv_weights_tz},
+            memory::data_type::bf16, memory::format_tag::any);
+    auto conv_dst_md = memory::desc(
+            {conv_dst_tz}, memory::data_type::bf16, memory::format_tag::any);
     // here bias data type is set to bf16.
     // additionally, f32 data type is supported for bf16 convolution.
-    auto conv_bias_md = memory::desc({conv_bias_tz}, dt::bf16, tag::any);
+    auto conv_bias_md = memory::desc(
+            {conv_bias_tz}, memory::data_type::bf16, memory::format_tag::any);
 
     // create a convolution primitive descriptor
 
@@ -225,11 +231,13 @@ void simple_net(engine::kind engine_kind) {
     memory::dims pool_padding = {0, 0};
 
     // create memory for pool dst data in user format
-    auto pool_user_dst_memory
-            = memory({{pool_dst_tz}, dt::f32, tag::nchw}, eng);
+    auto pool_user_dst_memory = memory(
+            {{pool_dst_tz}, memory::data_type::f32, memory::format_tag::nchw},
+            eng);
 
     // create pool dst memory descriptor in format any for bfloat16 data type
-    auto pool_dst_md = memory::desc({pool_dst_tz}, dt::bf16, tag::any);
+    auto pool_dst_md = memory::desc(
+            {pool_dst_tz}, memory::data_type::bf16, memory::format_tag::any);
 
     // create a pooling primitive descriptor
     auto pool_pd = pooling_forward::primitive_desc(eng, prop_kind::forward,
@@ -269,14 +277,17 @@ void simple_net(engine::kind engine_kind) {
         net_diff_dst[i] = sinf((float)i);
 
     // create memory for user diff dst data stored in float data type
-    auto pool_user_diff_dst_memory
-            = memory({{pool_dst_tz}, dt::f32, tag::nchw}, eng);
+    auto pool_user_diff_dst_memory = memory(
+            {{pool_dst_tz}, memory::data_type::f32, memory::format_tag::nchw},
+            eng);
     write_to_dnnl_memory(net_diff_dst.data(), pool_user_diff_dst_memory);
 
     // Backward pooling
     // create memory descriptors for pooling
-    auto pool_diff_src_md = memory::desc({lrn_data_tz}, dt::bf16, tag::any);
-    auto pool_diff_dst_md = memory::desc({pool_dst_tz}, dt::bf16, tag::any);
+    auto pool_diff_src_md = memory::desc(
+            {lrn_data_tz}, memory::data_type::bf16, memory::format_tag::any);
+    auto pool_diff_dst_md = memory::desc(
+            {pool_dst_tz}, memory::data_type::bf16, memory::format_tag::any);
 
     // backward primitive descriptor needs to hint forward descriptor
     auto pool_bwd_pd = pooling_backward::primitive_desc(eng,
@@ -305,7 +316,8 @@ void simple_net(engine::kind engine_kind) {
             {DNNL_ARG_WORKSPACE, pool_workspace_memory}});
 
     // Backward lrn
-    auto lrn_diff_dst_md = memory::desc({lrn_data_tz}, dt::bf16, tag::any);
+    auto lrn_diff_dst_md = memory::desc(
+            {lrn_data_tz}, memory::data_type::bf16, memory::format_tag::any);
     const auto &lrn_diff_src_md = lrn_diff_dst_md;
 
     // create backward lrn primitive descriptor
@@ -335,8 +347,10 @@ void simple_net(engine::kind engine_kind) {
             {DNNL_ARG_WORKSPACE, lrn_workspace_memory}});
 
     // Backward relu
-    auto relu_diff_src_md = memory::desc({relu_data_tz}, dt::bf16, tag::any);
-    auto relu_diff_dst_md = memory::desc({relu_data_tz}, dt::bf16, tag::any);
+    auto relu_diff_src_md = memory::desc(
+            {relu_data_tz}, memory::data_type::bf16, memory::format_tag::any);
+    auto relu_diff_dst_md = memory::desc(
+            {relu_data_tz}, memory::data_type::bf16, memory::format_tag::any);
     auto relu_src_md = conv_pd.dst_desc();
 
     // create backward relu primitive_descriptor
@@ -367,14 +381,20 @@ void simple_net(engine::kind engine_kind) {
     // create user format diff weights and diff bias memory for float data type
 
     auto conv_user_diff_weights_memory
-            = memory({{conv_weights_tz}, dt::f32, tag::nchw}, eng);
-    auto conv_diff_bias_memory = memory({{conv_bias_tz}, dt::f32, tag::x}, eng);
+            = memory({{conv_weights_tz}, memory::data_type::f32,
+                             memory::format_tag::nchw},
+                    eng);
+    auto conv_diff_bias_memory = memory(
+            {{conv_bias_tz}, memory::data_type::f32, memory::format_tag::x},
+            eng);
 
     // create memory descriptors for bfloat16 convolution data
-    auto conv_bwd_src_md = memory::desc({conv_src_tz}, dt::bf16, tag::any);
-    auto conv_diff_weights_md
-            = memory::desc({conv_weights_tz}, dt::bf16, tag::any);
-    auto conv_diff_dst_md = memory::desc({conv_dst_tz}, dt::bf16, tag::any);
+    auto conv_bwd_src_md = memory::desc(
+            {conv_src_tz}, memory::data_type::bf16, memory::format_tag::any);
+    auto conv_diff_weights_md = memory::desc({conv_weights_tz},
+            memory::data_type::bf16, memory::format_tag::any);
+    auto conv_diff_dst_md = memory::desc(
+            {conv_dst_tz}, memory::data_type::bf16, memory::format_tag::any);
 
     // use diff bias provided by the user
     auto conv_diff_bias_md = conv_diff_bias_memory.get_desc();