1 2 /* 3 * Copyright 2012 The Android Open Source Project 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9 #include "SkUtilsArm.h" 10 11 #if SK_ARM_NEON_IS_DYNAMIC 12 13 #include <unistd.h> 14 #include <fcntl.h> 15 #include <errno.h> 16 #include <string.h> 17 #include <pthread.h> 18 19 // Set USE_ANDROID_NDK_CPU_FEATURES to use the Android NDK's 20 // cpu-features helper library to detect NEON at runtime. See 21 // http://crbug.com/164154 to see why this is needed in Chromium 22 // for Android. 23 #if !defined(USE_ANDROID_NDK_CPU_FEATURES) 24 # if defined(SK_BUILD_FOR_ANDROID) 25 # define USE_ANDROID_NDK_CPU_FEATURES 1 26 # else 27 # define USE_ANDROID_NDK_CPU_FEATURES 0 28 # endif 29 #endif 30 31 #if USE_ANDROID_NDK_CPU_FEATURES 32 # include <cpu-features.h> 33 #endif 34 35 // Set NEON_DEBUG to 1 to allow debugging of the CPU features probing. 36 // For now, we always set it for SK_DEBUG builds. 37 #ifdef SK_DEBUG 38 # define NEON_DEBUG 1 39 #else 40 # define NEON_DEBUG 0 41 #endif 42 43 #if NEON_DEBUG 44 # ifdef SK_BUILD_FOR_ANDROID 45 // used to declare PROP_VALUE_MAX and __system_property_get() 46 # include <sys/system_properties.h> 47 # endif 48 #endif 49 50 // A function used to determine at runtime if the target CPU supports 51 // the ARM NEON instruction set. This implementation is Linux-specific. 52 static bool sk_cpu_arm_check_neon(void) { 53 bool result = false; 54 55 #if NEON_DEBUG 56 // Allow forcing the mode through the environment during debugging. 57 # ifdef SK_BUILD_FOR_ANDROID 58 // On Android, we use a system property 59 # define PROP_NAME "debug.skia.arm_neon_mode" 60 char prop[PROP_VALUE_MAX]; 61 if (__system_property_get(PROP_NAME, prop) > 0) { 62 # else 63 # define PROP_NAME "SKIA_ARM_NEON_MODE" 64 // On ARM Linux, we use an environment variable 65 const char* prop = getenv(PROP_NAME); 66 if (prop != NULL) { 67 # endif 68 SkDebugf("%s: %s", PROP_NAME, prop); 69 if (!strcmp(prop, "1")) { 70 SkDebugf("Forcing ARM Neon mode to full!\n"); 71 return true; 72 } 73 if (!strcmp(prop, "0")) { 74 SkDebugf("Disabling ARM NEON mode\n"); 75 return false; 76 } 77 } 78 SkDebugf("Running dynamic CPU feature detection\n"); 79 #endif 80 81 #if USE_ANDROID_NDK_CPU_FEATURES 82 83 result = (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0; 84 85 #else // USE_ANDROID_NDK_CPU_FEATURES 86 87 // There is no user-accessible CPUID instruction on ARM that we can use. 88 // Instead, we must parse /proc/cpuinfo and look for the 'neon' feature. 89 // For example, here's a typical output (Nexus S running ICS 4.0.3): 90 /* 91 Processor : ARMv7 Processor rev 2 (v7l) 92 BogoMIPS : 994.65 93 Features : swp half thumb fastmult vfp edsp thumbee neon vfpv3 94 CPU implementer : 0x41 95 CPU architecture: 7 96 CPU variant : 0x2 97 CPU part : 0xc08 98 CPU revision : 2 99 100 Hardware : herring 101 Revision : 000b 102 Serial : 3833c77d6dc000ec 103 */ 104 char buffer[4096]; 105 106 // If we fail any of the following, assume we don't have NEON instructions 107 // This allows us to return immediately in case of error. 108 result = false; 109 110 do { 111 // open /proc/cpuinfo 112 int fd = TEMP_FAILURE_RETRY(open("/proc/cpuinfo", O_RDONLY)); 113 if (fd < 0) { 114 SkDebugf("Could not open /proc/cpuinfo: %s\n", strerror(errno)); 115 break; 116 } 117 118 // Read the file. To simplify our search, we're going to place two 119 // sentinel '\n' characters: one at the start of the buffer, and one at 120 // the end. This means we reserve the first and last buffer bytes. 121 buffer[0] = '\n'; 122 int size = TEMP_FAILURE_RETRY(read(fd, buffer+1, sizeof(buffer)-2)); 123 close(fd); 124 125 if (size < 0) { // should not happen 126 SkDebugf("Could not read /proc/cpuinfo: %s\n", strerror(errno)); 127 break; 128 } 129 130 SkDebugf("START /proc/cpuinfo:\n%.*s\nEND /proc/cpuinfo\n", 131 size, buffer+1); 132 133 // Compute buffer limit, and place final sentinel 134 char* buffer_end = buffer + 1 + size; 135 buffer_end[0] = '\n'; 136 137 // Now, find a line that starts with "Features", i.e. look for 138 // '\nFeatures ' in our buffer. 139 const char features[] = "\nFeatures\t"; 140 const size_t features_len = sizeof(features)-1; 141 142 char* line = (char*) memmem(buffer, buffer_end - buffer, 143 features, features_len); 144 if (line == NULL) { // Weird, no Features line, bad kernel? 145 SkDebugf("Could not find a line starting with 'Features'" 146 "in /proc/cpuinfo ?\n"); 147 break; 148 } 149 150 line += features_len; // Skip the "\nFeatures\t" prefix 151 152 // Find the end of the current line 153 char* line_end = (char*) memchr(line, '\n', buffer_end - line); 154 if (line_end == NULL) 155 line_end = buffer_end; 156 157 // Now find an instance of 'neon' in the flags list. We want to 158 // ensure it's only 'neon' and not something fancy like 'noneon' 159 // so check that it follows a space. 160 const char neon[] = " neon"; 161 const size_t neon_len = sizeof(neon)-1; 162 const char* flag = (const char*) memmem(line, line_end - line, 163 neon, neon_len); 164 if (flag == NULL) 165 break; 166 167 // Ensure it is followed by a space or a newline. 168 if (flag[neon_len] != ' ' && flag[neon_len] != '\n') 169 break; 170 171 // Fine, we support Arm NEON ! 172 result = true; 173 174 } while (0); 175 176 #endif // USE_ANDROID_NDK_CPU_FEATURES 177 178 if (result) { 179 SkDebugf("Device supports ARM NEON instructions!\n"); 180 } else { 181 SkDebugf("Device does NOT support ARM NEON instructions!\n"); 182 } 183 return result; 184 } 185 186 static pthread_once_t sOnce; 187 static bool sHasArmNeon; 188 189 // called through pthread_once() 190 void sk_cpu_arm_probe_features(void) { 191 sHasArmNeon = sk_cpu_arm_check_neon(); 192 } 193 194 bool sk_cpu_arm_has_neon(void) { 195 pthread_once(&sOnce, sk_cpu_arm_probe_features); 196 return sHasArmNeon; 197 } 198 199 #endif // SK_ARM_NEON_IS_DYNAMIC 200
