Adding check for OS support to AVX

base/cpu.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/cpu.h"
 
 #include <string.h>
 
 #include <algorithm>
 
 #include "build/build_config.h"
 
 #if defined(ARCH_CPU_X86_FAMILY)
+#if defined(OS_LINUX)
+#include <stdio.h>
+#endif
+
+#if defined (OS_MACOSX)
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#endif
+
 #if defined(_MSC_VER)
 #include <intrin.h>
 #endif
 #endif
 
 namespace base {
 
 CPU::CPU()
   : type_(0),
     family_(0),
     model_(0),
     stepping_(0),
     ext_model_(0),
     ext_family_(0),
     has_mmx_(false),
     has_sse_(false),
     has_sse2_(false),
     has_sse3_(false),
     has_ssse3_(false),
     has_sse41_(false),
     has_sse42_(false),
+    has_avx_(false),
     cpu_vendor_("unknown") {
   Initialize();
 }
 
 #if defined(ARCH_CPU_X86_FAMILY)
 #ifndef _MSC_VER
 
 #if defined(__pic__) && defined(__i386__)
 
 void __cpuid(int cpu_info[4], int info_type) {
@@ skipping 29 matching lines @@
 void __cpuidex(int cpu_info[4], int info_type, int info_index) {
   __asm__ volatile (
     "cpuid \n\t"
     : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3])
     : "a"(info_type), "c"(info_index)
   );
 }
 
 #endif
 #endif  // _MSC_VER
+
+#if defined(OS_WIN)
+bool OSHasAVXSupport() {
+  OSVERSIONINFO version_info;
+
+  if (GetVersionEx(&version_info))

[apatrick_chromium, 2013/03/06 02:02:28]

Youu mean this?

if (!GetVersionEx(&version_info))

+    return false;
+
+  // Windows 7 SP1 added support for AVX.
+  return version_info.dwMajorVersion >= 6 && version_info.dwMinorVersion > 1;

[apatrick_chromium, 2013/03/06 02:02:28]

This won't work for 7.0 and 7.1 if the major version number ever gets bumped.
Also, it doesn't check for Windows 7 SP1, just Windows 8 and Windows Server
2012, right?

Check OSInfo in base/win/windows_version.h.

+}
+#elif defined(OS_LINUX)
+bool OSHasAVXSupport() {
+  FILE* f = fopen("/proc/cpuinfo", "r");

[apatrick_chromium, 2013/03/06 02:02:28]

I think you can use file_util::ReadFileToString here. Then there are no issues
with the fixed size buffer. Also, I think it will assert if it is called on a
thread that does not allow IO.

+  if (!f)
+    return false;
+
+  // Scan through /proc/cpuinfo to see if the kernel supports AVX.
+  char buffer[4096];
+  while (fgets(buffer, (int)sizeof(buffer), f)) {

[brettw, 2013/03/06 04:53:36]

Use C++ casts.

+    if (strncmp(buffer, "flags", sizeof(buffer))) {
+      if (strstr(buffer, "avx")) {

[apatrick_chromium, 2013/03/06 02:02:28]

Does /proc/cpuinfo reflect whether the OS has AVX or just the CPU?

+        fclose(f);
+        return true;
+      }
+    }
+  }
+
+  fclose(f);
+  return false;
+}
+#elif  defined(OS_MACOSX)
+bool OSHasAVXSupport() {
+  size_t length;
+  char* kernelVersion;

[apatrick_chromium, 2013/03/06 02:02:28]

nit: not chrome style

+  static int mib[2] = { CTL_KERN, KERN_OSRELEASE };
+
+  if (sysctl(mib, 2, NULL, &length, NULL, 0) < 0)
+    return false;
+
+  kernel_version = new char[length];

[apatrick_chromium, 2013/03/06 02:02:28]

scoped_ptr<char[]>

+  if (!kernel_version)
+    return false;
+
+  if (sysctl(mib, 2, kernel_version, &length, NULL, 0) < 0) {
+    delete [] kernel_version;

[apatrick_chromium, 2013/03/06 02:02:28]

not needed for scoped_ptr

+    return false;
+  }
+
+  int major, minor, patch_level;
+  if (sscanf(kernel_version, "%d.%d.%d", &major, &minor, &patch_level) != 3) {

[apatrick_chromium, 2013/03/06 02:02:28]

check base/version.h. It can deal with version numbers with a variable number of
components and has as IsOlderThan for comparisons.

+    if (sscanf(kernel_version, "%d.%d", &major, &minor) != 2) {
+      delete [] kernel_version;

[apatrick_chromium, 2013/03/06 02:02:28]

not needed for scoped_ptr

+      return false;
+    }
+  }
+  free(kernelVersion);

[apatrick_chromium, 2013/03/06 02:02:28]

kernelVersion is uninitialized

+
+  // AVX support was added in 10.6.8, which has kernel 10.8.
+  return major >= 10 && minor >= 8;

[apatrick_chromium, 2013/03/06 02:02:28]

This won't work for 11.0 through 11.7.

+}
+#else
+bool OSHasAVXSupport() {
+    return false;

[brettw, 2013/03/06 04:53:36]

indent.

+}
+#endif
 #endif  // ARCH_CPU_X86_FAMILY
 
 void CPU::Initialize() {
 #if defined(ARCH_CPU_X86_FAMILY)
   int cpu_info[4] = {-1};
   char cpu_string[48];
 
   // __cpuid with an InfoType argument of 0 returns the number of
   // valid Ids in CPUInfo[0] and the CPU identification string in
   // the other three array elements. The CPU identification string is
@@ skipping 16 matching lines @@
     type_ = (cpu_info[0] >> 12) & 0x3;
     ext_model_ = (cpu_info[0] >> 16) & 0xf;
     ext_family_ = (cpu_info[0] >> 20) & 0xff;
     has_mmx_ = (cpu_info[3] & 0x00800000) != 0;
     has_sse_ = (cpu_info[3] & 0x02000000) != 0;
     has_sse2_ = (cpu_info[3] & 0x04000000) != 0;
     has_sse3_ = (cpu_info[2] & 0x00000001) != 0;
     has_ssse3_ = (cpu_info[2] & 0x00000200) != 0;
     has_sse41_ = (cpu_info[2] & 0x00080000) != 0;
     has_sse42_ = (cpu_info[2] & 0x00100000) != 0;
-    has_avx_ = (cpu_info[2] & 0x10000000) != 0;
+    has_avx_ = (cpu_info[2] & 0x10000000) != 0 && OSHasAVXSupport();
   }
 
   // Get the brand string of the cpu.
   __cpuid(cpu_info, 0x80000000);
   const int parameter_end = 0x80000004;
 
   if (cpu_info[0] >= parameter_end) {
     char* cpu_string_ptr = cpu_string;
 
     for (int parameter = 0x80000002; parameter <= parameter_end &&
@@ skipping 12 matching lines @@
   if (has_sse42()) return SSE42;
   if (has_sse41()) return SSE41;
   if (has_ssse3()) return SSSE3;
   if (has_sse3()) return SSE3;
   if (has_sse2()) return SSE2;
   if (has_sse()) return SSE;
   return PENTIUM;
 }
 
 }  // namespace base