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 #if defined(SK_BUILD_FOR_ANDROID)
20 # include <cpu-features.h>
21 #endif
22
23 // A function used to determine at runtime if the target CPU supports
24 // the ARM NEON instruction set. This implementation is Linux-specific.
sk_cpu_arm_check_neon(void)25 static bool sk_cpu_arm_check_neon(void) {
26 // If we fail any of the following, assume we don't have NEON instructions
27 // This allows us to return immediately in case of error.
28 bool result = false;
29
30 // Use the Android NDK's cpu-features helper library to detect NEON at runtime.
31 // See http://crbug.com/164154 to see why this is needed in Chromium for Android.
32 #ifdef SK_BUILD_FOR_ANDROID
33
34 result = (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
35
36 #else // SK_BUILD_FOR_ANDROID
37
38 // There is no user-accessible CPUID instruction on ARM that we can use.
39 // Instead, we must parse /proc/cpuinfo and look for the 'neon' feature.
40 // For example, here's a typical output (Nexus S running ICS 4.0.3):
41 /*
42 Processor : ARMv7 Processor rev 2 (v7l)
43 BogoMIPS : 994.65
44 Features : swp half thumb fastmult vfp edsp thumbee neon vfpv3
45 CPU implementer : 0x41
46 CPU architecture: 7
47 CPU variant : 0x2
48 CPU part : 0xc08
49 CPU revision : 2
50
51 Hardware : herring
52 Revision : 000b
53 Serial : 3833c77d6dc000ec
54 */
55 char buffer[4096];
56
57 do {
58 // open /proc/cpuinfo
59 int fd = TEMP_FAILURE_RETRY(open("/proc/cpuinfo", O_RDONLY));
60 if (fd < 0) {
61 SkDebugf("Could not open /proc/cpuinfo: %s\n", strerror(errno));
62 break;
63 }
64
65 // Read the file. To simplify our search, we're going to place two
66 // sentinel '\n' characters: one at the start of the buffer, and one at
67 // the end. This means we reserve the first and last buffer bytes.
68 buffer[0] = '\n';
69 int size = TEMP_FAILURE_RETRY(read(fd, buffer+1, sizeof(buffer)-2));
70 close(fd);
71
72 if (size < 0) { // should not happen
73 SkDebugf("Could not read /proc/cpuinfo: %s\n", strerror(errno));
74 break;
75 }
76
77 SkDebugf("START /proc/cpuinfo:\n%.*s\nEND /proc/cpuinfo\n",
78 size, buffer+1);
79
80 // Compute buffer limit, and place final sentinel
81 char* buffer_end = buffer + 1 + size;
82 buffer_end[0] = '\n';
83
84 // Now, find a line that starts with "Features", i.e. look for
85 // '\nFeatures ' in our buffer.
86 const char features[] = "\nFeatures\t";
87 const size_t features_len = sizeof(features)-1;
88
89 char* line = (char*) memmem(buffer, buffer_end - buffer,
90 features, features_len);
91 if (line == nullptr) { // Weird, no Features line, bad kernel?
92 SkDebugf("Could not find a line starting with 'Features'"
93 "in /proc/cpuinfo ?\n");
94 break;
95 }
96
97 line += features_len; // Skip the "\nFeatures\t" prefix
98
99 // Find the end of the current line
100 char* line_end = (char*) memchr(line, '\n', buffer_end - line);
101 if (line_end == nullptr)
102 line_end = buffer_end;
103
104 // Now find an instance of 'neon' in the flags list. We want to
105 // ensure it's only 'neon' and not something fancy like 'noneon'
106 // so check that it follows a space.
107 const char neon[] = " neon";
108 const size_t neon_len = sizeof(neon)-1;
109 const char* flag = (const char*) memmem(line, line_end - line,
110 neon, neon_len);
111 if (flag == nullptr)
112 break;
113
114 // Ensure it is followed by a space or a newline.
115 if (flag[neon_len] != ' ' && flag[neon_len] != '\n')
116 break;
117
118 // Fine, we support Arm NEON !
119 result = true;
120
121 } while (0);
122
123 #endif // SK_BUILD_FOR_ANDROID
124
125 if (result) {
126 SkDEBUGF(("Device supports ARM NEON instructions!\n"));
127 } else {
128 SkDEBUGF(("Device does NOT support ARM NEON instructions!\n"));
129 }
130 return result;
131 }
132
133 static pthread_once_t sOnce;
134 static bool sHasArmNeon;
135
136 // called through pthread_once()
sk_cpu_arm_probe_features(void)137 void sk_cpu_arm_probe_features(void) {
138 sHasArmNeon = sk_cpu_arm_check_neon();
139 }
140
sk_cpu_arm_has_neon(void)141 bool sk_cpu_arm_has_neon(void) {
142 pthread_once(&sOnce, sk_cpu_arm_probe_features);
143 return sHasArmNeon;
144 }
145
146 #endif // SK_ARM_NEON_IS_DYNAMIC
147