1 // Copyright 2022 Google LLC 2 // 3 // This source code is licensed under the BSD-style license found in the 4 // LICENSE file in the root directory of this source tree. 5 6 #pragma once 7 8 #include <algorithm> 9 #include <array> 10 #include <functional> 11 #include <limits> 12 #include <memory> 13 #include <numeric> 14 #include <random> 15 #include <vector> 16 17 #include <xnnpack.h> 18 #include <xnnpack/node-type.h> 19 #include <xnnpack/operator.h> 20 #include <xnnpack/requantization.h> 21 #include <xnnpack/subgraph.h> 22 23 #include <gtest/gtest.h> 24 25 template <typename T> class BinaryTest : public ::testing::Test { 26 protected: BinaryTest()27 BinaryTest() 28 { 29 random_device = std::unique_ptr<std::random_device>(new std::random_device()); 30 rng = std::mt19937((*random_device)()); 31 shape_dist = std::uniform_int_distribution<size_t>(0, XNN_MAX_TENSOR_DIMS); 32 dim_dist = std::uniform_int_distribution<size_t>(1, 9); 33 f32dist = std::uniform_real_distribution<float>(0.01f, 1.0f); 34 i8dist = 35 std::uniform_int_distribution<int32_t>(std::numeric_limits<int8_t>::min(), std::numeric_limits<int8_t>::max()); 36 u8dist = 37 std::uniform_int_distribution<int32_t>(std::numeric_limits<uint8_t>::min(), std::numeric_limits<uint8_t>::max()); 38 scale_dist = std::uniform_real_distribution<float>(0.1f, 5.0f); 39 } 40 SetUp()41 void SetUp() override 42 { 43 std::vector<size_t> input1_shape = RandomShape(); 44 std::vector<size_t> input2_shape; 45 std::vector<size_t> output_shape; 46 // Create input dimensions. 47 // Create input 2 with an equal or larger number of dimensions. 48 const size_t input2_num_dims = std::uniform_int_distribution<size_t>(input1_shape.size(), XNN_MAX_TENSOR_DIMS)(rng); 49 input2_shape = RandomShape(input2_num_dims); 50 // Ensure that the inputs dimensions match. 51 std::copy_backward(input1_shape.begin(), input1_shape.end(), input2_shape.end()); 52 53 // Choose a random dimension to broadcast for each input. 54 const size_t input1_broadcast_dim = std::uniform_int_distribution<size_t>(0, input1_shape.size())(rng); 55 if (input1_broadcast_dim < input1_shape.size()) { 56 input1_shape[input1_broadcast_dim] = 1; 57 } 58 const size_t input2_broadcast_dim = std::uniform_int_distribution<size_t>(0, input2_shape.size())(rng); 59 if (input2_broadcast_dim < input2_shape.size()) { 60 input2_shape[input2_broadcast_dim] = 1; 61 } 62 // Calculate generalized shapes. 63 std::fill(input1_dims.begin(), input1_dims.end(), 1); 64 std::fill(input2_dims.begin(), input2_dims.end(), 1); 65 std::fill(output_dims.begin(), output_dims.end(), 1); 66 std::copy_backward(input1_shape.cbegin(), input1_shape.cend(), input1_dims.end()); 67 std::copy_backward(input2_shape.cbegin(), input2_shape.cend(), input2_dims.end()); 68 for (size_t i = 0; i < XNN_MAX_TENSOR_DIMS; i++) { 69 if (input1_dims[i] != 1 && input2_dims[i] != 1) { 70 ASSERT_EQ(input1_dims[i], input2_dims[i]) << "i: " << i; 71 } 72 output_dims[i] = std::max(input1_dims[i], input2_dims[i]); 73 } 74 75 input1 = std::vector<T>(XNN_EXTRA_BYTES / sizeof(T) + NumElements(input1_shape)); 76 input2 = std::vector<T>(XNN_EXTRA_BYTES / sizeof(T) + NumElements(input2_shape)); 77 operator_output = std::vector<T>(NumElements(output_dims)); 78 subgraph_output = std::vector<T>(operator_output.size()); 79 } 80 RandomShape(size_t num_dims)81 std::vector<size_t> RandomShape(size_t num_dims) 82 { 83 std::vector<size_t> dims(num_dims); 84 std::generate(dims.begin(), dims.end(), [&] { return dim_dist(rng); }); 85 return dims; 86 } 87 RandomShape()88 std::vector<size_t> RandomShape() { return RandomShape(shape_dist(rng)); } 89 NumElements(std::vector<size_t> & dims)90 size_t NumElements(std::vector<size_t>& dims) 91 { 92 return std::accumulate(dims.begin(), dims.end(), size_t(1), std::multiplies<size_t>()); 93 } 94 NumElements(std::array<size_t,XNN_MAX_TENSOR_DIMS> & dims)95 size_t NumElements(std::array<size_t, XNN_MAX_TENSOR_DIMS>& dims) 96 { 97 return std::accumulate(dims.begin(), dims.end(), size_t(1), std::multiplies<size_t>()); 98 } 99 100 std::unique_ptr<std::random_device> random_device; 101 std::mt19937 rng; 102 std::uniform_int_distribution<size_t> shape_dist; 103 std::uniform_int_distribution<size_t> dim_dist; 104 std::uniform_real_distribution<float> f32dist; 105 std::uniform_real_distribution<float> scale_dist; 106 std::uniform_int_distribution<int32_t> i8dist; 107 std::uniform_int_distribution<int32_t> u8dist; 108 109 float output_min = -std::numeric_limits<float>::infinity(); 110 float output_max = std::numeric_limits<float>::infinity(); 111 112 std::array<size_t, XNN_MAX_TENSOR_DIMS> input1_dims; 113 std::array<size_t, XNN_MAX_TENSOR_DIMS> input2_dims; 114 std::array<size_t, XNN_MAX_TENSOR_DIMS> output_dims; 115 116 std::vector<T> input1; 117 std::vector<T> input2; 118 std::vector<T> operator_output; 119 std::vector<T> subgraph_output; 120 }; 121