benchdnn: graph: enbale default value data filling

benchdnn: graph: remove init ref if no ref path enbabled

Author: wzt1997

tests/benchdnn/graph/bench_graph.cpp

@@ -58,17 +58,6 @@ void check_correctness(const settings_t &s) {
     }
 }
 
-int verify_input(const settings_t &s) {
-    if (has_bench_mode_modifier(mode_modifier_t::no_ref_memory)) {
-        // TODO: update graph driver doc page once the limitation is removed.
-        BENCHDNN_PRINT(0, "%s\n",
-                "Error: graph driver doesn't support "
-                "--mode-modifier=M/--mode=F.");
-        return FAIL;
-    }
-    return OK;
-}
-
 int bench(int argc, char **argv) {
     driver_name = "graph";
     using namespace parser;
@@ -88,7 +77,6 @@ int bench(int argc, char **argv) {
         if (!parsed_options) {
             if (!parse_input_file(s.json_file, argv[0]))
                 catch_unknown_options(argv[0]);
-            SAFE(verify_input(s), WARN);
             check_correctness(s);
             flush_temp_memory();
         }

tests/benchdnn/graph/custom_driver.cpp

@@ -293,6 +293,17 @@ void setup_cmp(compare::compare_t &cmp, const prb_t *prb, data_kind_t kind,
 
 int fill_mem(dnn_mem_t &mem_dt, dnn_mem_t &mem_fp, int f_min, int f_max) {
 
+    if (has_bench_mode_modifier(mode_modifier_t::no_ref_memory)) {
+        const int nhandles = query_md_num_handles(mem_dt.md_);
+        size_t sz = dnnl_memory_desc_get_size(mem_dt.md_);
+        if (sz != 0) {
+            for (int i = 0; i < nhandles; i++)
+                mem_dt.memset(dnnl_mem_default_perf_test_value, sz, i);
+        }
+
+        return OK;
+    }
+
     const auto nelems = mem_fp.nelems();
     if (nelems == 0) return OK;
 
@@ -339,8 +350,6 @@ void init_memory_args(dnn_mem_map_t &mem_map, const prb_t *prb,
 
 int init_ref_memory_args(dnn_mem_map_t &ref_mem_map, dnn_mem_map_t &mem_map,
         const prb_t *prb, res_t *res) {
-    if (has_bench_mode_modifier(mode_modifier_t::no_ref_memory)) return OK;
-
     switch (prb->alg) {
         case GENINDEX:
             SAFE(::custom::genindex::init_ref_memory_args(

tests/benchdnn/graph/graph.cpp

@@ -253,7 +253,6 @@ int make_input_tensors(std::vector<dnnl::graph::tensor> &input_ts,
         }
 
         // generate tensor for graph path
-
         const auto iter = partition_mem_map.find(lt_id);
         if (iter != partition_mem_map.end()) {
             const auto &graph_mem = iter->second;
@@ -663,10 +662,16 @@ int doit(const prb_t *prb, res_t *res) {
         std::vector<dnnl::graph::tensor> output_ts(outputs.size());
 
         ref_partition_t ref_partition(dg, partitions[i], inputs, outputs);
-        // Construct memory for both perf & corr modes
-        SAFE(ref_partition.init_ref(
-                     graph_in_ports, partition_mem_map_v[i], res),
-                WARN);
+
+        if (!has_bench_mode_modifier(mode_modifier_t::no_ref_memory)) {
+            // Construct memory for both perf & corr modes
+            SAFE(ref_partition.init_ref(
+                         graph_in_ports, partition_mem_map_v[i], res),
+                    WARN);
+            if (res->state == SKIPPED) return OK;
+        }
+
+        SAFE(ref_partition.init_graph_mem(partition_mem_map_v[i], res), WARN);
         if (res->state == SKIPPED) return OK;
 
         if (has_bench_mode_bit(mode_bit_t::corr)) {
@@ -682,15 +687,18 @@ int doit(const prb_t *prb, res_t *res) {
             }
         }
 
-        // unmap memory from host to device
-        map_unmap_partition_mem(partition_mem_map_v[i], inputs, UNMAP, res);
-        map_unmap_partition_mem(partition_mem_map_v[i], outputs, UNMAP, res);
-        if (res->state == FAIL) {
-            BENCHDNN_PRINT(0,
-                    "FAIL: Fail to unmap memories to host for partition "
-                    "%zu.\n",
-                    i);
-            return FAIL;
+        if (!has_bench_mode_modifier(mode_modifier_t::no_ref_memory)) {
+            // unmap memory from host to device
+            map_unmap_partition_mem(partition_mem_map_v[i], inputs, UNMAP, res);
+            map_unmap_partition_mem(
+                    partition_mem_map_v[i], outputs, UNMAP, res);
+            if (res->state == FAIL) {
+                BENCHDNN_PRINT(0,
+                        "FAIL: Fail to unmap memories to host for partition "
+                        "%zu.\n",
+                        i);
+                return FAIL;
+            }
         }
 
         const op_ref_list_t &op_list = ref_partition.get_partition_ops();

tests/benchdnn/graph/graph_memory.cpp

@@ -42,6 +42,36 @@ size_t get_benchdnn_device_limit() {
     return benchdnn_device_limit;
 }
 
+dnn_graph_mem_t::dnn_graph_mem_t(
+        const deserialized_lt &lt, const bool is_op_input)
+    : graph_dims_(lt.shape_), graph_strides_(lt.stride_) {
+
+    const auto &graph_dt = convert_dt(lt.get_data_type());
+    const auto data_type = static_cast<dnnl::memory::data_type>(graph_dt);
+
+    const auto &g_eng = get_graph_engine().operator const dnnl::engine &();
+
+    if (is_op_input) {
+
+        if (graph_dims_.empty()) graph_dims_.push_back(1);
+        if (graph_strides_.empty()) graph_strides_.push_back(1);
+
+        // create graph memory
+        dnnl::memory::desc md(graph_dims_, data_type, graph_strides_);
+        mem_ = dnn_mem_t(md.get(), g_eng.get());
+        size_t sz = dnnl_memory_desc_get_size(mem_.md_);
+        const int nhandles = query_md_num_handles(mem_.md_);
+
+        if (sz != 0) {
+            for (int i = 0; i < nhandles; i++)
+                mem_.memset(dnnl_mem_default_perf_test_value, sz, i);
+        }
+    } else {
+        dnnl::memory::desc md(graph_dims_, data_type, graph_strides_);
+        mem_ = dnn_mem_t(md.get(), g_eng.get());
+    }
+}
+
 // Constructs memories for all inputs and outputs needed for comparison.
 dnn_graph_mem_t::dnn_graph_mem_t(const dnn_mem_t &mem,
         const deserialized_lt &lt, const bool is_op_input,
@@ -93,7 +123,6 @@ dnn_graph_mem_t::dnn_graph_mem_t(const dnn_mem_t &mem,
             SAFE_V(c_mem.reorder(mem));
             prim_to_graph_memcpy(mem_, c_mem);
         } else {
-            // ... otherwise, perform a plain memcpy.
             prim_to_graph_memcpy(mem_, mem);
         }
     } else {

tests/benchdnn/graph/graph_memory.hpp

@@ -163,6 +163,8 @@ struct dnn_graph_mem_t {
     dnn_graph_mem_t(const dnn_mem_t &mem, const deserialized_lt &lt,
             const bool is_op_input, const bool is_fake_output = false);
 
+    dnn_graph_mem_t(const deserialized_lt &lt, const bool is_op_input);
+
     dnnl::graph::tensor make_graph_tensor(const deserialized_lt &lt) const;
 
     const dnn_mem_t &get_mem() const { return mem_; }

tests/benchdnn/graph/ref_partition.cpp

@@ -120,10 +120,12 @@ int ref_partition_t::init_ref(const std::vector<size_t> &graph_in_ports,
             }
         }
 
-        // Displace the data generated by the driver filling functions with
-        // values supplied from the dg object. Otherwise, the values for
-        // reference would diverge from the values passed to the Graph API.
-        SAFE(ref_prim->displace_scales(), WARN);
+        if (!has_bench_mode_modifier(mode_modifier_t::no_ref_memory)) {
+            // Displace the data generated by the driver filling functions with
+            // values supplied from the dg object. Otherwise, the values for
+            // reference would diverge from the values passed to the Graph API.
+            SAFE(ref_prim->displace_scales(), WARN);
+        }
 
         // Initialze the rest ops if current status is UNTESTED or EXECUTED
         // otherwise there is no need to init memory for the rest ops.
@@ -145,35 +147,50 @@ int ref_partition_t::init_ref(const std::vector<size_t> &graph_in_ports,
         }
     }
 
-    // displace data if needed
-    for (const auto &entry : lt_id_2_mems_) {
-        SAFE_V(data_displacer.displace_input_data(
-                entry.first, const_cast<dnn_mem_t &>(entry.second), res));
+    if (!has_bench_mode_modifier(mode_modifier_t::no_ref_memory)) {
+        // displace data if needed
+        for (const auto &entry : lt_id_2_mems_) {
+            SAFE_V(data_displacer.displace_input_data(
+                    entry.first, const_cast<dnn_mem_t &>(entry.second), res));
+        }
     }
+    return OK;
+}
+
+int ref_partition_t::init_graph_mem(
+        partition_mem_map_t &partition_mem_map, res_t *res) {
 
     // init graph input/oputput memory from lt_id_2_mems_
     for (const auto &id : partition_in_ids_) {
-        if (lt_id_2_mems_.find(id) == lt_id_2_mems_.end()) {
-            BENCHDNN_PRINT(0, "Fail: cannot find memory for %zu\n", id);
-            res->state = FAILED;
-            return FAIL;
-        }
-        partition_mem_map.emplace(id,
-                dnn_graph_mem_t(
-                        lt_id_2_mems_.at(id), lt_id_2_lt_.at(id), true));
+        if (!has_bench_mode_modifier(mode_modifier_t::no_ref_memory)) {
+            if (lt_id_2_mems_.find(id) == lt_id_2_mems_.end()) {
+                BENCHDNN_PRINT(0, "Fail: cannot find memory for %zu\n", id);
+                res->state = FAILED;
+                return FAIL;
+            }
+            partition_mem_map.emplace(id,
+                    dnn_graph_mem_t(
+                            lt_id_2_mems_.at(id), lt_id_2_lt_.at(id), true));
+        } else
+            partition_mem_map.emplace(
+                    id, dnn_graph_mem_t(lt_id_2_lt_.at(id), true));
     }
     for (const auto &id : partition_out_ids_) {
-        if (fake_lt_ids_.find(id) != fake_lt_ids_.end()) {
-            partition_mem_map.emplace(
-                    id, dnn_graph_mem_t({}, lt_id_2_lt_.at(id), false, true));
-        } else if (lt_id_2_mems_.find(id) == lt_id_2_mems_.end()) {
-            BENCHDNN_PRINT(0, "Fail: cannot find memory for %zu\n", id);
-            res->state = FAILED;
-            return FAIL;
+        if (!has_bench_mode_modifier(mode_modifier_t::no_ref_memory)) {
+            if (fake_lt_ids_.find(id) != fake_lt_ids_.end()) {
+                partition_mem_map.emplace(id,
+                        dnn_graph_mem_t({}, lt_id_2_lt_.at(id), false, true));
+            } else if (lt_id_2_mems_.find(id) == lt_id_2_mems_.end()) {
+                BENCHDNN_PRINT(0, "Fail: cannot find memory for %zu\n", id);
+                res->state = FAILED;
+                return FAIL;
+            } else
+                partition_mem_map.emplace(id,
+                        dnn_graph_mem_t(lt_id_2_mems_.at(id),
+                                lt_id_2_lt_.at(id), false));
         } else
-            partition_mem_map.emplace(id,
-                    dnn_graph_mem_t(
-                            lt_id_2_mems_.at(id), lt_id_2_lt_.at(id), false));
+            partition_mem_map.emplace(
+                    id, dnn_graph_mem_t(lt_id_2_lt_.at(id), false));
     }
 
     return OK;

tests/benchdnn/graph/ref_partition.hpp

@@ -42,6 +42,9 @@ class ref_partition_t {
     // prepare memories in both paths, one by one ref primitive
     int init_ref(const std::vector<size_t> &graph_ports,
             partition_mem_map_t &partition_mem_map, res_t *res);
+
+    int init_graph_mem(partition_mem_map_t &partition_mem_map, res_t *res);
+
     // run partition in ref path, one by one ref primitive
     void exec_ops(res_t *res);