| #ifndef _MATRIX_TEMPLATES_H_ |
| #define _MATRIX_TEMPLATES_H_ |
| |
| /*--------------------------------------------------------------------------------*/ |
| /* Includes */ |
| /*--------------------------------------------------------------------------------*/ |
| #include "test_templates.h" |
| |
| /*--------------------------------------------------------------------------------*/ |
| /* Group Specific Templates */ |
| /*--------------------------------------------------------------------------------*/ |
| |
| /** |
| * Compare the outputs from the function under test and the reference |
| * function. |
| */ |
| #define MATRIX_COMPARE_INTERFACE(output_type, output_content_type) \ |
| TEST_ASSERT_BUFFERS_EQUAL( \ |
| ((output_type *) &matrix_output_ref)->pData, \ |
| ((output_type *) &matrix_output_fut)->pData, \ |
| ((output_type *) &matrix_output_fut)->numRows * \ |
| ((output_type *) &matrix_output_ref)->numCols * \ |
| sizeof(output_content_type)) |
| |
| /** |
| * Comparison SNR thresholds for the data types used in matrix_tests. |
| */ |
| #define MATRIX_SNR_THRESHOLD 120 |
| |
| /** |
| * Compare the outputs from the function under test and the reference |
| * function using SNR. |
| */ |
| #define MATRIX_SNR_COMPARE_INTERFACE(output_type, output_content_type) \ |
| do \ |
| { \ |
| TEST_CONVERT_AND_ASSERT_SNR( \ |
| (float32_t *)matrix_output_f32_ref, \ |
| ((output_type *) &matrix_output_ref)->pData, \ |
| (float32_t *)matrix_output_f32_fut, \ |
| ((output_type *) &matrix_output_ref)->pData, \ |
| ((output_type *) &matrix_output_fut)->numRows * \ |
| ((output_type *) &matrix_output_ref)->numCols, \ |
| output_content_type, \ |
| MATRIX_SNR_THRESHOLD \ |
| ); \ |
| } while (0) |
| |
| /** |
| * Compare the outputs from the function under test and the reference |
| * function using SNR. This is special for float64_t |
| */ |
| #define MATRIX_DBL_SNR_COMPARE_INTERFACE(output_type) \ |
| do \ |
| { \ |
| TEST_ASSERT_DBL_SNR( \ |
| (float64_t *)matrix_output_f32_ref, \ |
| (float64_t *)matrix_output_f32_fut, \ |
| ((output_type *) &matrix_output_fut)->numRows * \ |
| ((output_type *) &matrix_output_ref)->numCols, \ |
| MATRIX_SNR_THRESHOLD \ |
| ); \ |
| } while (0) |
| |
| /*--------------------------------------------------------------------------------*/ |
| /* Input Interfaces */ |
| /*--------------------------------------------------------------------------------*/ |
| /* |
| * General: |
| * Input interfaces provide inputs to functions inside test templates. They |
| * ONLY provide the inputs. The output variables should be hard coded. |
| * |
| * The input interfaces must have the following format: |
| * |
| * ARM_xxx_INPUT_INTERFACE() or |
| * REF_xxx_INPUT_INTERFACE() |
| * |
| * The xxx must be lowercase, and is intended to be the indentifying substring |
| * in the function's name. Acceptable values are 'sub' or 'add' from the |
| * functions arm_add_q31. |
| */ |
| |
| #define ARM_mat_add_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \ |
| PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut) |
| |
| #define REF_mat_add_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \ |
| PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref) |
| |
| #define ARM_mat_cmplx_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \ |
| PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut) |
| |
| #define REF_mat_cmplx_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \ |
| PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref) |
| |
| #define ARM_mat_inverse_INPUT_INTERFACE(input_ptr) \ |
| PAREN(input_ptr, (void *) &matrix_output_fut) |
| |
| #define REF_mat_inverse_INPUT_INTERFACE(input_ptr) \ |
| PAREN(input_ptr, (void *) &matrix_output_ref) |
| |
| #define ARM_mat_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \ |
| PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut) |
| |
| #define REF_mat_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \ |
| PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref) |
| |
| #define ARM_mat_mult_fast_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \ |
| PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut) |
| |
| #define REF_mat_mult_fast_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \ |
| PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref) |
| |
| #define ARM_mat_sub_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \ |
| PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut) |
| |
| #define REF_mat_sub_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \ |
| PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref) |
| |
| #define ARM_mat_trans_INPUT_INTERFACE(input_ptr) \ |
| PAREN(input_ptr, (void *) &matrix_output_fut) |
| |
| #define REF_mat_trans_INPUT_INTERFACE(input_ptr) \ |
| PAREN(input_ptr, (void *) &matrix_output_ref) |
| |
| /*--------------------------------------------------------------------------------*/ |
| /* Dimension Validation Interfaces */ |
| /*--------------------------------------------------------------------------------*/ |
| |
| #define MATRIX_TEST_VALID_ADDITIVE_DIMENSIONS(input_type, \ |
| matrix_a_ptr, \ |
| matrix_b_ptr) \ |
| ((((input_type) (matrix_a_ptr))->numRows == \ |
| ((input_type) (matrix_b_ptr))->numRows) && \ |
| (((input_type) (matrix_a_ptr))->numCols == \ |
| ((input_type) (matrix_b_ptr))->numCols)) |
| |
| #define MATRIX_TEST_VALID_MULTIPLICATIVE_DIMENSIONS(input_type, \ |
| matrix_a_ptr, \ |
| matrix_b_ptr) \ |
| (((input_type) (matrix_a_ptr))->numCols == \ |
| ((input_type) (matrix_b_ptr))->numRows) |
| |
| #define MATRIX_TEST_VALID_SQUARE_DIMENSIONS(input_type, \ |
| matrix_ptr) \ |
| (((input_type)(matrix_ptr))->numRows == \ |
| ((input_type)(matrix_ptr))->numCols) |
| |
| #define MATRIX_TEST_VALID_DIMENSIONS_ALWAYS(input_type, \ |
| matrix_ptr) \ |
| (1 == 1) \ |
| |
| /*--------------------------------------------------------------------------------*/ |
| /* Output Configuration Interfaces */ |
| /*--------------------------------------------------------------------------------*/ |
| /* The matrix tests assume the output matrix is always the correct size. These |
| * interfaces size the properly size the output matrices according to the input |
| * matrices and the operation at hand.*/ |
| |
| #define MATRIX_TEST_CONFIG_ADDITIVE_OUTPUT(input_type, \ |
| matrix_a_ptr, \ |
| matrix_b_ptr) \ |
| do \ |
| { \ |
| ((input_type) &matrix_output_fut)->numRows = \ |
| ((input_type)(matrix_a_ptr))->numRows; \ |
| ((input_type) &matrix_output_fut)->numCols = \ |
| ((input_type)(matrix_a_ptr))->numCols; \ |
| ((input_type) &matrix_output_ref)->numRows = \ |
| ((input_type)(matrix_a_ptr))->numRows; \ |
| ((input_type) &matrix_output_ref)->numCols = \ |
| ((input_type)(matrix_a_ptr))->numCols; \ |
| } while (0) |
| |
| #define MATRIX_TEST_CONFIG_MULTIPLICATIVE_OUTPUT(input_type, \ |
| matrix_a_ptr, \ |
| matrix_b_ptr) \ |
| do \ |
| { \ |
| ((input_type) &matrix_output_fut)->numRows = \ |
| ((input_type)(matrix_a_ptr))->numRows; \ |
| ((input_type) &matrix_output_fut)->numCols = \ |
| ((input_type)(matrix_b_ptr))->numCols; \ |
| ((input_type) &matrix_output_ref)->numRows = \ |
| ((input_type)(matrix_a_ptr))->numRows; \ |
| ((input_type) &matrix_output_ref)->numCols = \ |
| ((input_type)(matrix_b_ptr))->numCols; \ |
| } while (0) |
| |
| #define MATRIX_TEST_CONFIG_SAMESIZE_OUTPUT(input_type, \ |
| matrix_ptr) \ |
| do \ |
| { \ |
| ((input_type) &matrix_output_fut)->numRows = \ |
| ((input_type)(matrix_ptr))->numRows; \ |
| ((input_type) &matrix_output_fut)->numCols = \ |
| ((input_type)(matrix_ptr))->numCols; \ |
| ((input_type) &matrix_output_ref)->numRows = \ |
| ((input_type)(matrix_ptr))->numRows; \ |
| ((input_type) &matrix_output_ref)->numCols = \ |
| ((input_type)(matrix_ptr))->numCols; \ |
| } while (0) |
| |
| #define MATRIX_TEST_CONFIG_TRANSPOSE_OUTPUT(input_type, \ |
| matrix_ptr) \ |
| do \ |
| { \ |
| ((input_type) &matrix_output_fut)->numRows = \ |
| ((input_type)(matrix_ptr))->numCols; \ |
| ((input_type) &matrix_output_fut)->numCols = \ |
| ((input_type)(matrix_ptr))->numRows; \ |
| ((input_type) &matrix_output_ref)->numRows = \ |
| ((input_type)(matrix_ptr))->numCols; \ |
| ((input_type) &matrix_output_ref)->numCols = \ |
| ((input_type)(matrix_ptr))->numRows; \ |
| } while (0) |
| |
| /*--------------------------------------------------------------------------------*/ |
| /* TEST Templates */ |
| /*--------------------------------------------------------------------------------*/ |
| |
| #define MATRIX_TEST_TEMPLATE_ELT1(arr_desc_inputs, \ |
| input_type, \ |
| output_type, output_content_type, \ |
| fut, fut_arg_interface, \ |
| ref, ref_arg_interface, \ |
| output_config_interface, \ |
| dim_validation_interface, \ |
| compare_interface) \ |
| do \ |
| { \ |
| TEMPLATE_DO_ARR_DESC( \ |
| input_idx, input_type, input, arr_desc_inputs \ |
| , \ |
| JTEST_DUMP_STRF("Matrix Dimensions: %dx%d\n", \ |
| (int)input->numRows, \ |
| (int)input->numCols); \ |
| \ |
| if (dim_validation_interface(input_type, \ |
| input)) { \ |
| output_config_interface(input_type, \ |
| input); \ |
| TEST_CALL_FUT_AND_REF( \ |
| fut, fut_arg_interface(input), \ |
| ref, ref_arg_interface(input)); \ |
| compare_interface(output_type, \ |
| output_content_type); \ |
| } else { \ |
| arm_status matrix_test_retval; \ |
| TEST_CALL_FUT( \ |
| matrix_test_retval = fut, \ |
| fut_arg_interface(input)); \ |
| \ |
| /* If dimensions are known bad, the fut should */ \ |
| /* detect it. */ \ |
| if ( matrix_test_retval != ARM_MATH_SIZE_MISMATCH) { \ |
| return JTEST_TEST_FAILED; \ |
| } \ |
| }); \ |
| return JTEST_TEST_PASSED; \ |
| } while (0) |
| |
| |
| #define MATRIX_TEST_TEMPLATE_ELT2(arr_desc_inputs_a, \ |
| arr_desc_inputs_b, \ |
| input_type, \ |
| output_type, output_content_type, \ |
| fut, fut_arg_interface, \ |
| ref, ref_arg_interface, \ |
| output_config_interface, \ |
| dim_validation_interface, \ |
| compare_interface) \ |
| do \ |
| { \ |
| TEMPLATE_DO_ARR_DESC( \ |
| input_a_idx, input_type, input_a, arr_desc_inputs_a \ |
| , \ |
| input_type input_b = ARR_DESC_ELT( \ |
| input_type, input_a_idx, \ |
| &(arr_desc_inputs_b)); \ |
| \ |
| JTEST_DUMP_STRF("Matrix Dimensions: A %dx%d B %dx%d\n", \ |
| (int)input_a->numRows, \ |
| (int)input_a->numCols, \ |
| (int)input_b->numRows, \ |
| (int)input_b->numCols); \ |
| \ |
| if (dim_validation_interface(input_type, \ |
| input_a, \ |
| input_b)) { \ |
| \ |
| output_config_interface(input_type, \ |
| input_a, \ |
| input_b); \ |
| \ |
| TEST_CALL_FUT_AND_REF( \ |
| fut, fut_arg_interface(input_a, input_b), \ |
| ref, ref_arg_interface(input_a, input_b)); \ |
| \ |
| compare_interface(output_type, output_content_type); \ |
| \ |
| } else { \ |
| arm_status matrix_test_retval; \ |
| TEST_CALL_FUT( \ |
| matrix_test_retval = fut, fut_arg_interface(input_a, input_b)); \ |
| \ |
| /* If dimensions are known bad, the fut should */ \ |
| /* detect it. */ \ |
| if ( matrix_test_retval != ARM_MATH_SIZE_MISMATCH) { \ |
| return JTEST_TEST_FAILED; \ |
| } \ |
| }); \ |
| return JTEST_TEST_PASSED; \ |
| } while (0) |
| |
| /** |
| * Specialization of #MATRIX_TEST_TEMPLATE_ELT2() for matrix tests. |
| * |
| * @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and |
| * REF_xxx_INPUT_INTERFACEs. |
| */ |
| #define MATRIX_DEFINE_TEST_TEMPLATE_ELT2(fn_name, suffix, \ |
| output_config_interface, \ |
| dim_validation_interface, \ |
| comparison_interface) \ |
| JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \ |
| arm_##fn_name##_##suffix) \ |
| { \ |
| MATRIX_TEST_TEMPLATE_ELT2( \ |
| matrix_##suffix##_a_inputs, \ |
| matrix_##suffix##_b_inputs, \ |
| arm_matrix_instance_##suffix * , \ |
| arm_matrix_instance_##suffix, \ |
| TYPE_FROM_ABBREV(suffix), \ |
| arm_##fn_name##_##suffix, \ |
| ARM_##fn_name##_INPUT_INTERFACE, \ |
| ref_##fn_name##_##suffix, \ |
| REF_##fn_name##_INPUT_INTERFACE, \ |
| output_config_interface, \ |
| dim_validation_interface, \ |
| comparison_interface); \ |
| } \ |
| |
| /** |
| * Specialization of #MATRIX_TEST_TEMPLATE_ELT1() for matrix tests. |
| * |
| * @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and |
| * REF_xxx_INPUT_INTERFACEs. |
| */ |
| #define MATRIX_DEFINE_TEST_TEMPLATE_ELT1(fn_name, suffix, \ |
| output_config_interface, \ |
| dim_validation_interface) \ |
| JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \ |
| arm_##fn_name##_##suffix) \ |
| { \ |
| MATRIX_TEST_TEMPLATE_ELT1( \ |
| matrix_##suffix##_a_inputs, \ |
| arm_matrix_instance_##suffix * , \ |
| arm_matrix_instance_##suffix, \ |
| TYPE_FROM_ABBREV(suffix), \ |
| arm_##fn_name##_##suffix, \ |
| ARM_##fn_name##_INPUT_INTERFACE, \ |
| ref_##fn_name##_##suffix, \ |
| REF_##fn_name##_INPUT_INTERFACE, \ |
| output_config_interface, \ |
| dim_validation_interface, \ |
| MATRIX_COMPARE_INTERFACE); \ |
| } \ |
| |
| |
| #endif /* _MATRIX_TEMPLATES_H_ */ |
