Publishing 2020.3.2 LTS content (#5290)

* Publishing 2020.3.2 LTS content

Author: Alexey Suhov

README.md

@@ -1,5 +1,5 @@
 # [OpenVINO™ Toolkit](https://01.org/openvinotoolkit) - Deep Learning Deployment Toolkit repository
-[![Stable release](https://img.shields.io/badge/version-2020.3-green.svg)](https://github.com/openvinotoolkit/openvino/releases/tag/2020.3.0)
+[![Stable release](https://img.shields.io/badge/version-2020.3-green.svg)](https://github.com/openvinotoolkit/openvino/releases/tag/2020.3.2)
 [![Apache License Version 2.0](https://img.shields.io/badge/license-Apache_2.0-green.svg)](LICENSE)
 
 This toolkit allows developers to deploy pre-trained deep learning models 

inference-engine/cmake/vpu_dependencies.cmake

@@ -19,7 +19,7 @@ set(VPU_SUPPORTED_FIRMWARES usb-ma2450 usb-ma2x8x pcie-ma248x)
 # Default packages
 #
 
-set(FIRMWARE_PACKAGE_VERSION 1119)
+set(FIRMWARE_PACKAGE_VERSION 1656)
 
 #
 # CMake variables to override default firmware files

inference-engine/samples/common/format_reader/bmp.h

@@ -23,14 +23,14 @@ class BitMap : public Reader {
 private:
     static Register<BitMap> reg;
 
-    typedef struct {
+    typedef struct BmpHeaderType {
         unsigned short type   = 0u;              /* Magic identifier            */
         unsigned int size     = 0u;              /* File size in bytes          */
         unsigned int reserved = 0u;
         unsigned int offset   = 0u;              /* Offset to image data, bytes */
     } BmpHeader;
 
-    typedef struct {
+    typedef struct BmpInfoHeaderType {
         unsigned int size = 0u;                  /* Header size in bytes      */
         int width = 0, height = 0;               /* Width and height of image */
         unsigned short planes = 0u;              /* Number of colour planes   */

inference-engine/src/vpu/graph_transformer/include/vpu/private_plugin_config.hpp

@@ -97,5 +97,7 @@ DECLARE_VPU_MYRIAD_CONFIG_KEY(PLUGIN_LOG_FILE_PATH);
 
 DECLARE_VPU_MYRIAD_CONFIG_KEY(DEVICE_CONNECT_TIMEOUT);
 
+DECLARE_VPU_MYRIAD_CONFIG_KEY(ENABLE_ASYNC_DMA);
+
 }  // namespace VPUConfigParams
 }  // namespace InferenceEngine

inference-engine/src/vpu/myriad_plugin/myriad_config.cpp

@@ -100,6 +100,7 @@ IE_SUPPRESS_DEPRECATED_END
     setOption(_pluginLogFilePath, config, VPU_MYRIAD_CONFIG_KEY(PLUGIN_LOG_FILE_PATH));
     setOption(_deviceName, config, CONFIG_KEY(DEVICE_ID));
     setOption(_forceReset, switches, config, VPU_MYRIAD_CONFIG_KEY(FORCE_RESET));
+    setOption(_enableAsyncDma, switches, config, VPU_MYRIAD_CONFIG_KEY(ENABLE_ASYNC_DMA));
     setOption(_platform, platforms, config, VPU_MYRIAD_CONFIG_KEY(PLATFORM));
     setOption(_protocol, protocols, config, VPU_MYRIAD_CONFIG_KEY(PROTOCOL));
     setOption(_watchdogInterval, watchdogIntervals, config, VPU_MYRIAD_CONFIG_KEY(WATCHDOG));

inference-engine/src/vpu/myriad_plugin/myriad_config.h

@@ -35,6 +35,10 @@ class MyriadConfig final : public ParsedConfig {
         return _forceReset;
     }
 
+    bool asyncDma() const {
+        return _enableAsyncDma;
+    }
+
     PowerConfig powerConfig() const {
         return _powerConfig;
     }
@@ -68,6 +72,7 @@ class MyriadConfig final : public ParsedConfig {
 private:
     std::string _pluginLogFilePath;
     bool _forceReset = false;
+    bool _enableAsyncDma = true;
     PowerConfig _powerConfig = PowerConfig::FULL;
     ncDevicePlatform_t _platform = NC_ANY_PLATFORM;
     ncDeviceProtocol_t _protocol = NC_ANY_PROTOCOL;

inference-engine/src/vpu/myriad_plugin/myriad_executor.cpp

@@ -89,6 +89,7 @@ ncStatus_t MyriadExecutor::bootNextDevice(std::vector<DevicePtr> &devicePool,
     const ncDeviceProtocol_t& configProtocol = config.protocol();
     const std::string& configDevName = config.deviceName();
     PowerConfig powerConfig = config.powerConfig();
+    int enableAsyncDma = config.asyncDma();
     int lastDeviceIdx = devicePool.empty() ? -1 : devicePool.back()->_deviceIdx;
 
     ncStatus_t statusOpen = NC_ERROR;
@@ -204,6 +205,14 @@ ncStatus_t MyriadExecutor::bootNextDevice(std::vector<DevicePtr> &devicePool,
         return status;
     }
 
+    status = ncDeviceSetOption(device._deviceHandle, NC_RW_ENABLE_ASYNC_DMA, reinterpret_cast<void*>(&enableAsyncDma), sizeof(dataLength));
+
+    if (status != NC_OK) {
+        _log->warning("Failed to set option for async DMA");
+        ncDeviceClose(&device._deviceHandle, _mvnc->watchdogHndl());
+        return status;
+    }
+
     /* TODO: what should we do if we do not know maximum available graphs? What if we got number <= 0? */
     device._graphNum = 1;
     device._deviceIdx = lastDeviceIdx + 1;

inference-engine/thirdparty/clDNN/kernel_selector/common/tensor_type.h

@@ -25,6 +25,7 @@
 #include <array>
 #include <string>
 #include <utility>
+#include <stdexcept>
 
 namespace kernel_selector {
 #define KERNEL_SELECTOR_TENSOR_DIM_MAX 9

inference-engine/thirdparty/movidius/mvnc/include/mvnc.h

@@ -121,6 +121,7 @@ typedef enum {
     NC_RO_DEVICE_PROTOCOL = 2018,               // returns device protocol (USB, PCIe)
     NC_RW_DEVICE_POWER_CONFIG = 2100,           // writes config for the power manager to device
     NC_RW_DEVICE_POWER_CONFIG_RESET = 2101,     // resets power manager config on device
+    NC_RW_ENABLE_ASYNC_DMA = 2102               // enable/disable asynchronous DMA on device
 } ncDeviceOption_t;
 
 typedef enum {

inference-engine/thirdparty/movidius/mvnc/include/ncCommPrivate.h

@@ -113,7 +113,8 @@ typedef enum {
     DEVICE_SET_STDIO_REDIRECT_XLINK = 5,
     DEVICE_SET_POWER_CONFIG         = 6,
     DEVICE_RESET_POWER_CONFIG       = 7,
-    DEVICE_COMMAND_LAST             = 8
+    DEVICE_ENABLE_ASYNC_DMA         = 8,
+    DEVICE_COMMAND_LAST             = 9
 } deviceCommandType_t;
 
 typedef struct {