| /* Copyright 2021 The TensorFlow Authors. All Rights Reserved. |
| |
| 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 <cstdint> |
| #include <cstring> |
| |
| #include "signal/micro/kernels/delay_flexbuffers_generated_data.h" |
| #include "tensorflow/lite/micro/kernels/kernel_runner.h" |
| #include "tensorflow/lite/micro/test_helpers.h" |
| #include "tensorflow/lite/micro/testing/micro_test.h" |
| |
| namespace tflite { |
| namespace { |
| |
| constexpr int kInputsSize = 1; |
| constexpr int kOutputsSize = 1; |
| constexpr int kTensorsSize = kInputsSize + kOutputsSize; |
| |
| class DelayKernelRunner { |
| public: |
| DelayKernelRunner(int* input_dims_data, int16_t* input_data, |
| int* output_dims_data, int16_t* output_data) |
| : tensors_{testing::CreateTensor( |
| input_data, testing::IntArrayFromInts(input_dims_data)), |
| testing::CreateTensor( |
| output_data, testing::IntArrayFromInts(output_dims_data))}, |
| inputs_array_{testing::IntArrayFromInts(inputs_array_data_)}, |
| outputs_array_{testing::IntArrayFromInts(outputs_array_data_)}, |
| kernel_runner_{*registration_, tensors_, kTensorsSize, |
| inputs_array_, outputs_array_, nullptr} {} |
| |
| micro::KernelRunner& kernel_runner() { return kernel_runner_; } |
| |
| private: |
| int inputs_array_data_[kInputsSize + 1] = {kInputsSize, 0}; |
| int outputs_array_data_[kOutputsSize + 1] = {kOutputsSize, 1}; |
| TfLiteTensor tensors_[kTensorsSize] = {}; |
| TfLiteIntArray* inputs_array_ = nullptr; |
| TfLiteIntArray* outputs_array_ = nullptr; |
| |
| TFLMRegistration* registration_ = tflm_signal::Register_DELAY(); |
| micro::KernelRunner kernel_runner_; |
| }; |
| |
| void TestDelayInvoke(const int16_t* input_data, int16_t* output_data, |
| const int16_t* golden, int input_size, int input_num, |
| micro::KernelRunner* runner, int16_t* input_buffer) { |
| for (int i = 0; i < input_num; i++) { |
| memcpy(input_buffer, &input_data[i * input_size], |
| sizeof(input_data[0]) * input_size); |
| TF_LITE_MICRO_EXPECT_EQ(runner->Invoke(), kTfLiteOk); |
| for (int j = 0; j < input_size; ++j) { |
| TF_LITE_MICRO_EXPECT_EQ(golden[i * input_size + j], output_data[j]); |
| } |
| } |
| } |
| |
| void TestDelay(int* input_dims_data, const int16_t* input_data, |
| int* output_dims_data, int16_t* output_data, |
| const int16_t* golden, int input_size, int input_num, |
| const unsigned char* flexbuffers_data, |
| const unsigned int flexbuffers_data_size, |
| int16_t* input_buffer) { |
| DelayKernelRunner delay_runner(input_dims_data, input_buffer, |
| output_dims_data, output_data); |
| |
| // TfLite uses a char* for the raw bytes whereas flexbuffers use an unsigned |
| // char*. This small discrepancy results in compiler warnings unless we |
| // reinterpret_cast right before passing in the flexbuffer bytes to the |
| // KernelRunner. |
| TF_LITE_MICRO_EXPECT_EQ(delay_runner.kernel_runner().InitAndPrepare( |
| reinterpret_cast<const char*>(flexbuffers_data), |
| flexbuffers_data_size), |
| kTfLiteOk); |
| TestDelayInvoke(input_data, output_data, golden, input_size, input_num, |
| &delay_runner.kernel_runner(), input_buffer); |
| } |
| // TestDelayReset() runs a test with the given inputs twice with a reset with |
| // the main purpose of testing the Delay's Reset functionality. If you just |
| // want to make sure Delay's Op output matches a set of golden values for an |
| // input use TestDelay() instead. |
| void TestDelayReset(int* input_dims_data, const int16_t* input_data, |
| int* output_dims_data, int16_t* output_data, |
| const int16_t* golden, int input_size, int input_num, |
| const unsigned char* flexbuffers_data, |
| const unsigned int flexbuffers_data_size, |
| int16_t* input_buffer) { |
| DelayKernelRunner delay_runner(input_dims_data, input_buffer, |
| output_dims_data, output_data); |
| |
| // TfLite uses a char* for the raw bytes whereas flexbuffers use an unsigned |
| // char*. This small discrepancy results in compiler warnings unless we |
| // reinterpret_cast right before passing in the flexbuffer bytes to the |
| // KernelRunner. |
| TF_LITE_MICRO_EXPECT_EQ(delay_runner.kernel_runner().InitAndPrepare( |
| reinterpret_cast<const char*>(flexbuffers_data), |
| flexbuffers_data_size), |
| kTfLiteOk); |
| TestDelayInvoke(input_data, output_data, golden, input_size, input_num, |
| &delay_runner.kernel_runner(), input_buffer); |
| delay_runner.kernel_runner().Reset(); |
| TestDelayInvoke(input_data, output_data, golden, input_size, input_num, |
| &delay_runner.kernel_runner(), input_buffer); |
| } |
| |
| } // namespace |
| } // namespace tflite |
| |
| TF_LITE_MICRO_TESTS_BEGIN |
| |
| TF_LITE_MICRO_TEST(DelayTestSingleDimDelayLessThanFrameSize) { |
| const int kInputSize = 8; |
| const int kInputNum = 2; |
| int input_shape[] = {1, kInputSize}; |
| int output_shape[] = {1, kInputSize}; |
| // The buffer that gets passed to the model. |
| int16_t input_buffer[kInputSize]; |
| // The input data. Gets copied to input_buffer kInputNum times. |
| const int16_t input[kInputNum * kInputSize] = { |
| 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, |
| }; |
| int16_t output[kInputNum * kInputSize] = {0}; |
| const int16_t golden[kInputNum * kInputSize] = {0x0, 0x0, 0x0, 0x1, 0x2, 0x3, |
| 0x4, 0x5, 0x6, 0x7, 0x8, 0x0, |
| 0x0, 0x0, 0x0, 0x0}; |
| tflite::TestDelay(input_shape, input, output_shape, output, golden, |
| kInputSize, kInputNum, g_gen_data_3_delay, |
| g_gen_data_size_3_delay, input_buffer); |
| } |
| |
| TF_LITE_MICRO_TEST(DelayTestSingleDimDelayGreaterThanFrameSize) { |
| const int kInputSize = 3; |
| const int kInputNum = 3; |
| int input_shape[] = {1, kInputSize}; |
| int output_shape[] = {1, kInputSize}; |
| // The buffer that gets passed to the model. |
| int16_t input_buffer[kInputSize]; |
| // The input data. Gets copied to input_buffer kInputNum times. |
| const int16_t input[kInputNum * kInputSize] = { |
| 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, |
| }; |
| int16_t output[kInputNum * kInputSize] = {0}; |
| const int16_t golden[kInputNum * kInputSize] = { |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, |
| }; |
| tflite::TestDelay(input_shape, input, output_shape, output, golden, |
| kInputSize, kInputNum, g_gen_data_5_delay, |
| g_gen_data_size_5_delay, input_buffer); |
| } |
| |
| TF_LITE_MICRO_TEST(DelayTestMultiDimDelayLessThanFrameSize) { |
| const int kInputSize = 16; |
| const int kInputNum = 2; |
| int input_shape[] = {2, 4, 4}; |
| int output_shape[] = {2, 4, 4}; |
| // The buffer that gets passed to the model. |
| int16_t input_buffer[kInputSize]; |
| // The op will be invoked 2 times (Input X, X=0,1) |
| // For each invocation, the input's shape is (4, 4) but flattened for clarity |
| // On each invocation, the input data is copied to input_buffer first. |
| const int16_t input[kInputNum * kInputSize] = { |
| 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, |
| 0xC, 0xD, 0xE, 0xF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, |
| }; |
| int16_t output[kInputNum * kInputSize] = {0}; |
| // For each invocation, we expect the following output (Output X, X=0,1) |
| // Each time, the output's shape is (4, 4) but flattened for clarity |
| const int16_t golden[kInputNum * kInputSize] = { |
| // Output 0 |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x1, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x5, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x9, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0xD, |
| // Output 1 |
| 0x2, |
| 0x3, |
| 0x4, |
| 0x0, |
| 0x6, |
| 0x7, |
| 0x8, |
| 0x0, |
| 0xA, |
| 0xB, |
| 0xC, |
| 0x0, |
| 0xE, |
| 0xF, |
| 0x0, |
| 0x0, |
| }; |
| tflite::TestDelay(input_shape, input, output_shape, output, golden, |
| kInputSize, kInputNum, g_gen_data_3_delay, |
| g_gen_data_size_3_delay, input_buffer); |
| } |
| |
| TF_LITE_MICRO_TEST(DelayTestMultiDimDelayGreaterThanFrameSize) { |
| const int kInputSize = 16; |
| const int kInputNum = 3; |
| int input_shape[] = {2, 4, 4}; |
| int output_shape[] = {2, 4, 4}; |
| // The buffer that gets passed to the model. |
| int16_t input_buffer[kInputSize]; |
| // The op will be invoked 3 times (Input X, X=0,1,2) |
| // For each invocation, the input's shape is (4, 4) but flattened for clarity |
| // On each invocation, the input data is copied to input_buffer first. |
| const int16_t input[kInputNum * kInputSize] = { |
| 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, 0xC, |
| 0xD, 0xE, 0xF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, |
| }; |
| int16_t output[kInputNum * kInputSize] = {0}; |
| // For each invocation, we expect the following output (Output X, X=0,1,2) |
| // Each time, the output's shape is (4, 4) but flattened for clarity |
| const int16_t golden[kInputNum * kInputSize] = { |
| // Output 0 |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| // Output 1 |
| 0x0, |
| 0x1, |
| 0x2, |
| 0x3, |
| 0x0, |
| 0x5, |
| 0x6, |
| 0x7, |
| 0x0, |
| 0x9, |
| 0xA, |
| 0xB, |
| 0x0, |
| 0xD, |
| 0xE, |
| 0xF, |
| // Output 2 |
| 0x4, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x8, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0xC, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| 0x0, |
| }; |
| tflite::TestDelay(input_shape, input, output_shape, output, golden, |
| kInputSize, kInputNum, g_gen_data_5_delay, |
| g_gen_data_size_5_delay, input_buffer); |
| } |
| |
| TF_LITE_MICRO_TEST(DelayTestResetSingleDimDelayLessThanFrameSize) { |
| const int kInputSize = 8; |
| const int kInputNum = 2; |
| int input_shape[] = {1, kInputSize}; |
| int output_shape[] = {1, kInputSize}; |
| // The buffer that gets passed to the model. |
| int16_t input_buffer[kInputSize]; |
| // The input data. Gets copied to input_buffer kInputNum times. |
| const int16_t input[kInputNum * kInputSize] = { |
| 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, |
| }; |
| int16_t output[kInputNum * kInputSize] = {0}; |
| const int16_t golden[kInputNum * kInputSize] = {0x0, 0x0, 0x0, 0x1, 0x2, 0x3, |
| 0x4, 0x5, 0x6, 0x7, 0x8, 0x0, |
| 0x0, 0x0, 0x0, 0x0}; |
| tflite::TestDelayReset(input_shape, input, output_shape, output, golden, |
| kInputSize, kInputNum, g_gen_data_3_delay, |
| g_gen_data_size_3_delay, input_buffer); |
| } |
| |
| TF_LITE_MICRO_TEST(DelayTestResetSingleResetDimDelayGreaterThanFrameSize) { |
| const int kInputSize = 3; |
| const int kInputNum = 3; |
| int input_shape[] = {1, kInputSize}; |
| int output_shape[] = {1, kInputSize}; |
| // The buffer that gets passed to the model. |
| int16_t input_buffer[kInputSize]; |
| // The input data. Gets copied to input_buffer kInputNum times. |
| const int16_t input[kInputNum * kInputSize] = { |
| 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, |
| }; |
| int16_t output[kInputNum * kInputSize] = {0}; |
| const int16_t golden[kInputNum * kInputSize] = { |
| 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, |
| }; |
| tflite::TestDelayReset(input_shape, input, output_shape, output, golden, |
| kInputSize, kInputNum, g_gen_data_5_delay, |
| g_gen_data_size_5_delay, input_buffer); |
| } |
| |
| TF_LITE_MICRO_TESTS_END |
