Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: CPL - Common Portability Library
4 : * Purpose: CPU features detection
5 : * Author: Even Rouault, <even dot rouault at spatialys dot com>
6 : *
7 : ******************************************************************************
8 : * Copyright (c) 2016, Even Rouault <even dot rouault at spatialys dot com>
9 : *
10 : * SPDX-License-Identifier: MIT
11 : ****************************************************************************/
12 :
13 : #include "cpl_port.h"
14 : #include "cpl_string.h"
15 : #include "cpl_cpu_features.h"
16 :
17 : //! @cond Doxygen_Suppress
18 :
19 : #define CPUID_SSSE3_ECX_BIT 9
20 : #define CPUID_OSXSAVE_ECX_BIT 27
21 : #define CPUID_AVX_ECX_BIT 28
22 :
23 : #define CPUID_SSE_EDX_BIT 25
24 :
25 : #define BIT_XMM_STATE (1 << 1)
26 : #define BIT_YMM_STATE (2 << 1)
27 :
28 : #define REG_EAX 0
29 : #define REG_EBX 1
30 : #define REG_ECX 2
31 : #define REG_EDX 3
32 :
33 : #if defined(__GNUC__)
34 : #if defined(__x86_64)
35 : #define GCC_CPUID(level, a, b, c, d) \
36 : __asm__("xchgq %%rbx, %q1\n" \
37 : "cpuid\n" \
38 : "xchgq %%rbx, %q1" \
39 : : "=a"(a), "=r"(b), "=c"(c), "=d"(d) \
40 : : "0"(level))
41 : #else
42 : #define GCC_CPUID(level, a, b, c, d) \
43 : __asm__("xchgl %%ebx, %1\n" \
44 : "cpuid\n" \
45 : "xchgl %%ebx, %1" \
46 : : "=a"(a), "=r"(b), "=c"(c), "=d"(d) \
47 : : "0"(level))
48 : #endif
49 :
50 : #define CPL_CPUID(level, array) \
51 : GCC_CPUID(level, array[0], array[1], array[2], array[3])
52 :
53 : #elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
54 :
55 : #include <intrin.h>
56 : #define CPL_CPUID(level, array) __cpuid(array, level)
57 :
58 : #endif
59 :
60 : #if defined(HAVE_SSE_AT_COMPILE_TIME) && !defined(HAVE_INLINE_SSE)
61 :
62 : /************************************************************************/
63 : /* CPLHaveRuntimeSSE() */
64 : /************************************************************************/
65 :
66 : bool CPLHaveRuntimeSSE()
67 : {
68 : int cpuinfo[4] = {0, 0, 0, 0};
69 : CPL_CPUID(1, cpuinfo);
70 : return (cpuinfo[REG_EDX] & (1 << CPUID_SSE_EDX_BIT)) != 0;
71 : }
72 :
73 : #endif
74 :
75 : #if defined(HAVE_SSSE3_AT_COMPILE_TIME) && !defined(HAVE_INLINE_SSSE3)
76 :
77 : /************************************************************************/
78 : /* CPLHaveRuntimeSSSE3() */
79 : /************************************************************************/
80 :
81 567195 : static inline bool CPLDetectSSSE3()
82 : {
83 567195 : int cpuinfo[4] = {0, 0, 0, 0};
84 567195 : CPL_CPUID(1, cpuinfo);
85 567195 : return (cpuinfo[REG_ECX] & (1 << CPUID_SSSE3_ECX_BIT)) != 0;
86 : }
87 :
88 : #if defined(__GNUC__) && !defined(DEBUG)
89 : bool bCPLHasSSSE3 = false;
90 : static void CPLHaveRuntimeSSSE3Initialize() __attribute__((constructor));
91 :
92 : static void CPLHaveRuntimeSSSE3Initialize()
93 : {
94 : bCPLHasSSSE3 = CPLDetectSSSE3();
95 : }
96 : #else
97 567098 : bool CPLHaveRuntimeSSSE3()
98 : {
99 : #ifdef DEBUG
100 567098 : if (!CPLTestBool(CPLGetConfigOption("GDAL_USE_SSSE3", "YES")))
101 3 : return false;
102 : #endif
103 567200 : return CPLDetectSSSE3();
104 : }
105 : #endif
106 :
107 : #endif // defined(HAVE_SSSE3_AT_COMPILE_TIME) && !defined(HAVE_INLINE_SSSE3)
108 :
109 : #if defined(HAVE_AVX_AT_COMPILE_TIME) && !defined(HAVE_INLINE_AVX)
110 :
111 : /************************************************************************/
112 : /* CPLHaveRuntimeAVX() */
113 : /************************************************************************/
114 :
115 : #if defined(__GNUC__)
116 :
117 1642 : static bool CPLDetectRuntimeAVX()
118 : {
119 1642 : int cpuinfo[4] = {0, 0, 0, 0};
120 1642 : CPL_CPUID(1, cpuinfo);
121 :
122 : // Check OSXSAVE feature.
123 1642 : if ((cpuinfo[REG_ECX] & (1 << CPUID_OSXSAVE_ECX_BIT)) == 0)
124 : {
125 0 : return false;
126 : }
127 :
128 : // Check AVX feature.
129 1642 : if ((cpuinfo[REG_ECX] & (1 << CPUID_AVX_ECX_BIT)) == 0)
130 : {
131 0 : return false;
132 : }
133 :
134 : // Issue XGETBV and check the XMM and YMM state bit.
135 : unsigned int nXCRLow;
136 : unsigned int nXCRHigh;
137 1642 : __asm__("xgetbv" : "=a"(nXCRLow), "=d"(nXCRHigh) : "c"(0));
138 1642 : if ((nXCRLow & (BIT_XMM_STATE | BIT_YMM_STATE)) !=
139 : (BIT_XMM_STATE | BIT_YMM_STATE))
140 : {
141 0 : return false;
142 : }
143 1642 : CPL_IGNORE_RET_VAL(nXCRHigh); // unused
144 :
145 1642 : return true;
146 : }
147 :
148 : bool bCPLHasAVX = false;
149 : static void CPLHaveRuntimeAVXInitialize() __attribute__((constructor(101)));
150 :
151 1642 : static void CPLHaveRuntimeAVXInitialize()
152 : {
153 1642 : bCPLHasAVX = CPLDetectRuntimeAVX();
154 1642 : }
155 :
156 : #elif defined(_MSC_VER)
157 : bool CPLHaveRuntimeAVX()
158 : {
159 : static const bool bHasAVX = []() -> bool
160 : {
161 : int cpuinfo[4] = {0, 0, 0, 0};
162 : CPL_CPUID(1, cpuinfo);
163 :
164 : // Check OSXSAVE feature.
165 : if ((cpuinfo[REG_ECX] & (1 << CPUID_OSXSAVE_ECX_BIT)) == 0)
166 : {
167 : return false;
168 : }
169 :
170 : // Check AVX feature.
171 : if ((cpuinfo[REG_ECX] & (1 << CPUID_AVX_ECX_BIT)) == 0)
172 : {
173 : return false;
174 : }
175 :
176 : // Issue XGETBV and check the XMM and YMM state bit.
177 : unsigned __int64 xcrFeatureMask = _xgetbv(_XCR_XFEATURE_ENABLED_MASK);
178 : if ((xcrFeatureMask & (BIT_XMM_STATE | BIT_YMM_STATE)) !=
179 : (BIT_XMM_STATE | BIT_YMM_STATE))
180 : {
181 : return false;
182 : }
183 :
184 : return true;
185 : }();
186 :
187 : return bHasAVX;
188 : }
189 :
190 : #else
191 :
192 : bool CPLHaveRuntimeAVX()
193 : {
194 : return false;
195 : }
196 :
197 : #endif
198 :
199 : #endif // defined(HAVE_AVX_AT_COMPILE_TIME) && !defined(HAVE_INLINE_AVX)
200 :
201 : #if defined(HAVE_AVX2_AT_COMPILE_TIME) && !defined(HAVE_INLINE_AVX2)
202 :
203 : #if defined(__GNUC__)
204 :
205 : bool bCPLHasAVX2 = false;
206 : // Use 102 because CPLHaveRuntimeAVXInitialize() uses 101, so we are run
207 : // afterwards
208 : static void CPLHaveRuntimeAVX2Initialize() __attribute__((constructor(102)));
209 :
210 1642 : static void CPLHaveRuntimeAVX2Initialize()
211 : {
212 1642 : bCPLHasAVX2 = CPLHaveRuntimeAVX() && __builtin_cpu_supports("avx2");
213 1642 : }
214 :
215 : #else
216 :
217 : /************************************************************************/
218 : /* CPLHaveRuntimeAVX2() */
219 : /************************************************************************/
220 :
221 : bool CPLHaveRuntimeAVX2()
222 : {
223 : static const bool bHasAVX2 = []() -> bool
224 : {
225 : #if defined(_MSC_VER)
226 : if (!CPLHaveRuntimeAVX())
227 : return false;
228 : int cpuInfo[4] = {};
229 : __cpuidex(cpuInfo, 7, 0);
230 : return (cpuInfo[REG_EBX] & (1 << 5)) != 0; // EBX bit 5 = AVX2
231 : #else
232 : return false;
233 : #endif
234 : }();
235 : return bHasAVX2;
236 : }
237 :
238 : #endif
239 :
240 : #endif // defined(HAVE_AVX2_AT_COMPILE_TIME) && !defined(HAVE_INLINE_AVX2)
241 :
242 : //! @endcond
|
