xbmc/platform/linux/CPUInfoLinux.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "CPUInfoLinux.h"
  10
  11 #include "utils/StringUtils.h"
  12 #include "utils/Temperature.h"
  13
  14 #include "platform/linux/SysfsPath.h"
  15
  16 #include <fstream>
  17 #include <regex>
  18 #include <sstream>
  19 #include <vector>
  20
  21 #if (defined(__arm__) && defined(HAS_NEON)) || defined(__aarch64__)
  22 #include <asm/hwcap.h>
  23 #include <sys/auxv.h>
  24 #elif defined(__i386__) || defined(__x86_64__)
  25 #include <cpuid.h>
  26 #endif
  27
  28 #include <unistd.h>
  29
  30 namespace
  31 {
  32 enum CpuStates
  33 {
  34   STATE_USER,
  35   STATE_NICE,
  36   STATE_SYSTEM,
  37   STATE_IDLE,
  38   STATE_IOWAIT,
  39   STATE_IRQ,
  40   STATE_SOFTIRQ,
  41   STATE_STEAL,
  42   STATE_GUEST,
  43   STATE_GUEST_NICE,
  44   STATE_MAX
  45 };
  46
  47 struct CpuData
  48 {
  49 public:
  50   std::size_t GetActiveTime() const
  51   {
  52     return state[STATE_USER] + state[STATE_NICE] + state[STATE_SYSTEM] + state[STATE_IRQ] +
  53            state[STATE_SOFTIRQ] + state[STATE_STEAL] + state[STATE_GUEST] + state[STATE_GUEST_NICE];
  54   }
  55
  56   std::size_t GetIdleTime() const { return state[STATE_IDLE] + state[STATE_IOWAIT]; }
  57
  58   std::size_t GetTotalTime() const { return GetActiveTime() + GetIdleTime(); }
  59
  60   std::string cpu;
  61   std::size_t state[STATE_MAX];
  62 };
  63 } // namespace
  64
  65 std::shared_ptr<CCPUInfo> CCPUInfo::GetCPUInfo()
  66 {
  67   return std::make_shared<CCPUInfoLinux>();
  68 }
  69
  70 CCPUInfoLinux::CCPUInfoLinux()
  71 {
  72   CSysfsPath machinePath{"/sys/bus/soc/devices/soc0/machine"};
  73   if (machinePath.Exists())
  74     m_cpuHardware = machinePath.Get<std::string>();
  75
  76   CSysfsPath familyPath{"/sys/bus/soc/devices/soc0/family"};
  77   if (familyPath.Exists())
  78     m_cpuSoC = familyPath.Get<std::string>();
  79
  80   CSysfsPath socPath{"/sys/bus/soc/devices/soc0/soc_id"};
  81   if (socPath.Exists())
  82     m_cpuSoC += " " + socPath.Get<std::string>();
  83
  84   CSysfsPath revisionPath{"/sys/bus/soc/devices/soc0/revision"};
  85   if (revisionPath.Exists())
  86     m_cpuRevision += revisionPath.Get<std::string>();
  87
  88   CSysfsPath serialPath{"/sys/bus/soc/devices/soc0/serial_number"};
  89   if (serialPath.Exists())
  90     m_cpuSerial += serialPath.Get<std::string>();
  91
  92   const std::string freqStr{"/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq"};
  93   CSysfsPath freqPath{freqStr};
  94   if (freqPath.Exists())
  95     m_freqPath = freqStr;
  96
  97   const std::array<std::string, 4> modules = {
  98       "coretemp",
  99       "k10temp",
 100       "scpi_sensors",
 101       "imx_thermal_zone",
 102   };
 103
 104   for (int i = 0; i < 20; i++)
 105   {
 106     CSysfsPath path{"/sys/class/hwmon/hwmon" + std::to_string(i) + "/name"};
 107     if (!path.Exists())
 108       continue;
 109
 110     auto name = path.Get<std::string>();
 111
 112     if (name.empty())
 113       continue;
 114
 115     for (const auto& module : modules)
 116     {
 117       if (module == name)
 118       {
 119         std::string tempStr{"/sys/class/hwmon/hwmon" + std::to_string(i) + "/temp1_input"};
 120         CSysfsPath tempPath{tempStr};
 121         if (!tempPath.Exists())
 122           continue;
 123
 124         m_tempPath = tempStr;
 125         break;
 126       }
 127     }
 128
 129     if (!m_tempPath.empty())
 130       break;
 131   }
 132
 133   m_cpuCount = sysconf(_SC_NPROCESSORS_ONLN);
 134
 135   for (int core = 0; core < m_cpuCount; core++)
 136   {
 137     CoreInfo coreInfo;
 138     coreInfo.m_id = core;
 139     m_cores.emplace_back(coreInfo);
 140   }
 141
 142 #if defined(__i386__) || defined(__x86_64__)
 143   unsigned int eax;
 144   unsigned int ebx;
 145   unsigned int ecx;
 146   unsigned int edx;
 147
 148   m_cpuVendor.clear();
 149
 150   if (__get_cpuid(CPUID_INFOTYPE_MANUFACTURER, &eax, &ebx, &ecx, &edx))
 151   {
 152     m_cpuVendor.append(reinterpret_cast<const char*>(&ebx), 4);
 153     m_cpuVendor.append(reinterpret_cast<const char*>(&edx), 4);
 154     m_cpuVendor.append(reinterpret_cast<const char*>(&ecx), 4);
 155   }
 156
 157   if (__get_cpuid(CPUID_INFOTYPE_EXTENDED_IMPLEMENTED, &eax, &ebx, &ecx, &edx))
 158   {
 159     if (eax >= CPUID_INFOTYPE_PROCESSOR_3)
 160     {
 161       m_cpuModel.clear();
 162
 163       if (__get_cpuid(CPUID_INFOTYPE_PROCESSOR_1, &eax, &ebx, &ecx, &edx))
 164       {
 165         m_cpuModel.append(reinterpret_cast<const char*>(&eax), 4);
 166         m_cpuModel.append(reinterpret_cast<const char*>(&ebx), 4);
 167         m_cpuModel.append(reinterpret_cast<const char*>(&ecx), 4);
 168         m_cpuModel.append(reinterpret_cast<const char*>(&edx), 4);
 169       }
 170
 171       if (__get_cpuid(CPUID_INFOTYPE_PROCESSOR_2, &eax, &ebx, &ecx, &edx))
 172       {
 173         m_cpuModel.append(reinterpret_cast<const char*>(&eax), 4);
 174         m_cpuModel.append(reinterpret_cast<const char*>(&ebx), 4);
 175         m_cpuModel.append(reinterpret_cast<const char*>(&ecx), 4);
 176         m_cpuModel.append(reinterpret_cast<const char*>(&edx), 4);
 177       }
 178
 179       if (__get_cpuid(CPUID_INFOTYPE_PROCESSOR_3, &eax, &ebx, &ecx, &edx))
 180       {
 181         m_cpuModel.append(reinterpret_cast<const char*>(&eax), 4);
 182         m_cpuModel.append(reinterpret_cast<const char*>(&ebx), 4);
 183         m_cpuModel.append(reinterpret_cast<const char*>(&ecx), 4);
 184         m_cpuModel.append(reinterpret_cast<const char*>(&edx), 4);
 185       }
 186     }
 187   }
 188
 189   if (__get_cpuid(CPUID_INFOTYPE_STANDARD, &eax, &eax, &ecx, &edx))
 190   {
 191     if (edx & CPUID_00000001_EDX_MMX)
 192       m_cpuFeatures |= CPU_FEATURE_MMX;
 193
 194     if (edx & CPUID_00000001_EDX_SSE)
 195       m_cpuFeatures |= CPU_FEATURE_SSE;
 196
 197     if (edx & CPUID_00000001_EDX_SSE2)
 198       m_cpuFeatures |= CPU_FEATURE_SSE2;
 199
 200     if (ecx & CPUID_00000001_ECX_SSE3)
 201       m_cpuFeatures |= CPU_FEATURE_SSE3;
 202
 203     if (ecx & CPUID_00000001_ECX_SSSE3)
 204       m_cpuFeatures |= CPU_FEATURE_SSSE3;
 205
 206     if (ecx & CPUID_00000001_ECX_SSE4)
 207       m_cpuFeatures |= CPU_FEATURE_SSE4;
 208
 209     if (ecx & CPUID_00000001_ECX_SSE42)
 210       m_cpuFeatures |= CPU_FEATURE_SSE42;
 211   }
 212
 213   if (__get_cpuid(CPUID_INFOTYPE_EXTENDED_IMPLEMENTED, &eax, &eax, &ecx, &edx))
 214   {
 215     if (eax >= CPUID_INFOTYPE_EXTENDED)
 216     {
 217       if (edx & CPUID_80000001_EDX_MMX)
 218         m_cpuFeatures |= CPU_FEATURE_MMX;
 219
 220       if (edx & CPUID_80000001_EDX_MMX2)
 221         m_cpuFeatures |= CPU_FEATURE_MMX2;
 222
 223       if (edx & CPUID_80000001_EDX_3DNOW)
 224         m_cpuFeatures |= CPU_FEATURE_3DNOW;
 225
 226       if (edx & CPUID_80000001_EDX_3DNOWEXT)
 227         m_cpuFeatures |= CPU_FEATURE_3DNOWEXT;
 228     }
 229   }
 230 #else
 231   std::ifstream cpuinfo("/proc/cpuinfo");
 232   std::regex re(".*: (.*)$");
 233
 234   for (std::string line; std::getline(cpuinfo, line);)
 235   {
 236     std::smatch match;
 237
 238     if (std::regex_match(line, match, re))
 239     {
 240       if (match.size() == 2)
 241       {
 242         std::ssub_match value = match[1];
 243
 244         if (line.find("model name") != std::string::npos)
 245         {
 246           if (m_cpuModel.empty())
 247             m_cpuModel = value.str();
 248         }
 249
 250         if (line.find("BogoMIPS") != std::string::npos)
 251         {
 252           if (m_cpuBogoMips.empty())
 253             m_cpuBogoMips = value.str();
 254         }
 255
 256         if (line.find("Hardware") != std::string::npos)
 257         {
 258           if (m_cpuHardware.empty())
 259             m_cpuHardware = value.str();
 260         }
 261
 262         if (line.find("Serial") != std::string::npos)
 263         {
 264           if (m_cpuSerial.empty())
 265             m_cpuSerial = value.str();
 266         }
 267
 268         if (line.find("Revision") != std::string::npos)
 269         {
 270           if (m_cpuRevision.empty())
 271             m_cpuRevision = value.str();
 272         }
 273       }
 274     }
 275   }
 276 #endif
 277
 278   m_cpuModel = m_cpuModel.substr(0, m_cpuModel.find(char(0))); // remove extra null terminations
 279
 280 #if defined(HAS_NEON) && defined(__arm__)
 281   if (getauxval(AT_HWCAP) & HWCAP_NEON)
 282     m_cpuFeatures |= CPU_FEATURE_NEON;
 283 #endif
 284
 285 #if defined(HAS_NEON) && defined(__aarch64__)
 286   if (getauxval(AT_HWCAP) & HWCAP_ASIMD)
 287     m_cpuFeatures |= CPU_FEATURE_NEON;
 288 #endif
 289
 290   // Set MMX2 when SSE is present as SSE is a superset of MMX2 and Intel doesn't set the MMX2 cap
 291   if (m_cpuFeatures & CPU_FEATURE_SSE)
 292     m_cpuFeatures |= CPU_FEATURE_MMX2;
 293 }
 294
 295 int CCPUInfoLinux::GetUsedPercentage()
 296 {
 297   if (!m_nextUsedReadTime.IsTimePast())
 298     return m_lastUsedPercentage;
 299
 300   std::vector<CpuData> cpuData;
 301
 302   std::ifstream infile("/proc/stat");
 303
 304   for (std::string line; std::getline(infile, line);)
 305   {
 306     if (line.find("cpu") != std::string::npos)
 307     {
 308       std::istringstream ss(line);
 309       CpuData info;
 310
 311       ss >> info.cpu;
 312
 313       for (int i = 0; i < STATE_MAX; i++)
 314       {
 315         ss >> info.state[i];
 316       }
 317
 318       cpuData.emplace_back(info);
 319     }
 320   }
 321
 322   auto activeTime = cpuData.front().GetActiveTime() - m_activeTime;
 323   auto idleTime = cpuData.front().GetIdleTime() - m_idleTime;
 324   auto totalTime = cpuData.front().GetTotalTime() - m_totalTime;
 325
 326   m_activeTime += activeTime;
 327   m_idleTime += idleTime;
 328   m_totalTime += totalTime;
 329
 330   m_lastUsedPercentage = activeTime * 100.0f / totalTime;
 331   m_nextUsedReadTime.Set(MINIMUM_TIME_BETWEEN_READS);
 332
 333   cpuData.erase(cpuData.begin());
 334
 335   for (std::size_t core = 0; core < cpuData.size(); core++)
 336   {
 337     auto activeTime = cpuData[core].GetActiveTime() - m_cores[core].m_activeTime;
 338     auto idleTime = cpuData[core].GetIdleTime() - m_cores[core].m_idleTime;
 339     auto totalTime = cpuData[core].GetTotalTime() - m_cores[core].m_totalTime;
 340
 341     m_cores[core].m_usagePercent = activeTime * 100.0 / totalTime;
 342
 343     m_cores[core].m_activeTime += activeTime;
 344     m_cores[core].m_idleTime += idleTime;
 345     m_cores[core].m_totalTime += totalTime;
 346   }
 347
 348   return static_cast<int>(m_lastUsedPercentage);
 349 }
 350
 351 float CCPUInfoLinux::GetCPUFrequency()
 352 {
 353   if (m_freqPath.empty())
 354     return 0;
 355
 356   CSysfsPath path{m_freqPath};
 357   return path.Get<float>() / 1000.0f;
 358 }
 359
 360 bool CCPUInfoLinux::GetTemperature(CTemperature& temperature)
 361 {
 362   if (CheckUserTemperatureCommand(temperature))
 363     return true;
 364
 365   if (m_tempPath.empty())
 366     return false;
 367
 368   CSysfsPath path{m_tempPath};
 369   double value = path.Get<double>() / 1000.0;
 370
 371   temperature = CTemperature::CreateFromCelsius(value);
 372   temperature.SetValid(true);
 373
 374   return true;
 375 }