Refactor activation LUT computation

* Moving the code out of Types.h will help
  with the compilation time.

* Added LUT support for all other activation functions.

* Resolves COMPMID-6292

Change-Id: I1b5f0b21f03237447163276b8796b2aeb3fdd45c
Signed-off-by: Pablo Marquez Tello <pablo.tello@arm.com>
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/9749
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Viet-Hoa Do <viet-hoa.do@arm.com>
Benchmark: Arm Jenkins <bsgcomp@arm.com>

6 files changed, 85 insertions, 175 deletions

diff --git a/arm_compute/core/QuantizationInfo.h b/arm_compute/core/QuantizationInfo.h
index 98ceec6c56..f760d7512c 100644
--- a/arm_compute/core/QuantizationInfo.h
+++ b/arm_compute/core/QuantizationInfo.h
@@ -399,68 +399,6 @@ inline float dequantize_qsymm8(int8_t value, const UniformQuantizationInfo &qinf
     return value * qinfo.scale;
 }
 
-inline qasymm8_t qasymm8_hard_swish(qasymm8_t                      in,
-                                    const UniformQuantizationInfo &qi_in,
-                                    const UniformQuantizationInfo &qi_out)
-{
-    float tmp_f         = dequantize_qasymm8(in, qi_in);
-    tmp_f               = tmp_f * ((std::min(std::max((tmp_f + 3), 0.0f), 6.0f)) * 0.166666667f);
-    const qasymm8_t tmp = quantize_qasymm8(tmp_f, qi_out);
-    return tmp;
-}
-
-inline qasymm8_signed_t qasymm8_signed_hard_swish(qasymm8_signed_t               in,
-                                                  const UniformQuantizationInfo &qi_in,
-                                                  const UniformQuantizationInfo &qi_out)
-{
-    float tmp_f         = dequantize_qasymm8_signed(in, qi_in);
-    tmp_f               = tmp_f * ((std::min(std::max((tmp_f + 3), 0.0f), 6.0f)) * 0.166666667f);
-    const qasymm8_t tmp = quantize_qasymm8_signed(tmp_f, qi_out);
-    return tmp;
-}
-
-inline qasymm8_t qasymm8_leaky_relu(qasymm8_t                      in,
-                                    const UniformQuantizationInfo &qi_in,
-                                    const UniformQuantizationInfo &qi_out,
-                                    float                          alpha)
-{
-    float tmp_f         = dequantize_qasymm8(in, qi_in);
-    tmp_f               = tmp_f > 0 ? tmp_f : tmp_f * alpha;
-    const qasymm8_t tmp = quantize_qasymm8(tmp_f, qi_out);
-    return tmp;
-}
-
-inline qasymm8_signed_t qasymm8_signed_leaky_relu(qasymm8_signed_t               in,
-                                                  const UniformQuantizationInfo &qi_in,
-                                                  const UniformQuantizationInfo &qi_out,
-                                                  float                          alpha)
-{
-    float tmp_f         = dequantize_qasymm8_signed(in, qi_in);
-    tmp_f               = tmp_f > 0 ? tmp_f : tmp_f * alpha;
-    const qasymm8_t tmp = quantize_qasymm8_signed(tmp_f, qi_out);
-    return tmp;
-}
-
-inline qasymm8_t qasymm8_logistic(qasymm8_t                      in,
-                                  const UniformQuantizationInfo &qi_in,
-                                  const UniformQuantizationInfo &qi_out)
-{
-    float tmp_f         = dequantize_qasymm8(in, qi_in);
-    tmp_f               = 1.f / (1.f + std::exp(-tmp_f));
-    const qasymm8_t tmp = quantize_qasymm8(tmp_f, qi_out);
-    return tmp;
-}
-
-inline qasymm8_signed_t qasymm8_signed_logistic(qasymm8_signed_t               in,
-                                                const UniformQuantizationInfo &qi_in,
-                                                const UniformQuantizationInfo &qi_out)
-{
-    float tmp_f                = dequantize_qasymm8_signed(in, qi_in);
-    tmp_f                      = 1.f / (1.f + std::exp(-tmp_f));
-    const qasymm8_signed_t tmp = quantize_qasymm8_signed(tmp_f, qi_out);
-    return tmp;
-}
-
 /** Dequantize a value given a 8-bit symmetric quantization scheme
  *
  * @param[in] value Value to dequantize
diff --git a/arm_compute/core/Types.h b/arm_compute/core/Types.h
index 09b77b5a11..2613d46d14 100644
--- a/arm_compute/core/Types.h
+++ b/arm_compute/core/Types.h
@@ -1721,66 +1721,11 @@ public:
     {
         return _lut;
     }
-
-    void init_lut(DataType data_type, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out)
+    void setLookupTable256(LookupTable256 &lut)
     {
-        if(_act == ActivationFunction::HARD_SWISH)
-        {
-            if(data_type == DataType::QASYMM8)
-            {
-                qasymm8_hard_swish_populate_table(_lut, qi_in, qi_out);
-            }
-            else
-            {
-                qasymm8_signed_hard_swish_populate_table(_lut, qi_in, qi_out);
-            }
-        }
-        else if(_act == ActivationFunction::LEAKY_RELU)
-        {
-            if(data_type == DataType::QASYMM8)
-            {
-                qasymm8_leaky_relu_populate_table(_lut, qi_in, qi_out, _a);
-            }
-            else
-            {
-                qasymm8_signed_leaky_relu_populate_table(_lut, qi_in, qi_out, _a);
-            }
-        }
-        else if(_act == ActivationFunction::LOGISTIC)
-        {
-            if(data_type == DataType::QASYMM8)
-            {
-                qasymm8_logistic_populate_table(_lut, qi_in, qi_out);
-            }
-            else
-            {
-                qasymm8_signed_logistic_populate_table(_lut, qi_in, qi_out);
-            }
-        }
+        _lut = std::move(lut);
     }
 #endif // __aarch64__
-
-    static inline bool is_lut_supported(ActivationFunction act_func, DataType data_type)
-    {
-#ifdef __aarch64__
-        switch(act_func)
-        {
-            case ActivationFunction::HARD_SWISH:
-                return data_type == DataType::QASYMM8 || data_type == DataType::QASYMM8_SIGNED;
-            case ActivationFunction::LEAKY_RELU:
-                return data_type == DataType::QASYMM8 || data_type == DataType::QASYMM8_SIGNED;
-            case ActivationFunction::LOGISTIC:
-                return data_type == DataType::QASYMM8 || data_type == DataType::QASYMM8_SIGNED;
-            default:
-                return false;
-        }
-#else  // __aarch64__
-        ARM_COMPUTE_UNUSED(act_func);
-        ARM_COMPUTE_UNUSED(data_type);
-        return false;
-#endif // __aarch64__
-    }
-
 private:
     ActivationFunction _act     = { ActivationLayerInfo::ActivationFunction::IDENTITY };
     float              _a       = {};
@@ -1789,54 +1734,6 @@ private:
 
 #ifdef __aarch64__
     LookupTable256 _lut = {};
-
-    static inline void qasymm8_hard_swish_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out)
-    {
-        for(size_t i = 0; i < lut.size(); ++i)
-        {
-            lut[i] = qasymm8_hard_swish(i, qi_in, qi_out);
-        }
-    }
-
-    static inline void qasymm8_signed_hard_swish_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out)
-    {
-        for(size_t i = 0; i < lut.size(); ++i)
-        {
-            lut[i] = qasymm8_signed_hard_swish(i, qi_in, qi_out);
-        }
-    }
-
-    static inline void qasymm8_leaky_relu_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out, float alpha)
-    {
-        for(size_t i = 0; i < lut.size(); ++i)
-        {
-            lut[i] = qasymm8_leaky_relu(i, qi_in, qi_out, alpha);
-        }
-    }
-
-    static inline void qasymm8_signed_leaky_relu_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out, float alpha)
-    {
-        for(size_t i = 0; i < lut.size(); ++i)
-        {
-            lut[i] = qasymm8_signed_leaky_relu(i, qi_in, qi_out, alpha);
-        }
-    }
-
-    static inline void qasymm8_logistic_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out)
-    {
-        for(size_t i = 0; i < lut.size(); ++i)
-        {
-            lut[i] = qasymm8_logistic(i, qi_in, qi_out);
-        }
-    }
-
-    static inline void qasymm8_signed_logistic_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out)
-    {
-        for(size_t i = 0; i < lut.size(); ++i)
-        {
-            lut[i] = qasymm8_signed_logistic(static_cast<int8_t>(i), qi_in, qi_out);
-        }
-    }
 #endif // __aarch64__
 };
 
diff --git a/src/cpu/kernels/CpuActivationKernel.cpp b/src/cpu/kernels/CpuActivationKernel.cpp
index 20a8489cdd..f4bd4e6cad 100644
--- a/src/cpu/kernels/CpuActivationKernel.cpp
+++ b/src/cpu/kernels/CpuActivationKernel.cpp
@@ -48,7 +48,7 @@ static const std::vector<CpuActivationKernel::ActivationKernel> available_kernel
 #ifdef ARM_COMPUTE_ENABLE_SVE
     {
         "sve2_q8_activation_lut",
-        [](const ActivationDataTypeISASelectorData & data) { return ActivationLayerInfo::is_lut_supported(data.f, data.dt) && data.cpumodel == CPUModel::A510 && data.isa.sve2; },
+        [](const ActivationDataTypeISASelectorData & data) { return (data.dt == DataType::QASYMM8 || data.dt == DataType::QASYMM8_SIGNED) && data.cpumodel == CPUModel::A510 && data.isa.sve2; },
         REGISTER_QASYMM8_SVE2(arm_compute::cpu::sve2_q8_activation_lut)
     },
 #endif // ARM_COMPUTE_ENABLE_SVE
@@ -56,7 +56,7 @@ static const std::vector<CpuActivationKernel::ActivationKernel> available_kernel
     {
         // Neon LUT implementantion takes precedence
         "neon_q8_activation_lut",
-        [](const ActivationDataTypeISASelectorData & data) { return ActivationLayerInfo::is_lut_supported(data.f, data.dt); },
+        [](const ActivationDataTypeISASelectorData & data) { return data.dt == DataType::QASYMM8 || data.dt == DataType::QASYMM8_SIGNED; },
         REGISTER_Q8_NEON(arm_compute::cpu::neon_q8_activation_lut)
     },
 #endif // __aarch64__
@@ -184,6 +184,72 @@ std::pair<Status, Window> validate_and_configure_window(const ITensorInfo *src,
 
     return std::make_pair(Status{}, win);
 }
+#ifdef __aarch64__
+void init_lut(ActivationLayerInfo::ActivationFunction act_func, DataType data_type,
+              const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out,
+              ActivationLayerInfo::LookupTable256 &lut, float a, float b)
+{
+    for(size_t i = 0; i < lut.size(); ++i)
+    {
+        float tmp_f = (data_type == DataType::QASYMM8) ? dequantize_qasymm8(i, qi_in) : dequantize_qasymm8_signed(i, qi_in);
+        switch(act_func)
+        {
+            case ActivationLayerInfo::ActivationFunction::HARD_SWISH:
+                tmp_f = tmp_f * ((std::min(std::max((tmp_f + 3), 0.0f), 6.0f)) * 0.166666667f);
+                break;
+            case ActivationLayerInfo::ActivationFunction::LEAKY_RELU:
+                tmp_f = tmp_f > 0 ? tmp_f : tmp_f * a;
+                break;
+            case ActivationLayerInfo::ActivationFunction::LOGISTIC:
+                tmp_f = 1.f / (1.f + std::exp(-tmp_f));
+                break;
+            case ActivationLayerInfo::ActivationFunction::ABS:
+                tmp_f = std::abs(tmp_f);
+                break;
+            case ActivationLayerInfo::ActivationFunction::LINEAR:
+                tmp_f = a * tmp_f + b;
+                break;
+            case ActivationLayerInfo::ActivationFunction::RELU:
+                tmp_f = std::max<>(0.f, tmp_f);
+                break;
+            case ActivationLayerInfo::ActivationFunction::BOUNDED_RELU:
+                tmp_f = std::min<>(a, std::max(0.f, tmp_f));
+                break;
+            case ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU:
+                tmp_f = std::min<>(a, std::max<>(b, tmp_f));
+                break;
+            case ActivationLayerInfo::ActivationFunction::SOFT_RELU:
+                tmp_f = (tmp_f > 12.f) ? tmp_f : std::log(1.f + std::exp(tmp_f));
+                break;
+            case ActivationLayerInfo::ActivationFunction::ELU:
+                tmp_f = (tmp_f >= 0) ? tmp_f : a * (std::exp(tmp_f) - 1);
+                break;
+            case ActivationLayerInfo::ActivationFunction::SQRT:
+                tmp_f = std::sqrt(tmp_f);
+                break;
+            case ActivationLayerInfo::ActivationFunction::SQUARE:
+                tmp_f = tmp_f * tmp_f;
+                break;
+            case ActivationLayerInfo::ActivationFunction::TANH:
+                tmp_f = a * std::tanh(b * tmp_f);
+                break;
+            case ActivationLayerInfo::ActivationFunction::IDENTITY:
+                break;
+            case ActivationLayerInfo::ActivationFunction::SWISH:
+                tmp_f = tmp_f / (1.f + std::exp(-a * tmp_f));
+                break;
+            case ActivationLayerInfo::ActivationFunction::GELU:
+                tmp_f = tmp_f * (0.5f * (1.0f + erff(tmp_f / 1.41421356237f)));
+                break;
+            default:
+                ARM_COMPUTE_ERROR("Not supported");
+                tmp_f = 0;
+                break;
+        }
+        lut[i] = (data_type == DataType::QASYMM8) ? quantize_qasymm8(tmp_f, qi_out) : quantize_qasymm8_signed(tmp_f, qi_out);
+    }
+}
+#endif // __aarch64__
 } // namespace
 
 void CpuActivationKernel::configure(const ITensorInfo *src, ITensorInfo *dst, ActivationLayerInfo activation_info)
@@ -205,9 +271,12 @@ void CpuActivationKernel::configure(const ITensorInfo *src, ITensorInfo *dst, Ac
     _name       = std::string("CpuActivationKernel").append("/").append(uk->name);
 
 #ifdef __aarch64__
-    if(ActivationLayerInfo::is_lut_supported(activation_info.activation(), src->data_type()))
+    if(src->data_type() == DataType::QASYMM8 || src->data_type() == DataType::QASYMM8_SIGNED)
     {
-        activation_info.init_lut(src->data_type(), src->quantization_info().uniform(), (dst) ? dst->quantization_info().uniform() : src->quantization_info().uniform());
+        ActivationLayerInfo::LookupTable256 tmp_lut;
+        init_lut(activation_info.activation(), src->data_type(), src->quantization_info().uniform(), (dst) ? dst->quantization_info().uniform() : src->quantization_info().uniform(),
+                 tmp_lut, activation_info.a(), activation_info.b());
+        activation_info.setLookupTable256(tmp_lut);
     }
 #endif // __aarch64__
     _act_info = activation_info;
diff --git a/src/cpu/kernels/activation/generic/neon/lut.cpp b/src/cpu/kernels/activation/generic/neon/lut.cpp
index 90690ffcaa..b44347550e 100644
--- a/src/cpu/kernels/activation/generic/neon/lut.cpp
+++ b/src/cpu/kernels/activation/generic/neon/lut.cpp
@@ -32,7 +32,7 @@ namespace cpu
 #ifdef __aarch64__
 void neon_q8_activation_lut(const ITensor *src, ITensor *dst, const ActivationLayerInfo &act_info, const Window &window)
 {
-    ARM_COMPUTE_ERROR_ON(!ActivationLayerInfo::is_lut_supported(act_info.activation(), src->info()->data_type()));
+    ARM_COMPUTE_ERROR_ON(src->info()->data_type() != DataType::QASYMM8 && src->info()->data_type() != DataType::QASYMM8_SIGNED);
     const auto window_end_x  = window.x().end();
     Window     win_collapsed = window.collapse_if_possible(window, Window::DimZ);
     win_collapsed.set(Window::DimX, Window::Dimension(0, 1, 1));
diff --git a/src/cpu/kernels/activation/generic/sve2/lut.cpp b/src/cpu/kernels/activation/generic/sve2/lut.cpp
index 2e5975744b..9dbeb305ff 100644
--- a/src/cpu/kernels/activation/generic/sve2/lut.cpp
+++ b/src/cpu/kernels/activation/generic/sve2/lut.cpp
@@ -32,7 +32,7 @@ namespace cpu
 #ifdef __aarch64__
 void sve2_q8_activation_lut(const ITensor *src, ITensor *dst, const ActivationLayerInfo &act_info, const Window &window)
 {
-    ARM_COMPUTE_ERROR_ON(!ActivationLayerInfo::is_lut_supported(act_info.activation(), src->info()->data_type()));
+    ARM_COMPUTE_ERROR_ON(src->info()->data_type() != DataType::QASYMM8 && src->info()->data_type() != DataType::QASYMM8_SIGNED);
     const auto window_end_x  = window.x().end();
     Window     win_collapsed = window.collapse_if_possible(window, Window::DimZ);
     win_collapsed.set(Window::DimX, Window::Dimension(0, 1, 1));
diff --git a/tests/validation/NEON/ActivationLayer.cpp b/tests/validation/NEON/ActivationLayer.cpp
index d64945ab31..5de35fe942 100644
--- a/tests/validation/NEON/ActivationLayer.cpp
+++ b/tests/validation/NEON/ActivationLayer.cpp
@@ -316,10 +316,16 @@ DATA_TEST_CASE(KernelSelection, framework::DatasetMode::ALL, concat(concat(
     const auto *selected_impl = CpuActivationKernel::get_implementation(ActivationDataTypeISASelectorData{data_type, CPUModel::GENERIC, cpu_isa,ActivationLayerInfo::ActivationFunction::BOUNDED_RELU}, cpu::KernelSelectionType::Preferred);
 
     ARM_COMPUTE_ERROR_ON_NULLPTR(selected_impl);
-
     std::string expected = lower_string(cpu_ext) + "_" + cpu_impl_dt(data_type) + "_activation";
+    if( data_type == DataType::QASYMM8 || data_type == DataType::QASYMM8_SIGNED)
+    {
+#ifdef __aarch64__
+        expected = "neon_q8_activation_lut";
+#else  // __aarch64__
+        expected = lower_string(cpu_ext) + "_" + cpu_impl_dt(data_type) + "_activation";
+#endif // __aarch64__
+    }
     std::string actual   = selected_impl->name;
-
     ARM_COMPUTE_EXPECT_EQUAL(expected, actual, framework::LogLevel::ERRORS);
 }
 // clang-format on