Cheri-research/snmalloc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove all instances of static_cast<size_t>(1).

Browse Source 
In preparation for removing magic numbers, simplify code that is
computing masks with a single bit set.
This commit is contained in:
David Chisnall
2019-04-30 11:49:00 +01:00
parent 95c23b1a00
commit 8bd136c224
7 changed files with 32 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
src/ds/bits.h
View File

@@ -85,6 +85,16 @@ namespace snmalloc
return BITS == 64;
}
/**
* Returns a value of type T that has a single bit set,
*/
template<typename T = size_t>
constexpr T one_at_bit(size_t shift)
{
static_assert(std::is_integral_v<T>, "Type must be integral");
return (static_cast<T>(1)) << shift;
}
static constexpr size_t ADDRESS_BITS = is64() ? 48 : 32;
inline void pause()
@@ -225,7 +235,7 @@ namespace snmalloc
for (int i = BITS - 1; i >= 0; i--)
{
size_t mask = static_cast<size_t>(1) << i;
size_t mask = one_at_bit(i);
if ((x & mask) == mask)
return n;
@@ -255,7 +265,7 @@ namespace snmalloc
for (size_t i = 0; i < BITS; i++)
{
size_t mask = static_cast<size_t>(1) << i;
size_t mask = one_at_bit(i);
if ((x & mask) == mask)
return n;
@@ -296,7 +306,7 @@ namespace snmalloc
if (x <= 2)
return x;
return static_cast<size_t>(1) << (BITS - clz(x - 1));
return one_at_bit(BITS - clz(x - 1));
}
inline size_t next_pow2_bits(size_t x)
@@ -311,7 +321,7 @@ namespace snmalloc
if (x <= 2)
return x;
return static_cast<size_t>(1) << (BITS - clz_const(x - 1));
return one_at_bit(BITS - clz_const(x - 1));
}
constexpr size_t next_pow2_bits_const(size_t x)
@@ -419,9 +429,8 @@ namespace snmalloc
template<size_t MANTISSA_BITS, size_t LOW_BITS = 0>
static size_t to_exp_mant(size_t value)
{
size_t LEADING_BIT =
(static_cast<size_t>(1) << (MANTISSA_BITS + LOW_BITS)) >> 1;
size_t MANTISSA_MASK = (static_cast<size_t>(1) << MANTISSA_BITS) - 1;
size_t LEADING_BIT = one_at_bit(MANTISSA_BITS + LOW_BITS) >> 1;
size_t MANTISSA_MASK = one_at_bit(MANTISSA_BITS) - 1;
value = value - 1;
@@ -436,9 +445,8 @@ namespace snmalloc
template<size_t MANTISSA_BITS, size_t LOW_BITS = 0>
constexpr static size_t to_exp_mant_const(size_t value)
{
size_t LEADING_BIT =
(static_cast<size_t>(1) << (MANTISSA_BITS + LOW_BITS)) >> 1;
size_t MANTISSA_MASK = (static_cast<size_t>(1) << MANTISSA_BITS) - 1;
size_t LEADING_BIT = one_at_bit(MANTISSA_BITS + LOW_BITS) >> 1;
size_t MANTISSA_MASK = one_at_bit(MANTISSA_BITS) - 1;
value = value - 1;
@@ -456,7 +464,7 @@ namespace snmalloc
if (MANTISSA_BITS > 0)
{
m_e = m_e + 1;
size_t MANTISSA_MASK = (static_cast<size_t>(1) << MANTISSA_BITS) - 1;
size_t MANTISSA_MASK = one_at_bit(MANTISSA_BITS) - 1;
size_t m = m_e & MANTISSA_MASK;
size_t e = m_e >> MANTISSA_BITS;
size_t b = e == 0 ? 0 : 1;
@@ -465,7 +473,7 @@ namespace snmalloc
return extended_m << (shifted_e + LOW_BITS);
}
return static_cast<size_t>(1) << (m_e + LOW_BITS);
return one_at_bit(m_e + LOW_BITS);
}
/**

2
src/mem/alloc.h
View File

@@ -1211,7 +1211,7 @@ namespace snmalloc
MEASURE_TIME(large_dealloc, 4, 16);
size_t size_bits = bits::next_pow2_bits(size);
size_t rsize = static_cast<size_t>(1) << size_bits;
size_t rsize = bits::one_at_bit(size_bits);
assert(rsize >= SUPERSLAB_SIZE);
size_t large_class = size_bits - SUPERSLAB_BITS;

2
src/mem/allocstats.h
View File

@@ -117,7 +117,7 @@ namespace snmalloc
static constexpr size_t BUCKETS = 1 << BUCKETS_BITS;
static constexpr size_t TOTAL_BUCKETS =
bits::to_exp_mant_const<BUCKETS_BITS>(
(static_cast<size_t>(1) << (bits::ADDRESS_BITS - 1)));
bits::one_at_bit(bits::ADDRESS_BITS - 1));
Stats sizeclass[N];
Stats large[LARGE_N];

5
src/mem/largealloc.h
View File

@@ -98,8 +98,7 @@ namespace snmalloc
{
break;
}
size_t rsize = (static_cast<size_t>(1) << SUPERSLAB_BITS)
<< large_class;
size_t rsize = bits::one_at_bit(SUPERSLAB_BITS) << large_class;
size_t decommit_size = rsize - OS_PAGE_SIZE;
// Grab all of the chunks of this size class.
auto* slab = large_stack[large_class].pop_all();
@@ -321,7 +320,7 @@ namespace snmalloc
template<ZeroMem zero_mem = NoZero, AllowReserve allow_reserve = YesReserve>
void* alloc(size_t large_class, size_t size)
{
size_t rsize = (static_cast<size_t>(1) << SUPERSLAB_BITS) << large_class;
size_t rsize = bits::one_at_bit(SUPERSLAB_BITS) << large_class;
if (size == 0)
size = rsize;

7
src/mem/metaslab.h
View File

@@ -102,10 +102,13 @@ namespace snmalloc
{
size_t size = sizeclass_to_size(sizeclass);
size_t offset = get_slab_offset(sizeclass, is_short);
size_t all_ones = std::numeric_limits<size_t>::is_signed ?
size_t(-1) :
std::numeric_limits<size_t>::max();
size_t head_start =
remove_cache_friendly_offset(head & ~static_cast<size_t>(1), sizeclass);
size_t slab_start = offset & ~static_cast<size_t>(1);
remove_cache_friendly_offset(head & all_ones, sizeclass);
size_t slab_start = offset & all_ones;
return ((head_start - slab_start) % size) == 0;
}

4
src/mem/sizeclass.h
View File

@@ -30,12 +30,12 @@ namespace snmalloc
constexpr static inline size_t large_sizeclass_to_size(uint8_t large_class)
{
return static_cast<size_t>(1) << (large_class + SUPERSLAB_BITS);
return bits::one_at_bit(large_class + SUPERSLAB_BITS);
}
// Small classes range from [MIN, SLAB], i.e. inclusive.
static constexpr size_t NUM_SMALL_CLASSES =
size_to_sizeclass_const(static_cast<size_t>(1) << SLAB_BITS) + 1;
size_to_sizeclass_const(bits::one_at_bit(SLAB_BITS)) + 1;
static constexpr size_t NUM_SIZECLASSES =
size_to_sizeclass_const(SUPERSLAB_SIZE);

3
src/mem/sizeclasstable.h
View File

@@ -30,8 +30,7 @@ namespace snmalloc
bits::from_exp_mant<INTERMEDIATE_BITS, MIN_ALLOC_BITS>(sizeclass);
size_t alignment = bits::min(
static_cast<size_t>(1) << bits::ctz_const(size[sizeclass]),
OS_PAGE_SIZE);
bits::one_at_bit(bits::ctz_const(size[sizeclass])), OS_PAGE_SIZE);
cache_friendly_mask[sizeclass] = (alignment - 1);
inverse_cache_friendly_mask[sizeclass] = ~(alignment - 1);
}