• OpenCV Optimization - Stage II Update
  • Perform Optimization Plan on Aarchie
    • Looking for similar functions
    • Code Example after Optimization:
  • Safety Test
  • Performance Test
    • Time Before Optimization
    • Time After Optimization
    • Table of Time Improvment Percentage
    • Usage Before Optimization
    • Usage After Optimization
    • Optimization Result
  • Other Architecture
    • Usage Before Optimization
    • Usage After Optimization
  • Conclusion

OpenCV Optimization - Stage II Update

There are the list of tasks I need to add for stage II:

• Perform: Details about the processes of performing optimiation plan
• Safety Test: Will the optimized functions pass the safety test?
• Performace Test: Compare the performance of target functions before and after optimization
• Other Architecture: What is the preformance of the target functions in other platform?

Perform Optimization Plan on Aarchie

After read the source code of fast_math.cpp, I realized that the OpenCV developers call lrint(value) function inside of the body of cvRound(), but use regular way to perform cvCeil() and cvFloor() on Archie

CV_INLINE int
cvRound( double value )
{
    ...
#elif defined CV_ICC || defined __GNUC__
    return (int)(lrint(value));
    ...
}

CV_INLINE int cvCeil( float value )
{
    ...
#else
    int i = (int)value;
    return i + (i < value);
#endif
}

As I mentioned before, the optimization plan is to find functions which are similar with lrint(value) and see whether the performance of cvCeil() and cvFloor() can approach to cvRound().

Looking for similar functions

According to Linux Programmer’s Manual, ceil(),ceilf(), floor() and floorf() have similar implementation to lrint(value).

long int lrint(double x);
long int lrintf(float x);

double ceil(double x);
float ceilf(float x);

double floor(double x);
float floorf(float x);

The only concern is that the return value of lrint is long integer, then use (int)lrint(value)concatinate to integer. But for ceil() and floor() will return double and float, then do the concatinate to int.

Code Example after Optimization:

CV_INLINE int cvCeil( float value )
{
#if (defined CV__FASTMATH_ENABLE_GCC_MATH_BUILTINS || defined CV__FASTMATH_ENABLE_CLANG_MATH_BUILTINS) \
    && ( \
        defined(__PPC64__) \
    )
    return __builtin_ceilf(value);
#elif __aarch64__
    return (int)(ceilf(value));
#else
    int i = (int)value;
    return i + (i < value);
#endif
}

Safety Test

According to the following result, it seems the cvCeil and cvFloor pass the safety test. So this optimization will not affect the safety of these two functions.

__aarch64__ cvCeil(float)
total cvCeil float a: 9760000000
correct answer: 9760000000

total cvCeil float b: -3630000000
correct answer: -3630000000

__aarch64__ cvCeil(double)
total cvCeil double a: 5540000000
correct answer: 5540000000

total cvCeil double b -6340000000
correct answer: -6340000000

__aarch64__ cvFloor(float)
total cvFloor float a: 9750000000
correct answer: 9750000000

total cvFloor float b: -3640000000
correct answer: -3640000000

__aarch64__ cvFloor(double)
total cvFloor double a 5530000000
correct answer: 5530000000

total cvFloor double b -6350000000
correct answer: -6350000000

Performance Test

Note: these are median results after multiple runs.

Time Before Optimization

Time After Optimization

Table of Time Improvment Percentage

Usage Before Optimization

Usage After Optimization

Optimization Result

According to tables above, we can see that currently the time usage for cvRound, cvCeil and cvFloor are very close. The real time for cvCeil and cvFloor is about 0.2 second faster. The CPU execution time (usr+sys) of these two function are still approximatey 0.2 second faster. The usage after optimization for cvCeil and cvFloor decrease around 10% than before and is very close to cvRound

Other Architecture

Aarch64 - Betty

The safety test on Betty is passed.

Time Before Optimization

Time After Optimization

Usage Before Optimization

Usage After Optimization

Conclusion

Overall, we can see performance imporvement of cvCeil and cvFloor in both Archie and Betty. On Archie, the time of these 2 functions droped ~0.2 second and usage dropped ~12% compare with the result before optimization. On Betty, the time for cvCeil and cvFloor dropped 0.1 seconds and usage decrease 10% - 50%. Now the time and usage performance of cvCeil and cvFloor is very close to cvRound.