cpu.c 12 KB
Newer Older
Laurent Aimar's avatar
Laurent Aimar committed
1
/*****************************************************************************
Fiona Glaser's avatar
Fiona Glaser committed
2
 * cpu.c: cpu detection
Laurent Aimar's avatar
Laurent Aimar committed
3
 *****************************************************************************
Sean McGovern's avatar
Sean McGovern committed
4
 * Copyright (C) 2003-2011 x264 project
Laurent Aimar's avatar
Laurent Aimar committed
5
 *
6 7
 * Authors: Loren Merritt <lorenm@u.washington.edu>
 *          Laurent Aimar <fenrir@via.ecp.fr>
8
 *          Fiona Glaser <fiona@x264.com>
Laurent Aimar's avatar
Laurent Aimar committed
9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
Fiona Glaser's avatar
Fiona Glaser committed
23 24 25
 *
 * This program is also available under a commercial proprietary license.
 * For more information, contact us at licensing@x264.com.
Laurent Aimar's avatar
Laurent Aimar committed
26 27
 *****************************************************************************/

28 29 30 31
#define _GNU_SOURCE // for sched_getaffinity
#include "common.h"
#include "cpu.h"

32
#if HAVE_POSIXTHREAD && SYS_LINUX
33 34
#include <sched.h>
#endif
Steven Walters's avatar
Steven Walters committed
35
#if SYS_BEOS
36 37
#include <kernel/OS.h>
#endif
Steven Walters's avatar
Steven Walters committed
38
#if SYS_MACOSX || SYS_FREEBSD
39 40 41
#include <sys/types.h>
#include <sys/sysctl.h>
#endif
Steven Walters's avatar
Steven Walters committed
42
#if SYS_OPENBSD
43 44 45 46
#include <sys/param.h>
#include <sys/sysctl.h>
#include <machine/cpu.h>
#endif
47

48 49
const x264_cpu_name_t x264_cpu_names[] =
{
50 51
    {"Altivec", X264_CPU_ALTIVEC},
//  {"MMX",     X264_CPU_MMX}, // we don't support asm on mmx1 cpus anymore
52 53
    {"MMX2",    X264_CPU_MMX|X264_CPU_MMXEXT},
    {"MMXEXT",  X264_CPU_MMX|X264_CPU_MMXEXT},
54 55
//  {"SSE",     X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE}, // there are no sse1 functions in x264
    {"SSE2Slow",X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE|X264_CPU_SSE2|X264_CPU_SSE2_IS_SLOW},
56
    {"SSE2",    X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE|X264_CPU_SSE2},
57
    {"SSE2Fast",X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE|X264_CPU_SSE2|X264_CPU_SSE2_IS_FAST},
58 59
    {"SSE3",    X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE|X264_CPU_SSE2|X264_CPU_SSE3},
    {"SSSE3",   X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE|X264_CPU_SSE2|X264_CPU_SSE3|X264_CPU_SSSE3},
Fiona Glaser's avatar
Fiona Glaser committed
60
    {"FastShuffle",   X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE|X264_CPU_SSE2|X264_CPU_SHUFFLE_IS_FAST},
61 62
    {"SSE4.1",  X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE|X264_CPU_SSE2|X264_CPU_SSE3|X264_CPU_SSSE3|X264_CPU_SSE4},
    {"SSE4.2",  X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE|X264_CPU_SSE2|X264_CPU_SSE3|X264_CPU_SSSE3|X264_CPU_SSE4|X264_CPU_SSE42},
Fiona Glaser's avatar
Fiona Glaser committed
63
    {"AVX", X264_CPU_AVX},
64 65
    {"Cache32", X264_CPU_CACHELINE_32},
    {"Cache64", X264_CPU_CACHELINE_64},
Fiona Glaser's avatar
Fiona Glaser committed
66
    {"SSEMisalign", X264_CPU_SSE_MISALIGN},
67
    {"LZCNT", X264_CPU_LZCNT},
68
    {"Slow_mod4_stack", X264_CPU_STACK_MOD4},
69 70 71
    {"ARMv6", X264_CPU_ARMV6},
    {"NEON",  X264_CPU_NEON},
    {"Fast_NEON_MRC",  X264_CPU_FAST_NEON_MRC},
72 73
    {"SlowCTZ", X264_CPU_SLOW_CTZ},
    {"SlowAtom", X264_CPU_SLOW_ATOM},
74 75 76
    {"", 0},
};

Steven Walters's avatar
Steven Walters committed
77
#if (ARCH_PPC && SYS_LINUX) || (ARCH_ARM && !HAVE_NEON)
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
#include <signal.h>
#include <setjmp.h>
static sigjmp_buf jmpbuf;
static volatile sig_atomic_t canjump = 0;

static void sigill_handler( int sig )
{
    if( !canjump )
    {
        signal( sig, SIG_DFL );
        raise( sig );
    }

    canjump = 0;
    siglongjmp( jmpbuf, 1 );
}
#endif
Fiona Glaser's avatar
Fiona Glaser committed
95

Steven Walters's avatar
Steven Walters committed
96
#if HAVE_MMX
Anton Mitrofanov's avatar
Anton Mitrofanov committed
97
int x264_cpu_cpuid_test( void );
98
void x264_cpu_cpuid( uint32_t op, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx );
Fiona Glaser's avatar
Fiona Glaser committed
99
void x264_cpu_xgetbv( uint32_t op, uint32_t *eax, uint32_t *edx );
Laurent Aimar's avatar
Laurent Aimar committed
100 101 102 103 104

uint32_t x264_cpu_detect( void )
{
    uint32_t cpu = 0;
    uint32_t eax, ebx, ecx, edx;
105
    uint32_t vendor[4] = {0};
106
    uint32_t max_extended_cap;
107
    int cache;
Laurent Aimar's avatar
Laurent Aimar committed
108

Steven Walters's avatar
Steven Walters committed
109
#if !ARCH_X86_64
Laurent Aimar's avatar
Laurent Aimar committed
110 111
    if( !x264_cpu_cpuid_test() )
        return 0;
112
#endif
Laurent Aimar's avatar
Laurent Aimar committed
113

114
    x264_cpu_cpuid( 0, &eax, vendor+0, vendor+2, vendor+1 );
Laurent Aimar's avatar
Laurent Aimar committed
115 116 117 118
    if( eax == 0 )
        return 0;

    x264_cpu_cpuid( 1, &eax, &ebx, &ecx, &edx );
119 120 121
    if( edx&0x00800000 )
        cpu |= X264_CPU_MMX;
    else
Laurent Aimar's avatar
Laurent Aimar committed
122
        return 0;
123
    if( edx&0x02000000 )
Laurent Aimar's avatar
Laurent Aimar committed
124
        cpu |= X264_CPU_MMXEXT|X264_CPU_SSE;
125
    if( edx&0x04000000 )
Laurent Aimar's avatar
Laurent Aimar committed
126
        cpu |= X264_CPU_SSE2;
127
    if( ecx&0x00000001 )
128
        cpu |= X264_CPU_SSE3;
129
    if( ecx&0x00000200 )
130
        cpu |= X264_CPU_SSSE3;
131 132
    if( ecx&0x00080000 )
        cpu |= X264_CPU_SSE4;
133 134
    if( ecx&0x00100000 )
        cpu |= X264_CPU_SSE42;
135 136 137 138 139 140 141 142
    /* Check OXSAVE and AVX bits */
    if( (ecx&0x18000000) == 0x18000000 )
    {
        /* Check for OS support */
        x264_cpu_xgetbv( 0, &eax, &edx );
        if( (eax&0x6) == 0x6 )
            cpu |= X264_CPU_AVX;
    }
Laurent Aimar's avatar
Laurent Aimar committed
143

144 145 146
    if( cpu & X264_CPU_SSSE3 )
        cpu |= X264_CPU_SSE2_IS_FAST;
    if( cpu & X264_CPU_SSE4 )
Fiona Glaser's avatar
Fiona Glaser committed
147
        cpu |= X264_CPU_SHUFFLE_IS_FAST;
148

Laurent Aimar's avatar
Laurent Aimar committed
149
    x264_cpu_cpuid( 0x80000000, &eax, &ebx, &ecx, &edx );
150 151 152
    max_extended_cap = eax;

    if( !strcmp((char*)vendor, "AuthenticAMD") && max_extended_cap >= 0x80000001 )
Laurent Aimar's avatar
Laurent Aimar committed
153
    {
154
        cpu |= X264_CPU_SLOW_CTZ;
155 156 157
        x264_cpu_cpuid( 0x80000001, &eax, &ebx, &ecx, &edx );
        if( edx&0x00400000 )
            cpu |= X264_CPU_MMXEXT;
158 159 160
        if( cpu & X264_CPU_SSE2 )
        {
            if( ecx&0x00000040 ) /* SSE4a */
Fiona Glaser's avatar
Fiona Glaser committed
161
            {
162
                cpu |= X264_CPU_SSE2_IS_FAST;
163
                cpu |= X264_CPU_LZCNT;
Fiona Glaser's avatar
Fiona Glaser committed
164
                cpu |= X264_CPU_SHUFFLE_IS_FAST;
165
                cpu &= ~X264_CPU_SLOW_CTZ;
Fiona Glaser's avatar
Fiona Glaser committed
166
            }
167 168
            else
                cpu |= X264_CPU_SSE2_IS_SLOW;
169 170 171 172 173 174

            if( ecx&0x00000080 ) /* Misalign SSE */
            {
                cpu |= X264_CPU_SSE_MISALIGN;
                x264_cpu_mask_misalign_sse();
            }
175
        }
Laurent Aimar's avatar
Laurent Aimar committed
176 177
    }

178
    if( !strcmp((char*)vendor, "GenuineIntel") )
Laurent Aimar's avatar
Laurent Aimar committed
179
    {
180
        x264_cpu_cpuid( 1, &eax, &ebx, &ecx, &edx );
181 182
        int family = ((eax>>8)&0xf) + ((eax>>20)&0xff);
        int model  = ((eax>>4)&0xf) + ((eax>>12)&0xf0);
183
        if( family == 6 )
184
        {
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
            /* 6/9 (pentium-m "banias"), 6/13 (pentium-m "dothan"), and 6/14 (core1 "yonah")
             * theoretically support sse2, but it's significantly slower than mmx for
             * almost all of x264's functions, so let's just pretend they don't. */
            if( model == 9 || model == 13 || model == 14 )
            {
                cpu &= ~(X264_CPU_SSE2|X264_CPU_SSE3);
                assert(!(cpu&(X264_CPU_SSSE3|X264_CPU_SSE4)));
            }
            /* Detect Atom CPU */
            else if( model == 28 )
            {
                cpu |= X264_CPU_SLOW_ATOM;
                cpu |= X264_CPU_SLOW_CTZ;
            }
            /* Some Penryns and Nehalems are pointlessly crippled (SSE4 disabled), so
             * detect them here. */
            else if( model >= 23 )
                cpu |= X264_CPU_SHUFFLE_IS_FAST;
203
        }
Laurent Aimar's avatar
Laurent Aimar committed
204
    }
205

206
    if( (!strcmp((char*)vendor, "GenuineIntel") || !strcmp((char*)vendor, "CyrixInstead")) && !(cpu&X264_CPU_SSE42))
Laurent Aimar's avatar
Laurent Aimar committed
207
    {
208 209 210 211 212 213 214 215 216 217 218 219
        /* cacheline size is specified in 3 places, any of which may be missing */
        x264_cpu_cpuid( 1, &eax, &ebx, &ecx, &edx );
        cache = (ebx&0xff00)>>5; // cflush size
        if( !cache && max_extended_cap >= 0x80000006 )
        {
            x264_cpu_cpuid( 0x80000006, &eax, &ebx, &ecx, &edx );
            cache = ecx&0xff; // cacheline size
        }
        if( !cache )
        {
            // Cache and TLB Information
            static const char cache32_ids[] = { 0x0a, 0x0c, 0x41, 0x42, 0x43, 0x44, 0x45, 0x82, 0x83, 0x84, 0x85, 0 };
220 221
            static const char cache64_ids[] = { 0x22, 0x23, 0x25, 0x29, 0x2c, 0x46, 0x47, 0x49, 0x60, 0x66, 0x67,
                                                0x68, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7c, 0x7f, 0x86, 0x87, 0 };
222
            uint32_t buf[4];
223
            int max, i = 0;
224 225 226 227
            do {
                x264_cpu_cpuid( 2, buf+0, buf+1, buf+2, buf+3 );
                max = buf[0]&0xff;
                buf[0] &= ~0xff;
228
                for( int j = 0; j < 4; j++ )
229 230 231 232 233 234 235 236 237 238 239
                    if( !(buf[j]>>31) )
                        while( buf[j] )
                        {
                            if( strchr( cache32_ids, buf[j]&0xff ) )
                                cache = 32;
                            if( strchr( cache64_ids, buf[j]&0xff ) )
                                cache = 64;
                            buf[j] >>= 8;
                        }
            } while( ++i < max );
        }
Laurent Aimar's avatar
Laurent Aimar committed
240

241 242 243 244 245
        if( cache == 32 )
            cpu |= X264_CPU_CACHELINE_32;
        else if( cache == 64 )
            cpu |= X264_CPU_CACHELINE_64;
        else
246
            x264_log( NULL, X264_LOG_WARNING, "unable to determine cacheline size\n" );
247
    }
248

Steven Walters's avatar
Steven Walters committed
249
#if BROKEN_STACK_ALIGNMENT
250 251 252
    cpu |= X264_CPU_STACK_MOD4;
#endif

Laurent Aimar's avatar
Laurent Aimar committed
253 254 255
    return cpu;
}

Steven Walters's avatar
Steven Walters committed
256
#elif ARCH_PPC
Laurent Aimar's avatar
Laurent Aimar committed
257

Steven Walters's avatar
Steven Walters committed
258
#if SYS_MACOSX || SYS_OPENBSD
259
#include <sys/sysctl.h>
Laurent Aimar's avatar
Laurent Aimar committed
260 261
uint32_t x264_cpu_detect( void )
{
262
    /* Thank you VLC */
Laurent Aimar's avatar
Laurent Aimar committed
263
    uint32_t cpu = 0;
Steven Walters's avatar
Steven Walters committed
264
#if SYS_OPENBSD
265 266
    int      selectors[2] = { CTL_MACHDEP, CPU_ALTIVEC };
#else
Laurent Aimar's avatar
Laurent Aimar committed
267
    int      selectors[2] = { CTL_HW, HW_VECTORUNIT };
268
#endif
Laurent Aimar's avatar
Laurent Aimar committed
269 270 271 272 273 274 275 276 277 278
    int      has_altivec = 0;
    size_t   length = sizeof( has_altivec );
    int      error = sysctl( selectors, 2, &has_altivec, &length, NULL, 0 );

    if( error == 0 && has_altivec != 0 )
        cpu |= X264_CPU_ALTIVEC;

    return cpu;
}

Steven Walters's avatar
Steven Walters committed
279
#elif SYS_LINUX
280

281 282
uint32_t x264_cpu_detect( void )
{
283
    static void (*oldsig)( int );
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300

    oldsig = signal( SIGILL, sigill_handler );
    if( sigsetjmp( jmpbuf, 1 ) )
    {
        signal( SIGILL, oldsig );
        return 0;
    }

    canjump = 1;
    asm volatile( "mtspr 256, %0\n\t"
                  "vand 0, 0, 0\n\t"
                  :
                  : "r"(-1) );
    canjump = 0;

    signal( SIGILL, oldsig );

301 302 303 304
    return X264_CPU_ALTIVEC;
}
#endif

Steven Walters's avatar
Steven Walters committed
305
#elif ARCH_ARM
306

307 308
void x264_cpu_neon_test( void );
int x264_cpu_fast_neon_mrc_test( void );
309 310 311 312

uint32_t x264_cpu_detect( void )
{
    int flags = 0;
Steven Walters's avatar
Steven Walters committed
313
#if HAVE_ARMV6
314 315 316
    flags |= X264_CPU_ARMV6;

    // don't do this hack if compiled with -mfpu=neon
Steven Walters's avatar
Steven Walters committed
317
#if !HAVE_NEON
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
    static void (* oldsig)( int );
    oldsig = signal( SIGILL, sigill_handler );
    if( sigsetjmp( jmpbuf, 1 ) )
    {
        signal( SIGILL, oldsig );
        return flags;
    }

    canjump = 1;
    x264_cpu_neon_test();
    canjump = 0;
    signal( SIGILL, oldsig );
#endif

    flags |= X264_CPU_NEON;

    // fast neon -> arm (Cortex-A9) detection relies on user access to the
    // cycle counter; this assumes ARMv7 performance counters.
    // NEON requires at least ARMv7, ARMv8 may require changes here, but
    // hopefully this hacky detection method will have been replaced by then.
    // Note that there is potential for a race condition if another program or
    // x264 instance disables or reinits the counters while x264 is using them,
    // which may result in incorrect detection and the counters stuck enabled.
    flags |= x264_cpu_fast_neon_mrc_test() ? X264_CPU_FAST_NEON_MRC : 0;
    // TODO: write dual issue test? currently it's A8 (dual issue) vs. A9 (fast mrc)
#endif
    return flags;
}

Laurent Aimar's avatar
Laurent Aimar committed
347 348 349 350 351 352 353
#else

uint32_t x264_cpu_detect( void )
{
    return 0;
}

354 355
#endif

356 357
int x264_cpu_num_processors( void )
{
358
#if !HAVE_THREAD
359 360
    return 1;

361
#elif SYS_WINDOWS
362
    return x264_pthread_num_processors_np();
363

364 365 366
#elif SYS_CYGWIN
    return sysconf( _SC_NPROCESSORS_ONLN );

Steven Walters's avatar
Steven Walters committed
367
#elif SYS_LINUX
368
    cpu_set_t p_aff;
369 370 371 372 373 374 375 376 377 378 379
    memset( &p_aff, 0, sizeof(p_aff) );
    if( sched_getaffinity( 0, sizeof(p_aff), &p_aff ) )
        return 1;
#if HAVE_CPU_COUNT
    return CPU_COUNT(&p_aff);
#else
    int np = 0;
    for( unsigned int bit = 0; bit < 8 * sizeof(p_aff); bit++ )
        np += (((uint8_t *)&p_aff)[bit / 8] >> (bit % 8)) & 1;
    return np;
#endif
380

Steven Walters's avatar
Steven Walters committed
381
#elif SYS_BEOS
382 383 384 385
    system_info info;
    get_system_info( &info );
    return info.cpu_count;

Steven Walters's avatar
Steven Walters committed
386
#elif SYS_MACOSX || SYS_FREEBSD || SYS_OPENBSD
Anton Mitrofanov's avatar
Anton Mitrofanov committed
387 388
    int ncpu;
    size_t length = sizeof( ncpu );
Steven Walters's avatar
Steven Walters committed
389
#if SYS_OPENBSD
390
    int mib[2] = { CTL_HW, HW_NCPU };
Anton Mitrofanov's avatar
Anton Mitrofanov committed
391
    if( sysctl(mib, 2, &ncpu, &length, NULL, 0) )
392
#else
Anton Mitrofanov's avatar
Anton Mitrofanov committed
393
    if( sysctlbyname("hw.ncpu", &ncpu, &length, NULL, 0) )
394
#endif
395
    {
Anton Mitrofanov's avatar
Anton Mitrofanov committed
396
        ncpu = 1;
397
    }
Anton Mitrofanov's avatar
Anton Mitrofanov committed
398
    return ncpu;
399

400
#else
401 402
    return 1;
#endif
403
}