bab0507ff2
This releases the requirement that we need to preserve the memory for all regions at the beginning. It needs a huge amount of contiguous pages and which may be a challenge in certain cases. Therefore, adding a new flag, EnableContiguousRegions, to indicate whether we want to allocate all the regions next to each other. Note that once the EnableContiguousRegions is disabled, EnableRandomOffset becomes irrelevant because the base of each region is already random.
130 lines
4.7 KiB
C++
130 lines
4.7 KiB
C++
//===-- allocator_config.def ------------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines all the flags and types supported in Scudo. For optional
|
|
// flags and types, only explicitly define them when interested (i.e., unused
|
|
// optional flags or types can be skipped).
|
|
|
|
#ifndef BASE_REQUIRED_TEMPLATE_TYPE
|
|
#define BASE_REQUIRED_TEMPLATE_TYPE(...)
|
|
#endif
|
|
#ifndef BASE_OPTIONAL
|
|
#define BASE_OPTIONAL(...)
|
|
#endif
|
|
#ifndef PRIMARY_REQUIRED_TYPE
|
|
#define PRIMARY_REQUIRED_TYPE(...)
|
|
#endif
|
|
#ifndef PRIMARY_REQUIRED
|
|
#define PRIMARY_REQUIRED(...)
|
|
#endif
|
|
#ifndef PRIMARY_OPTIONAL
|
|
#define PRIMARY_OPTIONAL(...)
|
|
#endif
|
|
#ifndef PRIMARY_OPTIONAL_TYPE
|
|
#define PRIMARY_OPTIONAL_TYPE(...)
|
|
#endif
|
|
#ifndef SECONDARY_REQUIRED_TEMPLATE_TYPE
|
|
#define SECONDARY_REQUIRED_TEMPLATE_TYPE(...)
|
|
#endif
|
|
#ifndef SECONDARY_CACHE_OPTIONAL
|
|
#define SECONDARY_CACHE_OPTIONAL(...)
|
|
#endif
|
|
|
|
// BASE_REQUIRED_TEMPLATE_TYPE(NAME)
|
|
//
|
|
// Thread-Specific Data Registry used, shared or exclusive.
|
|
BASE_REQUIRED_TEMPLATE_TYPE(TSDRegistryT)
|
|
|
|
// Defines the type of Primary allocator to use.
|
|
BASE_REQUIRED_TEMPLATE_TYPE(PrimaryT)
|
|
|
|
// Defines the type of Secondary allocator to use.
|
|
BASE_REQUIRED_TEMPLATE_TYPE(SecondaryT)
|
|
|
|
// BASE_OPTIONAL(TYPE, NAME, DEFAULT)
|
|
//
|
|
// Indicates possible support for Memory Tagging.
|
|
BASE_OPTIONAL(const bool, MaySupportMemoryTagging, false)
|
|
|
|
// PRIMARY_REQUIRED_TYPE(NAME)
|
|
//
|
|
// SizeClassMap to use with the Primary.
|
|
PRIMARY_REQUIRED_TYPE(SizeClassMap)
|
|
|
|
// Defines the type and scale of a compact pointer. A compact pointer can
|
|
// be understood as the offset of a pointer within the region it belongs
|
|
// to, in increments of a power-of-2 scale. See `CompactPtrScale` also.
|
|
PRIMARY_REQUIRED_TYPE(CompactPtrT)
|
|
|
|
// PRIMARY_REQUIRED(TYPE, NAME)
|
|
//
|
|
// The scale of a compact pointer. E.g., Ptr = Base + (CompactPtr << Scale).
|
|
PRIMARY_REQUIRED(const uptr, CompactPtrScale)
|
|
|
|
// Log2 of the size of a size class region, as used by the Primary.
|
|
PRIMARY_REQUIRED(const uptr, RegionSizeLog)
|
|
|
|
// Conceptually, a region will be divided into groups based on the address
|
|
// range. Each allocation consumes blocks in the same group until exhaustion
|
|
// then it pops out blocks in a new group. Therefore, `GroupSizeLog` is always
|
|
// smaller or equal to `RegionSizeLog`. Note that `GroupSizeLog` needs to be
|
|
// equal to `RegionSizeLog` for SizeClassAllocator32 because of certain
|
|
// constraints.
|
|
PRIMARY_REQUIRED(const uptr, GroupSizeLog)
|
|
|
|
// Call map for user memory with at least this size. Only used with primary64.
|
|
PRIMARY_REQUIRED(const uptr, MapSizeIncrement)
|
|
|
|
// Defines the minimal & maximal release interval that can be set.
|
|
PRIMARY_REQUIRED(const s32, MinReleaseToOsIntervalMs)
|
|
PRIMARY_REQUIRED(const s32, MaxReleaseToOsIntervalMs)
|
|
|
|
// PRIMARY_OPTIONAL(TYPE, NAME, DEFAULT)
|
|
//
|
|
// Indicates support for offsetting the start of a region by a random number of
|
|
// pages. This is only used if `EnableContiguousRegions` is enabled.
|
|
PRIMARY_OPTIONAL(const bool, EnableRandomOffset, false)
|
|
|
|
// When `EnableContiguousRegions` is true, all regions will be be arranged in
|
|
// adjacency. This will reduce the fragmentation caused by region allocations
|
|
// but may require a huge amount of contiguous pages at initialization.
|
|
PRIMARY_OPTIONAL(const bool, EnableContiguousRegions, true)
|
|
|
|
// PRIMARY_OPTIONAL_TYPE(NAME, DEFAULT)
|
|
//
|
|
// Use condition variable to shorten the waiting time of refillment of
|
|
// freelist. Note that this depends on the implementation of condition
|
|
// variable on each platform and the performance may vary so that it does not
|
|
// guarantee a performance benefit.
|
|
PRIMARY_OPTIONAL_TYPE(ConditionVariableT, ConditionVariableDummy)
|
|
|
|
// SECONDARY_REQUIRED_TEMPLATE_TYPE(NAME)
|
|
//
|
|
// Defines the type of Secondary Cache to use.
|
|
SECONDARY_REQUIRED_TEMPLATE_TYPE(CacheT)
|
|
|
|
// SECONDARY_CACHE_OPTIONAL(TYPE, NAME, DEFAULT)
|
|
//
|
|
// Defines the type of cache used by the Secondary. Some additional
|
|
// configuration entries can be necessary depending on the Cache.
|
|
SECONDARY_CACHE_OPTIONAL(const u32, EntriesArraySize, 0)
|
|
SECONDARY_CACHE_OPTIONAL(const u32, QuarantineSize, 0)
|
|
SECONDARY_CACHE_OPTIONAL(const u32, DefaultMaxEntriesCount, 0)
|
|
SECONDARY_CACHE_OPTIONAL(const uptr, DefaultMaxEntrySize, 0)
|
|
SECONDARY_CACHE_OPTIONAL(const s32, MinReleaseToOsIntervalMs, INT32_MIN)
|
|
SECONDARY_CACHE_OPTIONAL(const s32, MaxReleaseToOsIntervalMs, INT32_MAX)
|
|
|
|
#undef SECONDARY_CACHE_OPTIONAL
|
|
#undef SECONDARY_REQUIRED_TEMPLATE_TYPE
|
|
#undef PRIMARY_OPTIONAL_TYPE
|
|
#undef PRIMARY_OPTIONAL
|
|
#undef PRIMARY_REQUIRED
|
|
#undef PRIMARY_REQUIRED_TYPE
|
|
#undef BASE_OPTIONAL
|
|
#undef BASE_REQUIRED_TEMPLATE_TYPE
|