src/armnn/optimizations/ConvertConstants.hpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #pragma once
   7
   8 #include "Optimization.hpp"
   9
  10 #include <backendsCommon/CpuTensorHandle.hpp>
  11 #include <FloatingPointConverter.hpp>
  12
  13 #include <Half.hpp>
  14
  15 namespace armnn
  16 {
  17 namespace optimizations
  18 {
  19
  20 struct Float16ToFloat32
  21 {
  22     static void Func(std::unique_ptr<ScopedCpuTensorHandle>& handle)
  23     {
  24         const TensorInfo& info = handle->GetTensorInfo();
  25
  26         if (info.GetDataType() == DataType::Float16)
  27         {
  28             std::vector<float> newValues(info.GetNumElements());
  29
  30             armnnUtils::FloatingPointConverter::ConvertFloat16To32(handle->GetTensor<Half>(),
  31                                                                    info.GetNumElements(),
  32                                                                    newValues.data());
  33
  34             TensorInfo newInfo(info.GetShape(), DataType::Float32);
  35             ConstTensor newInput(newInfo, newValues);
  36             handle.reset(new ScopedCpuTensorHandle(newInput));
  37         }
  38     }
  39 };
  40
  41 struct Float32ToFloat16
  42 {
  43     static void Func(std::unique_ptr<ScopedCpuTensorHandle>& handle)
  44     {
  45         const TensorInfo& info = handle->GetTensorInfo();
  46
  47         if (info.GetDataType() == DataType::Float32)
  48         {
  49             std::vector<Half> newValues(info.GetNumElements());
  50
  51             armnnUtils::FloatingPointConverter::ConvertFloat32To16(handle->GetTensor<float>(),
  52                                                                    info.GetNumElements(),
  53                                                                    newValues.data());
  54
  55             TensorInfo newInfo(info.GetShape(), DataType::Float16);
  56             ConstTensor newInput(newInfo, newValues);
  57             handle.reset(new ScopedCpuTensorHandle(newInput));
  58         }
  59     }
  60 };
  61
  62 template<typename Converter, typename Predicate>
  63 class ConvertConstants : public Optimization
  64 {
  65 public:
  66     ConvertConstants() = default;
  67     ConvertConstants(const ConvertConstants&) = default;
  68     virtual ~ConvertConstants() = default;
  69
  70     void Run(Graph& graph, Layer& layer) const override
  71     {
  72         if (Predicate::Test(layer))
  73         {
  74             layer.OperateOnConstantTensors(Converter::Func);
  75         }
  76     }
  77 protected:
  78 };
  79
  80 struct IsFloat32Layer
  81 {
  82     static bool Test(const Layer& layer)
  83     {
  84         return layer.GetDataType() == DataType::Float32;
  85     }
  86 };
  87
  88 struct IsFloat16Layer
  89 {
  90     static bool Test(const Layer& layer)
  91     {
  92         return layer.GetDataType() == DataType::Float16;
  93     }
  94 };
  95
  96 using ConvertConstantsHalfToFloat = ConvertConstants<Float16ToFloat32, IsFloat32Layer>;
  97 using ConvertConstantsFloatToHalf = ConvertConstants<Float32ToFloat16, IsFloat16Layer>;
  98
  99 } //namespace optimizations
 100 } //namespace armnn