text: // Copyright (C) 2018 Intel Corporation
  //
  // SPDX-License-Identifier: Apache-2.0
  //
  
  #pragma once
  
  #include <vector>
  #include <iostream>
  #include <iomanip>
  #include <string>
  #include <set>
  #include <map>
  #include <algorithm>
  #include "cpp/ie_cnn_network.h"
  #include <CPP/memory.hpp>
  #include <CPP/primitive.hpp>
  #include <CPP/network.hpp>
  
  // Debugging options flags
  // #define _DEBUG_LAYER_CONTENT
  // #define _DEBUG_LAYER_CONTENT_FULL
  // #define _DEBUG_LAYER_FORMAT
  // #define _PLUGIN_PERF_PRINTS
  
  namespace CLDNNPlugin {
  
  class DebugOptions {
  public:
      bool m_bDebugLayerContent;
      bool m_bDebugLayerContentIndexed;
      bool m_bDebugLayerFormat;
      bool m_bPluginPerfPrints;
      cldnn::tensor::value_type m_maxPrintSize;
  
      DebugOptions();
      void PrintOptions() const;
      static std::string GetFormatName(cldnn::format::type format);
      static std::string GetDataTypeName(cldnn::data_types dataType);
      void PrintInput(const InferenceEngine::TBlob<float>& input) const;
      void PrintIndexedValue(const cldnn::memory& mem, const cldnn::tensor index) const;
      static uint32_t CalcLinearIndex(const cldnn::layout& memLayout, const cldnn::tensor index);
  
      void PrintNetworkOutputs(std::map<cldnn::primitive_id, cldnn::network_output>& outputsMap) const;
      void DumpSingleOutput(cldnn::primitive_id name, std::map<cldnn::primitive_id, cldnn::network_output>& outputs, bool bSingleFeatureMap = false)const;
  
      // the functions below will work in release unlike the rest
      void AddTimedEvent(std::string eventName, std::string startingAt = std::string());
      void PrintTimedEvents();
      void ClearTimedEvents();
  
      void EnableWA(std::string name);
      void DisableWA(std::string name);
      bool IsWAActive(std::string name);
  
      static std::string IELayoutToString(InferenceEngine::Layout layout);
  
  protected:
      std::map<std::string, std::chrono::steady_clock::time_point> m_TimedEventTimestamp;
      std::map<std::string, std::string> m_TimedEventStart;
      std::set<std::string> m_workaroundNames;
  
      static float SimpleConvertFP16toFP32(uint16_t u16val);
  
      template <typename T>
      static void DumpElementsRaw(cldnn::memory& mem, const std::vector<size_t>& pitches, size_t numElements) {
  #ifndef NDEBUG
          auto layout = mem.get_layout();
          auto ptr = mem.pointer<T>();
          auto data = ptr.data();  // +offset;
          auto elements = std::min(layout.count(), numElements);
          cldnn::status_t status = CLDNN_SUCCESS;
          for (size_t i = 0; i < elements;) {
              // size_t linearAddress = ... // todo calc linear with pitches
              std::cout << std::setprecision(10)
                        << ((layout.data_type == cldnn::data_types::f32) ? data[i] : cldnn_half_to_float(uint16_t(data[i]), &status))
                        << ", ";
              i++;
              for (auto& pitch : pitches) {
                  if ((i % pitch) == 0) {
                      std::cout << std::endl;
                  }
              }
          }
  #endif  // NDEBUG
      }
  };
  
  };  // namespace CLDNNPlugin