simple verbose mode impl (#768)

* simple verbose mode impl

Author: Alexander-Makaryev

dpnp/backend/CMakeLists.txt

@@ -186,7 +186,9 @@ set(DPNP_SRC
     kernels/dpnp_krnl_statistics.cpp
     src/dpnp_iface_fptr.cpp
     src/memory_sycl.cpp
-    src/queue_sycl.cpp)
+    src/queue_sycl.cpp
+    src/verbose.cpp
+    )
 
 if(DPNP_STATIC_LIB_ENABLE)
   add_library(dpnp_backend_c STATIC ${DPNP_SRC})

dpnp/backend/kernels/dpnp_krnl_linalg.cpp

@@ -415,9 +415,15 @@ void dpnp_qr_c(void* array1_in, void* result1, void* result2, void* result3, siz
     _ComputeDT* geqrf_scratchpad =
         reinterpret_cast<_ComputeDT*>(dpnp_memory_alloc_c(geqrf_scratchpad_size * sizeof(_ComputeDT)));
 
-    event = mkl_lapack::geqrf(DPNP_QUEUE, size_m, size_n, in_a, lda, tau, geqrf_scratchpad, geqrf_scratchpad_size);
+    cl::sycl::vector_class<cl::sycl::event> depends(1);
+    set_barrier_event(DPNP_QUEUE, depends);
+
+    event = mkl_lapack::geqrf(DPNP_QUEUE, size_m, size_n, in_a, lda, tau, geqrf_scratchpad, geqrf_scratchpad_size, depends);
 
     event.wait();
+
+    verbose_print("oneapi::mkl::lapack::geqrf", depends.front(), event);
+
     dpnp_memory_free_c(geqrf_scratchpad);
 
     // R
@@ -444,10 +450,16 @@ void dpnp_qr_c(void* array1_in, void* result1, void* result2, void* result3, siz
     _ComputeDT* orgqr_scratchpad =
         reinterpret_cast<_ComputeDT*>(dpnp_memory_alloc_c(orgqr_scratchpad_size * sizeof(_ComputeDT)));
 
+    depends.clear();
+    set_barrier_event(DPNP_QUEUE, depends);
+
     event =
-        mkl_lapack::orgqr(DPNP_QUEUE, size_m, size_m, nrefl, in_a, lda, tau, orgqr_scratchpad, orgqr_scratchpad_size);
+        mkl_lapack::orgqr(DPNP_QUEUE, size_m, size_m, nrefl, in_a, lda, tau, orgqr_scratchpad, orgqr_scratchpad_size, depends);
 
     event.wait();
+
+    verbose_print("oneapi::mkl::lapack::orgqr", depends.front(), event);
+
     dpnp_memory_free_c(orgqr_scratchpad);
 
     for (size_t i = 0; i < size_m; ++i)

dpnp/backend/src/queue_sycl.cpp

@@ -170,7 +170,15 @@ void backend_sycl::backend_sycl_queue_init(QueueOptions selector)
         dev = get_default_sycl_device();
     }
 
-    queue = new cl::sycl::queue(dev, exception_handler);
+    if (is_verbose_mode())
+    {
+        cl::sycl::property_list properties{sycl::property::queue::enable_profiling()};
+        queue = new cl::sycl::queue(dev, exception_handler, properties);
+    }
+    else
+    {
+        queue = new cl::sycl::queue(dev, exception_handler);
+    }
 
     std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
     std::chrono::duration<double> time_queue_init = std::chrono::duration_cast<std::chrono::duration<double>>(t2 - t1);

dpnp/backend/src/queue_sycl.hpp

@@ -46,6 +46,8 @@
 
 #include "dpnp_pstl.hpp" // this header must be included after <mkl.hpp>
 
+#include "verbose.hpp"
+
 namespace mkl_rng = oneapi::mkl::rng;
 
 #define DPNP_QUEUE      backend_sycl::get_queue()

dpnp/backend/src/verbose.cpp

@@ -0,0 +1,72 @@
+//*****************************************************************************
+// Copyright (c) 2016-2020, Intel Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// - Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// - Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+// THE POSSIBILITY OF SUCH DAMAGE.
+//*****************************************************************************
+
+#include "verbose.hpp"
+#include <iostream>
+
+bool _is_verbose_mode = false;
+bool _is_verbose_mode_init = false;
+
+bool is_verbose_mode()
+{
+    if(!_is_verbose_mode_init)
+    {
+        _is_verbose_mode = false;
+        const char* env_var = std::getenv("DPNP_VERBOSE");
+        if (env_var and env_var == std::string("1"))
+        {
+            _is_verbose_mode = true;
+        }
+        _is_verbose_mode_init = true;
+    }
+    return _is_verbose_mode;
+}
+
+class barrierKernelClass;
+
+void set_barrier_event(cl::sycl::queue queue, sycl::vector_class<sycl::event> & depends)
+{
+    if (is_verbose_mode())
+    {
+        cl::sycl::event barrier_event = queue.single_task<barrierKernelClass>(depends, [=] {});
+        depends.clear();
+        depends.push_back(barrier_event);
+    }
+}
+
+void verbose_print(std::string header, cl::sycl::event first_event, cl::sycl::event last_event)
+{
+    if (is_verbose_mode())
+    {
+        auto first_event_end = first_event.get_profiling_info<sycl::info::event_profiling::command_end>();
+        auto last_event_end = last_event.get_profiling_info<sycl::info::event_profiling::command_end>();
+        std::cout << "DPNP_VERBOSE "
+                  << header
+                  << " Time: "
+                  << (last_event_end - first_event_end)/1.0e9
+                  << " s"
+                  << std::endl;
+    }
+}

dpnp/backend/src/verbose.hpp

@@ -0,0 +1,36 @@
+//*****************************************************************************
+// Copyright (c) 2016-2020, Intel Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// - Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// - Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+// THE POSSIBILITY OF SUCH DAMAGE.
+//*****************************************************************************
+
+#pragma once
+#ifndef VERBOSE_H // Cython compatibility
+#define VERBOSE_H
+
+#include <CL/sycl.hpp>
+
+bool is_verbose_mode();
+void set_barrier_event(cl::sycl::queue queue, sycl::vector_class<sycl::event> & depends);
+void verbose_print(std::string header, cl::sycl::event first_event, cl::sycl::event last_event);
+
+#endif // VERBOSE_H