git.sesse.net Git - x264/blob - common/cpu.c

   1 /*****************************************************************************
   2  * cpu.c: h264 encoder library
   3  *****************************************************************************
   4  * Copyright (C) 2003 Laurent Aimar
   5  * $Id: cpu.c,v 1.1 2004/06/03 19:27:06 fenrir Exp $
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 #if defined(HAVE_PTHREAD) && defined(SYS_LINUX)
  25 #define _GNU_SOURCE
  26 #include <sched.h>
  27 #endif
  28 #ifdef SYS_BEOS
  29 #include <kernel/OS.h>
  30 #endif
  31 #if defined(SYS_MACOSX) || defined(SYS_FREEBSD)
  32 #include <sys/types.h>
  33 #include <sys/sysctl.h>
  34 #endif
  35
  36 #include "common.h"
  37
  38 const struct {
  39     const char name[8];
  40     int flags;
  41 } x264_cpu_names[] = {
  42     {"MMX",     X264_CPU_MMX},
  43     {"MMX2",    X264_CPU_MMX|X264_CPU_MMXEXT},
  44     {"MMXEXT",  X264_CPU_MMX|X264_CPU_MMXEXT},
  45     {"SSE",     X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE},
  46     {"SSE1",    X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE},
  47     {"SSE2",    X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE|X264_CPU_SSE2},
  48     {"SSE3",    X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE|X264_CPU_SSE2|X264_CPU_SSE3},
  49     {"SSSE3",   X264_CPU_MMX|X264_CPU_MMXEXT|X264_CPU_SSE|X264_CPU_SSE2|X264_CPU_SSE3|X264_CPU_SSSE3},
  50     {"3DNow",   X264_CPU_3DNOW},
  51     {"Altivec", X264_CPU_ALTIVEC},
  52     {"Cache32", X264_CPU_CACHELINE_SPLIT|X264_CPU_CACHELINE_32},
  53     {"Cache64", X264_CPU_CACHELINE_SPLIT|X264_CPU_CACHELINE_64},
  54     {"", 0},
  55 };
  56
  57 #ifdef HAVE_MMX
  58 extern int  x264_cpu_cpuid_test( void );
  59 extern uint32_t  x264_cpu_cpuid( uint32_t op, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx );
  60
  61 uint32_t x264_cpu_detect( void )
  62 {
  63     uint32_t cpu = 0;
  64     uint32_t eax, ebx, ecx, edx;
  65     uint32_t vendor[4] = {0};
  66     int max_extended_cap;
  67     int cache;
  68
  69 #ifndef ARCH_X86_64
  70     if( !x264_cpu_cpuid_test() )
  71         return 0;
  72 #endif
  73
  74     x264_cpu_cpuid( 0, &eax, vendor+0, vendor+2, vendor+1 );
  75     if( eax == 0 )
  76         return 0;
  77
  78     x264_cpu_cpuid( 1, &eax, &ebx, &ecx, &edx );
  79     if( edx&0x00800000 )
  80         cpu |= X264_CPU_MMX;
  81     else
  82         return 0;
  83     if( edx&0x02000000 )
  84         cpu |= X264_CPU_MMXEXT|X264_CPU_SSE;
  85     if( edx&0x04000000 )
  86         cpu |= X264_CPU_SSE2;
  87 #ifdef HAVE_SSE3
  88     if( ecx&0x00000001 )
  89         cpu |= X264_CPU_SSE3;
  90     if( ecx&0x00000200 )
  91         cpu |= X264_CPU_SSSE3;
  92 #endif
  93
  94     x264_cpu_cpuid( 0x80000000, &eax, &ebx, &ecx, &edx );
  95     max_extended_cap = eax;
  96
  97     if( !strcmp((char*)vendor, "AuthenticAMD") && max_extended_cap >= 0x80000001 )
  98     {
  99         x264_cpu_cpuid( 0x80000001, &eax, &ebx, &ecx, &edx );
 100         if( edx&0x80000000 )
 101             cpu |= X264_CPU_3DNOW;
 102         if( edx&0x00400000 )
 103             cpu |= X264_CPU_MMXEXT;
 104     }
 105
 106     if( !strcmp((char*)vendor, "GenuineIntel") || !strcmp((char*)vendor, "CyrixInstead") )
 107         cpu |= X264_CPU_CACHELINE_SPLIT;
 108     /* cacheline size is specified in 3 places, any of which may be missing */
 109     x264_cpu_cpuid( 1, &eax, &ebx, &ecx, &edx );
 110     cache = (ebx&0xff00)>>5; // cflush size
 111     if( !cache && max_extended_cap >= 0x80000006 )
 112     {
 113         x264_cpu_cpuid( 0x80000006, &eax, &ebx, &ecx, &edx );
 114         cache = ecx&0xff; // cacheline size
 115     }
 116     if( !cache )
 117     {
 118         // Cache and TLB Information
 119         static const char cache32_ids[] = { 0x0a, 0x0c, 0x41, 0x42, 0x43, 0x44, 0x45, 0x82, 0x83, 0x84, 0x85, 0 };
 120         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 };
 121         uint32_t buf[4];
 122         int max, i=0, j;
 123         do {
 124             x264_cpu_cpuid( 2, buf+0, buf+1, buf+2, buf+3 );
 125             max = buf[0]&0xff;
 126             buf[0] &= ~0xff;
 127             for(j=0; j<4; j++)
 128                 if( !(buf[j]>>31) )
 129                     while( buf[j] )
 130                     {
 131                         if( strchr( cache32_ids, buf[j]&0xff ) )
 132                             cache = 32;
 133                         if( strchr( cache64_ids, buf[j]&0xff ) )
 134                             cache = 64;
 135                         buf[j] >>= 8;
 136                     }
 137         } while( ++i < max );
 138     }
 139
 140     if( cache == 32 )
 141         cpu |= X264_CPU_CACHELINE_32;
 142     if( cache == 64 )
 143         cpu |= X264_CPU_CACHELINE_64;
 144
 145     return cpu;
 146 }
 147
 148 #elif defined( ARCH_PPC )
 149
 150 #ifdef SYS_MACOSX
 151 #include <sys/sysctl.h>
 152 uint32_t x264_cpu_detect( void )
 153 {
 154     /* Thank you VLC */
 155     uint32_t cpu = 0;
 156     int      selectors[2] = { CTL_HW, HW_VECTORUNIT };
 157     int      has_altivec = 0;
 158     size_t   length = sizeof( has_altivec );
 159     int      error = sysctl( selectors, 2, &has_altivec, &length, NULL, 0 );
 160
 161     if( error == 0 && has_altivec != 0 )
 162     {
 163         cpu |= X264_CPU_ALTIVEC;
 164     }
 165
 166     return cpu;
 167 }
 168
 169 #elif defined( SYS_LINUX )
 170 #include <signal.h>
 171 #include <setjmp.h>
 172 static sigjmp_buf jmpbuf;
 173 static volatile sig_atomic_t canjump = 0;
 174
 175 static void sigill_handler( int sig )
 176 {
 177     if( !canjump )
 178     {
 179         signal( sig, SIG_DFL );
 180         raise( sig );
 181     }
 182
 183     canjump = 0;
 184     siglongjmp( jmpbuf, 1 );
 185 }
 186
 187 uint32_t x264_cpu_detect( void )
 188 {
 189     static void (* oldsig)( int );
 190
 191     oldsig = signal( SIGILL, sigill_handler );
 192     if( sigsetjmp( jmpbuf, 1 ) )
 193     {
 194         signal( SIGILL, oldsig );
 195         return 0;
 196     }
 197
 198     canjump = 1;
 199     asm volatile( "mtspr 256, %0\n\t"
 200                   "vand 0, 0, 0\n\t"
 201                   :
 202                   : "r"(-1) );
 203     canjump = 0;
 204
 205     signal( SIGILL, oldsig );
 206
 207     return X264_CPU_ALTIVEC;
 208 }
 209 #endif
 210
 211 #else
 212
 213 uint32_t x264_cpu_detect( void )
 214 {
 215     return 0;
 216 }
 217
 218 #endif
 219
 220 #ifndef HAVE_MMX
 221 void x264_emms( void )
 222 {
 223 }
 224 #endif
 225
 226
 227 int x264_cpu_num_processors( void )
 228 {
 229 #if !defined(HAVE_PTHREAD)
 230     return 1;
 231
 232 #elif defined(_WIN32)
 233     return pthread_num_processors_np();
 234
 235 #elif defined(SYS_LINUX)
 236     unsigned int bit;
 237     int np;
 238     cpu_set_t p_aff;
 239     memset( &p_aff, 0, sizeof(p_aff) );
 240     sched_getaffinity( 0, sizeof(p_aff), &p_aff );
 241     for( np = 0, bit = 0; bit < sizeof(p_aff); bit++ )
 242         np += (((uint8_t *)&p_aff)[bit / 8] >> (bit % 8)) & 1;
 243     return np;
 244
 245 #elif defined(SYS_BEOS)
 246     system_info info;
 247     get_system_info( &info );
 248     return info.cpu_count;
 249
 250 #elif defined(SYS_MACOSX) || defined(SYS_FREEBSD)
 251     int numberOfCPUs;
 252     size_t length = sizeof( numberOfCPUs );
 253     if( sysctlbyname("hw.ncpu", &numberOfCPUs, &length, NULL, 0) )
 254     {
 255         numberOfCPUs = 1;
 256     }
 257     return numberOfCPUs;
 258
 259 #else
 260     return 1;
 261 #endif
 262 }