ndk/apps/hello-neon/project/jni/helloneon.c

   1 #include <jni.h>
   2 #include <time.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <cpu-features.h>
   6 #include "helloneon-intrinsics.h"
   7
   8 #define DEBUG 0
   9
  10 #if DEBUG
  11 #include <android/log.h>
  12 #  define  D(x...)  __android_log_print(ANDROID_LOG_INFO,"helloneon",x)
  13 #else
  14 #  define  D(...)  do {} while (0)
  15 #endif
  16
  17 /* return current time in milliseconds */
  18 static double
  19 now_ms(void)
  20 {
  21     struct timespec res;
  22     clock_gettime(CLOCK_REALTIME, &res);
  23     return 1000.0*res.tv_sec + (double)res.tv_nsec/1e6;
  24 }
  25
  26
  27 /* this is a FIR filter implemented in C */
  28 static void
  29 fir_filter_c(short *output, const short* input, const short* kernel, int width, int kernelSize)
  30 {
  31     int  offset = -kernelSize/2;
  32     int  nn;
  33     for (nn = 0; nn < width; nn++) {
  34         int sum = 0;
  35         int mm;
  36         for (mm = 0; mm < kernelSize; mm++) {
  37             sum += kernel[mm]*input[nn+offset+mm];
  38         }
  39         output[nn] = (short)((sum + 0x8000) >> 16);
  40     }
  41 }
  42
  43 #define  FIR_KERNEL_SIZE   32
  44 #define  FIR_OUTPUT_SIZE   2560
  45 #define  FIR_INPUT_SIZE    (FIR_OUTPUT_SIZE + FIR_KERNEL_SIZE)
  46 #define  FIR_ITERATIONS    600
  47
  48 static const short  fir_kernel[FIR_KERNEL_SIZE] = {
  49     0x10, 0x20, 0x40, 0x70, 0x8c, 0xa2, 0xce, 0xf0, 0xe9, 0xce, 0xa2, 0x8c, 070, 0x40, 0x20, 0x10,
  50     0x10, 0x20, 0x40, 0x70, 0x8c, 0xa2, 0xce, 0xf0, 0xe9, 0xce, 0xa2, 0x8c, 070, 0x40, 0x20, 0x10 };
  51
  52 static short        fir_output[FIR_OUTPUT_SIZE];
  53 static short        fir_input_0[FIR_INPUT_SIZE];
  54 static const short* fir_input = fir_input_0 + (FIR_KERNEL_SIZE/2);
  55 static short        fir_output_expected[FIR_OUTPUT_SIZE];
  56
  57 /* This is a trivial JNI example where we use a native method
  58  * to return a new VM String. See the corresponding Java source
  59  * file located at:
  60  *
  61  *   apps/samples/hello-neon/project/src/com/example/neon/HelloNeon.java
  62  */
  63 jstring
  64 Java_com_example_neon_HelloNeon_stringFromJNI( JNIEnv* env,
  65                                                jobject thiz )
  66 {
  67     char*  str;
  68     uint64_t features;
  69     char buffer[512];
  70     char tryNeon = 0;
  71     double  t0, t1, time_c, time_neon;
  72
  73     /* setup FIR input - whatever */
  74     {
  75         int  nn;
  76         for (nn = 0; nn < FIR_INPUT_SIZE; nn++) {
  77             fir_input_0[nn] = (5*nn) & 255;
  78         }
  79         fir_filter_c(fir_output_expected, fir_input, fir_kernel, FIR_OUTPUT_SIZE, FIR_KERNEL_SIZE);
  80     }
  81
  82     /* Benchmark small FIR filter loop - C version */
  83     t0 = now_ms();
  84     {
  85         int  count = FIR_ITERATIONS;
  86         for (; count > 0; count--) {
  87             fir_filter_c(fir_output, fir_input, fir_kernel, FIR_OUTPUT_SIZE, FIR_KERNEL_SIZE);
  88         }
  89     }
  90     t1 = now_ms();
  91     time_c = t1 - t0;
  92
  93     asprintf(&str, "FIR Filter benchmark:\nC version          : %g ms\n", time_c);
  94     strlcpy(buffer, str, sizeof buffer);
  95     free(str);
  96
  97     strlcat(buffer, "Neon version   : ", sizeof buffer);
  98
  99     if (android_getCpuFamily() != ANDROID_CPU_FAMILY_ARM) {
 100         strlcat(buffer, "Not an ARM CPU !\n", sizeof buffer);
 101         goto EXIT;
 102     }
 103
 104     features = android_getCpuFeatures();
 105     if ((features & ANDROID_CPU_ARM_FEATURE_ARMv7) == 0) {
 106         strlcat(buffer, "Not an ARMv7 CPU !\n", sizeof buffer);
 107         goto EXIT;
 108     }
 109
 110     /* HAVE_NEON is defined in Android.mk ! */
 111 #ifdef HAVE_NEON
 112     if ((features & ANDROID_CPU_ARM_FEATURE_NEON) == 0) {
 113         strlcat(buffer, "CPU doesn't support NEON !\n", sizeof buffer);
 114         goto EXIT;
 115     }
 116
 117     /* Benchmark small FIR filter loop - Neon version */
 118     t0 = now_ms();
 119     {
 120         int  count = FIR_ITERATIONS;
 121         for (; count > 0; count--) {
 122             fir_filter_neon_intrinsics(fir_output, fir_input, fir_kernel, FIR_OUTPUT_SIZE, FIR_KERNEL_SIZE);
 123         }
 124     }
 125     t1 = now_ms();
 126     time_neon = t1 - t0;
 127     asprintf(&str, "%g ms (x%g faster)\n", time_neon, time_c / (time_neon < 1e-6 ? 1. : time_neon));
 128     strlcat(buffer, str, sizeof buffer);
 129     free(str);
 130
 131     /* check the result, just in case */
 132     {
 133         int  nn, fails = 0;
 134         for (nn = 0; nn < FIR_OUTPUT_SIZE; nn++) {
 135             if (fir_output[nn] != fir_output_expected[nn]) {
 136                 if (++fails < 16)
 137                     D("neon[%d] = %d expected %d", nn, fir_output[nn], fir_output_expected[nn]);
 138             }
 139         }
 140         D("%d fails\n", fails);
 141     }
 142 #else /* !HAVE_NEON */
 143     strlcat(buffer, "Program not compiled with ARMv7 support !\n", sizeof buffer);
 144 #endif /* !HAVE_NEON */
 145 EXIT:
 146     return (*env)->NewStringUTF(env, buffer);
 147 }