Add reduce product verifier

* Add verifiers to validate the result of a reduce produce operation.
* Add test cases for the new validator.

Change-Id: I666d1a67f498e7893e0f224bc5408a4134f2ef6c
Signed-off-by: Jack Frankland <jack.frankland@arm.com>

5 files changed, 121 insertions, 0 deletions

diff --git a/reference_model/src/verify/verifiers.h b/reference_model/src/verify/verifiers.h
index bdc8fe7..dd97122 100644
--- a/reference_model/src/verify/verifiers.h
+++ b/reference_model/src/verify/verifiers.h
@@ -41,6 +41,16 @@ bool verifyDotProduct(const CTensor* ref,
 /// \return True if compliant else false
 bool verifyExact(const CTensor* referenceTensor, const CTensor* implementationTensor);
 
+/// \brief Perform reduce product result verification
+///
+/// \param referenceTensor    Reference tensor
+/// \param implementationTensor    Implementation resulting tensor
+/// \param m    Number of manisa bits in the floating point representation
+/// \param n    Number of elements in the product
+///
+/// \return True if compliant else false
+bool verifyReduceProduct(const CTensor* referenceTensor, const CTensor* implementationTensor, uint64_t m, uint64_t n);
+
 /// \brief Perform ULP result verification
 ///
 /// \param referenceTensor    Reference tensor
diff --git a/reference_model/src/verify/verify_entry.cc b/reference_model/src/verify/verify_entry.cc
index 32614b6..1ddd52b 100644
--- a/reference_model/src/verify/verify_entry.cc
+++ b/reference_model/src/verify/verify_entry.cc
@@ -34,6 +34,9 @@ bool verify(const CTensor* ref, const CTensor* refBnd, const CTensor* imp, const
         case VerifyMode::Exact: {
             return verifyExact(ref, imp);
         }
+        case VerifyMode::ReduceProduct: {
+            return verifyReduceProduct(ref, imp, cfg.reduceProductInfo.m, cfg.reduceProductInfo.n);
+        }
         case VerifyMode::Ulp: {
             return verifyULP(ref, imp, cfg.ulpInfo.ulp);
         }
diff --git a/reference_model/src/verify/verify_reduce_product.cc b/reference_model/src/verify/verify_reduce_product.cc
new file mode 100644
index 0000000..d233b0f
--- /dev/null
+++ b/reference_model/src/verify/verify_reduce_product.cc
@@ -0,0 +1,88 @@
+
+// Copyright (c) 2023, ARM Limited.
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//         http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+
+#include <cmath>
+#include <vector>
+
+#include "verifiers.h"
+#include "verify/verify_utils.h"
+
+namespace
+{
+
+auto calculateError(uint64_t M, uint64_t N)
+{
+    return std::pow(1 + std::pow(2, -static_cast<int64_t>(M) - 1), N) - 1;
+}
+
+template <typename FP>
+auto calculateTolerance(uint64_t M, uint64_t N, FP value)
+{
+    return std::abs(value) * calculateError(M, N);
+}
+}    // namespace
+
+namespace TosaReference
+{
+
+bool verifyReduceProduct(const CTensor* referenceTensor, const CTensor* implementationTensor, uint64_t m, uint64_t n)
+{
+    // Validate that tensors are provided
+    TOSA_REF_REQUIRE(referenceTensor != nullptr, "reference tensor is missing");
+    TOSA_REF_REQUIRE(implementationTensor != nullptr, "implementation tensor is missing");
+
+    // Get number of elements
+    const auto elementCount =
+        numElements(std::vector<int32_t>(referenceTensor->shape, referenceTensor->shape + referenceTensor->num_dims));
+    TOSA_REF_REQUIRE(elementCount > 0, "invalid shape for reference tensor");
+
+    switch (implementationTensor->data_type)
+    {
+        case tosa_datatype_fp32_t: {
+            const auto* refData = reinterpret_cast<const float*>(referenceTensor->data);
+            TOSA_REF_REQUIRE(refData != nullptr, "missing data for reference");
+
+            const auto* impData = reinterpret_cast<const float*>(implementationTensor->data);
+            TOSA_REF_REQUIRE(impData != nullptr, "missing data for implementation");
+
+            return std::equal(refData, std::next(refData, elementCount), impData, std::next(impData, elementCount),
+                              [m, n](const auto& referenceValue, const auto& implementationValue) {
+                                  // Result overflows must be set to zero of the correct sign.
+                                  if (std::isinf(implementationValue))
+                                  {
+                                      return implementationValue == referenceValue;
+                                  }
+
+                                  // Result underflows must be set to a zero of the correct sign.
+                                  if (implementationValue == 0.f || implementationValue == -0.f)
+                                  {
+                                      return implementationValue == referenceValue;
+                                  }
+
+                                  // Otherwise we are in the normal range.
+                                  const auto absoulteError = (referenceValue < implementationValue)
+                                                                 ? implementationValue - referenceValue
+                                                                 : referenceValue - implementationValue;
+                                  return absoulteError <= calculateTolerance(m, n, implementationValue);
+                              });
+        }
+        default:
+            WARNING("tosa verifier: data-type not supported.");
+            break;
+    }
+
+    return false;
+}
+}    // namespace TosaReference
diff --git a/reference_model/src/verify/verify_utils.cc b/reference_model/src/verify/verify_utils.cc
index 786ab40..366238b 100644
--- a/reference_model/src/verify/verify_utils.cc
+++ b/reference_model/src/verify/verify_utils.cc
@@ -62,6 +62,12 @@ void from_json(const nlohmann::json& j, DotProductVerifyInfo& dotProductInfo)
     j.at("ks").get_to(dotProductInfo.ks);
 }
 
+void from_json(const nlohmann::json& j, ReduceProductVerifyInfo& reduceProduceInfo)
+{
+    j.at("m").get_to(reduceProduceInfo.m);
+    j.at("n").get_to(reduceProduceInfo.n);
+}
+
 void from_json(const nlohmann::json& j, VerifyConfig& cfg)
 {
     j.at("mode").get_to(cfg.mode);
@@ -74,6 +80,10 @@ void from_json(const nlohmann::json& j, VerifyConfig& cfg)
     {
         j.at("dot_product_info").get_to(cfg.dotProductInfo);
     }
+    if (j.contains("reduce_product_info"))
+    {
+        j.at("reduce_product_info").get_to(cfg.reduceProductInfo);
+    }
 }
 
 std::optional<VerifyConfig> parseVerifyConfig(const char* tensorName, const char* json)
diff --git a/reference_model/src/verify/verify_utils.h b/reference_model/src/verify/verify_utils.h
index 5b98f5c..0afd804 100644
--- a/reference_model/src/verify/verify_utils.h
+++ b/reference_model/src/verify/verify_utils.h
@@ -64,6 +64,15 @@ struct DotProductVerifyInfo
     int32_t ks;
 };
 
+/// \brief reduce-product verification meta-data
+struct ReduceProductVerifyInfo
+{
+    ReduceProductVerifyInfo() = default;
+
+    int64_t m;
+    int64_t n;
+};
+
 /// \brief Verification meta-data
 struct VerifyConfig
 {
@@ -73,6 +82,7 @@ struct VerifyConfig
     DType dataType;
     UlpInfo ulpInfo;
     DotProductVerifyInfo dotProductInfo;
+    ReduceProductVerifyInfo reduceProductInfo;
 };
 
 /// \brief Parse the verification config for a tensor when given in JSON form