Android neon 优化
Android社区 人气:0搭建实验环境
首先新建一个包含native代码的项目:
然后在gradle中添加对neon的支持:
externalNativeBuild { cmake { cppFlags "-std=c++14" arguments "-DANDROID_ARM_NEON=TRUE" } }
这样,项目就可以支持neon加速了。
小试牛刀
一个最简单的neon编程的流程大致是这样的: 1、装载数据到neon寄存器 2、执行运算 3、从neon寄存器中把结果写回内存。
没有例子不知从何说起,先上一个超级简单的例子吧:
#include <jni.h> #include <string> #include <arm_neon.h> #include <android/log.h> #define LOG_TAG "TEST_NEON" #define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__) #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__) extern "C"{ void test() { int16_t result[8]; int8x8_t a = vdup_n_s8(121); int8x8_t b = vdup_n_s8(2); int16x8_t c; c = vmull_s8(a,b); vst1q_s16(result,c); for(int i=0;i<8;i++){ LOGD("data[%d] is %d ",i,result[i]); } } JNIEXPORT jstring JNICALL Java_com_example_javer_myapplication_MainActivity_stringFromJNI( JNIEnv *env, jobject /* this */) { std::string hello = "Hello from C++"; test(); return env->NewStringUTF(hello.c_str()); } }
执行结果:
09-07 12:03:08.335 11709-11709/? D/TEST_NEON:
data[0] is 242
data[1] is 242
data[2] is 242
data[3] is 242
data[4] is 242
data[5] is 242
data[6] is 242
data[7] is 242
代码中,test函数中实现了两个64位neon寄存器的乘法。
vdup是数据复制指令,这里把128这个8位的数复制到一个64位的寄存器中,64位能存放8个8位的数,因此,此时a指向的neon寄存器存放了8个128。
两个8位的数相乘,结果可能是16位的,因此,结果需要用一个128位的寄存器来保存。int16x8就表示的是一个128位的寄存器。
vmull_s8把a,b相乘,并将结果保存在c中。c指向的是neon的128位寄存器,因此,我们需要把结果写回内存。
vst1q_s16把c中的数据协会result指向的内存中。
这是一个简单的测试neon指令的代码,通过这个代码我们能清晰的认识到neon加速的原理:一次装载8个8位的数到64位寄存器,一条指令能把实现两个8*8的数据块的乘法。
这样效率不就接近提升8倍么?当然没有这么理想,毕竟装载数据和写回数据也是需要时间的。
实战尝试
接下来,尝试一个比较简单的rgb转灰度图的code:
void normal_convert (uint8_t * __restrict dest, uint8_t * __restrict src, int n) { int i; for (i=0; i<n; i++) { int r = *src++; // load red int g = *src++; // load green int b = *src++; // load blue // build weighted average: int y = (r*77)+(g*151)+(b*28); // undo the scale by 256 and write to memory: *dest++ = (y>>8); } } void neon_convert (uint8_t * __restrict dest, uint8_t * __restrict src, int n) { int i; uint8x8_t rfac = vdup_n_u8 (77); uint8x8_t gfac = vdup_n_u8 (151); uint8x8_t bfac = vdup_n_u8 (28); n/=8; for (i=0; i<n; i++) { uint16x8_t temp; uint8x8x3_t rgb = vld3_u8 (src); uint8x8_t result; temp = vmull_u8 (rgb.val[0], rfac); temp = vmlal_u8 (temp,rgb.val[1], gfac); temp = vmlal_u8 (temp,rgb.val[2], bfac); result = vshrn_n_u16 (temp, 8); vst1_u8 (dest, result); src += 8*3; dest += 8; } } void test1() { //准备一张图片,使用软件模拟生成,格式为rgb rgb .. uint32_t const array_size = 2048*2048; uint8_t * rgb = new uint8_t[array_size*3]; for(int i=0;i<array_size;i++){ rgb[i*3]=234; rgb[i*3+1]=94; rgb[i*3+2]=23; } //灰度图大小为rgb的1/3 uint8_t * gray = new uint8_t[array_size]; struct timeval tv1,tv2; gettimeofday(&tv1,NULL); normal_convert(gray,rgb,array_size); gettimeofday(&tv2,NULL); LOGD("pure cpu cost time:%ld",(tv2.tv_sec-tv1.tv_sec)*1000000+(tv2.tv_usec-tv1.tv_usec)); gettimeofday(&tv1,NULL); neon_convert(gray,rgb,array_size); gettimeofday(&tv2,NULL); LOGD("neon cost time:%ld",(tv2.tv_sec-tv1.tv_sec)*1000000+(tv2.tv_usec-tv1.tv_usec)); delete[] rgb; delete[] gray; } JNIEXPORT jstring JNICALL Java_com_example_javer_myapplication_MainActivity_stringFromJNI( JNIEnv *env, jobject /* this */) { std::string hello = "Hello from C++"; test1(); return env->NewStringUTF(hello.c_str()); }
具体的指令就不一一说明了,大家参考neon汇编指令集,对照着看就好。
纯cpu耗时53ms,neon优化后耗时43ms,提升非常有限,跟提升近8倍的预期相差甚远。这主要是因为c转换为汇编后,生成的汇编指令不够简洁,使得效率大大降低。因此,接下来,使用汇编对代码进行优化。
CMake添加汇编支持
为了在Cmake中编译汇编文件,我们需要在CMakeLists.txt文件中申明对汇编语言的支持,添加ENABLE_LANGUAGE(ASM)即可实现对汇编的支持,接着将汇编文件添加进来,此处贴出完整的CMakeLists.txt文件供大家参考:
# For more information about using CMake with Android Studio, read the # documentation: https://d.android.com/studio/projects/add-native-code.html # Sets the minimum version of CMake required to build the native library. cmake_minimum_required(VERSION 3.4.1) # Creates and names a library, sets it as either STATIC # or SHARED, and provides the relative paths to its source code. # You can define multiple libraries, and CMake builds them for you. # Gradle automatically packages shared libraries with your APK. ENABLE_LANGUAGE(ASM) add_library( # Sets the name of the library. native-lib # Sets the library as a shared library. SHARED # Provides a relative path to your source file(s). src/main/cpp/Neon.S src/main/cpp/native-lib.cpp ) # Searches for a specified prebuilt library and stores the path as a # variable. Because CMake includes system libraries in the search path by # default, you only need to specify the name of the public NDK library # you want to add. CMake verifies that the library exists before # completing its build. find_library( # Sets the name of the path variable. log-lib # Specifies the name of the NDK library that # you want CMake to locate. log ) # Specifies libraries CMake should link to your target library. You # can link multiple libraries, such as libraries you define in this # build script, prebuilt third-party libraries, or system libraries. target_link_libraries( # Specifies the target library. native-lib # Links the target library to the log library # included in the NDK. ${log-lib} )
实现汇编Neon优化
然后在cpp文件中申明:
void neon_asm_convert(uint8_t * dest, uint8_t * src,int n);
注意,这个申明是包含在extern “C”中的。 然后在Neon.S中实现neon_asm_convert函数:
.globl neon_asm_convert neon_asm_convert: # r0: Ptr to destination data # r1: Ptr to source data # r2: Iteration count: push {r4-r5,lr} lsr r2, r2, #3 # build the three constants: mov r3, #77 mov r4, #151 mov r5, #28 vdup.8 d3, r3 vdup.8 d4, r4 vdup.8 d5, r5 .loop: # load 8 pixels: vld3.8 {d0-d2}, [r1]! # do the weight average: vmull.u8 q3, d0, d3 vmlal.u8 q3, d1, d4 vmlal.u8 q3, d2, d5 # shift and store: vshrn.u16 d6, q3, #8 vst1.8 {d6}, [r0]! subs r2, r2, #1 bne .loop pop { r4-r5, pc }
为了对比结果的正确性,专门写了个比对函数:
int compare(uint8_t *a,uint8_t* b,int n) { for(int i=0;i<n;i++){ if(a[i]!=b[i]){ return -1; } } return 0; }
并将结果打印在时间后面:
LOGD("neon c cost time:%ld,result is %d",(tv2.tv_sec-tv1.tv_sec)*1000000+(tv2.tv_usec-tv1.tv_usec),result);
三者对比:
09-07 17:12:19.946 25861-25861/com.example.javer.myapplication D/TEST_NEON: pure cpu cost time:57073
09-07 17:12:20.012 25861-25861/com.example.javer.myapplication D/TEST_NEON: neon c cost time:45460,result is 0
09-07 17:12:20.034 25861-25861/com.example.javer.myapplication D/TEST_NEON: neon asm cost time:3397,result is 0
09-07 17:12:25.271 25861-25861/com.example.javer.myapplication D/TEST_NEON: pure cpu cost time:57404
09-07 17:12:25.336 25861-25861/com.example.javer.myapplication D/TEST_NEON: neon c cost time:45166,result is 0
09-07 17:12:25.359 25861-25861/com.example.javer.myapplication D/TEST_NEON: neon asm cost time:3493,result is 0
最终发现,汇编执行的结果完全正确,时间提升超过了16倍!!!!!!!!!!! 我甚至不敢相信能提升这么多。。。可对比的结果是完全一样啊!!这…….
如果程序有问题,感谢大神指出。
最后附完整代码: native_lib.cpp:
#include <jni.h> #include <string> #include <arm_neon.h> #include <android/log.h> #define LOG_TAG "TEST_NEON" #define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__) #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__) extern "C"{ void neon_asm_convert(uint8_t * dest, uint8_t * src,int n); void test() { int16_t result[8]; int8x8_t a = vdup_n_s8(121); int8x8_t b = vdup_n_s8(2); int16x8_t c; c = vmull_s8(a,b); vst1q_s16(result,c); for(int i=0;i<8;i++){ LOGD("data[%d] is %d ",i,result[i]); } } void normal_convert (uint8_t * __restrict dest, uint8_t * __restrict src, int n) { int i; for (i=0; i<n; i++) { int r = *src++; // load red int g = *src++; // load green int b = *src++; // load blue // build weighted average: int y = (r*77)+(g*151)+(b*28); // undo the scale by 256 and write to memory: *dest++ = (y>>8); } } void neon_convert (uint8_t * __restrict dest, uint8_t * __restrict src, int n) { int i; uint8x8_t rfac = vdup_n_u8 (77); uint8x8_t gfac = vdup_n_u8 (151); uint8x8_t bfac = vdup_n_u8 (28); n/=8; for (i=0; i<n; i++) { uint16x8_t temp; uint8x8x3_t rgb = vld3_u8 (src); uint8x8_t result; temp = vmull_u8 (rgb.val[0], rfac); temp = vmlal_u8 (temp,rgb.val[1], gfac); temp = vmlal_u8 (temp,rgb.val[2], bfac); result = vshrn_n_u16 (temp, 8); vst1_u8 (dest, result); src += 8*3; dest += 8; } } int compare(uint8_t *a,uint8_t* b,int n) { for(int i=0;i<n;i++){ if(a[i]!=b[i]){ return -1; } } return 0; } void test1() { //准备一张图片,使用软件模拟生成,格式为rgb rgb .. uint32_t const array_size = 2048*2048; uint8_t * rgb = new uint8_t[array_size*3]; for(int i=0;i<array_size;i++){ rgb[i*3]=234; rgb[i*3+1]=94; rgb[i*3+2]=23; } //灰度图大小为rgb的1/3 uint8_t * gray_cpu = new uint8_t[array_size]; uint8_t * gray_neon = new uint8_t[array_size]; uint8_t * gray_neon_asm = new uint8_t[array_size]; struct timeval tv1,tv2; gettimeofday(&tv1,NULL); normal_convert(gray_cpu,rgb,array_size); gettimeofday(&tv2,NULL); LOGD("pure cpu cost time:%ld",(tv2.tv_sec-tv1.tv_sec)*1000000+(tv2.tv_usec-tv1.tv_usec)); gettimeofday(&tv1,NULL); neon_convert(gray_neon,rgb,array_size); gettimeofday(&tv2,NULL); bool result = compare(gray_cpu,gray_neon,array_size); LOGD("neon c cost time:%ld,result is %d",(tv2.tv_sec-tv1.tv_sec)*1000000+(tv2.tv_usec-tv1.tv_usec),result); gettimeofday(&tv1,NULL); neon_asm_convert(gray_neon_asm,rgb,array_size); gettimeofday(&tv2,NULL); result = compare(gray_cpu,gray_neon_asm,array_size); LOGD("neon asm cost time:%ld,result is %d",(tv2.tv_sec-tv1.tv_sec)*1000000+(tv2.tv_usec-tv1.tv_usec),result); delete[] rgb; delete[] gray_cpu; delete[] gray_neon; delete[] gray_neon_asm; } JNIEXPORT jstring JNICALL Java_com_example_javer_myapplication_MainActivity_stringFromJNI( JNIEnv *env, jobject /* this */) { std::string hello = "Hello from C++"; test1(); return env->NewStringUTF(hello.c_str()); } }
Neon.S
.globl neon_asm_convert neon_asm_convert: # r0: Ptr to destination data # r1: Ptr to source data # r2: Iteration count: push {r4-r5,lr} lsr r2, r2, #3 # build the three constants: mov r3, #77 mov r4, #151 mov r5, #28 vdup.8 d3, r3 vdup.8 d4, r4 vdup.8 d5, r5 .loop: # load 8 pixels: vld3.8 {d0-d2}, [r1]! # do the weight average: vmull.u8 q3, d0, d3 vmlal.u8 q3, d1, d4 vmlal.u8 q3, d2, d5 # shift and store: vshrn.u16 d6, q3, #8 vst1.8 {d6}, [r0]! subs r2, r2, #1 bne .loop pop { r4-r5, pc }
加载全部内容