libs/pbd/fpu.cc

   1 /*
   2     Copyright (C) 2012 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "libpbd-config.h"
  21
  22 #define _XOPEN_SOURCE 600
  23 #include <cstring> // for memset
  24 #include <cstdlib>
  25 #include <stdint.h>
  26 #include <assert.h>
  27
  28 #ifdef PLATFORM_WINDOWS
  29 #include <intrin.h>
  30 #endif
  31
  32 #include "pbd/fpu.h"
  33 #include "pbd/error.h"
  34
  35 #include "i18n.h"
  36
  37 using namespace PBD;
  38 using namespace std;
  39
  40 FPU::FPU ()
  41 {
  42         unsigned long cpuflags = 0;
  43
  44         _flags = Flags (0);
  45
  46 #if !( (defined __x86_64__) || (defined __i386__) || (defined _M_X64) || (defined _M_IX86) ) // !ARCH_X86
  47         return;
  48 #else
  49
  50 #ifdef PLATFORM_WINDOWS
  51
  52         // Get CPU flags using Microsoft function
  53         // It works for both 64 and 32 bit systems
  54         // no need to use assembler for getting info from register, this function does this for us
  55         int cpuInfo[4];
  56         __cpuid (cpuInfo, 1);
  57         cpuflags = cpuInfo[3];
  58
  59 #else
  60
  61 #ifndef _LP64 /* *nix; 32 bit version. This odd macro constant is required because we need something that identifies this as a 32 bit
  62                  build on Linux and on OS X. Anything that serves this purpose will do, but this is the best thing we've identified
  63                  so far.
  64               */
  65
  66         asm volatile (
  67                 "mov $1, %%eax\n"
  68                 "pushl %%ebx\n"
  69                 "cpuid\n"
  70                 "movl %%edx, %0\n"
  71                 "popl %%ebx\n"
  72                 : "=r" (cpuflags)
  73                 :
  74                 : "%eax", "%ecx", "%edx"
  75                 );
  76
  77 #else /* *nix; 64 bit version */
  78
  79         /* asm notes: although we explicitly save&restore rbx, we must tell
  80            gcc that ebx,rbx is clobbered so that it doesn't try to use it as an intermediate
  81            register when storing rbx. gcc 4.3 didn't make this "mistake", but gcc 4.4
  82            does, at least on x86_64.
  83         */
  84
  85         asm volatile (
  86                 "pushq %%rbx\n"
  87                 "movq $1, %%rax\n"
  88                 "cpuid\n"
  89                 "movq %%rdx, %0\n"
  90                 "popq %%rbx\n"
  91                 : "=r" (cpuflags)
  92                 :
  93                 : "%rax", "%rbx", "%rcx", "%rdx"
  94                 );
  95
  96 #endif /* _LP64 */
  97 #endif /* PLATFORM_WINDOWS */
  98
  99 #ifndef __APPLE__
 100         if (cpuflags & ((1<<27) /* AVX */ |(1<<28) /* XGETBV */)) {
 101
 102                 std::cerr << "Looks like AVX\n";
 103
 104                 /* now check if YMM resters state is saved: which means OS does
 105                  * know about new YMM registers and saves them during context
 106                  * switches it's true for most cases, but we must be sure
 107                  *
 108                  * giving 0 as the argument to _xgetbv() fetches the
 109                  * XCR_XFEATURE_ENABLED_MASK, which we need to check for
 110                  * the 2nd and 3rd bits, indicating correct register save/restore.
 111                  */
 112
 113                 uint64_t xcrFeatureMask = 0;
 114
 115 #if __GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4
 116                 unsigned int eax, edx, index = 0;
 117                 asm volatile("xgetbv" : "=a"(eax), "=d"(edx) : "c"(index));
 118                 xcrFeatureMask = ((unsigned long long)edx << 32) | eax;
 119 #elif defined (COMPILER_MSVC)
 120                 xcrFeatureMask = _xgetbv(_XCR_XFEATURE_ENABLED_MASK);
 121 #endif
 122                 if (xcrFeatureMask & 0x6) {
 123                         std::cerr << "Definitely AVX\n";
 124                         _flags = Flags (_flags | (HasAVX) );
 125                 }
 126         }
 127 #endif /* !__APPLE__ */
 128
 129         if (cpuflags & (1<<25)) {
 130                 _flags = Flags (_flags | (HasSSE|HasFlushToZero));
 131         }
 132
 133         if (cpuflags & (1<<26)) {
 134                 _flags = Flags (_flags | HasSSE2);
 135         }
 136
 137         if (cpuflags & (1 << 24)) {
 138
 139                 char** fxbuf = 0;
 140
 141                 /* DAZ wasn't available in the first version of SSE. Since
 142                    setting a reserved bit in MXCSR causes a general protection
 143                    fault, we need to be able to check the availability of this
 144                    feature without causing problems. To do this, one needs to
 145                    set up a 512-byte area of memory to save the SSE state to,
 146                    using fxsave, and then one needs to inspect bytes 28 through
 147                    31 for the MXCSR_MASK value. If bit 6 is set, DAZ is
 148                    supported, otherwise, it isn't.
 149                 */
 150
 151 #ifndef HAVE_POSIX_MEMALIGN
 152 #  ifdef PLATFORM_WINDOWS
 153                 fxbuf = (char **) _aligned_malloc (sizeof (char *), 16);
 154                 assert (fxbuf);
 155                 *fxbuf = (char *) _aligned_malloc (512, 16);
 156                 assert (*fxbuf);
 157 #  else
 158 #  warning using default malloc for aligned memory
 159                 fxbuf = (char **) malloc (sizeof (char *));
 160                 assert (fxbuf);
 161                 *fxbuf = (char *) malloc (512);
 162                 assert (*fxbuf);
 163 #  endif
 164 #else
 165                 (void) posix_memalign ((void **) &fxbuf, 16, sizeof (char *));
 166                 assert (fxbuf);
 167                 (void) posix_memalign ((void **) fxbuf, 16, 512);
 168                 assert (*fxbuf);
 169 #endif
 170
 171                 memset (*fxbuf, 0, 512);
 172
 173 #ifdef COMPILER_MSVC
 174                 char *buf = *fxbuf;
 175                 __asm {
 176                         mov eax, buf
 177                         fxsave   [eax]
 178                 };
 179 #else
 180                 asm volatile (
 181                         "fxsave (%0)"
 182                         :
 183                         : "r" (*fxbuf)
 184                         : "memory"
 185                         );
 186 #endif
 187
 188                 uint32_t mxcsr_mask = *((uint32_t*) &((*fxbuf)[28]));
 189
 190                 /* if the mask is zero, set its default value (from intel specs) */
 191
 192                 if (mxcsr_mask == 0) {
 193                         mxcsr_mask = 0xffbf;
 194                 }
 195
 196                 if (mxcsr_mask & (1<<6)) {
 197                         _flags = Flags (_flags | HasDenormalsAreZero);
 198                 }
 199
 200 #if !defined HAVE_POSIX_MEMALIGN && defined PLATFORM_WINDOWS
 201                 _aligned_free (*fxbuf);
 202                 _aligned_free (fxbuf);
 203 #else
 204                 free (*fxbuf);
 205                 free (fxbuf);
 206 #endif
 207         }
 208 #endif
 209 }
 210
 211 FPU::~FPU ()
 212 {
 213 }