From ea54a01f6bd30f013cbe88ae1751985bc86b6af5 Mon Sep 17 00:00:00 2001 From: Narumol Prangnawarat Date: Mon, 16 Mar 2020 16:36:10 +0000 Subject: IVGCVSW-4516 Add ConvertFp32ToBf16Layer and Ref workload support Signed-off-by: Narumol Prangnawarat Change-Id: I9099a4f840fb747336f77d20a0868b64e801a310 --- src/armnn/InternalTypes.cpp | 1 + src/armnn/InternalTypes.hpp | 1 + src/armnn/LayersFwd.hpp | 2 + src/armnn/layers/ConvertBf16ToFp32Layer.hpp | 1 - src/armnn/layers/ConvertFp16ToFp32Layer.hpp | 1 - src/armnn/layers/ConvertFp32ToBf16Layer.cpp | 55 ++++++++++++++++ src/armnn/layers/ConvertFp32ToBf16Layer.hpp | 41 ++++++++++++ src/armnn/layers/ConvertFp32ToFp16Layer.hpp | 1 - src/backends/backendsCommon/LayerSupportBase.cpp | 8 +++ src/backends/backendsCommon/LayerSupportBase.hpp | 4 ++ src/backends/backendsCommon/Workload.hpp | 5 ++ src/backends/backendsCommon/WorkloadData.cpp | 23 +++++++ src/backends/backendsCommon/WorkloadData.hpp | 5 ++ src/backends/backendsCommon/WorkloadFactory.cpp | 13 ++++ src/backends/backendsCommon/WorkloadFactory.hpp | 3 + src/backends/backendsCommon/common.mk | 1 + src/backends/backendsCommon/test/CMakeLists.txt | 2 + .../test/IsLayerSupportedTestImpl.hpp | 2 + src/backends/backendsCommon/test/LayerTests.hpp | 1 + .../test/layerTests/ConvertFp32ToBf16TestImpl.cpp | 77 ++++++++++++++++++++++ .../test/layerTests/ConvertFp32ToBf16TestImpl.hpp | 17 +++++ src/backends/reference/RefLayerSupport.cpp | 15 +++++ src/backends/reference/RefLayerSupport.hpp | 4 ++ src/backends/reference/RefWorkloadFactory.cpp | 7 ++ src/backends/reference/RefWorkloadFactory.hpp | 3 + src/backends/reference/backend.mk | 1 + .../reference/test/RefLayerSupportTests.cpp | 32 +++++++++ src/backends/reference/test/RefLayerTests.cpp | 3 + src/backends/reference/workloads/CMakeLists.txt | 2 + .../workloads/RefConvertFp32ToBf16Workload.cpp | 27 ++++++++ .../workloads/RefConvertFp32ToBf16Workload.hpp | 21 ++++++ .../reference/workloads/RefWorkloadUtils.hpp | 6 ++ src/backends/reference/workloads/RefWorkloads.hpp | 1 + 33 files changed, 383 insertions(+), 3 deletions(-) create mode 100644 src/armnn/layers/ConvertFp32ToBf16Layer.cpp create mode 100644 src/armnn/layers/ConvertFp32ToBf16Layer.hpp create mode 100644 src/backends/backendsCommon/test/layerTests/ConvertFp32ToBf16TestImpl.cpp create mode 100644 src/backends/backendsCommon/test/layerTests/ConvertFp32ToBf16TestImpl.hpp create mode 100644 src/backends/reference/workloads/RefConvertFp32ToBf16Workload.cpp create mode 100644 src/backends/reference/workloads/RefConvertFp32ToBf16Workload.hpp (limited to 'src') diff --git a/src/armnn/InternalTypes.cpp b/src/armnn/InternalTypes.cpp index 3f3eed56e7..d688257142 100644 --- a/src/armnn/InternalTypes.cpp +++ b/src/armnn/InternalTypes.cpp @@ -24,6 +24,7 @@ char const* GetLayerTypeAsCString(LayerType type) case LayerType::Constant: return "Constant"; case LayerType::ConvertBf16ToFp32: return "ConvertBf16ToFp32"; case LayerType::ConvertFp16ToFp32: return "ConvertFp16ToFp32"; + case LayerType::ConvertFp32ToBf16: return "ConvertFp32ToBf16"; case LayerType::ConvertFp32ToFp16: return "ConvertFp32ToFp16"; case LayerType::Convolution2d: return "Convolution2d"; case LayerType::Debug: return "Debug"; diff --git a/src/armnn/InternalTypes.hpp b/src/armnn/InternalTypes.hpp index 9330122246..8dd9a9eb1c 100644 --- a/src/armnn/InternalTypes.hpp +++ b/src/armnn/InternalTypes.hpp @@ -24,6 +24,7 @@ enum class LayerType Constant, ConvertBf16ToFp32, ConvertFp16ToFp32, + ConvertFp32ToBf16, ConvertFp32ToFp16, Convolution2d, Debug, diff --git a/src/armnn/LayersFwd.hpp b/src/armnn/LayersFwd.hpp index 3dde908fc3..4159f488c1 100644 --- a/src/armnn/LayersFwd.hpp +++ b/src/armnn/LayersFwd.hpp @@ -16,6 +16,7 @@ #include "layers/ConstantLayer.hpp" #include "layers/ConvertBf16ToFp32Layer.hpp" #include "layers/ConvertFp16ToFp32Layer.hpp" +#include "layers/ConvertFp32ToBf16Layer.hpp" #include "layers/ConvertFp32ToFp16Layer.hpp" #include "layers/Convolution2dLayer.hpp" #include "layers/DebugLayer.hpp" @@ -102,6 +103,7 @@ DECLARE_LAYER(Concat) DECLARE_LAYER(Constant) DECLARE_LAYER(ConvertBf16ToFp32) DECLARE_LAYER(ConvertFp16ToFp32) +DECLARE_LAYER(ConvertFp32ToBf16) DECLARE_LAYER(ConvertFp32ToFp16) DECLARE_LAYER(Convolution2d) DECLARE_LAYER(Debug) diff --git a/src/armnn/layers/ConvertBf16ToFp32Layer.hpp b/src/armnn/layers/ConvertBf16ToFp32Layer.hpp index 2a79a1cb65..b419e5c2a3 100644 --- a/src/armnn/layers/ConvertBf16ToFp32Layer.hpp +++ b/src/armnn/layers/ConvertBf16ToFp32Layer.hpp @@ -15,7 +15,6 @@ class ConvertBf16ToFp32Layer : public Layer { public: /// Makes a workload for the ConvertBf16ToFp32 type. - /// @param [in] graph The graph where this layer can be found. /// @param [in] factory The workload factory which will create the workload. /// @return A pointer to the created workload, or nullptr if not created. virtual std::unique_ptr CreateWorkload(const IWorkloadFactory& factory) const override; diff --git a/src/armnn/layers/ConvertFp16ToFp32Layer.hpp b/src/armnn/layers/ConvertFp16ToFp32Layer.hpp index 03d7dfa568..e3b798beec 100644 --- a/src/armnn/layers/ConvertFp16ToFp32Layer.hpp +++ b/src/armnn/layers/ConvertFp16ToFp32Layer.hpp @@ -15,7 +15,6 @@ class ConvertFp16ToFp32Layer : public Layer { public: /// Makes a workload for the ConvertFp16ToFp32 type. - /// @param [in] graph The graph where this layer can be found. /// @param [in] factory The workload factory which will create the workload. /// @return A pointer to the created workload, or nullptr if not created. virtual std::unique_ptr CreateWorkload(const IWorkloadFactory& factory) const override; diff --git a/src/armnn/layers/ConvertFp32ToBf16Layer.cpp b/src/armnn/layers/ConvertFp32ToBf16Layer.cpp new file mode 100644 index 0000000000..936acf61ab --- /dev/null +++ b/src/armnn/layers/ConvertFp32ToBf16Layer.cpp @@ -0,0 +1,55 @@ +// +// Copyright © 2020 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "ConvertFp32ToBf16Layer.hpp" +#include "LayerCloneBase.hpp" + +#include + +#include +#include + +namespace armnn +{ + +ConvertFp32ToBf16Layer::ConvertFp32ToBf16Layer(const char* name) + : Layer(1, 1, LayerType::ConvertFp32ToBf16, name) +{ +} + +std::unique_ptr ConvertFp32ToBf16Layer::CreateWorkload(const IWorkloadFactory& factory) const +{ + ConvertFp32ToBf16QueueDescriptor descriptor; + return factory.CreateConvertFp32ToBf16(descriptor, PrepInfoAndDesc(descriptor)); +} + +ConvertFp32ToBf16Layer* ConvertFp32ToBf16Layer::Clone(Graph& graph) const +{ + return CloneBase(graph, GetName()); +} + +void ConvertFp32ToBf16Layer::ValidateTensorShapesFromInputs() +{ + VerifyLayerConnections(1, CHECK_LOCATION()); + + auto inferredShapes = InferOutputShapes({ GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape() }); + + BOOST_ASSERT(inferredShapes.size() == 1); + + ConditionalThrowIfNotEqual( + "ConvertFp32ToBf16Layer: TensorShape set on OutputSlot[0] does not match the inferred shape.", + GetOutputSlot(0).GetTensorInfo().GetShape(), + inferredShapes[0]); +} + +void ConvertFp32ToBf16Layer::Accept(ILayerVisitor& visitor) const +{ + // these conversion layers are only inserted by the + // optimizer and so will never be in an input graph. + IgnoreUnused(visitor); + throw armnn::Exception("ConvertFp32ToBf16Layer should never appear in an input graph"); +} + +} // namespace armnn diff --git a/src/armnn/layers/ConvertFp32ToBf16Layer.hpp b/src/armnn/layers/ConvertFp32ToBf16Layer.hpp new file mode 100644 index 0000000000..225b03314e --- /dev/null +++ b/src/armnn/layers/ConvertFp32ToBf16Layer.hpp @@ -0,0 +1,41 @@ +// +// Copyright © 2020 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include + +namespace armnn +{ + +/// This layer converts data type Float32 to BFloat16. +class ConvertFp32ToBf16Layer : public Layer +{ +public: + /// Makes a workload for the ConvertFp32ToBf16Layer type. + /// @param [in] factory The workload factory which will create the workload. + /// @return A pointer to the created workload, or nullptr if not created. + virtual std::unique_ptr CreateWorkload(const IWorkloadFactory& factory) const override; + + /// Creates a dynamically-allocated copy of this layer. + /// @param [in] graph The graph into which this layer is being cloned. + ConvertFp32ToBf16Layer* Clone(Graph& graph) const override; + + /// Check if the input tensor shape(s) + /// will lead to a valid configuration of @ref ConvertFp32ToBf16Layer. + void ValidateTensorShapesFromInputs() override; + + void Accept(ILayerVisitor& visitor) const override; + +protected: + /// Constructor to create a ConvertFp32ToBf16Layer. + /// @param [in] name Optional name for the layer. + ConvertFp32ToBf16Layer(const char* name); + + /// Default destructor + ~ConvertFp32ToBf16Layer() = default; +}; + +} // namespace diff --git a/src/armnn/layers/ConvertFp32ToFp16Layer.hpp b/src/armnn/layers/ConvertFp32ToFp16Layer.hpp index 907a55f084..8bb28f84ad 100644 --- a/src/armnn/layers/ConvertFp32ToFp16Layer.hpp +++ b/src/armnn/layers/ConvertFp32ToFp16Layer.hpp @@ -14,7 +14,6 @@ class ConvertFp32ToFp16Layer : public Layer { public: /// Makes a workload for the ConvertFp32ToFp16 type. - /// @param [in] graph The graph where this layer can be found. /// @param [in] factory The workload factory which will create the workload. /// @return A pointer to the created workload, or nullptr if not created. virtual std::unique_ptr CreateWorkload(const IWorkloadFactory& factory) const override; diff --git a/src/backends/backendsCommon/LayerSupportBase.cpp b/src/backends/backendsCommon/LayerSupportBase.cpp index 1ac08afd7a..c3c8421267 100644 --- a/src/backends/backendsCommon/LayerSupportBase.cpp +++ b/src/backends/backendsCommon/LayerSupportBase.cpp @@ -125,6 +125,14 @@ bool LayerSupportBase::IsConvertFp16ToFp32Supported(const TensorInfo& /*input*/, return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported); } +bool LayerSupportBase::IsConvertFp32ToBf16Supported(const TensorInfo& /*input*/, + const TensorInfo& /*output*/, + Optional reasonIfUnsupported) const +{ + return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported); +} + + bool LayerSupportBase::IsConvertFp32ToFp16Supported(const TensorInfo& /*input*/, const TensorInfo& /*output*/, Optional reasonIfUnsupported) const diff --git a/src/backends/backendsCommon/LayerSupportBase.hpp b/src/backends/backendsCommon/LayerSupportBase.hpp index 59e8b969bd..063983357e 100644 --- a/src/backends/backendsCommon/LayerSupportBase.hpp +++ b/src/backends/backendsCommon/LayerSupportBase.hpp @@ -69,6 +69,10 @@ public: const TensorInfo& output, Optional reasonIfUnsupported = EmptyOptional()) const override; + bool IsConvertFp32ToBf16Supported(const TensorInfo& input, + const TensorInfo& output, + Optional reasonIfUnsupported = EmptyOptional()) const override; + bool IsConvertFp32ToFp16Supported( const TensorInfo& input, const TensorInfo& output, diff --git a/src/backends/backendsCommon/Workload.hpp b/src/backends/backendsCommon/Workload.hpp index 56736cebb3..984443b79b 100644 --- a/src/backends/backendsCommon/Workload.hpp +++ b/src/backends/backendsCommon/Workload.hpp @@ -181,6 +181,11 @@ using BFloat16ToFloat32Workload = MultiTypedWorkload; +template +using Float32ToBFloat16Workload = MultiTypedWorkload; + template using Float16ToFloat32Workload = MultiTypedWorkloadIsConvertFp16ToFp32Supported(input, output, reason); break; } + case LayerType::ConvertFp32ToBf16: + { + const TensorInfo& input = layer.GetInputSlot(0).GetConnection()->GetTensorInfo(); + const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo(); + result = layerSupportObject->IsConvertFp32ToBf16Supported(input, output, reason); + break; + } case LayerType::ConvertFp32ToFp16: { const TensorInfo& input = layer.GetInputSlot(0).GetConnection()->GetTensorInfo(); @@ -1163,6 +1170,12 @@ std::unique_ptr IWorkloadFactory::CreateConvertFp16ToFp32(const Conve return std::unique_ptr(); } +std::unique_ptr IWorkloadFactory::CreateConvertFp32ToBf16(const ConvertFp32ToBf16QueueDescriptor& /*desc*/, + const WorkloadInfo& /*info*/) const +{ + return std::unique_ptr(); +} + std::unique_ptr IWorkloadFactory::CreateConvertFp32ToFp16(const ConvertFp32ToFp16QueueDescriptor& /*desc*/, const WorkloadInfo& /*info*/) const { diff --git a/src/backends/backendsCommon/WorkloadFactory.hpp b/src/backends/backendsCommon/WorkloadFactory.hpp index 8c22452f2e..0fc7ab9bce 100644 --- a/src/backends/backendsCommon/WorkloadFactory.hpp +++ b/src/backends/backendsCommon/WorkloadFactory.hpp @@ -85,6 +85,9 @@ public: virtual std::unique_ptr CreateConvertFp16ToFp32(const ConvertFp16ToFp32QueueDescriptor& descriptor, const WorkloadInfo& info) const; + virtual std::unique_ptr CreateConvertFp32ToBf16(const ConvertFp32ToBf16QueueDescriptor& descriptor, + const WorkloadInfo& info) const; + virtual std::unique_ptr CreateConvertFp32ToFp16(const ConvertFp32ToFp16QueueDescriptor& descriptor, const WorkloadInfo& info) const; diff --git a/src/backends/backendsCommon/common.mk b/src/backends/backendsCommon/common.mk index 22de3db77c..ba5518010d 100644 --- a/src/backends/backendsCommon/common.mk +++ b/src/backends/backendsCommon/common.mk @@ -46,6 +46,7 @@ COMMON_TEST_SOURCES := \ test/layerTests/Conv2dTestImpl.cpp \ test/layerTests/ConvertBf16ToFp32TestImpl.cpp \ test/layerTests/ConvertFp16ToFp32TestImpl.cpp \ + test/layerTests/ConvertFp32ToBf16TestImpl.cpp \ test/layerTests/ConvertFp32ToFp16TestImpl.cpp \ test/layerTests/DebugTestImpl.cpp \ test/layerTests/DepthToSpaceTestImpl.cpp \ diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt index ea214de771..bfaca6c44b 100644 --- a/src/backends/backendsCommon/test/CMakeLists.txt +++ b/src/backends/backendsCommon/test/CMakeLists.txt @@ -73,6 +73,8 @@ list(APPEND armnnBackendsCommonUnitTests_sources layerTests/ConvertBf16ToFp32TestImpl.hpp layerTests/ConvertFp16ToFp32TestImpl.cpp layerTests/ConvertFp16ToFp32TestImpl.hpp + layerTests/ConvertFp32ToBf16TestImpl.cpp + layerTests/ConvertFp32ToBf16TestImpl.hpp layerTests/ConvertFp32ToFp16TestImpl.cpp layerTests/ConvertFp32ToFp16TestImpl.hpp layerTests/DebugTestImpl.cpp diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp index a070ac05e8..d646847cbc 100644 --- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp +++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp @@ -447,6 +447,8 @@ DECLARE_LAYER_POLICY_1_PARAM(ConvertBf16ToFp32) DECLARE_LAYER_POLICY_1_PARAM(ConvertFp16ToFp32) +DECLARE_LAYER_POLICY_1_PARAM(ConvertFp32ToBf16) + DECLARE_LAYER_POLICY_1_PARAM(ConvertFp32ToFp16) DECLARE_LAYER_POLICY_2_PARAM(Convolution2d) diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp index 1c6277a333..600a261fe3 100644 --- a/src/backends/backendsCommon/test/LayerTests.hpp +++ b/src/backends/backendsCommon/test/LayerTests.hpp @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include diff --git a/src/backends/backendsCommon/test/layerTests/ConvertFp32ToBf16TestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ConvertFp32ToBf16TestImpl.cpp new file mode 100644 index 0000000000..66eb4ee28c --- /dev/null +++ b/src/backends/backendsCommon/test/layerTests/ConvertFp32ToBf16TestImpl.cpp @@ -0,0 +1,77 @@ +// +// Copyright © 2020 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "ConvertFp32ToBf16TestImpl.hpp" + +#include +#include + +#include + +LayerTestResult ConvertFp32ToBf16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + IgnoreUnused(memoryManager); + + const armnn::TensorInfo inputTensorInfo({1, 2, 4, 3}, armnn::DataType::Float32); + const armnn::TensorInfo outputTensorInfo({1, 2, 4, 3}, armnn::DataType::BFloat16); + + auto input = MakeTensor(inputTensorInfo, + { -37.5f, -15.2f, -8.76f, + -2.0f, -1.5f, -1.3f, + -0.5f, -0.4f, 0.0f, + 1.0f, 0.4f, 0.5f, + 1.3f, 1.5f, 2.0f, + 8.76f, 15.2f, 37.5f, + 3.8f, // 0x40733333 Round down + 3.1055E+29f, // 0x707ADC3C Round up + 9.149516E-10f, // 0x307B7FFF Round down + -3.8f, // 0xC0733333 Round down + -3.1055E+29f, // 0xF07ADC3C Round up + -9.149516E-10f // 0xB07B7FFF Round down + }); + + std::vector outputValues = armnnUtils::QuantizedVector( + { + -37.5f, -15.2f, -8.76f, + -2.0f, -1.5f, -1.3f, + -0.5f, -0.4f, 0.0f, + 1.0f, 0.4f, 0.5f, + 1.3f, 1.5f, 2.0f, + 8.76f, 15.2f, 37.5f, + 3.796875f, // 0x4073 + 3.1072295E29f, // 0x707B + 9.131327E-10f, // 0x307B + -3.796875f, // 0xC073 + -3.1072295E29f, // 0xF07B + -9.131327E-10f // 0xB07B + }, + 1.0f, 0); + + LayerTestResult ret(outputTensorInfo); + ret.outputExpected = MakeTensor(outputTensorInfo, outputValues); + + std::unique_ptr inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo); + std::unique_ptr outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo); + + armnn::ConvertFp32ToBf16QueueDescriptor data; + armnn::WorkloadInfo info; + AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get()); + AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get()); + + std::unique_ptr workload = workloadFactory.CreateConvertFp32ToBf16(data, info); + + inputHandle->Allocate(); + outputHandle->Allocate(); + + CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]); + + workload->Execute(); + + CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get()); + + return ret; +} diff --git a/src/backends/backendsCommon/test/layerTests/ConvertFp32ToBf16TestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ConvertFp32ToBf16TestImpl.hpp new file mode 100644 index 0000000000..4c6125f585 --- /dev/null +++ b/src/backends/backendsCommon/test/layerTests/ConvertFp32ToBf16TestImpl.hpp @@ -0,0 +1,17 @@ +// +// Copyright © 2020 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include "LayerTestResult.hpp" + +#include + +#include +#include + +LayerTestResult ConvertFp32ToBf16Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp index a4f4efd92a..9f22b9ef0e 100644 --- a/src/backends/reference/RefLayerSupport.cpp +++ b/src/backends/reference/RefLayerSupport.cpp @@ -411,6 +411,21 @@ bool RefLayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input, &FalseFuncU8<>)); } +bool RefLayerSupport::IsConvertFp32ToBf16Supported(const TensorInfo& input, + const TensorInfo& output, + Optional reasonIfUnsupported) const +{ + bool supported = true; + + supported &= CheckSupportRule(TypeIs(input, DataType::Float32), reasonIfUnsupported, + "Reference for ConvertFp32ToBf16 layer: input type not supported"); + + supported &= CheckSupportRule(TypeIs(output, DataType::BFloat16), reasonIfUnsupported, + "Reference for ConvertFp32ToBf16 layer: output type not supported"); + + return supported; +} + bool RefLayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input, const TensorInfo& output, Optional reasonIfUnsupported) const diff --git a/src/backends/reference/RefLayerSupport.hpp b/src/backends/reference/RefLayerSupport.hpp index ff3478142f..30f45c37f2 100644 --- a/src/backends/reference/RefLayerSupport.hpp +++ b/src/backends/reference/RefLayerSupport.hpp @@ -68,6 +68,10 @@ public: const TensorInfo& output, Optional reasonIfUnsupported = EmptyOptional()) const override; + bool IsConvertFp32ToBf16Supported(const TensorInfo& input, + const TensorInfo& output, + Optional reasonIfUnsupported = EmptyOptional()) const override; + bool IsConvertFp32ToFp16Supported(const TensorInfo& input, const TensorInfo& output, Optional reasonIfUnsupported = EmptyOptional()) const override; diff --git a/src/backends/reference/RefWorkloadFactory.cpp b/src/backends/reference/RefWorkloadFactory.cpp index c9fc626bc1..5d3775a59d 100644 --- a/src/backends/reference/RefWorkloadFactory.cpp +++ b/src/backends/reference/RefWorkloadFactory.cpp @@ -194,6 +194,13 @@ std::unique_ptr RefWorkloadFactory::CreateConvertFp16ToFp32( return std::make_unique(descriptor, info); } +std::unique_ptr RefWorkloadFactory::CreateConvertFp32ToBf16( + const ConvertFp32ToBf16QueueDescriptor& descriptor, + const WorkloadInfo& info) const +{ + return std::make_unique(descriptor, info); +} + std::unique_ptr RefWorkloadFactory::CreateConvertFp32ToFp16( const ConvertFp32ToFp16QueueDescriptor& descriptor, const WorkloadInfo& info) const diff --git a/src/backends/reference/RefWorkloadFactory.hpp b/src/backends/reference/RefWorkloadFactory.hpp index 119605b998..9a53ae2e5a 100644 --- a/src/backends/reference/RefWorkloadFactory.hpp +++ b/src/backends/reference/RefWorkloadFactory.hpp @@ -92,6 +92,9 @@ public: std::unique_ptr CreateConvertFp16ToFp32(const ConvertFp16ToFp32QueueDescriptor& descriptor, const WorkloadInfo& info) const override; + std::unique_ptr CreateConvertFp32ToBf16(const ConvertFp32ToBf16QueueDescriptor& descriptor, + const WorkloadInfo& info) const override; + std::unique_ptr CreateConvertFp32ToFp16(const ConvertFp32ToFp16QueueDescriptor& descriptor, const WorkloadInfo& info) const override; diff --git a/src/backends/reference/backend.mk b/src/backends/reference/backend.mk index aeac2e28b9..239863f2c7 100644 --- a/src/backends/reference/backend.mk +++ b/src/backends/reference/backend.mk @@ -51,6 +51,7 @@ BACKEND_SOURCES := \ workloads/RefConstantWorkload.cpp \ workloads/RefConvertBf16ToFp32Workload.cpp \ workloads/RefConvertFp16ToFp32Workload.cpp \ + workloads/RefConvertFp32ToBf16Workload.cpp \ workloads/RefConvertFp32ToFp16Workload.cpp \ workloads/RefConvolution2dWorkload.cpp \ workloads/RefDebugWorkload.cpp \ diff --git a/src/backends/reference/test/RefLayerSupportTests.cpp b/src/backends/reference/test/RefLayerSupportTests.cpp index 0b549dbb77..f0c69f92cc 100644 --- a/src/backends/reference/test/RefLayerSupportTests.cpp +++ b/src/backends/reference/test/RefLayerSupportTests.cpp @@ -148,6 +148,38 @@ BOOST_AUTO_TEST_CASE(IsConvertBf16ToFp32SupportedBf16OutputReference) BOOST_CHECK_EQUAL(reasonIfUnsupported, "Reference for ConvertBf16ToFp32 layer: output type not supported\n"); } +BOOST_AUTO_TEST_CASE(IsConvertFp32ToBf16SupportedReference) +{ + std::string reasonIfUnsupported; + + bool result = IsConvertLayerSupportedTests(reasonIfUnsupported); + + BOOST_CHECK(result); +} + +BOOST_AUTO_TEST_CASE(IsConvertFp32ToBf16SupportedBf16InputReference) +{ + std::string reasonIfUnsupported; + + bool result = IsConvertLayerSupportedTests(reasonIfUnsupported); + + BOOST_CHECK(!result); + BOOST_CHECK_EQUAL(reasonIfUnsupported, "Reference for ConvertFp32ToBf16 layer: input type not supported\n"); +} + +BOOST_AUTO_TEST_CASE(IsConvertFp32ToBf16SupportedFp32OutputReference) +{ + std::string reasonIfUnsupported; + + bool result = IsConvertLayerSupportedTests(reasonIfUnsupported); + + BOOST_CHECK(!result); + BOOST_CHECK_EQUAL(reasonIfUnsupported, "Reference for ConvertFp32ToBf16 layer: output type not supported\n"); +} + BOOST_AUTO_TEST_CASE(IsConvertFp32ToFp16SupportedReference) { std::string reasonIfUnsupported; diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp index 08cfa2843f..f5c1c65c88 100644 --- a/src/backends/reference/test/RefLayerTests.cpp +++ b/src/backends/reference/test/RefLayerTests.cpp @@ -1145,6 +1145,9 @@ ARMNN_AUTO_TEST_CASE(LstmLayerInt16NoCifgNoPeepholeNoProjectionInt16Constant, // Convert from BFloat16 to Float32 ARMNN_AUTO_TEST_CASE(ConvertBf16ToFp32, ConvertBf16ToFp32Test) +// Convert from Float32 to BFloat16 +ARMNN_AUTO_TEST_CASE(ConvertFp32ToBf16, ConvertFp32ToBf16Test) + // Convert from Float16 to Float32 ARMNN_AUTO_TEST_CASE(SimpleConvertFp16ToFp32, SimpleConvertFp16ToFp32Test) // Convert from Float32 to Float16 diff --git a/src/backends/reference/workloads/CMakeLists.txt b/src/backends/reference/workloads/CMakeLists.txt index 86764d8a01..9f3880e077 100644 --- a/src/backends/reference/workloads/CMakeLists.txt +++ b/src/backends/reference/workloads/CMakeLists.txt @@ -73,6 +73,8 @@ list(APPEND armnnRefBackendWorkloads_sources RefConvertBf16ToFp32Workload.hpp RefConvertFp16ToFp32Workload.cpp RefConvertFp16ToFp32Workload.hpp + RefConvertFp32ToBf16Workload.cpp + RefConvertFp32ToBf16Workload.hpp RefConvertFp32ToFp16Workload.cpp RefConvertFp32ToFp16Workload.hpp RefConvolution2dWorkload.cpp diff --git a/src/backends/reference/workloads/RefConvertFp32ToBf16Workload.cpp b/src/backends/reference/workloads/RefConvertFp32ToBf16Workload.cpp new file mode 100644 index 0000000000..181b236e83 --- /dev/null +++ b/src/backends/reference/workloads/RefConvertFp32ToBf16Workload.cpp @@ -0,0 +1,27 @@ +// +// Copyright © 2020 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "RefConvertFp32ToBf16Workload.hpp" +#include "RefWorkloadUtils.hpp" + +#include + +#include + +namespace armnn +{ + +void RefConvertFp32ToBf16Workload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefConvertFp32ToBf16Workload_Execute"); + + const float* const input = GetInputTensorDataFloat(0, m_Data); + BFloat16* const output = GetOutputTensorDataBFloat16(0, m_Data); + + unsigned int numElements = GetTensorInfo(m_Data.m_Inputs[0]).GetNumElements(); + armnnUtils::FloatingPointConverter::ConvertFloat32ToBFloat16(input, numElements, output); +} + +} //namespace armnn diff --git a/src/backends/reference/workloads/RefConvertFp32ToBf16Workload.hpp b/src/backends/reference/workloads/RefConvertFp32ToBf16Workload.hpp new file mode 100644 index 0000000000..409603bb6c --- /dev/null +++ b/src/backends/reference/workloads/RefConvertFp32ToBf16Workload.hpp @@ -0,0 +1,21 @@ +// +// Copyright © 2020 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include +#include + +namespace armnn +{ + +class RefConvertFp32ToBf16Workload : public Float32ToBFloat16Workload +{ +public: + using Float32ToBFloat16Workload::Float32ToBFloat16Workload; + virtual void Execute() const override; +}; + +} //namespace armnn diff --git a/src/backends/reference/workloads/RefWorkloadUtils.hpp b/src/backends/reference/workloads/RefWorkloadUtils.hpp index 69713145c0..f1b31571db 100644 --- a/src/backends/reference/workloads/RefWorkloadUtils.hpp +++ b/src/backends/reference/workloads/RefWorkloadUtils.hpp @@ -75,6 +75,12 @@ const BFloat16* GetInputTensorDataBFloat16(unsigned int idx, const PayloadType& return GetInputTensorData(idx, data); } +template +BFloat16* GetOutputTensorDataBFloat16(unsigned int idx, const PayloadType& data) +{ + return GetOutputTensorData(idx, data); +} + //////////////////////////////////////////// /// u8 helpers //////////////////////////////////////////// diff --git a/src/backends/reference/workloads/RefWorkloads.hpp b/src/backends/reference/workloads/RefWorkloads.hpp index 37d79f0fc0..cbfade3c02 100644 --- a/src/backends/reference/workloads/RefWorkloads.hpp +++ b/src/backends/reference/workloads/RefWorkloads.hpp @@ -24,6 +24,7 @@ #include "RefConcatWorkload.hpp" #include "RefConvertBf16ToFp32Workload.hpp" #include "RefConvertFp16ToFp32Workload.hpp" +#include "RefConvertFp32ToBf16Workload.hpp" #include "RefConvertFp32ToFp16Workload.hpp" #include "RefDebugWorkload.hpp" #include "RefDepthToSpaceWorkload.hpp" -- cgit v1.2.1