chromium/base/system/sys_info.cc

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/system/sys_info.h"

#include <algorithm>

#include "base/base_switches.h"
#include "base/command_line.h"
#include "base/features.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/location.h"
#include "base/notreached.h"
#include "base/system/sys_info_internal.h"
#include "base/task/task_traits.h"
#include "base/task/thread_pool.h"
#include "base/time/time.h"
#include "build/build_config.h"

namespace base {
namespace {
uint64_t GetLowMemoryDeviceThresholdMB() { … }

std::optional<uint64_t> g_amount_of_physical_memory_mb_for_testing;
}  // namespace

// static
int SysInfo::NumberOfEfficientProcessors() { … }

// static
uint64_t SysInfo::AmountOfPhysicalMemory() { … }

// static
uint64_t SysInfo::AmountOfAvailablePhysicalMemory() { … }

bool SysInfo::IsLowEndDevice() { … }

#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS)

namespace {

enum class BucketizedSize {
  k2GbOrLess,
  k3Gb,
  k4Gb,
  k6Gb,
  k8GbOrHigher,
};

BucketizedSize GetSystemRamBucketizedSize() {
  int physical_memory = base::SysInfo::AmountOfPhysicalMemoryMB();

  // Because of Android carveouts, AmountOfPhysicalMemory() returns smaller
  // than the actual memory size, So we will use a small lowerbound than "X"GB
  // to discriminate real "X"GB devices from lower memory ones.
  // Addendum: This logic should also work for ChromeOS.

  constexpr int kUpperBound2GB = 2 * 1024;  // inclusive
  if (physical_memory <= kUpperBound2GB) {
    return BucketizedSize::k2GbOrLess;
  }

  constexpr int kLowerBound3GB = kUpperBound2GB;  // exclusive
  constexpr int kUpperBound3GB = 3.2 * 1024;      // inclusive
  if (kLowerBound3GB < physical_memory && physical_memory <= kUpperBound3GB) {
    return BucketizedSize::k3Gb;
  }

  constexpr int kLowerBound4GB = kUpperBound3GB;  // exclusive
  constexpr int kUpperBound4GB = 4 * 1024;        // inclusive
  if (kLowerBound4GB < physical_memory && physical_memory <= kUpperBound4GB) {
    return BucketizedSize::k4Gb;
  }

  constexpr int kLowerBound6GB = kUpperBound4GB;  // exclusive
  constexpr int kUpperBound6GB = 6.5 * 1024 - 1;  // inclusive
  if (kLowerBound6GB < physical_memory && physical_memory <= kUpperBound6GB) {
    return BucketizedSize::k6Gb;
  }

  return BucketizedSize::k8GbOrHigher;
}

BucketizedSize GetCachedSystemRamBucketizedSize() {
  static BucketizedSize s_size = GetSystemRamBucketizedSize();
  return s_size;
}

bool IsPartialLowEndModeOnMidRangeDevicesEnabled() {
  // TODO(crbug.com/40264947): make the feature not enable on 32-bit devices
  // before launching or going to high Stable %.
  return SysInfo::Is4GbOr6GbDevice() &&
         base::FeatureList::IsEnabled(
             features::kPartialLowEndModeOnMidRangeDevices);
}

bool IsPartialLowEndModeOn3GbDevicesEnabled() {
  return SysInfo::Is3GbDevice() &&
         base::FeatureList::IsEnabled(features::kPartialLowEndModeOn3GbDevices);
}

}  // namespace

bool SysInfo::Is3GbDevice() {
  return GetCachedSystemRamBucketizedSize() == BucketizedSize::k3Gb;
}

bool SysInfo::Is4GbDevice() {
  return GetCachedSystemRamBucketizedSize() == BucketizedSize::k4Gb;
}

bool SysInfo::Is4GbOr6GbDevice() {
  return GetCachedSystemRamBucketizedSize() == BucketizedSize::k4Gb ||
         GetCachedSystemRamBucketizedSize() == BucketizedSize::k6Gb;
}

bool SysInfo::Is6GbDevice() {
  return GetCachedSystemRamBucketizedSize() == BucketizedSize::k6Gb;
}

#endif  // BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS)

// TODO(crbug.com/40264947): This method is for chromium native code.
// We need to update the java-side code, i.e.
// base/android/java/src/org/chromium/base/SysUtils.java,
// and to make the selected components in java to see this feature.
bool SysInfo::IsLowEndDeviceOrPartialLowEndModeEnabled() { … }

bool SysInfo::IsLowEndDeviceOrPartialLowEndModeEnabled(
    const FeatureParam<bool>& param_for_exclusion) { … }

#if !BUILDFLAG(IS_ANDROID)
// The Android equivalent of this lives in `detectLowEndDevice()` at:
// base/android/java/src/org/chromium/base/SysUtils.java
bool DetectLowEndDevice() { … }

// static
bool SysInfo::IsLowEndDeviceImpl() { … }
#endif

#if !BUILDFLAG(IS_APPLE) && !BUILDFLAG(IS_ANDROID) && !BUILDFLAG(IS_WIN) && \
    !BUILDFLAG(IS_CHROMEOS)
std::string SysInfo::HardwareModelName() { … }
#endif

void SysInfo::GetHardwareInfo(base::OnceCallback<void(HardwareInfo)> callback) { … }

// static
base::TimeDelta SysInfo::Uptime() { … }

// static
std::string SysInfo::ProcessCPUArchitecture() { … }

// static
std::optional<uint64_t> SysInfo::SetAmountOfPhysicalMemoryMbForTesting(
    const uint64_t amount_of_memory_mb) { … }

// static
void SysInfo::ClearAmountOfPhysicalMemoryMbForTesting() { … }

}  // namespace base