mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2026-07-17 00:13:50 +03:00
434 lines
18 KiB
C++
434 lines
18 KiB
C++
// Copyright 2020 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/allocator/partition_alloc_features.h"
|
|
|
|
#include "base/base_export.h"
|
|
#include "base/feature_list.h"
|
|
#include "base/features.h"
|
|
#include "build/build_config.h"
|
|
#include "build/chromecast_buildflags.h"
|
|
#include "partition_alloc/buildflags.h"
|
|
#include "partition_alloc/partition_alloc_constants.h"
|
|
#include "partition_alloc/partition_root.h"
|
|
#include "partition_alloc/shim/allocator_shim_dispatch_to_noop_on_free.h"
|
|
|
|
namespace base::features {
|
|
|
|
namespace {
|
|
|
|
static constexpr char kPAFeatureEnabledProcessesStr[] = "enabled-processes";
|
|
static constexpr char kBrowserOnlyStr[] = "browser-only";
|
|
static constexpr char kBrowserAndRendererStr[] = "browser-and-renderer";
|
|
static constexpr char kNonRendererStr[] = "non-renderer";
|
|
#if PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
|
|
static constexpr char kGPUOnlyStr[] = "gpu-only";
|
|
static constexpr char kBrowserAndGPUStr[] = "browser-and-gpu";
|
|
#endif // PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
|
|
static constexpr char kAllProcessesStr[] = "all-processes";
|
|
|
|
} // namespace
|
|
|
|
BASE_FEATURE(kPartitionAllocUnretainedDanglingPtr, FEATURE_ENABLED_BY_DEFAULT);
|
|
|
|
constexpr FeatureParam<UnretainedDanglingPtrMode>::Option
|
|
kUnretainedDanglingPtrModeOption[] = {
|
|
{UnretainedDanglingPtrMode::kCrash, "crash"},
|
|
{UnretainedDanglingPtrMode::kDumpWithoutCrashing,
|
|
"dump_without_crashing"},
|
|
};
|
|
// Note: Do not use the prepared macro as of no need for a local cache.
|
|
constinit const FeatureParam<UnretainedDanglingPtrMode>
|
|
kUnretainedDanglingPtrModeParam = {
|
|
&kPartitionAllocUnretainedDanglingPtr,
|
|
"mode",
|
|
UnretainedDanglingPtrMode::kCrash,
|
|
&kUnretainedDanglingPtrModeOption,
|
|
};
|
|
|
|
// Note: DPD conflicts with no-op `free()` (see
|
|
// `base::allocator::MakeFreeNoOp()`). No-op `free()` stands down in the
|
|
// presence of DPD, but hypothetically fully launching DPD should prompt
|
|
// a rethink of no-op `free()`.
|
|
BASE_FEATURE(kPartitionAllocDanglingPtr,
|
|
#if PA_BUILDFLAG(ENABLE_DANGLING_RAW_PTR_FEATURE_FLAG)
|
|
FEATURE_ENABLED_BY_DEFAULT
|
|
#else
|
|
FEATURE_DISABLED_BY_DEFAULT
|
|
#endif
|
|
);
|
|
|
|
constexpr FeatureParam<DanglingPtrMode>::Option kDanglingPtrModeOption[] = {
|
|
{DanglingPtrMode::kCrash, "crash"},
|
|
{DanglingPtrMode::kLogOnly, "log_only"},
|
|
};
|
|
// Note: Do not use the prepared macro as of no need for a local cache.
|
|
constinit const FeatureParam<DanglingPtrMode> kDanglingPtrModeParam{
|
|
&kPartitionAllocDanglingPtr,
|
|
"mode",
|
|
DanglingPtrMode::kCrash,
|
|
&kDanglingPtrModeOption,
|
|
};
|
|
constexpr FeatureParam<DanglingPtrType>::Option kDanglingPtrTypeOption[] = {
|
|
{DanglingPtrType::kAll, "all"},
|
|
{DanglingPtrType::kCrossTask, "cross_task"},
|
|
};
|
|
// Note: Do not use the prepared macro as of no need for a local cache.
|
|
constinit const FeatureParam<DanglingPtrType> kDanglingPtrTypeParam{
|
|
&kPartitionAllocDanglingPtr,
|
|
"type",
|
|
DanglingPtrType::kAll,
|
|
&kDanglingPtrTypeOption,
|
|
};
|
|
|
|
#if PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
|
|
// Use a larger maximum thread cache cacheable bucket size.
|
|
BASE_FEATURE(kPartitionAllocLargeThreadCacheSize, FEATURE_ENABLED_BY_DEFAULT);
|
|
|
|
BASE_FEATURE(kPartitionAllocLargeEmptySlotSpanRing,
|
|
#if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_WIN)
|
|
FEATURE_ENABLED_BY_DEFAULT);
|
|
#else
|
|
FEATURE_DISABLED_BY_DEFAULT);
|
|
#endif
|
|
BASE_FEATURE_PARAM(int,
|
|
kPartitionAllocLargeEmptySlotSpanRingSize,
|
|
&kPartitionAllocLargeEmptySlotSpanRing,
|
|
"ring-size",
|
|
partition_alloc::internal::SlotSpanRingMaxSize::kMedium);
|
|
|
|
BASE_FEATURE(kPartitionAllocWithAdvancedChecks, FEATURE_DISABLED_BY_DEFAULT);
|
|
constexpr FeatureParam<PartitionAllocWithAdvancedChecksEnabledProcesses>::Option
|
|
kPartitionAllocWithAdvancedChecksEnabledProcessesOptions[] = {
|
|
{PartitionAllocWithAdvancedChecksEnabledProcesses::kBrowserOnly,
|
|
kBrowserOnlyStr},
|
|
{PartitionAllocWithAdvancedChecksEnabledProcesses::kBrowserAndRenderer,
|
|
kBrowserAndRendererStr},
|
|
{PartitionAllocWithAdvancedChecksEnabledProcesses::kNonRenderer,
|
|
kNonRendererStr},
|
|
{PartitionAllocWithAdvancedChecksEnabledProcesses::kGPUOnly,
|
|
kGPUOnlyStr},
|
|
{PartitionAllocWithAdvancedChecksEnabledProcesses::kBrowserAndGPU,
|
|
kBrowserAndGPUStr},
|
|
{PartitionAllocWithAdvancedChecksEnabledProcesses::kAllProcesses,
|
|
kAllProcessesStr}};
|
|
// Note: Do not use the prepared macro as of no need for a local cache.
|
|
constinit const FeatureParam<PartitionAllocWithAdvancedChecksEnabledProcesses>
|
|
kPartitionAllocWithAdvancedChecksEnabledProcessesParam{
|
|
&kPartitionAllocWithAdvancedChecks, kPAFeatureEnabledProcessesStr,
|
|
PartitionAllocWithAdvancedChecksEnabledProcesses::kBrowserOnly,
|
|
&kPartitionAllocWithAdvancedChecksEnabledProcessesOptions};
|
|
|
|
BASE_FEATURE(kPartitionAllocSchedulerLoopQuarantine,
|
|
FEATURE_DISABLED_BY_DEFAULT);
|
|
// Scheduler Loop Quarantine's config.
|
|
// Note: Do not use the prepared macro as of no need for a local cache.
|
|
constinit const FeatureParam<std::string>
|
|
kPartitionAllocSchedulerLoopQuarantineConfig{
|
|
&kPartitionAllocSchedulerLoopQuarantine,
|
|
"PartitionAllocSchedulerLoopQuarantineConfig", "{}"};
|
|
|
|
BASE_FEATURE(kPartitionAllocSchedulerLoopQuarantineTaskControlledPurge,
|
|
FEATURE_DISABLED_BY_DEFAULT);
|
|
constexpr FeatureParam<
|
|
PartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcesses>::Option
|
|
kPartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcessesOptions[] = {
|
|
{PartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcesses::
|
|
kBrowserOnly,
|
|
kBrowserOnlyStr},
|
|
{PartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcesses::
|
|
kBrowserAndRenderer,
|
|
kBrowserAndRendererStr},
|
|
{PartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcesses::
|
|
kNonRenderer,
|
|
kNonRendererStr},
|
|
{PartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcesses::
|
|
kGPUOnly,
|
|
kGPUOnlyStr},
|
|
{PartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcesses::
|
|
kBrowserAndGPU,
|
|
kBrowserAndGPUStr},
|
|
{PartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcesses::
|
|
kAllProcesses,
|
|
kAllProcessesStr}};
|
|
// Note: Do not use the prepared macro as of no need for a local cache.
|
|
constinit const FeatureParam<
|
|
PartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcesses>
|
|
kPartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcessesParam{
|
|
&kPartitionAllocSchedulerLoopQuarantineTaskControlledPurge,
|
|
"PartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcess"
|
|
"es",
|
|
PartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcesses::
|
|
kBrowserOnly,
|
|
&kPartitionAllocSchedulerLoopQuarantineTaskControlledPurgeEnabledProcessesOptions};
|
|
|
|
BASE_FEATURE(kPartitionAllocEventuallyZeroFreedMemory,
|
|
FEATURE_DISABLED_BY_DEFAULT);
|
|
|
|
#endif // PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
|
|
|
|
BASE_FEATURE(kPartitionAllocBackupRefPtr,
|
|
#if PA_BUILDFLAG(ENABLE_BACKUP_REF_PTR_FEATURE_FLAG)
|
|
FEATURE_ENABLED_BY_DEFAULT
|
|
#else
|
|
FEATURE_DISABLED_BY_DEFAULT
|
|
#endif
|
|
);
|
|
|
|
constexpr FeatureParam<BackupRefPtrEnabledProcesses>::Option
|
|
kBackupRefPtrEnabledProcessesOptions[] = {
|
|
{BackupRefPtrEnabledProcesses::kBrowserOnly, kBrowserOnlyStr},
|
|
{BackupRefPtrEnabledProcesses::kBrowserAndRenderer,
|
|
kBrowserAndRendererStr},
|
|
{BackupRefPtrEnabledProcesses::kNonRenderer, kNonRendererStr},
|
|
{BackupRefPtrEnabledProcesses::kAllProcesses, kAllProcessesStr}};
|
|
|
|
BASE_FEATURE_ENUM_PARAM(BackupRefPtrEnabledProcesses,
|
|
kBackupRefPtrEnabledProcessesParam,
|
|
&kPartitionAllocBackupRefPtr,
|
|
kPAFeatureEnabledProcessesStr,
|
|
#if PA_BUILDFLAG(IS_ANDROID)
|
|
BackupRefPtrEnabledProcesses::kNonRenderer,
|
|
#else
|
|
BackupRefPtrEnabledProcesses::kAllProcesses,
|
|
#endif
|
|
&kBackupRefPtrEnabledProcessesOptions);
|
|
|
|
constexpr FeatureParam<BackupRefPtrMode>::Option kBackupRefPtrModeOptions[] = {
|
|
{BackupRefPtrMode::kDisabled, "disabled"},
|
|
{BackupRefPtrMode::kEnabled, "enabled"},
|
|
};
|
|
|
|
BASE_FEATURE_ENUM_PARAM(BackupRefPtrMode,
|
|
kBackupRefPtrModeParam,
|
|
&kPartitionAllocBackupRefPtr,
|
|
"brp-mode",
|
|
BackupRefPtrMode::kEnabled,
|
|
&kBackupRefPtrModeOptions);
|
|
// Note: Do not use the prepared macro as of no need for a local cache.
|
|
constinit const FeatureParam<int> kBackupRefPtrExtraExtrasSizeParam{
|
|
&kPartitionAllocBackupRefPtr, "brp-extra-extras-size", 0};
|
|
constinit const FeatureParam<bool> kBackupRefPtrSuppressDoubleFreeDetectedCrash{
|
|
&kPartitionAllocBackupRefPtr, "brp-suppress-double-free-detected-crash",
|
|
false};
|
|
constinit const FeatureParam<bool> kBackupRefPtrSuppressCorruptionDetectedCrash{
|
|
&kPartitionAllocBackupRefPtr, "brp-suppress-corruption-detected-crash",
|
|
#if PA_BUILDFLAG(IS_IOS)
|
|
// TODO(crbug.com/41497028): Continue investigation and remove once
|
|
// addressed.
|
|
true};
|
|
#else
|
|
false};
|
|
#endif
|
|
|
|
BASE_FEATURE(kPartitionAllocMemoryTagging,
|
|
#if PA_BUILDFLAG(USE_FULL_MTE) || BUILDFLAG(IS_ANDROID)
|
|
FEATURE_ENABLED_BY_DEFAULT
|
|
#else
|
|
FEATURE_DISABLED_BY_DEFAULT
|
|
#endif
|
|
);
|
|
|
|
constexpr FeatureParam<MemtagMode>::Option kMemtagModeOptions[] = {
|
|
{MemtagMode::kSync, "sync"},
|
|
{MemtagMode::kAsync, "async"}};
|
|
|
|
// Note: Do not use the prepared muacro as of no need for a local cache.
|
|
constinit const FeatureParam<MemtagMode> kMemtagModeParam{
|
|
&kPartitionAllocMemoryTagging, "memtag-mode",
|
|
#if PA_BUILDFLAG(USE_FULL_MTE)
|
|
MemtagMode::kSync,
|
|
#else
|
|
MemtagMode::kAsync,
|
|
#endif
|
|
&kMemtagModeOptions};
|
|
|
|
constexpr FeatureParam<RetagMode>::Option kRetagModeOptions[] = {
|
|
{RetagMode::kIncrement, "increment"},
|
|
{RetagMode::kRandom, "random"},
|
|
};
|
|
|
|
// Note: Do not use the prepared macro as of no need for a local cache.
|
|
constinit const FeatureParam<RetagMode> kRetagModeParam{
|
|
&kPartitionAllocMemoryTagging, "retag-mode", RetagMode::kIncrement,
|
|
&kRetagModeOptions};
|
|
|
|
constexpr FeatureParam<MemoryTaggingEnabledProcesses>::Option
|
|
kMemoryTaggingEnabledProcessesOptions[] = {
|
|
{MemoryTaggingEnabledProcesses::kBrowserOnly, kBrowserOnlyStr},
|
|
{MemoryTaggingEnabledProcesses::kNonRenderer, kNonRendererStr},
|
|
{MemoryTaggingEnabledProcesses::kAllProcesses, kAllProcessesStr}};
|
|
|
|
// Note: Do not use the prepared macro as of no need for a local cache.
|
|
constinit const FeatureParam<MemoryTaggingEnabledProcesses>
|
|
kMemoryTaggingEnabledProcessesParam{
|
|
&kPartitionAllocMemoryTagging, kPAFeatureEnabledProcessesStr,
|
|
#if PA_BUILDFLAG(USE_FULL_MTE)
|
|
MemoryTaggingEnabledProcesses::kAllProcesses,
|
|
#else
|
|
MemoryTaggingEnabledProcesses::kNonRenderer,
|
|
#endif
|
|
&kMemoryTaggingEnabledProcessesOptions};
|
|
|
|
BASE_FEATURE(kKillPartitionAllocMemoryTagging, FEATURE_DISABLED_BY_DEFAULT);
|
|
|
|
BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPermissiveMte);
|
|
BASE_FEATURE(kPartitionAllocPermissiveMte,
|
|
#if PA_BUILDFLAG(USE_FULL_MTE)
|
|
// We want to actually crash if USE_FULL_MTE is enabled.
|
|
FEATURE_DISABLED_BY_DEFAULT
|
|
#else
|
|
FEATURE_ENABLED_BY_DEFAULT
|
|
#endif
|
|
);
|
|
|
|
BASE_FEATURE(kAsanBrpDereferenceCheck, FEATURE_ENABLED_BY_DEFAULT);
|
|
BASE_FEATURE(kAsanBrpExtractionCheck, // Not much noise at the moment to
|
|
FEATURE_DISABLED_BY_DEFAULT); // enable by default.
|
|
BASE_FEATURE(kAsanBrpInstantiationCheck, FEATURE_ENABLED_BY_DEFAULT);
|
|
|
|
// If enabled, switches the bucket distribution to a denser one.
|
|
//
|
|
// We enable this by default everywhere except for 32-bit Android, since we saw
|
|
// regressions there.
|
|
BASE_FEATURE(kPartitionAllocUseDenserDistribution,
|
|
#if BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS)
|
|
FEATURE_DISABLED_BY_DEFAULT
|
|
#else
|
|
FEATURE_ENABLED_BY_DEFAULT
|
|
#endif // BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS)
|
|
);
|
|
const FeatureParam<BucketDistributionMode>::Option
|
|
kPartitionAllocBucketDistributionOption[] = {
|
|
{BucketDistributionMode::kDefault, "default"},
|
|
{BucketDistributionMode::kDenser, "denser"},
|
|
};
|
|
// Note: Do not use the prepared macro as of no need for a local cache.
|
|
constinit const FeatureParam<BucketDistributionMode>
|
|
kPartitionAllocBucketDistributionParam{
|
|
&kPartitionAllocUseDenserDistribution, "mode",
|
|
#if BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS)
|
|
BucketDistributionMode::kDefault,
|
|
#else
|
|
BucketDistributionMode::kDenser,
|
|
#endif // BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS)
|
|
&kPartitionAllocBucketDistributionOption};
|
|
|
|
BASE_FEATURE(kPartitionAllocMemoryReclaimer, FEATURE_ENABLED_BY_DEFAULT);
|
|
BASE_FEATURE_PARAM(TimeDelta,
|
|
kPartitionAllocMemoryReclaimerInterval,
|
|
&kPartitionAllocMemoryReclaimer,
|
|
"interval",
|
|
TimeDelta() // Defaults to zero.
|
|
);
|
|
|
|
// Configures whether we set a lower limit for renderers that do not have a main
|
|
// frame, similar to the limit that is already done for backgrounded renderers.
|
|
BASE_FEATURE(kLowerPAMemoryLimitForNonMainRenderers,
|
|
FEATURE_DISABLED_BY_DEFAULT);
|
|
|
|
// Whether to straighten free lists for larger slot spans in PurgeMemory() ->
|
|
// ... -> PartitionPurgeSlotSpan().
|
|
BASE_FEATURE(kPartitionAllocStraightenLargerSlotSpanFreeLists,
|
|
FEATURE_ENABLED_BY_DEFAULT);
|
|
const FeatureParam<partition_alloc::StraightenLargerSlotSpanFreeListsMode>::
|
|
Option kPartitionAllocStraightenLargerSlotSpanFreeListsModeOption[] = {
|
|
{partition_alloc::StraightenLargerSlotSpanFreeListsMode::
|
|
kOnlyWhenUnprovisioning,
|
|
"only-when-unprovisioning"},
|
|
{partition_alloc::StraightenLargerSlotSpanFreeListsMode::kAlways,
|
|
"always"},
|
|
};
|
|
// Note: Do not use the prepared macro as of no need for a local cache.
|
|
constinit const FeatureParam<
|
|
partition_alloc::StraightenLargerSlotSpanFreeListsMode>
|
|
kPartitionAllocStraightenLargerSlotSpanFreeListsMode = {
|
|
&kPartitionAllocStraightenLargerSlotSpanFreeLists,
|
|
"mode",
|
|
partition_alloc::StraightenLargerSlotSpanFreeListsMode::
|
|
kOnlyWhenUnprovisioning,
|
|
&kPartitionAllocStraightenLargerSlotSpanFreeListsModeOption,
|
|
};
|
|
|
|
// Whether to sort free lists for smaller slot spans in PurgeMemory().
|
|
BASE_FEATURE(kPartitionAllocSortSmallerSlotSpanFreeLists,
|
|
FEATURE_ENABLED_BY_DEFAULT);
|
|
|
|
// Whether to sort the active slot spans in PurgeMemory().
|
|
BASE_FEATURE(kPartitionAllocSortActiveSlotSpans, FEATURE_DISABLED_BY_DEFAULT);
|
|
|
|
#if BUILDFLAG(IS_WIN)
|
|
// Whether to retry allocations when commit fails.
|
|
BASE_FEATURE(kPageAllocatorRetryOnCommitFailure, FEATURE_ENABLED_BY_DEFAULT);
|
|
#endif
|
|
|
|
#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS)
|
|
// A parameter to exclude or not exclude PartitionAllocSupport from
|
|
// PartialLowModeOnMidRangeDevices. This is used to see how it affects
|
|
// renderer performances, e.g. blink_perf.parser benchmark.
|
|
// The feature: kPartialLowEndModeOnMidRangeDevices is defined in
|
|
// //base/features.cc. Since the following feature param is related to
|
|
// PartitionAlloc, define the param here.
|
|
BASE_FEATURE_PARAM(bool,
|
|
kPartialLowEndModeExcludePartitionAllocSupport,
|
|
&kPartialLowEndModeOnMidRangeDevices,
|
|
"exclude-partition-alloc-support",
|
|
false);
|
|
#endif
|
|
|
|
constexpr partition_alloc::internal::base::TimeDelta ToPartitionAllocTimeDelta(
|
|
TimeDelta time_delta) {
|
|
return partition_alloc::internal::base::Microseconds(
|
|
time_delta.InMicroseconds());
|
|
}
|
|
|
|
constexpr TimeDelta FromPartitionAllocTimeDelta(
|
|
partition_alloc::internal::base::TimeDelta time_delta) {
|
|
return Microseconds(time_delta.InMicroseconds());
|
|
}
|
|
|
|
BASE_FEATURE(kPartitionAllocAdjustSizeWhenInForeground,
|
|
#if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_WIN)
|
|
FEATURE_ENABLED_BY_DEFAULT);
|
|
#else
|
|
FEATURE_DISABLED_BY_DEFAULT);
|
|
#endif
|
|
BASE_FEATURE_PARAM(
|
|
int,
|
|
kPartitionAllocForegroundEmptySlotSpanRingSize,
|
|
&kPartitionAllocAdjustSizeWhenInForeground,
|
|
"foreground-ring-size",
|
|
static_cast<int>(partition_alloc::internal::kMaxEmptySlotSpanRingSize));
|
|
BASE_FEATURE_PARAM(int,
|
|
kPartitionAllocBackgroundEmptySlotSpanRingSize,
|
|
&kPartitionAllocAdjustSizeWhenInForeground,
|
|
"background-ring-size",
|
|
partition_alloc::internal::SlotSpanRingMaxSize::kMedium);
|
|
|
|
#if PA_BUILDFLAG(ENABLE_PARTITION_LOCK_PRIORITY_INHERITANCE)
|
|
BASE_FEATURE(kPartitionAllocUsePriorityInheritanceLocks,
|
|
FEATURE_DISABLED_BY_DEFAULT);
|
|
#endif // PA_BUILDFLAG(ENABLE_PARTITION_LOCK_PRIORITY_INHERITANCE)
|
|
|
|
BASE_FEATURE(kPartitionAllocFreeWithSize, FEATURE_ENABLED_BY_DEFAULT);
|
|
BASE_FEATURE_PARAM(bool,
|
|
kPartitionAllocStrictFreeSizeCheck,
|
|
&kPartitionAllocFreeWithSize,
|
|
"strict-free-size-check",
|
|
true);
|
|
|
|
#if BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_ARM64)
|
|
BASE_FEATURE(kPartitionAllocLockTuneSpin, FEATURE_DISABLED_BY_DEFAULT);
|
|
|
|
// On ARM64, 2048 cycles results in spinning for 500-1500 nanoseconds on most
|
|
// Android devices which overlaps with the time spent on a futex syscall.
|
|
BASE_FEATURE_PARAM(int,
|
|
kPartitionAllocLockSpinCount,
|
|
&kPartitionAllocLockTuneSpin,
|
|
"spin_count",
|
|
2048);
|
|
#endif // BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_ARM64)
|
|
|
|
} // namespace base::features
|