Jingxu10/cpu device verbose 2 (#155)

* enable mkldnn on-demands verbose functionality

* make ipex verbose compatible to non-verbose enabled pytorch

* fine tune for clang format

* clang format; removed apply_to_pytorch parameter of ipex verbose class

* added ut for verbose functionality

* removed not used packages from test_verbose.py

* added verbose on and off scenarios to test_verbose.py

* removed magic numbers

* fix a bug in test/cpu/verbose.py

* add abs path to verbose.py for test_verbose.py

Author: jingxu10

ideep/ideep/utils.hpp

@@ -298,6 +298,10 @@ inline void array_set(T *arr, const U &val, size_t size) {
     arr[i] = static_cast<T>(val);
 }
 
+inline int set_verbose(int level) {
+  dnnl::status ret = dnnl::set_verbose(level);
+  return ret == dnnl::status::success;
+}
 }
 }
 #endif

intel_pytorch_extension_py/utils.py

@@ -8,6 +8,7 @@
 from .weight_prepack import _weight_prepack_with_ipex
 from .weight_cast import _weight_dtype_convert_with_ipex
 from .optimizer_utils import _ipex_optimizer
+import _torch_ipex as core
 
 def _replace_dropout_with_identity(model):
     # replace dropout with identity during inference, so that aten::dropout won't be on the JIT graph.
@@ -100,3 +101,36 @@ def optimize(model, dtype=torch.bfloat16, optimizer=None, level='O1', inplace=Fa
         return optimized_model
     else:
         return optimized_model, optimized_optimizer
+
+VERBOSE_OFF = 0
+VERBOSE_ON = 1
+VERBOSE_ON_CREATION = 2
+class verbose(object):
+    def __init__(self, level):
+        self.level = level
+
+    def __enter__(self):
+        if self.level == VERBOSE_OFF:
+            return
+        try:
+            st = torch._C._verbose.mkldnn_set_verbose(self.level)
+            assert bool(st), "Failed to set Verbose mode of MKLDNN in PyTorch. Please consider to disable this verbose scope."
+        except:
+            pass
+        st = core.mkldnn_set_verbose(self.level)
+        assert bool(st), "Failed to set Verbose mode of MKLDNN in IPEX. Please consider to disable this verbose scope."
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        core.mkldnn_set_verbose(VERBOSE_OFF)
+        try:
+            torch._C._verbose.mkldnn_set_verbose(VERBOSE_OFF)
+        except:
+            pass
+        return False
+
+try:
+    verbose_torch=torch.backends.mkldnn.verbose
+    torch.backends.mkldnn.verbose = verbose
+except:
+    pass

tests/cpu/test_verbose.py

@@ -0,0 +1,28 @@
+import unittest
+from common_utils import TestCase
+import os
+import subprocess
+
+class TestVerbose(TestCase):
+    def test_verbose_on(self):
+        num = 0
+        loc = os.path.dirname(os.path.abspath(__file__))
+        with subprocess.Popen('python -u {}/verbose.py --verbose-level=1'.format(loc), shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as p:
+            for line in p.stdout.readlines():
+                line = str(line, 'utf-8').strip()
+                if line.startswith("dnnl_verbose"):
+                    num = num + 1
+        assert num > 0, 'oneDNN verbose messages not found.'
+
+    def test_verbose_off(self):
+        num = 0
+        loc = os.path.dirname(os.path.abspath(__file__))
+        with subprocess.Popen('python -u {}/verbose.py --verbose-level=0'.format(loc), shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as p:
+            for line in p.stdout.readlines():
+                line = str(line, 'utf-8').strip()
+                if line.startswith("dnnl_verbose"):
+                    num = num + 1
+        assert num == 0, 'unexpected oneDNN verbose messages found.'
+
+if __name__ == '__main__':
+    test = unittest.main()

tests/cpu/verbose.py

@@ -0,0 +1,25 @@
+import argparse
+import torch
+import intel_pytorch_extension as ipex
+
+class Module(torch.nn.Module):
+    def __init__(self):
+        super(Module, self).__init__()
+        self.conv = torch.nn.Conv2d(1, 10, 5, 1)
+
+    def forward(self, x):
+        y = self.conv(x)
+        return y
+
+def run_model(level):
+    m = Module()
+    m = ipex.optimize(m, dtype=torch.float32, level="O1")
+    d = torch.rand(1, 1, 112, 112)
+    with ipex.utils.verbose(level):
+        m(d)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--verbose-level", default=0, type=int)
+    args = parser.parse_args()
+    run_model(args.verbose_level)

torch_ipex/csrc/cpu/mkldnn/MKLDNNCommon.cpp

@@ -121,4 +121,5 @@ at::Tensor empty_aten_tensor_from_desc(const ideep::tensor::desc& desc, const at
   return at::empty(at_sizes, options);
 }
 
+int mkldnn_set_verbose(int level) { return ideep::utils::set_verbose(level); }
 }}

torch_ipex/csrc/cpu/mkldnn/MKLDNNCommon.h

@@ -25,4 +25,5 @@ ideep::tensor itensor_from_tensor(const at::Tensor& tensor);
 
 at::Tensor empty_aten_tensor_from_desc(const ideep::tensor::desc& desc, const at::TensorOptions& options);
 
+int mkldnn_set_verbose(int level);
 }}

torch_ipex/csrc/init_python_bindings.cpp

@@ -19,11 +19,12 @@
 #include <string>
 #include <vector>
 
-#include "utils.h"
 #include "auto_opt_config.hpp"
-#include "quantization/Observer.hpp"
-#include "quantization/Config.hpp"
 #include "quantization/AutoCast.hpp"
+#include "quantization/Config.hpp"
+#include "quantization/Observer.hpp"
+#include "utils.h"
+#include "verbose.hpp"
 
 //#include "ProcessGroupCCL.hpp"
 #include <pybind11/chrono.h>
@@ -47,6 +48,7 @@ py::object GetRevisions() {
 
 void InitIpexModuleBindings(py::module m) {
   m.def("_get_git_revs", []() { return GetRevisions(); });
+  m.def("mkldnn_set_verbose", &torch_ipex::verbose::_mkldnn_set_verbose);
   // ipex amp autocast
   m.def("is_autocast_enabled", &torch_ipex::autocast::is_autocast_enabled);
   m.def("set_autocast_enabled", &torch_ipex::autocast::set_autocast_enabled);
@@ -65,7 +67,7 @@ void InitIpexModuleBindings(py::module m) {
   m.def("autocast_decrement_nesting",
         &torch_ipex::autocast::autocast_decrement_nesting);
   m.def("clear_autocast_cache", &torch_ipex::autocast::clear_autocast_cache);
-  
+
   // llga path
   m.def("_jit_set_llga_enabled", &torch::jit::RegisterLlgaFuseGraph::setEnabled);
   m.def("_jit_llga_enabled", &torch::jit::RegisterLlgaFuseGraph::isEnabled);
@@ -108,7 +110,7 @@ void InitIpexModuleBindings(py::module m) {
         d["weight_granularity"] = indicator.get_indicator_weight_granularity();
         std::vector<float> x_scales, y_scales;
         std::vector<int64_t> x_zero_points, y_zero_points;
-        std::vector<quant_utils::TensorQuantizationParams> x_params, y_params; 
+        std::vector<quant_utils::TensorQuantizationParams> x_params, y_params;
         std::tie(x_params, y_params) = indicator.get_indicator_scales();
         for (auto& p: x_params) {
           x_scales.push_back(p.scale);
@@ -123,13 +125,14 @@ void InitIpexModuleBindings(py::module m) {
         d["input_zero_points"] = x_zero_points;
         d["output_scales"] = y_scales;
         d["output_zero_points"] = y_zero_points;
-        d["weight_scales"] = w_scales; 
+        d["weight_scales"] = w_scales;
         std::vector<std::string> i_quantized_dtypes, o_quantized_dtypes;
         std::tie(i_quantized_dtypes, o_quantized_dtypes)= indicator.get_indicator_quantized_dtypes();
         d["input_quantized_dtypes"] = i_quantized_dtypes;
         d["output_quantized_dtypes"] = o_quantized_dtypes;
         std::vector<bool> inputs_quantized, outputs_quantized;
-        std::tie(inputs_quantized, outputs_quantized) = indicator.get_indicator_insert_quantized_status(); 
+        std::tie(inputs_quantized, outputs_quantized) =
+            indicator.get_indicator_insert_quantized_status();
         d["inputs_quantized"] = inputs_quantized;
         d["outputs_quantized"] = outputs_quantized;
         std::vector<std::string> inputs_flow, outputs_flow;
@@ -188,7 +191,7 @@ using namespace torch::jit;
 
 void InitIpexBindings(py::module m) {
   InitIpexModuleBindings(m);
-  
+
   // // llga jit fusion pass
   // torch::jit::registerPrePass([](std::shared_ptr<Graph>& g) {
   //   if (torch::jit::RegisterLlgaFuseGraph::isEnabled()) {

torch_ipex/csrc/verbose.hpp

@@ -0,0 +1,12 @@
+#include "cpu/mkldnn/MKLDNNCommon.h"
+
+namespace torch_ipex {
+
+namespace verbose {
+
+int _mkldnn_set_verbose(int level) {
+  return torch_ipex::cpu::mkldnn_set_verbose(level);
+}
+
+} // namespace verbose
+} // namespace torch_ipex