From 38d4483b2797d1c00eff9326f24b5cd609f52b4f Mon Sep 17 00:00:00 2001 From: Matthew Parkinson Date: Wed, 21 Sep 2022 11:14:14 +0100 Subject: [PATCH] [NFC] Simplify static constexpr inline (#563) * [NFC] Simplify static constexpr inline `constexpr` => `inline` and when not in a class scope `constexpr` => `static` This PR removes the redundant use of `inline` and `static`. It also prefers `static constexpr` over `constexpr static` --- src/snmalloc/aal/aal.h | 2 +- src/snmalloc/backend_helpers/commonconfig.h | 4 +- src/snmalloc/ds_core/bits.h | 19 ++++--- src/snmalloc/mem/backend_wrappers.h | 23 +++++---- src/snmalloc/mem/sizeclasstable.h | 55 ++++++++++----------- src/snmalloc/pal/pal_consts.h | 2 +- 6 files changed, 51 insertions(+), 54 deletions(-) diff --git a/src/snmalloc/aal/aal.h b/src/snmalloc/aal/aal.h index 3d44d564..f56d89ea 100644 --- a/src/snmalloc/aal/aal.h +++ b/src/snmalloc/aal/aal.h @@ -250,7 +250,7 @@ namespace snmalloc #endif template - constexpr static bool aal_supports = (AAL::aal_features & F) == F; + constexpr bool aal_supports = (AAL::aal_features & F) == F; /* * The backend's leading-order response to StrictProvenance is entirely diff --git a/src/snmalloc/backend_helpers/commonconfig.h b/src/snmalloc/backend_helpers/commonconfig.h index 119d6c84..a69b6a38 100644 --- a/src/snmalloc/backend_helpers/commonconfig.h +++ b/src/snmalloc/backend_helpers/commonconfig.h @@ -15,14 +15,14 @@ namespace snmalloc * this as a field of the global object: * * ```c++ - * constexpr static snmalloc::Flags Options{}; + * static constexpr snmalloc::Flags Options{}; * ``` * * A global configuration that wished to use out-of-line message queues but * accept the defaults for everything else would instead do this: * * ```c++ - * constexpr static snmalloc::Flags Options{.IsQueueInline = false}; + * static constexpr snmalloc::Flags Options{.IsQueueInline = false}; * ``` * * To maintain backwards source compatibility in future versions, any new diff --git a/src/snmalloc/ds_core/bits.h b/src/snmalloc/ds_core/bits.h index f1dc4ffd..b82ee846 100644 --- a/src/snmalloc/ds_core/bits.h +++ b/src/snmalloc/ds_core/bits.h @@ -96,14 +96,14 @@ namespace snmalloc #endif } - inline constexpr size_t rotr_const(size_t x, size_t n) + constexpr size_t rotr_const(size_t x, size_t n) { size_t nn = n & (BITS - 1); return (x >> nn) | (x << ((static_cast(-static_cast(nn))) & (BITS - 1))); } - inline constexpr size_t rotl_const(size_t x, size_t n) + constexpr size_t rotl_const(size_t x, size_t n) { size_t nn = n & (BITS - 1); return (x << nn) | @@ -260,12 +260,12 @@ namespace snmalloc return one_at_bit(BITS - (clz_const(x + 1) + 1)); } - inline constexpr size_t next_pow2_bits_const(size_t x) + constexpr size_t next_pow2_bits_const(size_t x) { return BITS - clz_const(x - 1); } - inline constexpr SNMALLOC_FAST_PATH size_t + constexpr SNMALLOC_FAST_PATH size_t align_down(size_t value, size_t alignment) { SNMALLOC_ASSERT(is_pow2(alignment)); @@ -275,8 +275,7 @@ namespace snmalloc return value; } - inline constexpr SNMALLOC_FAST_PATH size_t - align_up(size_t value, size_t alignment) + constexpr SNMALLOC_FAST_PATH size_t align_up(size_t value, size_t alignment) { SNMALLOC_ASSERT(is_pow2(alignment)); @@ -331,7 +330,7 @@ namespace snmalloc } template - constexpr static size_t to_exp_mant_const(size_t value) + constexpr size_t to_exp_mant_const(size_t value) { constexpr size_t LEADING_BIT = one_at_bit(MANTISSA_BITS + LOW_BITS) >> 1; constexpr size_t MANTISSA_MASK = one_at_bit(MANTISSA_BITS) - 1; @@ -347,7 +346,7 @@ namespace snmalloc } template - constexpr static size_t from_exp_mant(size_t m_e) + constexpr size_t from_exp_mant(size_t m_e) { if (MANTISSA_BITS > 0) { @@ -371,7 +370,7 @@ namespace snmalloc * We write our own to reduce the code that potentially needs reviewing. */ template - constexpr inline T min(T t1, T t2) + constexpr T min(T t1, T t2) { return t1 < t2 ? t1 : t2; } @@ -383,7 +382,7 @@ namespace snmalloc * We write our own to reduce the code that potentially needs reviewing. */ template - constexpr inline T max(T t1, T t2) + constexpr T max(T t1, T t2) { return t1 > t2 ? t1 : t2; } diff --git a/src/snmalloc/mem/backend_wrappers.h b/src/snmalloc/mem/backend_wrappers.h index 98320b2f..a7f47db4 100644 --- a/src/snmalloc/mem/backend_wrappers.h +++ b/src/snmalloc/mem/backend_wrappers.h @@ -43,17 +43,16 @@ namespace snmalloc SNMALLOC_CONCEPT(IsConfigDomestication) Config, typename T, SNMALLOC_CONCEPT(capptr::IsBound) B> - constexpr SNMALLOC_FAST_PATH_INLINE auto has_domesticate(int) - -> std::enable_if_t< - std::is_same_v< - decltype(Config::capptr_domesticate( - std::declval(), - std::declval>())), - CapPtr< - T, - typename B::template with_wildness< - capptr::dimension::Wildness::Tame>>>, - bool> + constexpr SNMALLOC_FAST_PATH auto has_domesticate(int) -> std::enable_if_t< + std::is_same_v< + decltype(Config::capptr_domesticate( + std::declval(), + std::declval>())), + CapPtr< + T, + typename B::template with_wildness< + capptr::dimension::Wildness::Tame>>>, + bool> { return true; } @@ -66,7 +65,7 @@ namespace snmalloc SNMALLOC_CONCEPT(IsConfig) Config, typename T, SNMALLOC_CONCEPT(capptr::IsBound) B> - constexpr SNMALLOC_FAST_PATH_INLINE bool has_domesticate(long) + constexpr SNMALLOC_FAST_PATH bool has_domesticate(long) { return false; } diff --git a/src/snmalloc/mem/sizeclasstable.h b/src/snmalloc/mem/sizeclasstable.h index 4590ebb5..28f08a28 100644 --- a/src/snmalloc/mem/sizeclasstable.h +++ b/src/snmalloc/mem/sizeclasstable.h @@ -18,7 +18,7 @@ namespace snmalloc using smallsizeclass_t = size_t; using chunksizeclass_t = size_t; - constexpr static inline smallsizeclass_t size_to_sizeclass_const(size_t size) + static constexpr smallsizeclass_t size_to_sizeclass_const(size_t size) { // Don't use sizeclasses that are not a multiple of the alignment. // For example, 24 byte allocations can be @@ -31,22 +31,22 @@ namespace snmalloc return sc; } - static constexpr size_t NUM_SMALL_SIZECLASSES = + constexpr size_t NUM_SMALL_SIZECLASSES = size_to_sizeclass_const(MAX_SMALL_SIZECLASS_SIZE); // Large classes range from [MAX_SMALL_SIZECLASS_SIZE, ADDRESS_SPACE). - static constexpr size_t NUM_LARGE_CLASSES = + constexpr size_t NUM_LARGE_CLASSES = DefaultPal::address_bits - MAX_SMALL_SIZECLASS_BITS; // How many bits are required to represent either a large or a small // sizeclass. - static constexpr size_t TAG_SIZECLASS_BITS = bits::max( + constexpr size_t TAG_SIZECLASS_BITS = bits::max( bits::next_pow2_bits_const(NUM_SMALL_SIZECLASSES + 1), bits::next_pow2_bits_const(NUM_LARGE_CLASSES + 1)); // Number of bits required to represent a tagged sizeclass that can be // either small or large. - static constexpr size_t SIZECLASS_REP_SIZE = + constexpr size_t SIZECLASS_REP_SIZE = bits::one_at_bit(TAG_SIZECLASS_BITS + 1); /** @@ -66,7 +66,7 @@ namespace snmalloc public: constexpr sizeclass_t() = default; - constexpr static sizeclass_t from_small_class(smallsizeclass_t sc) + static constexpr sizeclass_t from_small_class(smallsizeclass_t sc) { SNMALLOC_ASSERT(sc < TAG); // Note could use `+` or `|`. Using `+` as will combine nicely with array @@ -78,13 +78,13 @@ namespace snmalloc * Takes the number of leading zero bits from the actual large size-1. * See size_to_sizeclass_full */ - constexpr static sizeclass_t from_large_class(size_t large_class) + static constexpr sizeclass_t from_large_class(size_t large_class) { SNMALLOC_ASSERT(large_class < TAG); return {large_class}; } - constexpr static sizeclass_t from_raw(size_t raw) + static constexpr sizeclass_t from_raw(size_t raw) { return {raw}; } @@ -129,7 +129,7 @@ namespace snmalloc using sizeclass_compress_t = uint8_t; - inline SNMALLOC_FAST_PATH static size_t + constexpr SNMALLOC_FAST_PATH static size_t aligned_size(size_t alignment, size_t size) { // Client responsible for checking alignment is not zero @@ -270,26 +270,26 @@ namespace snmalloc } }; - static inline constexpr SizeClassTable sizeclass_metadata = SizeClassTable(); + constexpr SizeClassTable sizeclass_metadata = SizeClassTable(); - static constexpr size_t DIV_MULT_SHIFT = sizeclass_metadata.DIV_MULT_SHIFT; + constexpr size_t DIV_MULT_SHIFT = sizeclass_metadata.DIV_MULT_SHIFT; - constexpr static inline size_t sizeclass_to_size(smallsizeclass_t sizeclass) + constexpr size_t sizeclass_to_size(smallsizeclass_t sizeclass) { return sizeclass_metadata.fast_small(sizeclass).size; } - static inline size_t sizeclass_full_to_size(sizeclass_t sizeclass) + constexpr size_t sizeclass_full_to_size(sizeclass_t sizeclass) { return sizeclass_metadata.fast(sizeclass).size; } - inline static size_t sizeclass_full_to_slab_size(sizeclass_t sizeclass) + constexpr size_t sizeclass_full_to_slab_size(sizeclass_t sizeclass) { return sizeclass_metadata.fast(sizeclass).slab_mask + 1; } - inline static size_t sizeclass_to_slab_size(smallsizeclass_t sizeclass) + constexpr size_t sizeclass_to_slab_size(smallsizeclass_t sizeclass) { return sizeclass_metadata.fast_small(sizeclass).slab_mask + 1; } @@ -301,7 +301,7 @@ namespace snmalloc * * It also increases entropy, when we have randomisation. */ - inline uint16_t threshold_for_waking_slab(smallsizeclass_t sizeclass) + constexpr uint16_t threshold_for_waking_slab(smallsizeclass_t sizeclass) { return sizeclass_metadata.slow(sizeclass_t::from_small_class(sizeclass)) .waking; @@ -314,7 +314,7 @@ namespace snmalloc return bits::next_pow2_bits(ssize) - MIN_CHUNK_BITS; } - inline static size_t slab_sizeclass_to_size(chunksizeclass_t sizeclass) + constexpr size_t slab_sizeclass_to_size(chunksizeclass_t sizeclass) { return bits::one_at_bit(MIN_CHUNK_BITS + sizeclass); } @@ -323,20 +323,19 @@ namespace snmalloc * For large allocations, the metaentry stores the raw log_2 of the size, * which must be shifted into the index space of slab_sizeclass-es. */ - inline static size_t + constexpr size_t metaentry_chunk_sizeclass_to_slab_sizeclass(chunksizeclass_t sizeclass) { return sizeclass - MIN_CHUNK_BITS; } - inline constexpr static uint16_t - sizeclass_to_slab_object_count(smallsizeclass_t sizeclass) + constexpr uint16_t sizeclass_to_slab_object_count(smallsizeclass_t sizeclass) { return sizeclass_metadata.slow(sizeclass_t::from_small_class(sizeclass)) .capacity; } - inline static address_t start_of_object(sizeclass_t sc, address_t addr) + constexpr address_t start_of_object(sizeclass_t sc, address_t addr) { auto meta = sizeclass_metadata.fast(sc); address_t slab_start = addr & ~meta.slab_mask; @@ -365,17 +364,17 @@ namespace snmalloc } } - inline static size_t index_in_object(sizeclass_t sc, address_t addr) + constexpr size_t index_in_object(sizeclass_t sc, address_t addr) { return addr - start_of_object(sc, addr); } - inline static size_t remaining_bytes(sizeclass_t sc, address_t addr) + constexpr size_t remaining_bytes(sizeclass_t sc, address_t addr) { return sizeclass_metadata.fast(sc).size - index_in_object(sc, addr); } - inline static bool is_start_of_object(sizeclass_t sc, address_t addr) + constexpr bool is_start_of_object(sizeclass_t sc, address_t addr) { size_t offset = addr & (sizeclass_full_to_slab_size(sc) - 1); @@ -405,16 +404,16 @@ namespace snmalloc return bits::next_pow2_bits(size) - MIN_CHUNK_BITS; } - constexpr static SNMALLOC_PURE size_t sizeclass_lookup_index(const size_t s) + constexpr SNMALLOC_PURE size_t sizeclass_lookup_index(const size_t s) { // We subtract and shift to reduce the size of the table, i.e. we don't have // to store a value for every size. return (s - 1) >> MIN_ALLOC_BITS; } - static inline smallsizeclass_t size_to_sizeclass(size_t size) + constexpr smallsizeclass_t size_to_sizeclass(size_t size) { - constexpr static size_t sizeclass_lookup_size = + constexpr size_t sizeclass_lookup_size = sizeclass_lookup_index(MAX_SMALL_SIZECLASS_SIZE); /** @@ -444,7 +443,7 @@ namespace snmalloc } }; - static constexpr SizeClassLookup sizeclass_lookup = SizeClassLookup(); + constexpr SizeClassLookup sizeclass_lookup = SizeClassLookup(); auto index = sizeclass_lookup_index(size); if (index < sizeclass_lookup_size) diff --git a/src/snmalloc/pal/pal_consts.h b/src/snmalloc/pal/pal_consts.h index 8de4cb09..6ea5b36b 100644 --- a/src/snmalloc/pal/pal_consts.h +++ b/src/snmalloc/pal/pal_consts.h @@ -103,5 +103,5 @@ namespace snmalloc * Query whether the PAL supports a specific feature. */ template - constexpr static bool pal_supports = (PAL::pal_features & F) == F; + static constexpr bool pal_supports = (PAL::pal_features & F) == F; } // namespace snmalloc