Add Mask::count() method to count true elements

[GrigoryEvko]

Add Mask::count() method

Motivation

The Mask API currently provides boolean queries (any(), all()) and index queries (first_set()), but lacks a method to count the number of true elements. This forces users to either convert to arrays and iterate, or manually use to_bitmask().count_ones(), which exposes implementation details.

Current workarounds:

// Option 1: Verbose, requires knowing bitmask representation
let count = mask.to_bitmask().count_ones() as usize;

// Option 2: Inefficient, allocates array
let count = mask.to_array().iter().filter(|&&x| x).count();

Proposed:

let count = mask.count();

This pattern appears frequently in SIMD code when pre-sizing allocations to avoid reallocation overhead:

// Two-pass filtering: count matches, allocate once, then collect
let mask = values.simd_gt(threshold);
let mut results = Vec::with_capacity(mask.count());
for (i, &val) in data.iter().enumerate() {
    if mask.test(i) {
        results.push(val);
    }
}

Other common use cases include histogram generation, SQL-style COUNT aggregation, and sparse data analysis.

API Design

impl<T, const N: usize> Mask<T, N>
where
    T: MaskElement,
    LaneCount<N>: SupportedLaneCount,
{
    #[inline]
    #[must_use]
    pub fn count(self) -> usize {
        self.to_bitmask().count_ones() as usize
    }
}

Design decisions:

1. Returns usize - Consistent with Iterator::count() and suitable for array indexing
2. Named count() not len() - len() implies container size; count() matches the semantic operation (counting true values)
3. Simple #[must_use] attribute - Follows Vec::len() and slice::len() precedent (no message)
4. Not const - to_bitmask() uses intrinsics that cannot be const-evaluated

Implementation

The implementation delegates to to_bitmask().count_ones(), which already uses LLVM's llvm.ctpop intrinsic. This compiles to efficient platform-specific instructions:

• x86/x86_64: POPCNT (SSE4.2)
• ARM/AArch64: CNT (NEON)
• RISC-V: CPOP (Zbb extension)
• WebAssembly: i64.popcnt

No platform-specific code is required; LLVM handles optimization for each target.

Performance

Benchmarked on x86_64 (Intel Core i7-14700HX, -C target-cpu=native):

Mask size	count()	Manual iteration	Speedup
mask32x4	0.36 ns	0.52 ns	44%
mask32x8	0.45 ns	0.76 ns	69%
mask32x16	1.04 ns	1.15 ns	11%

Assembly verification shows the expected codegen (x86_64):

vmovmskps  eax, ymm0    ; Extract mask to integer
popcnt     eax, eax     ; Population count

The operation is branch-free and density-independent: mask16 measured at 1.03-1.05ns across all densities (0%, 25%, 50%, 75%, 100%), confirming constant-time behavior regardless of true element count.

[calebzulawski]

I have two concerns with this implementation:

• as supported vector sizes increase, to_bitmask will truncate to the first 64 bits
• to_bitmask is pretty slow on some architectures. On those architectures, I wonder if something like (mask.to_int() >> (size_of<T>() * 8 - 1)).reduce_sum() would work better