SPECIAL data gen mode for FP16 and FP32
Signed-off-by: evacha01 <evan.chandler@arm.com>
Change-Id: I5a9a1c63345bd83ca04bc6c2a99b0ef3612971ee
diff --git a/reference_model/CMakeLists.txt b/reference_model/CMakeLists.txt
index b780781..cf1e9fe 100644
--- a/reference_model/CMakeLists.txt
+++ b/reference_model/CMakeLists.txt
@@ -75,6 +75,7 @@
src/generate/generate_pseudo_random.cc
src/generate/generate_fixed_data.cc
src/generate/generate_full_range.cc
+ src/generate/generate_fp_special.cc
src/generate/generate_entry.cc
src/generate/generate_utils.cc
src/verify/verify_abs_error.cc
@@ -84,6 +85,7 @@
src/verify/verify_reduce_product.cc
src/verify/verify_relative.cc
src/verify/verify_ulp.cc
+ src/verify/verify_fp_special.cc
src/verify/verify_utils.cc
src/ops/op_factory.cc
src/ops/tensor_ops.cc
@@ -161,6 +163,7 @@
src/verify/verify_reduce_product.cc
src/verify/verify_relative.cc
src/verify/verify_ulp.cc
+ src/verify/verify_fp_special.cc
src/verify/verify_utils.cc
src/verify/verify_config.cc
src/func_debug.cc
@@ -179,6 +182,7 @@
src/generate/generate_pseudo_random.cc
src/generate/generate_fixed_data.cc
src/generate/generate_full_range.cc
+ src/generate/generate_fp_special.cc
src/generate/generate_entry.cc
src/generate/generate_utils.cc
src/generate/generate_config.cc
diff --git a/reference_model/src/generate/generate_entry.cc b/reference_model/src/generate/generate_entry.cc
index 6f797b3..36d99ad 100644
--- a/reference_model/src/generate/generate_entry.cc
+++ b/reference_model/src/generate/generate_entry.cc
@@ -16,6 +16,7 @@
#include "generate_dot_product.h"
#include "generate_fixed_data.h"
+#include "generate_fp_special.h"
#include "generate_full_range.h"
#include "generate_pseudo_random.h"
#include "generate_utils.h"
@@ -46,6 +47,10 @@
return generateFullRange(cfg, data, size);
break;
}
+ case GeneratorType::FpSpecial: {
+ return generateFpSpecial(cfg, data, size);
+ break;
+ }
default: {
WARNING("[Generator] Unsupported generation mode.");
break;
diff --git a/reference_model/src/generate/generate_fp_special.cc b/reference_model/src/generate/generate_fp_special.cc
new file mode 100644
index 0000000..3602f51
--- /dev/null
+++ b/reference_model/src/generate/generate_fp_special.cc
@@ -0,0 +1,180 @@
+// Copyright (c) 2024, 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 "generate_fp_special.h"
+#include "half.hpp"
+
+#include <map>
+
+namespace
+{
+
+class SpecialValue
+{
+public:
+ enum SpecialValsEnum
+ {
+ Zero,
+ Inf,
+ NaN,
+ Min,
+ Max,
+ One,
+ };
+
+ SpecialValue() = default;
+ SpecialValue(SpecialValsEnum v)
+ : value(v)
+ {}
+ operator SpecialValsEnum() const
+ {
+ return value;
+ }
+ SpecialValue& operator=(SpecialValsEnum v)
+ {
+ value = v;
+ return *this;
+ }
+ bool operator==(const SpecialValsEnum v) const
+ {
+ return value == v;
+ }
+ bool operator!=(const SpecialValsEnum v) const
+ {
+ return value != v;
+ }
+ SpecialValue operator-()
+ {
+ negative = !negative;
+ return *this;
+ }
+
+ template <typename DataType>
+ DataType evaluate()
+ {
+ switch (value)
+ {
+ case Zero:
+ return static_cast<DataType>(negative ? -0.0 : 0.0);
+ case Inf:
+ return negative ? -std::numeric_limits<DataType>::infinity()
+ : std::numeric_limits<DataType>::infinity();
+ case NaN:
+ return std::numeric_limits<DataType>::quiet_NaN();
+ case Min:
+ return negative ? -std::numeric_limits<DataType>::min() : std::numeric_limits<DataType>::min();
+ case Max:
+ return negative ? -std::numeric_limits<DataType>::max() : std::numeric_limits<DataType>::max();
+ case One:
+ return static_cast<DataType>(negative ? -1.0 : 1.0);
+ default:
+ WARNING("[Generator][FS] Uninitialised special value.");
+ return static_cast<DataType>(0.0);
+ }
+ }
+
+private:
+ SpecialValsEnum value;
+ bool negative = false;
+};
+
+/*
+Test vals format
+
+I: Number of inputs to an op - referenced by cfg.inputPos
+T: Number of test cases defined for the op
+
+vector of test inputs: {
+ vector of values for test 0: { valueForinputPos0, valueForinputPos1, ..., valueForinputPosI-1 },
+ vector of values for test 1: { valueForinputPos0, valueForinputPos1, ..., valueForinputPosI-1 },
+ ...
+ vector of values for test T-1: { valueForinputPos0, valueForinputPos1, ..., valueForinputPosI-1 },
+}
+*/
+using TestValues = std::vector<std::vector<SpecialValue>>;
+
+TestValues equalOpsTestVals{ { SpecialValue(SpecialValue::Zero), -SpecialValue(SpecialValue::Zero) },
+ { SpecialValue(SpecialValue::Inf), -SpecialValue(SpecialValue::Inf) } };
+
+TestValues addTestVals{ { SpecialValue(SpecialValue::Max), SpecialValue(SpecialValue::One) },
+ { SpecialValue(SpecialValue::Inf), -SpecialValue(SpecialValue::Inf) } };
+
+TestValues defaultTestVals{ { SpecialValue(SpecialValue::Zero) }, { -SpecialValue(SpecialValue::Zero) },
+ { SpecialValue(SpecialValue::Inf) }, { -SpecialValue(SpecialValue::Inf) },
+ { SpecialValue(SpecialValue::NaN) }, { SpecialValue(SpecialValue::Min) },
+ { SpecialValue(SpecialValue::Max) } };
+
+std::map<Op, TestValues> testValues = { { Op::Op_EQUAL, equalOpsTestVals },
+ { Op::Op_GREATER, equalOpsTestVals },
+ { Op::Op_GREATER_EQUAL, equalOpsTestVals },
+ { Op::Op_ADD, addTestVals } };
+
+template <typename DataType>
+bool generate(const TosaReference::GenerateConfig& cfg, DataType* data, size_t size)
+{
+ const TosaReference::FpSpecialInfo& fsinfo = cfg.fpSpecialInfo;
+ uint8_t startIndex = fsinfo.startIndex;
+
+ std::vector<DataType> values;
+ auto testValuesResult = testValues.find(cfg.opType);
+ TestValues opTestVals = defaultTestVals;
+ size_t inputIndex = 0;
+ if (testValuesResult != testValues.end())
+ {
+ // When an op has an entry in testValues we use its op specific special test values, otherwise default values are used
+ opTestVals = testValuesResult->second;
+ inputIndex = cfg.inputPos;
+ }
+
+ for (std::vector<SpecialValue> inputs : opTestVals)
+ {
+ values.push_back(inputs[inputIndex].evaluate<DataType>());
+ }
+
+ const auto T = TosaReference::numElementsFromShape(cfg.shape);
+ for (auto t = 0; t < T; ++t)
+ {
+ data[t] = values[(t + startIndex) % values.size()];
+ }
+ return true;
+}
+} // namespace
+
+namespace TosaReference
+{
+bool generateFpSpecial(const GenerateConfig& cfg, void* data, size_t size)
+{
+ // Check we support the operator
+ if (cfg.opType == Op::Op_UNKNOWN)
+ {
+ WARNING("[Generator][FS] Unknown operator.");
+ return false;
+ }
+
+ switch (cfg.dataType)
+ {
+ case DType::DType_FP16: {
+ half_float::half* outData = reinterpret_cast<half_float::half*>(data);
+ return generate(cfg, outData, size);
+ }
+ case DType::DType_FP32: {
+ float* outData = reinterpret_cast<float*>(data);
+ return generate(cfg, outData, size);
+ }
+ default:
+ WARNING("[Generator][FS] Unsupported type.");
+ return false;
+ }
+}
+} // namespace TosaReference
\ No newline at end of file
diff --git a/reference_model/src/generate/generate_fp_special.h b/reference_model/src/generate/generate_fp_special.h
new file mode 100644
index 0000000..9a7315b
--- /dev/null
+++ b/reference_model/src/generate/generate_fp_special.h
@@ -0,0 +1,34 @@
+// Copyright (c) 2024, 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.
+
+#ifndef GENERATE_FP_SPECIAL_H_
+#define GENERATE_FP_SPECIAL_H_
+
+#include "generate_utils.h"
+
+namespace TosaReference
+{
+
+/// \brief Perform FP special data generation
+///
+/// \param cfg Generator related meta-data
+/// \param data Buffer to generate the data to
+/// \param size Size of the buffer
+///
+/// \return True on successful generation
+bool generateFpSpecial(const GenerateConfig& cfg, void* data, size_t size);
+
+}; // namespace TosaReference
+
+#endif // GENERATE_FP_SPECIAL_H_
\ No newline at end of file
diff --git a/reference_model/src/generate/generate_utils.cc b/reference_model/src/generate/generate_utils.cc
index f31b443..d62c247 100644
--- a/reference_model/src/generate/generate_utils.cc
+++ b/reference_model/src/generate/generate_utils.cc
@@ -107,7 +107,7 @@
{ GeneratorType::DotProduct, "DOT_PRODUCT" },
{ GeneratorType::FullRange, "FULL_RANGE" },
{ GeneratorType::Boundary, "BOUNDARY" },
- { GeneratorType::Special, "SPECIAL" },
+ { GeneratorType::FpSpecial, "FP_SPECIAL" },
{ GeneratorType::FixedData, "FIXED_DATA" },
})
@@ -159,6 +159,14 @@
}
}
+void from_json(const nlohmann::json& j, FpSpecialInfo& fpSpecialInfo)
+{
+ if (j.contains("start_idx"))
+ {
+ j.at("start_idx").get_to(fpSpecialInfo.startIndex);
+ }
+}
+
void from_json(const nlohmann::json& j, GenerateConfig& cfg)
{
j.at("data_type").get_to(cfg.dataType);
@@ -201,6 +209,13 @@
{
j.at("full_range_info").get_to(cfg.fullRangeInfo);
}
+
+ //Set up defaults for fpSpecialInfo
+ cfg.fpSpecialInfo.startIndex = 0;
+ if (j.contains("fp_special_info"))
+ {
+ j.at("fp_special_info").get_to(cfg.fpSpecialInfo);
+ }
}
std::optional<GenerateConfig> parseGenerateConfig(const char* json, const char* tensorName)
diff --git a/reference_model/src/generate/generate_utils.h b/reference_model/src/generate/generate_utils.h
index 8ce9b0e..0428fd8 100644
--- a/reference_model/src/generate/generate_utils.h
+++ b/reference_model/src/generate/generate_utils.h
@@ -33,7 +33,7 @@
DotProduct,
FullRange,
Boundary,
- Special,
+ FpSpecial,
FixedData,
};
@@ -82,6 +82,14 @@
uint16_t startVal;
};
+/// \brief Op specific generator meta-data
+struct FpSpecialInfo
+{
+ FpSpecialInfo() = default;
+
+ uint8_t startIndex;
+};
+
/// \brief Generator configuration
struct GenerateConfig
{
@@ -95,6 +103,7 @@
PseudoRandomInfo pseudoRandomInfo;
FixedDataInfo fixedDataInfo;
FullRangeInfo fullRangeInfo;
+ FpSpecialInfo fpSpecialInfo;
};
/// \brief Parse the generator config when given in JSON form
diff --git a/reference_model/src/verify/verifiers.h b/reference_model/src/verify/verifiers.h
index e5f9df1..48c971d 100644
--- a/reference_model/src/verify/verifiers.h
+++ b/reference_model/src/verify/verifiers.h
@@ -85,6 +85,14 @@
const CTensor* implementationTensor,
const RelativeVerifyInfo& rInfo);
+/// \brief Perform FP special tests verification
+///
+/// \param referenceTensor Reference tensor
+/// \param implementationTensor Implementation resulting tensor
+///
+/// \return True if compliant else false
+bool verifyFpSpecial(const CTensor* referenceTensor, const CTensor* implementationTensor);
+
}; // namespace TosaReference
#endif // VERIFIERS_H_
diff --git a/reference_model/src/verify/verify_entry.cc b/reference_model/src/verify/verify_entry.cc
index 9702c36..a04c62e 100644
--- a/reference_model/src/verify/verify_entry.cc
+++ b/reference_model/src/verify/verify_entry.cc
@@ -46,6 +46,9 @@
case VerifyMode::Relative: {
return verifyRelative(ref, imp, cfg.relativeInfo);
}
+ case VerifyMode::FpSpecial: {
+ return verifyFpSpecial(ref, imp);
+ }
default: {
WARNING("[Verifier] Unsupported verification mode.");
break;
diff --git a/reference_model/src/verify/verify_fp_special.cc b/reference_model/src/verify/verify_fp_special.cc
new file mode 100644
index 0000000..94550fd
--- /dev/null
+++ b/reference_model/src/verify/verify_fp_special.cc
@@ -0,0 +1,106 @@
+// Copyright (c) 2024, 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 "half.hpp"
+#include "verifiers.h"
+
+namespace
+{
+template <typename Datatype>
+bool compliant(const double& referenceValue, const Datatype& implementationValue)
+{
+ // Compliant when values are both nans OR when values are both finite/infinite and have the same sign
+ return (std::isnan(referenceValue) && std::isnan(implementationValue)) ||
+ (std::isnan(referenceValue) == std::isnan(implementationValue) &&
+ std::isfinite(referenceValue) == std::isfinite(implementationValue) &&
+ std::signbit(referenceValue) == std::signbit(implementationValue));
+}
+
+template <>
+bool compliant(const double& referenceValue, const half_float::half& implementationValue)
+{
+ // Compliant when values are both nans OR when values are both finite/infinite and have the same sign
+ return (std::isnan(referenceValue) && half_float::isnan(implementationValue)) ||
+ (std::isnan(referenceValue) == half_float::isnan(implementationValue) &&
+ std::isfinite(referenceValue) == half_float::isfinite(implementationValue) &&
+ std::signbit(referenceValue) == half_float::signbit(implementationValue));
+}
+
+template <typename Datatype>
+bool verify(const double* refData,
+ const double* refDataEnd,
+ Datatype* impData,
+ const int64_t elementCount,
+ const std::vector<int32_t> refShape)
+{
+ auto pair = std::mismatch(refData, refDataEnd, impData, std::next(impData, elementCount),
+ [](const double& referenceValue, const Datatype& implementationValue) {
+ return compliant(referenceValue, implementationValue);
+ });
+
+ if (std::get<0>(pair) == refDataEnd)
+ {
+ // No mismatch found
+ return true;
+ }
+ else
+ {
+ auto pos = TosaReference::indexToPosition(std::get<0>(pair) - refData, refShape);
+ WARNING("[Verfier][FS] Location %s", TosaReference::positionToString(pos).c_str());
+ return false;
+ }
+}
+} // namespace
+
+namespace TosaReference
+{
+
+bool verifyFpSpecial(const CTensor* referenceTensor, const CTensor* implementationTensor)
+{
+ // Validate that tensors are provided
+ TOSA_REF_REQUIRE(referenceTensor != nullptr, "[FS] Reference tensor is missing");
+ TOSA_REF_REQUIRE(implementationTensor != nullptr, "[FS] Implementation tensor is missing");
+
+ // Get number of elements
+ const std::vector<int32_t> refShape(referenceTensor->shape, referenceTensor->shape + referenceTensor->num_dims);
+ const auto elementCount = numElements(refShape);
+ TOSA_REF_REQUIRE(elementCount > 0, "[FS] Invalid shape for reference tensor");
+
+ TOSA_REF_REQUIRE(referenceTensor->data_type == tosa_datatype_fp64_t, "[FS] Reference tensor is not fp64");
+ const auto* refData = reinterpret_cast<const double*>(referenceTensor->data);
+ TOSA_REF_REQUIRE(refData != nullptr, "[FS] Missing data for reference");
+ const auto* refDataEnd = std::next(refData, elementCount);
+
+ switch (implementationTensor->data_type)
+ {
+ case tosa_datatype_fp32_t: {
+ const auto* impData = reinterpret_cast<const float*>(implementationTensor->data);
+ TOSA_REF_REQUIRE(impData != nullptr, "[FS] Missing data for implementation");
+
+ return verify(refData, refDataEnd, impData, elementCount, refShape);
+ }
+ case tosa_datatype_fp16_t: {
+ const auto* impData = reinterpret_cast<const half_float::half*>(implementationTensor->data);
+ TOSA_REF_REQUIRE(impData != nullptr, "[FS] Missing data for implementation");
+
+ return verify(refData, refDataEnd, impData, elementCount, refShape);
+ }
+ default:
+ WARNING("[Verifier][FS] Data-type not supported.");
+ break;
+ }
+
+ return false;
+}
+} // namespace TosaReference
diff --git a/reference_model/test/generate_tests.cpp b/reference_model/test/generate_tests.cpp
index 73db631..19b808b 100644
--- a/reference_model/test/generate_tests.cpp
+++ b/reference_model/test/generate_tests.cpp
@@ -1609,4 +1609,101 @@
}
}
+void fp_special_test_FP32(const std::string tosaName,
+ const size_t tosaElements,
+ const std::string templateJsonCfg,
+ const std::string opStr,
+ const std::string startIndexStr,
+ const std::vector<uint32_t> expected)
+{
+ std::string jsonCfg = templateJsonCfg;
+ update_json_template(jsonCfg, "_OP_", opStr);
+ update_json_template(jsonCfg, "_START_", startIndexStr);
+
+ std::vector<float> buffer(tosaElements);
+ REQUIRE(tgd_generate_data(jsonCfg.c_str(), tosaName.c_str(), (void*)buffer.data(), tosaElements * 4));
+ check_output<float>(buffer, expected);
+}
+
+TEST_CASE("positive - FP32 FP Special")
+{
+ std::string templateJsonCfg = R"({
+ "tensors" : {
+ "input0" : {
+ "generator": "FP_SPECIAL",
+ "data_type": "FP32",
+ "input_type": "VARIABLE",
+ "shape" : [ 5, 6, 7 ],
+ "input_pos": 0,
+ "op" : "_OP_",
+ "fp_special_info": {
+ "start_idx": _START_
+ }
+ },
+ "input1" : {
+ "generator": "FP_SPECIAL",
+ "data_type": "FP32",
+ "input_type": "VARIABLE",
+ "shape" : [ 5, 6, 7 ],
+ "input_pos": 1,
+ "op" : "_OP_",
+ "fp_special_info": {
+ "start_idx": _START_
+ }
+ }
+ }
+ })";
+
+ const std::string tosaName0 = "input0";
+ const std::string tosaName1 = "input1";
+ const size_t tosaElements = 5 * 6 * 7;
+
+ SUBCASE("equal, input 0")
+ {
+ std::vector<uint32_t> expected = { 0x0, 0x7F800000, 0x0 };
+ fp_special_test_FP32(tosaName0, tosaElements, templateJsonCfg, "EQUAL", "0", expected);
+ }
+ SUBCASE("equal, input 1")
+ {
+ std::vector<uint32_t> expected = { 0x80000000, 0xFF800000, 0x80000000 };
+ fp_special_test_FP32(tosaName1, tosaElements, templateJsonCfg, "EQUAL", "0", expected);
+ }
+ SUBCASE("greater, input 0")
+ {
+ std::vector<uint32_t> expected = { 0x0, 0x7F800000, 0x0 };
+ fp_special_test_FP32(tosaName0, tosaElements, templateJsonCfg, "GREATER", "0", expected);
+ }
+ SUBCASE("greater, input 1")
+ {
+ std::vector<uint32_t> expected = { 0x80000000, 0xFF800000, 0x80000000 };
+ fp_special_test_FP32(tosaName1, tosaElements, templateJsonCfg, "GREATER", "0", expected);
+ }
+ SUBCASE("add, input 0")
+ {
+ std::vector<uint32_t> expected = { 0x7F7FFFFF, 0x7F800000, 0x7F7FFFFF };
+ fp_special_test_FP32(tosaName0, tosaElements, templateJsonCfg, "ADD", "0", expected);
+ }
+ SUBCASE("add, input 1")
+ {
+ std::vector<uint32_t> expected = { 0x3F800000, 0xFF800000, 0x3F800000 };
+ fp_special_test_FP32(tosaName1, tosaElements, templateJsonCfg, "ADD", "0", expected);
+ }
+ SUBCASE("maximum, input 0")
+ {
+ std::vector<uint32_t> expected = { 0x0, 0x80000000, 0x7F800000 };
+ fp_special_test_FP32(tosaName0, tosaElements, templateJsonCfg, "MAXIMUM", "0", expected);
+ }
+ SUBCASE("maximum, input 1")
+ {
+ std::vector<uint32_t> expected = { 0x0, 0x80000000, 0x7F800000 };
+ fp_special_test_FP32(tosaName1, tosaElements, templateJsonCfg, "MAXIMUM", "0", expected);
+ }
+ SUBCASE("maximum, startIndex 100")
+ {
+ // A startIndex of 100 creates an offset of 2 in the MAXIMUM op's test data (size: 7) 100 % 7 = 2
+ std::vector<uint32_t> expected = { 0x7F800000, 0xFF800000, 0x7FC00000 };
+ fp_special_test_FP32(tosaName0, tosaElements, templateJsonCfg, "MAXIMUM", "100", expected);
+ }
+}
+
TEST_SUITE_END(); // generate
diff --git a/scripts/schemavalidation/datagen-config.schema.json b/scripts/schemavalidation/datagen-config.schema.json
index 19e8b62..6046873 100644
--- a/scripts/schemavalidation/datagen-config.schema.json
+++ b/scripts/schemavalidation/datagen-config.schema.json
@@ -22,7 +22,7 @@
"type": "object",
"properties": {
"generator": {
- "description": "data generator name - PSEUDO_RANDOM, DOT_PRODUCT, FULL_RANGE, BOUNDARY, or SPECIAL",
+ "description": "data generator name - PSEUDO_RANDOM, DOT_PRODUCT, FULL_RANGE, BOUNDARY, or FP_SPECIAL",
"type": "string"
},
"data_type": {
@@ -134,6 +134,20 @@
"additionalProperties": false,
"required": [ ]
},
+ "fp_special_info": {
+ "description": "info required for the FP_SPECIAL generator",
+ "type": "object",
+ "properties":
+ {
+ "start_idx": {
+ "description": "starting index for the test data",
+ "type": "integer",
+ "minimum": 0
+ }
+ },
+ "additionalProperties": false,
+ "required": [ ]
+ },
"fixed_data_info": {
"description": "info required for FIXED_DATA generator",
"type": "object",
diff --git a/verif/conformance/test_select.py b/verif/conformance/test_select.py
index e3a8ffb..e3f1738 100644
--- a/verif/conformance/test_select.py
+++ b/verif/conformance/test_select.py
@@ -259,9 +259,9 @@
negative and "ERRORIF" in str(path)
):
# Check for test set paths
- match = re.match(r"(.*)_(s[0-9]+|full)", path.name)
+ match = re.match(r"(.*)_(s[0-9]+|full|fs)", path.name)
if match:
- if match.group(2) in ["s0", "full"]:
+ if match.group(2) in ["s0", "full", "fs"]:
# Only return the truncated test name
# of the first test of a set, and for full tests
yield path.with_name(match.group(1))
@@ -317,7 +317,7 @@
def _get_extra_test_paths(path):
"""Expand a path to find extra tests."""
paths = []
- for suffix in ["full"]:
+ for suffix in ["full", "fs"]:
suffix_path = path.with_name(f"{path.name}_{suffix}")
if suffix_path.exists():
paths.append(suffix_path)
diff --git a/verif/generator/tosa_arg_gen.py b/verif/generator/tosa_arg_gen.py
index 8d6c8d7..5957a33 100644
--- a/verif/generator/tosa_arg_gen.py
+++ b/verif/generator/tosa_arg_gen.py
@@ -264,6 +264,9 @@
return [[]] * num_shapes
shape = testGen.makeShape(rng, rank)
+ # Do not broadcast for some tests
+ if error_name is None and rng.randInt(high=100) < 10:
+ return [shape] * num_shapes
shape_list = []
# Choose any one of the inputs to broadcast
@@ -785,6 +788,10 @@
"tensors": {},
}
dg_tens_meta = tens_data["tensors"]
+
+ fp_special_info = {}
+ fp_special_info["start_idx"] = int(rng.randInt())
+
for idx, shape in enumerate(shapeList):
tens_meta = {}
@@ -858,6 +865,8 @@
rng.randInt(0, gtu.DTYPE_ATTRIBUTES[dtypeList[idx]]["fullset"])
)
tens_meta["full_range_info"] = info
+ elif dg_type == gtu.DataGenType.FP_SPECIAL:
+ tens_meta["fp_special_info"] = fp_special_info
else:
# TODO - other data gen type
assert False, "TODO: support other data gen types"
@@ -1862,16 +1871,12 @@
for dg_type in dataGenTypesList:
for arg_str, args_dict in arg_list:
gen_args_dict = args_dict.copy()
+ # Only create one test by default - no sets of tests
+ num_test_sets = 0
+
if dg_type == gtu.DataGenType.PSEUDO_RANDOM:
if error_name is None:
- num_test_sets = (
- args_dict["num_test_sets"]
- if "num_test_sets" in args_dict
- else 0
- )
- else:
- # Add single test for pseudo random
- num_test_sets = 0
+ num_test_sets = args_dict.get("num_test_sets", 0)
elif dg_type == gtu.DataGenType.DOT_PRODUCT:
# Extra tests for each dot product test set
@@ -1900,13 +1905,23 @@
f"Skipping {opName}{shape_info} as tensor data size too small for full range of values {tensor_size} < {gtu.DTYPE_ATTRIBUTES[dtype]['fullset']}"
)
continue
- # Large enough tensor data size for full range, add a single test
- num_test_sets = 0
+ # Large enough tensor data size for full range, add full test
arg_str = f"{arg_str}_full" if arg_str else "full"
gen_args_dict["tags"] = args_dict.get("tags", []) + [
"non_finite_fp_data"
]
+ elif dg_type == gtu.DataGenType.FP_SPECIAL:
+ shapes_set = {tuple(x) for x in shapeList}
+ if len(shapes_set) != 1:
+ logger.info(
+ f"Changing {opName} input shapes {shapes_set} - broadcasting incompatable with special test"
+ )
+ shapeList = [np.int32(np.broadcast_shapes(*shapeList))] * len(
+ shapeList
+ )
+ arg_str = f"{arg_str}_fs" if arg_str else "fs"
+
gen_args_dict["dg_type"] = dg_type
if num_test_sets > 0:
for s in range(0, num_test_sets):
diff --git a/verif/generator/tosa_test_gen.py b/verif/generator/tosa_test_gen.py
index 38ab3f4..40788a2 100644
--- a/verif/generator/tosa_test_gen.py
+++ b/verif/generator/tosa_test_gen.py
@@ -268,7 +268,7 @@
if "ksb" in argsDict
else int(argsDict["ks"]),
}
- elif argsDict["dg_type"] == gtu.DataGenType.SPECIAL:
+ elif argsDict["dg_type"] == gtu.DataGenType.FP_SPECIAL:
mode = gtu.ComplianceMode.FP_SPECIAL
elif "compliance" in op and "ulp" in op["compliance"]:
mode = gtu.ComplianceMode.ULP
@@ -3352,7 +3352,11 @@
DType.FP32: (gtu.DataGenType.DOT_PRODUCT,),
}
EW_UNARY_DATAGEN = {
- DType.FP16: (gtu.DataGenType.PSEUDO_RANDOM, gtu.DataGenType.FULL_RANGE)
+ DType.FP16: (gtu.DataGenType.PSEUDO_RANDOM, gtu.DataGenType.FULL_RANGE),
+ }
+ PR_FS_DATAGEN = {
+ DType.FP16: (gtu.DataGenType.PSEUDO_RANDOM, gtu.DataGenType.FP_SPECIAL),
+ DType.FP32: (gtu.DataGenType.PSEUDO_RANDOM, gtu.DataGenType.FP_SPECIAL),
}
TOSA_OP_LIST = {
@@ -3716,7 +3720,7 @@
TosaErrorValidator.evDimensionMismatch,
TosaErrorValidator.evBroadcastShapesMismatch,
),
- "data_gen": PSEUDO_RANDOM_DATAGEN,
+ "data_gen": PR_FS_DATAGEN,
"compliance": {"ulp": 0.5},
},
"arithmetic_right_shift": {
@@ -3938,7 +3942,7 @@
TosaErrorValidator.evDimensionMismatch,
TosaErrorValidator.evBroadcastShapesMismatch,
),
- "data_gen": PSEUDO_RANDOM_DATAGEN,
+ "data_gen": PR_FS_DATAGEN,
},
"minimum": {
"op": Op.MINIMUM,
@@ -4330,7 +4334,7 @@
TosaErrorValidator.evDimensionMismatch,
TosaErrorValidator.evBroadcastShapesMismatch,
),
- "data_gen": PSEUDO_RANDOM_DATAGEN,
+ "data_gen": PR_FS_DATAGEN,
},
"greater_equal": {
"op": Op.GREATER_EQUAL,
@@ -4351,7 +4355,7 @@
TosaErrorValidator.evDimensionMismatch,
TosaErrorValidator.evBroadcastShapesMismatch,
),
- "data_gen": PSEUDO_RANDOM_DATAGEN,
+ "data_gen": PR_FS_DATAGEN,
},
"greater": {
"op": Op.GREATER,
@@ -4372,7 +4376,7 @@
TosaErrorValidator.evDimensionMismatch,
TosaErrorValidator.evBroadcastShapesMismatch,
),
- "data_gen": PSEUDO_RANDOM_DATAGEN,
+ "data_gen": PR_FS_DATAGEN,
},
# Reduction operators
"reduce_all": {
diff --git a/verif/generator/tosa_utils.py b/verif/generator/tosa_utils.py
index a8e321e..478190d 100644
--- a/verif/generator/tosa_utils.py
+++ b/verif/generator/tosa_utils.py
@@ -55,7 +55,7 @@
DOT_PRODUCT = 1
BOUNDARY = 2
FULL_RANGE = 3
- SPECIAL = 4
+ FP_SPECIAL = 4
FIXED_DATA = 5
diff --git a/verif/tests/test_tosa_refmodel.py b/verif/tests/test_tosa_refmodel.py
index 24ee9e2..bb52a86 100644
--- a/verif/tests/test_tosa_refmodel.py
+++ b/verif/tests/test_tosa_refmodel.py
@@ -1,5 +1,5 @@
"""Tests for tosa_reference_model."""
-# Copyright (c) 2022-2023, ARM Limited.
+# Copyright (c) 2022-2024, ARM Limited.
# SPDX-License-Identifier: Apache-2.0
import json
import re
@@ -134,9 +134,10 @@
# Tests - op_name, ref_model_type, num_expected_tests
+# FP Special datagen adds a second expected test to FP16 and FP32 tests for OPs it is added to
TEST_PARAMS = [
("add", "int32", 1),
- ("add", "fp32", 1),
+ ("add", "fp32", 2),
("abs", "int32", 1),
("abs", "fp32", 1),
("abs", "fp16", 1),
@@ -223,13 +224,20 @@
assert const_file.is_file()
consts.append(np.load(str(const_file)))
+ # Check if the data is from FP special datagen which can give invalid results
+ fp_special_data = test_dir.match("*_fs")
+
# Perform Numpy operation
if op_name == "abs":
assert len(tensors) == 1
result = np.abs(tensors[0])
elif op_name == "add":
assert len(tensors) == 2
- result = np.add(tensors[0], tensors[1])
+ if fp_special_data:
+ with np.errstate(invalid="ignore"):
+ result = np.add(tensors[0], tensors[1])
+ else:
+ result = np.add(tensors[0], tensors[1])
elif op_name == "concat":
assert len(consts) == 1
# Get axis from test directory name