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_WIN)
+#include "base/win/windows_version.h"
+#endif
+
+#if defined(OS_LINUX)
+#include "base/file_util.h"
+#endif
+
+#if defined(OS_MACOSX)
+#include "base/mac/mac_util.h"
+#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() {
+  base::win::OSInfo* info = base::win::OSInfo::GetInstance();
+
+  // Windows 7 SP1 added support for AVX.
+  return info->version() > base::win::VERSION_VISTA ||

[apatrick_chromium, 2013/03/07 21:22:47]

This is checking for Windows 7 all versions or Vista SP1 and later. Comment says
Windows 7 SP1 and later. It looks like the Internet thinks the comment is right?
So the constants should be base::win::VERSION_WIN7 no? If
base::win::VERSION_VISTA is right then please update the comment.

+      info->version() == base::win::VERSION_VISTA &&
+      info->service_pack().major >= 1;
+}
+
+#elif defined(OS_LINUX)
+
+bool OSHasAVXSupport() {
+  std::string buffer;
+  if (!file_util::ReadFileToString(base::FilePath("/proc/cpuinfo"), &buffer))

[DaleCurtis, 2013/03/07 21:12:11]

As mentioned earlier, I'm pretty sure this will cause a sandbox violation.  Have
you tested this code on a Linux machine with AVX support? 
media/base/vector_math.cc and media/base/yuv_convert.cc both use this from the
renderer side (as well as in the GPU process I believe).

[whunt, 2013/03/07 21:17:08]

With this patch, Chrome *appears* to run correctly under linux.  It launches, I
can surf.  I do get the following message at start-up but I'm not sure if it's
relevant or not: [17878:17878:0307/131402:ERROR:zygote_host_impl_linux.cc(146)]
Running without the SUID sandbox! See
https://code.google.com/p/chromium/wiki/LinuxSUIDSandboxDevelopment for more
information on developing with the sandbox on.

[DaleCurtis, 2013/03/07 21:33:36]

Ah looks like it doesn't crash but instead just fails to open the file; so this
check will always be false when used in the renderer side on Linux.

If you can come up with a check which doesn't read a file that'd be best.

[whunt, 2013/03/07 21:49:03]

I am neither very knowledgeable about linux or the sandbox.  linux_util.h
doesn't have an interface for getting the kernel version (we need kernel version
2.6.30).  I assume opening /proc/version or /proc/sys/kernel/osrelease will have
the same problem.  Do you know who I could ask about this?

[DaleCurtis, 2013/03/07 21:57:43]

Looks like you can use the xgetbv intrinsic once the CPUID indicates avx is
available.  I believe this is platform independent, so you don't need to use any
of these other platform specific defines.  Take a look at these instances
already in the code base:

https://code.google.com/p/chromium/codesearch#search/&q=xgetbv&sq=package:chr...

[whunt, 2013/03/07 23:28:54]

awesome suggestion, done

+    return false;
+
+  // Scan through /proc/cpuinfo to see if the kernel supports AVX.
+  return buffer.find("avx") != std::string::npos;
+}
+
+#elif defined(OS_MACOSX)
+
+bool OSHasAVXSupport() {
+  // AVX support was added in 10.6.8
+  // This check is conservative due to the fact that IsOS... doesn't
+  // have minor versions
+  return base::mac::IsOSLionOrLater();
+}
+
+#else
+bool OSHasAVXSupport() {
+  return false;
+}
+
+#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