cpu.c (7417B)
1 /* 2 * Copyright © 2018, VideoLAN and dav1d authors 3 * Copyright © 2018, Janne Grunau 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright notice, this 10 * list of conditions and the following disclaimer. 11 * 12 * 2. Redistributions in binary form must reproduce the above copyright notice, 13 * this list of conditions and the following disclaimer in the documentation 14 * and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include "config.h" 29 30 #include "common/attributes.h" 31 32 #include "src/cpu.h" 33 #include "src/arm/cpu.h" 34 35 #if HAVE_GETAUXVAL || HAVE_ELF_AUX_INFO 36 #include <sys/auxv.h> 37 38 #if ARCH_AARCH64 39 40 #define HWCAP_AARCH64_ASIMDDP (1 << 20) 41 #define HWCAP_AARCH64_SVE (1 << 22) 42 #define HWCAP2_AARCH64_SVE2 (1 << 1) 43 #define HWCAP2_AARCH64_I8MM (1 << 13) 44 45 COLD unsigned dav1d_get_cpu_flags_arm(void) { 46 unsigned long hw_cap = dav1d_getauxval(AT_HWCAP); 47 unsigned long hw_cap2 = dav1d_getauxval(AT_HWCAP2); 48 49 unsigned flags = dav1d_get_default_cpu_flags(); 50 flags |= (hw_cap & HWCAP_AARCH64_ASIMDDP) ? DAV1D_ARM_CPU_FLAG_DOTPROD : 0; 51 flags |= (hw_cap2 & HWCAP2_AARCH64_I8MM) ? DAV1D_ARM_CPU_FLAG_I8MM : 0; 52 flags |= (hw_cap & HWCAP_AARCH64_SVE) ? DAV1D_ARM_CPU_FLAG_SVE : 0; 53 flags |= (hw_cap2 & HWCAP2_AARCH64_SVE2) ? DAV1D_ARM_CPU_FLAG_SVE2 : 0; 54 return flags; 55 } 56 #else /* !ARCH_AARCH64 */ 57 58 #ifndef HWCAP_ARM_NEON 59 #define HWCAP_ARM_NEON (1 << 12) 60 #endif 61 #define HWCAP_ARM_ASIMDDP (1 << 24) 62 #define HWCAP_ARM_I8MM (1 << 27) 63 64 COLD unsigned dav1d_get_cpu_flags_arm(void) { 65 unsigned long hw_cap = dav1d_getauxval(AT_HWCAP); 66 67 unsigned flags = dav1d_get_default_cpu_flags(); 68 flags |= (hw_cap & HWCAP_ARM_NEON) ? DAV1D_ARM_CPU_FLAG_NEON : 0; 69 flags |= (hw_cap & HWCAP_ARM_ASIMDDP) ? DAV1D_ARM_CPU_FLAG_DOTPROD : 0; 70 flags |= (hw_cap & HWCAP_ARM_I8MM) ? DAV1D_ARM_CPU_FLAG_I8MM : 0; 71 return flags; 72 } 73 #endif /* ARCH_AARCH64 */ 74 75 #elif defined(__APPLE__) 76 #include <sys/sysctl.h> 77 78 static int have_feature(const char *feature) { 79 int supported = 0; 80 size_t size = sizeof(supported); 81 if (sysctlbyname(feature, &supported, &size, NULL, 0) != 0) { 82 return 0; 83 } 84 return supported; 85 } 86 87 COLD unsigned dav1d_get_cpu_flags_arm(void) { 88 unsigned flags = dav1d_get_default_cpu_flags(); 89 if (have_feature("hw.optional.arm.FEAT_DotProd")) 90 flags |= DAV1D_ARM_CPU_FLAG_DOTPROD; 91 if (have_feature("hw.optional.arm.FEAT_I8MM")) 92 flags |= DAV1D_ARM_CPU_FLAG_I8MM; 93 /* No SVE and SVE2 feature detection available on Apple platforms. */ 94 return flags; 95 } 96 97 #elif defined(__OpenBSD__) && ARCH_AARCH64 98 #include <machine/armreg.h> 99 #include <machine/cpu.h> 100 #include <sys/types.h> 101 #include <sys/sysctl.h> 102 103 COLD unsigned dav1d_get_cpu_flags_arm(void) { 104 unsigned flags = dav1d_get_default_cpu_flags(); 105 106 #ifdef CPU_ID_AA64ISAR0 107 int mib[2]; 108 uint64_t isar0; 109 uint64_t isar1; 110 size_t len; 111 112 mib[0] = CTL_MACHDEP; 113 mib[1] = CPU_ID_AA64ISAR0; 114 len = sizeof(isar0); 115 if (sysctl(mib, 2, &isar0, &len, NULL, 0) != -1) { 116 if (ID_AA64ISAR0_DP(isar0) >= ID_AA64ISAR0_DP_IMPL) 117 flags |= DAV1D_ARM_CPU_FLAG_DOTPROD; 118 } 119 120 mib[0] = CTL_MACHDEP; 121 mib[1] = CPU_ID_AA64ISAR1; 122 len = sizeof(isar1); 123 if (sysctl(mib, 2, &isar1, &len, NULL, 0) != -1) { 124 #ifdef ID_AA64ISAR1_I8MM_IMPL 125 if (ID_AA64ISAR1_I8MM(isar1) >= ID_AA64ISAR1_I8MM_IMPL) 126 flags |= DAV1D_ARM_CPU_FLAG_I8MM; 127 #endif 128 } 129 #endif 130 131 return flags; 132 } 133 134 #elif defined(_WIN32) 135 #include <windows.h> 136 137 COLD unsigned dav1d_get_cpu_flags_arm(void) { 138 unsigned flags = dav1d_get_default_cpu_flags(); 139 #ifdef PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE 140 if (IsProcessorFeaturePresent(PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE)) 141 flags |= DAV1D_ARM_CPU_FLAG_DOTPROD; 142 #endif 143 #ifdef PF_ARM_SVE_INSTRUCTIONS_AVAILABLE 144 if (IsProcessorFeaturePresent(PF_ARM_SVE_INSTRUCTIONS_AVAILABLE)) 145 flags |= DAV1D_ARM_CPU_FLAG_SVE; 146 #endif 147 #ifdef PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE 148 if (IsProcessorFeaturePresent(PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE)) 149 flags |= DAV1D_ARM_CPU_FLAG_SVE2; 150 #endif 151 #ifdef PF_ARM_SVE_I8MM_INSTRUCTIONS_AVAILABLE 152 /* There's no PF_* flag that indicates whether plain I8MM is available 153 * or not. But if SVE_I8MM is available, that also implies that 154 * regular I8MM is available. */ 155 if (IsProcessorFeaturePresent(PF_ARM_SVE_I8MM_INSTRUCTIONS_AVAILABLE)) 156 flags |= DAV1D_ARM_CPU_FLAG_I8MM; 157 #endif 158 return flags; 159 } 160 161 #elif defined(__ANDROID__) || defined(__linux__) 162 #include <ctype.h> 163 #include <stdio.h> 164 #include <string.h> 165 166 static unsigned parse_proc_cpuinfo(const char *flag) { 167 FILE *file = fopen("/proc/cpuinfo", "r"); 168 if (!file) 169 return 0; 170 171 char line_buffer[120]; 172 const char *line; 173 174 size_t flaglen = strlen(flag); 175 while ((line = fgets(line_buffer, sizeof(line_buffer), file))) { 176 // check all occurances as whole words 177 const char *found = line; 178 while ((found = strstr(found, flag))) { 179 if ((found == line_buffer || !isgraph(found[-1])) && 180 (isspace(found[flaglen]) || feof(file))) { 181 fclose(file); 182 return 1; 183 } 184 found += flaglen; 185 } 186 // if line is incomplete seek back to avoid splitting the search 187 // string into two buffers 188 if (!strchr(line, '\n') && strlen(line) > flaglen) { 189 // use fseek since the 64 bit fseeko is only available since 190 // Android API level 24 and meson defines _FILE_OFFSET_BITS 191 // by default 64 192 if (fseek(file, -flaglen, SEEK_CUR)) 193 break; 194 } 195 } 196 197 fclose(file); 198 199 return 0; 200 } 201 202 COLD unsigned dav1d_get_cpu_flags_arm(void) { 203 unsigned flags = dav1d_get_default_cpu_flags(); 204 flags |= parse_proc_cpuinfo("neon") ? DAV1D_ARM_CPU_FLAG_NEON : 0; 205 flags |= parse_proc_cpuinfo("asimd") ? DAV1D_ARM_CPU_FLAG_NEON : 0; 206 flags |= parse_proc_cpuinfo("asimddp") ? DAV1D_ARM_CPU_FLAG_DOTPROD : 0; 207 flags |= parse_proc_cpuinfo("i8mm") ? DAV1D_ARM_CPU_FLAG_I8MM : 0; 208 #if ARCH_AARCH64 209 flags |= parse_proc_cpuinfo("sve") ? DAV1D_ARM_CPU_FLAG_SVE : 0; 210 flags |= parse_proc_cpuinfo("sve2") ? DAV1D_ARM_CPU_FLAG_SVE2 : 0; 211 #endif /* ARCH_AARCH64 */ 212 return flags; 213 } 214 215 #else /* Unsupported OS */ 216 217 COLD unsigned dav1d_get_cpu_flags_arm(void) { 218 return dav1d_get_default_cpu_flags(); 219 } 220 221 #endif