diff --git a/Source/QuaternionMathFunctions/arm_quaternion2rotation_f32.c b/Source/QuaternionMathFunctions/arm_quaternion2rotation_f32.c index 86e6fea0..9e9cfbce 100755 --- a/Source/QuaternionMathFunctions/arm_quaternion2rotation_f32.c +++ b/Source/QuaternionMathFunctions/arm_quaternion2rotation_f32.c @@ -71,6 +71,74 @@ Rotation matrix is saved in row order : R00 R01 R02 R10 R11 R12 R20 R21 R22 */ + +#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) + +#include "arm_helium_utils.h" + +void arm_quaternion2rotation_f32(const float32_t *pInputQuaternions, + float32_t *pOutputRotations, + uint32_t nbQuaternions) +{ + f32x4_t vec0,vec1, vec2 ,vec3; + float32_t q2q3, tmp1, tmp2 ; + + for(uint32_t nb=0; nb < nbQuaternions; nb++) + { + + // q0 q1 q2 q3 + vec0 = vld1q(pInputQuaternions); + + // q0^2 q1^2 q2^2 q3^2 + vec1 = vmulq(vec0,vec0); + + // q0^2 q1q0 q2q0 q3q0 + vec2 = vmulq_n_f32(vec0, vgetq_lane(vec0,0)); + + // 2 (q0^2 q1q0 q2q0 q3q0) + vec2 = vmulq_n_f32(vec2, 2.0f); + + + // 2 q2q3 + q2q3 = vgetq_lane(vec0,2) * vgetq_lane(vec0,3); + q2q3 = q2q3 * 2.0f; + + // 2 (q0q1 q1^2 q2q1 q3q1) + vec3 = vmulq_n_f32(vec0, vgetq_lane(vec0,1)); + vec3 = vmulq_n_f32(vec3, 2.0f); + + + + vec0 = vsetq_lane(vgetq_lane(vec1,0) + vgetq_lane(vec1,1),vec0,0); + vec0 = vsetq_lane(vgetq_lane(vec0,0) - vgetq_lane(vec1,2),vec0,0); + vec0 = vsetq_lane(vgetq_lane(vec0,0) - vgetq_lane(vec1,3),vec0,0); + vec0 = vsetq_lane(vgetq_lane(vec3,2) - vgetq_lane(vec2,3),vec0,1); + vec0 = vsetq_lane(vgetq_lane(vec3,3) + vgetq_lane(vec2,2),vec0,2); + vec0 = vsetq_lane(vgetq_lane(vec3,2) + vgetq_lane(vec2,3),vec0,3); + + vst1q(pOutputRotations, vec0); + pOutputRotations += 4; + + tmp1 = vgetq_lane(vec1,0) - vgetq_lane(vec1,1); + tmp2 = vgetq_lane(vec1,2) - vgetq_lane(vec1,3); + + + vec0 = vsetq_lane(tmp1 + tmp2,vec0,0); + vec0 = vsetq_lane(q2q3 - vgetq_lane(vec2,1) ,vec0,1); + vec0 = vsetq_lane(vgetq_lane(vec3,3) - vgetq_lane(vec2,2),vec0,2); + vec0 = vsetq_lane(q2q3 + vgetq_lane(vec2,1) ,vec0,3); + + vst1q(pOutputRotations, vec0); + pOutputRotations += 4; + + *pOutputRotations = tmp1 - tmp2; + pOutputRotations ++; + + pInputQuaternions += 4; + } +} + +#else void arm_quaternion2rotation_f32(const float32_t *pInputQuaternions, float32_t *pOutputRotations, uint32_t nbQuaternions) @@ -103,6 +171,7 @@ void arm_quaternion2rotation_f32(const float32_t *pInputQuaternions, pOutputRotations[6 + nb * 9] = zx; pOutputRotations[7 + nb * 9] = zy; pOutputRotations[8 + nb * 9] = zz; } } +#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */ /** @} end of QuatRot group diff --git a/Source/QuaternionMathFunctions/arm_quaternion_conjugate_f32.c b/Source/QuaternionMathFunctions/arm_quaternion_conjugate_f32.c index f3d7c708..f13d5404 100755 --- a/Source/QuaternionMathFunctions/arm_quaternion_conjugate_f32.c +++ b/Source/QuaternionMathFunctions/arm_quaternion_conjugate_f32.c @@ -49,6 +49,32 @@ @param[in] nbQuaternions number of quaternions in each vector @return none */ + +#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) + +#include "arm_helium_utils.h" +void arm_quaternion_conjugate_f32(const float32_t *pInputQuaternions, + float32_t *pConjugateQuaternions, + uint32_t nbQuaternions) +{ + f32x4_t vec1; + + for(uint32_t i=0; i < nbQuaternions; i++) + { + vec1 = vld1q(pInputQuaternions); + + + vec1 = vsetq_lane_f32(-vgetq_lane(vec1, 0),vec1,0); + vec1 = vnegq_f32(vec1); + + vst1q(pConjugateQuaternions, vec1); + + + pInputQuaternions += 4; + pConjugateQuaternions += 4; + } +} +#else void arm_quaternion_conjugate_f32(const float32_t *pInputQuaternions, float32_t *pConjugateQuaternions, uint32_t nbQuaternions) @@ -62,6 +88,7 @@ void arm_quaternion_conjugate_f32(const float32_t *pInputQuaternions, pConjugateQuaternions[4 * i + 3] = -pInputQuaternions[4 * i + 3]; } } +#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */ /** @} end of QuatConjugate group diff --git a/Source/QuaternionMathFunctions/arm_quaternion_inverse_f32.c b/Source/QuaternionMathFunctions/arm_quaternion_inverse_f32.c index 8c8f4e6f..b0edb8fe 100755 --- a/Source/QuaternionMathFunctions/arm_quaternion_inverse_f32.c +++ b/Source/QuaternionMathFunctions/arm_quaternion_inverse_f32.c @@ -51,7 +51,39 @@ */ +#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) +#include "arm_helium_utils.h" + +void arm_quaternion_inverse_f32(const float32_t *pInputQuaternions, + float32_t *pInverseQuaternions, + uint32_t nbQuaternions) +{ + f32x4_t vec1,vec2; + float32_t squaredSum; + + for(uint32_t i=0; i < nbQuaternions; i++) + { + + vec1 = vld1q(pInputQuaternions); + vec2 = vmulq(vec1,vec1); + squaredSum = vecAddAcrossF32Mve(vec2); + + + vec1 = vmulq_n_f32(vec1, 1.0f / squaredSum); + vec1 = vsetq_lane_f32(-vgetq_lane(vec1, 0),vec1,0); + vec1 = vnegq_f32(vec1); + + vst1q(pInverseQuaternions, vec1); + + + pInputQuaternions += 4; + pInverseQuaternions += 4; + + } +} + +#else void arm_quaternion_inverse_f32(const float32_t *pInputQuaternions, float32_t *pInverseQuaternions, uint32_t nbQuaternions) @@ -72,6 +104,7 @@ void arm_quaternion_inverse_f32(const float32_t *pInputQuaternions, pInverseQuaternions[4 * i + 3] = -pInputQuaternions[4 * i + 3] / temp; } } +#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */ /** @} end of QuatInverse group diff --git a/Source/QuaternionMathFunctions/arm_quaternion_norm_f32.c b/Source/QuaternionMathFunctions/arm_quaternion_norm_f32.c index 2bee87c9..cbb8d0a6 100755 --- a/Source/QuaternionMathFunctions/arm_quaternion_norm_f32.c +++ b/Source/QuaternionMathFunctions/arm_quaternion_norm_f32.c @@ -51,6 +51,31 @@ */ +#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) + +#include "arm_helium_utils.h" + +void arm_quaternion_norm_f32(const float32_t *pInputQuaternions, + float32_t *pNorms, + uint32_t nbQuaternions) +{ + f32x4_t vec1; + float32_t squaredSum; + + for(uint32_t i=0; i < nbQuaternions; i++) + { + vec1 = vld1q(pInputQuaternions); + vec1 = vmulq(vec1,vec1); + squaredSum = vecAddAcrossF32Mve(vec1); + arm_sqrt_f32(squaredSum,pNorms); + + pInputQuaternions+= 4; + pNorms ++; + } + +} + +#else void arm_quaternion_norm_f32(const float32_t *pInputQuaternions, float32_t *pNorms, @@ -67,6 +92,7 @@ void arm_quaternion_norm_f32(const float32_t *pInputQuaternions, pNorms[i] = sqrtf(temp); } } +#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */ /** @} end of QuatNorm group diff --git a/Source/QuaternionMathFunctions/arm_quaternion_normalize_f32.c b/Source/QuaternionMathFunctions/arm_quaternion_normalize_f32.c index f4cdc523..651f8443 100755 --- a/Source/QuaternionMathFunctions/arm_quaternion_normalize_f32.c +++ b/Source/QuaternionMathFunctions/arm_quaternion_normalize_f32.c @@ -49,6 +49,34 @@ @param[in] nbQuaternions number of quaternions in each vector @return none */ + +#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) + +#include "arm_helium_utils.h" + +void arm_quaternion_normalize_f32(const float32_t *pInputQuaternions, + float32_t *pNormalizedQuaternions, + uint32_t nbQuaternions) +{ + f32x4_t vec1,vec2; + float32_t squaredSum,norm; + + for(uint32_t i=0; i < nbQuaternions; i++) + { + vec1 = vld1q(pInputQuaternions); + vec2 = vmulq(vec1,vec1); + squaredSum = vecAddAcrossF32Mve(vec2); + arm_sqrt_f32(squaredSum,&norm); + vec1 = vmulq_n_f32(vec1, 1.0f / norm); + vst1q(pNormalizedQuaternions, vec1); + + pInputQuaternions += 4; + pNormalizedQuaternions += 4; + + } +} + +#else void arm_quaternion_normalize_f32(const float32_t *pInputQuaternions, float32_t *pNormalizedQuaternions, uint32_t nbQuaternions) @@ -69,6 +97,7 @@ void arm_quaternion_normalize_f32(const float32_t *pInputQuaternions, pNormalizedQuaternions[4 * i + 3] = pInputQuaternions[4 * i + 3] / temp; } } +#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */ /** @} end of QuatNormalized group diff --git a/Source/QuaternionMathFunctions/arm_quaternion_product_f32.c b/Source/QuaternionMathFunctions/arm_quaternion_product_f32.c index 3403d452..6bb800db 100755 --- a/Source/QuaternionMathFunctions/arm_quaternion_product_f32.c +++ b/Source/QuaternionMathFunctions/arm_quaternion_product_f32.c @@ -46,10 +46,75 @@ @brief Floating-point elementwise product two quaternions. @param[in] qa first array of quaternions @param[in] qb second array of quaternions - @param[out] r elementwise product of quaternions + @param[out] qr elementwise product of quaternions @param[in] nbQuaternions number of quaternions in the array @return none */ + +#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) + +#include "arm_helium_utils.h" + +void arm_quaternion_product_f32(const float32_t *qa, + const float32_t *qb, + float32_t *qr, + uint32_t nbQuaternions) +{ + static uint32_t patternA[4] = { 0, 1, 0, 1 }; + static uint32_t patternB[4] = { 3, 2, 3, 2 }; + static uint32_t patternC[4] = { 3, 2, 1, 0 }; + static float32_t signA[4] = { -1, -1, 1, 1 }; + + uint32x4_t vecA = vld1q_u32(patternA); + uint32x4_t vecB = vld1q_u32(patternB); + uint32x4_t vecC = vld1q_u32(patternC); + f32x4_t vecSignA = vld1q_f32(signA); + + while (nbQuaternions > 0U) + { + f32x4_t vecTmpA, vecTmpB, vecAcc; + + vecTmpA = vldrwq_gather_shifted_offset_f32(qa, vecA); + vecTmpB = vld1q(qb); + /* + * vcmul(r, [a1, a2, a1, a2], [b1, b2, b3, b4], 0) + */ + vecAcc = vcmulq(vecTmpA, vecTmpB); + /* + * vcmla(r, [a1, a2, a1, a2], [b1, b2, b3, b4], 90) + */ + vecAcc = vcmlaq_rot90(vecAcc, vecTmpA, vecTmpB); + + vecTmpA = vldrwq_gather_shifted_offset_f32(qa, vecB); + vecTmpB = vldrwq_gather_shifted_offset_f32(qb, vecC); + /* + * build [-b4, -b3, b2, b1] + */ + vecTmpB = vecTmpB * vecSignA; + /* + * vcmla(r, [a4, a3, a4, a3], [-b4, -b3, b2, b1], 270) + */ + vecAcc = vcmlaq_rot270(vecAcc, vecTmpA, vecTmpB); + /* + * vcmla(r, [a4, a3, a4, a3], [-b4, -b3, b2, b1], 0) + */ + vecAcc = vcmlaq(vecAcc, vecTmpA, vecTmpB); + /* + * store accumulator + */ + vst1q_f32(qr, vecAcc); + + /* move to next quaternion */ + qa += 4; + qb += 4; + qr += 4; + + nbQuaternions--; + } +} + +#else + void arm_quaternion_product_f32(const float32_t *qa, const float32_t *qb, float32_t *r, @@ -64,6 +129,7 @@ void arm_quaternion_product_f32(const float32_t *qa, r += 4; } } +#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */ /** @} end of QuatProd group diff --git a/Source/QuaternionMathFunctions/arm_quaternion_product_single_f32.c b/Source/QuaternionMathFunctions/arm_quaternion_product_single_f32.c index e6500b44..94ffc6e0 100755 --- a/Source/QuaternionMathFunctions/arm_quaternion_product_single_f32.c +++ b/Source/QuaternionMathFunctions/arm_quaternion_product_single_f32.c @@ -46,9 +46,48 @@ @brief Floating-point product of two quaternions. @param[in] qa first quaternion @param[in] qb second quaternion - @param[out] r product of two quaternions + @param[out] qr product of two quaternions @return none */ + +#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) + +#include "arm_helium_utils.h" +void arm_quaternion_product_single_f32(const float32_t *qa, + const float32_t *qb, + float32_t *qr) +{ + static uint32_t patternA[4] = { 0, 1, 0, 1 }; + static uint32_t patternB[4] = { 3, 2, 3, 2 }; + static uint32_t patternC[4] = { 3, 2, 1, 0 }; + static float32_t signA[4] = { -1, -1, 1, 1 }; + + uint32x4_t vecA = vld1q_u32(patternA); + uint32x4_t vecB = vld1q_u32(patternB); + uint32x4_t vecC = vld1q_u32(patternC); + f32x4_t vecSignA = vld1q_f32(signA); + + + f32x4_t vecTmpA, vecTmpB, vecAcc; + + vecTmpA = vldrwq_gather_shifted_offset_f32(qa, vecA); + vecTmpB = vld1q_f32(qb); + + vecAcc = vcmulq_f32(vecTmpA, vecTmpB); + vecAcc = vcmlaq_rot90_f32(vecAcc, vecTmpA, vecTmpB); + + vecTmpA = vldrwq_gather_shifted_offset_f32(qa, vecB); + vecTmpB = vldrwq_gather_shifted_offset_f32(qb, vecC); + + vecTmpB = vecTmpB * vecSignA; + + vecAcc = vcmlaq_rot270_f32(vecAcc, vecTmpA, vecTmpB); + vecAcc = vcmlaq_f32(vecAcc, vecTmpA, vecTmpB); + + vst1q_f32(qr, vecAcc); +} + +#else void arm_quaternion_product_single_f32(const float32_t *qa, const float32_t *qb, float32_t *r) @@ -58,6 +97,7 @@ void arm_quaternion_product_single_f32(const float32_t *qa, r[2] = qa[0] * qb[2] + qa[2] * qb[0] + qa[3] * qb[1] - qa[1] * qb[3]; r[3] = qa[0] * qb[3] + qa[3] * qb[0] + qa[1] * qb[2] - qa[2] * qb[1]; } +#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */ /** @} end of QuatProdSingle group diff --git a/Source/QuaternionMathFunctions/arm_rotation2quaternion_f32.c b/Source/QuaternionMathFunctions/arm_rotation2quaternion_f32.c index 130034c4..7b4d6580 100755 --- a/Source/QuaternionMathFunctions/arm_rotation2quaternion_f32.c +++ b/Source/QuaternionMathFunctions/arm_rotation2quaternion_f32.c @@ -56,6 +56,110 @@ * account when using the output of this function. * */ + +#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) + +#include "arm_helium_utils.h" + +#define R00 vgetq_lane(q1,0) +#define R01 vgetq_lane(q1,1) +#define R02 vgetq_lane(q1,2) +#define R10 vgetq_lane(q1,3) +#define R11 vgetq_lane(q2,0) +#define R12 vgetq_lane(q2,1) +#define R20 vgetq_lane(q2,2) +#define R21 vgetq_lane(q2,3) +#define R22 ro22 + +void arm_rotation2quaternion_f32(const float32_t *pInputRotations, + float32_t *pOutputQuaternions, + uint32_t nbQuaternions) +{ + float32_t ro22, trace; + f32x4_t q1,q2, q; + + float32_t doubler; + float32_t s; + + q = vdupq_n_f32(0.0f); + + for(uint32_t nb=0; nb < nbQuaternions; nb++) + { + q1 = vld1q(pInputRotations); + pInputRotations += 4; + + q2 = vld1q(pInputRotations); + pInputRotations += 4; + + ro22 = *pInputRotations++; + + trace = R00 + R11 + R22; + + + if (trace > 0) + { + (void)arm_sqrt_f32(trace + 1.0, &doubler) ; // invs=4*qw + doubler = 2*doubler; + s = 1.0 / doubler; + + q1 = vmulq_n_f32(q1,s); + q2 = vmulq_n_f32(q2,s); + + q[0] = 0.25 * doubler; + q[1] = R21 - R12; + q[2] = R02 - R20; + q[3] = R10 - R01; + } + else if ((R00 > R11) && (R00 > R22) ) + { + (void)arm_sqrt_f32(1.0 + R00 - R11 - R22,&doubler); // invs=4*qx + doubler = 2*doubler; + s = 1.0 / doubler; + + q1 = vmulq_n_f32(q1,s); + q2 = vmulq_n_f32(q2,s); + + q[0] = R21 - R12; + q[1] = 0.25 * doubler; + q[2] = R01 + R10; + q[3] = R02 + R20; + } + else if (R11 > R22) + { + (void)arm_sqrt_f32(1.0 + R11 - R00 - R22,&doubler); // invs=4*qy + doubler = 2*doubler; + s = 1.0 / doubler; + + q1 = vmulq_n_f32(q1,s); + q2 = vmulq_n_f32(q2,s); + + q[0] = R02 - R20; + q[1] = R01 + R10; + q[2] = 0.25 * doubler; + q[3] = R12 + R21; + } + else + { + (void)arm_sqrt_f32(1.0 + R22 - R00 - R11,&doubler); // invs=4*qz + doubler = 2*doubler; + s = 1.0 / doubler; + + q1 = vmulq_n_f32(q1,s); + q2 = vmulq_n_f32(q2,s); + + q[0] = R10 - R01; + q[1] = R02 + R20; + q[2] = R12 + R21; + q[3] = 0.25 * doubler; + } + + vst1q(pOutputQuaternions, q); + pOutputQuaternions += 4; + + } +} + +#else void arm_rotation2quaternion_f32(const float32_t *pInputRotations, float32_t *pOutputQuaternions, uint32_t nbQuaternions) @@ -111,6 +215,7 @@ void arm_rotation2quaternion_f32(const float32_t *pInputRotations, } } +#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */ /** @} end of RotQuat group diff --git a/Testing/CMakeLists.txt b/Testing/CMakeLists.txt index ce962dca..d91ec4ec 100644 --- a/Testing/CMakeLists.txt +++ b/Testing/CMakeLists.txt @@ -156,6 +156,7 @@ set (NNSRC Source/Benchmarks/ComplexMathsBenchmarksF32.cpp Source/Benchmarks/ComplexMathsBenchmarksQ31.cpp Source/Benchmarks/ComplexMathsBenchmarksQ15.cpp + Source/Benchmarks/QuaternionMathsBenchmarksF32.cpp Source/Benchmarks/BayesF32.cpp Source/Benchmarks/SVMF32.cpp Source/Benchmarks/DistanceF32.cpp diff --git a/Testing/Include/Benchmarks/QuaternionMathsBenchmarksF32.h b/Testing/Include/Benchmarks/QuaternionMathsBenchmarksF32.h new file mode 100755 index 00000000..d9094c12 --- /dev/null +++ b/Testing/Include/Benchmarks/QuaternionMathsBenchmarksF32.h @@ -0,0 +1,29 @@ +#include "Test.h" +#include "Pattern.h" + +#include "dsp/quaternion_math_functions.h" + +class QuaternionMathsBenchmarksF32:public Client::Suite + { + public: + QuaternionMathsBenchmarksF32(Testing::testID_t id); + virtual void setUp(Testing::testID_t,std::vector& params,Client::PatternMgr *mgr); + virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr); + private: + #include "QuaternionMathsBenchmarksF32_decl.h" + Client::Pattern input1; + Client::Pattern input2; + Client::LocalPattern output; + + Client::RefPattern ref; + + + int nb; + + float32_t *inp1; + float32_t *inp2; + float32_t *outp; + + float32_t *refp; + + }; diff --git a/Testing/Source/Benchmarks/QuaternionMathsBenchmarksF32.cpp b/Testing/Source/Benchmarks/QuaternionMathsBenchmarksF32.cpp new file mode 100755 index 00000000..db030515 --- /dev/null +++ b/Testing/Source/Benchmarks/QuaternionMathsBenchmarksF32.cpp @@ -0,0 +1,158 @@ +#include "QuaternionMathsBenchmarksF32.h" +#include "Error.h" + + + void QuaternionMathsBenchmarksF32::test_quaternion_norm_f32() + { + arm_quaternion_norm_f32(this->inp1,this->outp,this->nb); + + } + + void QuaternionMathsBenchmarksF32::test_quaternion_inverse_f32() + { + + arm_quaternion_inverse_f32(this->inp1,this->outp,this->nb); + + + } + + void QuaternionMathsBenchmarksF32::test_quaternion_conjugate_f32() + { + + arm_quaternion_conjugate_f32(this->inp1,this->outp,this->nb); + + } + + void QuaternionMathsBenchmarksF32::test_quaternion_normalize_f32() + { + + arm_quaternion_normalize_f32(this->inp1,this->outp,this->nb); + + + } + + void QuaternionMathsBenchmarksF32::test_quaternion_prod_single_f32() + { + + for(int i=0; i < this->nb; i++) + { + arm_quaternion_product_single_f32(this->inp1,this->inp2,this->outp); + this->outp += 4; + this->inp1 += 4; + this->inp2 += 4; + } + + } + + void QuaternionMathsBenchmarksF32::test_quaternion_product_f32() + { + + arm_quaternion_product_f32(this->inp1,this->inp2,outp,this->nb); + + + + } + + void QuaternionMathsBenchmarksF32::test_quaternion2rotation_f32() + { + arm_quaternion2rotation_f32(this->inp1,this->outp,this->nb); + + + + } + + void QuaternionMathsBenchmarksF32::test_rotation2quaternion_f32() + { + + + arm_rotation2quaternion_f32(this->inp1,this->outp,this->nb); + + + + } + + + void QuaternionMathsBenchmarksF32::setUp(Testing::testID_t id,std::vector& params,Client::PatternMgr *mgr) + { + + this->setForceInCache(true); + std::vector::iterator it = params.begin(); + this->nb = *it; + + + switch(id) + { + case QuaternionMathsBenchmarksF32::TEST_QUATERNION_NORM_F32_1: + input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4); + output.create(this->nb,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr); + + this->inp1=input1.ptr(); + this->outp=output.ptr(); + break; + + case QuaternionMathsBenchmarksF32::TEST_QUATERNION_INVERSE_F32_2: + input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4); + output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr); + + this->inp1=input1.ptr(); + this->outp=output.ptr(); + break; + + case QuaternionMathsBenchmarksF32::TEST_QUATERNION_CONJUGATE_F32_3: + input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4); + output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr); + + this->inp1=input1.ptr(); + this->outp=output.ptr(); + break; + + case QuaternionMathsBenchmarksF32::TEST_QUATERNION_NORMALIZE_F32_4: + input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4); + output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr); + + this->inp1=input1.ptr(); + this->outp=output.ptr(); + break; + + case QuaternionMathsBenchmarksF32::TEST_QUATERNION_PROD_SINGLE_F32_5: + input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4); + input2.reload(QuaternionMathsBenchmarksF32::INPUT2_F32_ID,mgr,this->nb*4); + output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr); + + this->inp1=input1.ptr(); + this->inp2=input2.ptr(); + this->outp=output.ptr(); + break; + + case QuaternionMathsBenchmarksF32::TEST_QUATERNION_PRODUCT_F32_6: + input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4); + input2.reload(QuaternionMathsBenchmarksF32::INPUT2_F32_ID,mgr,this->nb*4); + output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr); + + this->inp1=input1.ptr(); + this->inp2=input2.ptr(); + this->outp=output.ptr(); + break; + + case QuaternionMathsBenchmarksF32::TEST_QUATERNION2ROTATION_F32_7: + input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4); + output.create(this->nb*9,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr); + + this->inp1=input1.ptr(); + this->outp=output.ptr(); + break; + + case QuaternionMathsBenchmarksF32::TEST_ROTATION2QUATERNION_F32_8: + input1.reload(QuaternionMathsBenchmarksF32::INPUT_ROT_F32_ID,mgr,this->nb*9); + output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr); + + this->inp1=input1.ptr(); + this->outp=output.ptr(); + break; + + } + } + + void QuaternionMathsBenchmarksF32::tearDown(Testing::testID_t id,Client::PatternMgr *mgr) + { + } diff --git a/Testing/bench.txt b/Testing/bench.txt index 3e8bfee3..ba6caaff 100755 --- a/Testing/bench.txt +++ b/Testing/bench.txt @@ -399,6 +399,43 @@ group Root { } } + group Quaternion Maths { + class = QuaternionBenchmarks + folder = QuaternionMaths + + suite Quaternion Maths Benchmarks F32 { + class = QuaternionMathsBenchmarksF32 + folder = QuaternionMathsF32 + + ParamList { + NB + Summary NB + Names "NB Samples" + Formula "NB" + } + + Pattern INPUT1_F32_ID : Input1_f32.txt + Pattern INPUT2_F32_ID : Input2_f32.txt + Pattern INPUT_ROT_F32_ID : Input7_f32.txt + + Output OUT_SAMPLES_F32_ID : Output + Params PARAM1_ID = { + A = [16,32,64,128] + } + + Functions { + Quaternion Norm:test_quaternion_norm_f32 + Quaternion inverse:test_quaternion_inverse_f32 + Quaternion conjugate:test_quaternion_conjugate_f32 + Quaternion normalization:test_quaternion_normalize_f32 + Quaternion product:test_quaternion_prod_single_f32 + Quaternion Elementwise product:test_quaternion_product_f32 + Quaternion to rotation:test_quaternion2rotation_f32 + Rotation to quaternion:test_rotation2quaternion_f32 + } -> PARAM1_ID + } + } + group Filtering { class = DSPFiltering folder = Filtering