Parsing /proc/cpuinfo for model on Android and Aura

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 "base/basictypes.h"
+#include "base/file_util.h"
+#include "base/lazy_instance.h"
 #include "build/build_config.h"
 
 #if defined(ARCH_CPU_X86_FAMILY)
 #if defined(_MSC_VER)
 #include <intrin.h>
 #include <immintrin.h>  // For _xgetbv()
 #endif
 #endif
 
 namespace base {
@@ skipping 57 matching lines @@
 
   __asm__ volatile ("xgetbv" : "=a" (eax), "=d" (edx) : "c" (xcr));
   return (static_cast<uint64>(edx) << 32) | eax;
 }
 
 #endif  // !_MSC_VER
 #endif  // ARCH_CPU_X86_FAMILY
 
 }  // anonymous namespace
 
+#if defined(ARCH_CPU_ARM_FAMILY)
+#if defined(OS_ANDROID) || defined(USE_AURA)
+
+std::string CpuBrandInfo() {
+  const char kProcessorPrefix[] = "Processor";
+  std::string contents, cpu_brand;
+  ReadFileToString(FilePath("/proc/cpuinfo"), &contents);
+  DCHECK(!contents.empty());
+  if (!contents.empty()) {
+    std::istringstream iss(contents);
+    std::string line;
+    while (std::getline(iss, line)) {
+      if (line.compare(0, strlen(kProcessorPrefix), kProcessorPrefix) == 0) {
+        size_t pos = line.find(": ");
+        if (pos != std::string::npos) {

[rptr, 2014/03/08 13:03:06]

Takes care of review comment if ": " is not found in Processor string.

+          cpu_brand.assign(line.substr(pos + 2));
+          break;

[rptr, 2014/03/08 13:03:06]

Takes care of review comment: Do file lookup untill Processor line is found or
EOF.

+        }
+      }
+    }
+  }
+  return cpu_brand;
+}
+
+template <typename T, T (*F)(void)>

[rptr, 2014/03/08 13:03:06]

Perform cpu brand caching using lazy instance as suggested by review comments.

[Mark Mentovai, 2014/03/10 14:16:24]

Why is this templated? You only use it once.

[rptr, 2014/03/11 15:47:14]

Done.

+class LazyCpuInfoValue {
+ public:
+  LazyCpuInfoValue() : value_(F()) {}
+  ~LazyCpuInfoValue() {}
+  T value() { return value_; }
+
+ private:
+  const T value_;
+  DISALLOW_COPY_AND_ASSIGN(LazyCpuInfoValue);
+};
+
+base::LazyInstance<LazyCpuInfoValue<std::string, CpuBrandInfo> >::Leaky
+    g_lazy_cpu_brand = LAZY_INSTANCE_INITIALIZER;
+
+// static
+std::string CPU::CpuBrandInfo() { return g_lazy_cpu_brand.Get().value(); }

[Mark Mentovai, 2014/03/10 14:16:24]

Why not a const string&?

[rptr, 2014/03/11 15:47:14]

Done.

+
+#endif  // defined(OS_ANDROID) || defined(USE_AURA)
+#endif  // ARCH_CPU_ARM_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
   // not in linear order. The code below arranges the information
   // in a human readable form. The human readable order is CPUInfo[1] |
@@ skipping 52 matching lines @@
     }
     cpu_brand_.assign(cpu_string, cpu_string_ptr - cpu_string);
   }
 
   const int parameter_containing_non_stop_time_stamp_counter = 0x80000007;
   if (max_parameter >= parameter_containing_non_stop_time_stamp_counter) {
     __cpuid(cpu_info, parameter_containing_non_stop_time_stamp_counter);
     has_non_stop_time_stamp_counter_ = (cpu_info[3] & (1 << 8)) != 0;
   }
 #elif defined(ARCH_CPU_ARM_FAMILY)
-  // TODO(piman): Expand this. ARM has a CPUID register, but it's not available
-  // in user mode. /proc/cpuinfo has some information, but it's non standard,
-  // platform-specific, and not accessible from the sandbox.
-  // For some purposes, this first approximation is enough.
-  // crbug.com/313454
-  cpu_brand_.assign("ARM");
+#if defined(OS_ANDROID) || defined(USE_AURA)

[Mark Mentovai, 2014/03/10 14:16:24]

What’s this got to do with Aura?

[rptr, 2014/03/11 15:47:14]

My understanding is that (from comments of piman and siva in crbug:313454)
ARCH_CPU_ARM is currently run on android and linux with aura. Please correct me
if its wrong.

+  cpu_brand_.assign(CPU::CpuBrandInfo());
+#endif
 #endif
 }
 
 CPU::IntelMicroArchitecture CPU::GetIntelMicroArchitecture() const {
   if (has_avx()) return AVX;
   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