如果您不关心乘法顺序，那很容易。关键是来自SSE 4.1 set的_mm_blendv_pd指令。这使您可以完全无分支。

// Load 2 double values from source pointer,and conditionally multiply with the product.
// Returns the new product.
template<int startIdx>
inline __m128d product2( const double* pSource,__m128i mask,__m128d oldProduct )
{
    // Multiply values unconditionally
    const __m128d source = _mm_loadu_pd( pSource + startIdx );
    const __m128d newProduct = _mm_mul_pd( source,oldProduct );

    // We only calling product2 with 4 different template arguments.
    // There are 16 vector registers in total,enough for all 4 different `maskAndBits` values.
    constexpr int64_t bit1 = 1 << startIdx;
    constexpr int64_t bit2 = 1 << ( startIdx + 1 );
    const __m128i maskAndBits = _mm_setr_epi64x( bit1,bit2 );
    mask = _mm_and_si128( mask,maskAndBits );

    // NAN if the mask is 0 after the above AND i.e. the bit was not set,0.0 if the bit was set
    const __m128d maskDouble = _mm_castsi128_pd( _mm_cmpeq_epi64( mask,_mm_setzero_si128() ) );

    // This instruction actually does the masking,it's from SSE 4.1
    return _mm_blendv_pd( newProduct,oldProduct,maskDouble );
}

double conditionalProducts( const double* ptr,const uint8_t* masks,size_t size )
{
    // Round down the size of your input vector,and multiply last couple values the old way.
    assert( 0 == size % 8 );
    __m128d prod = _mm_set1_pd( 1.0 );
    const double* const end = ptr + size;
    while( ptr < end )
    {
        // Broadcast the mask byte into 64-bit integer lanes
        const __m128i mask = _mm_set1_epi64x( *masks );
        // Compute the conditional products of 8 values
        prod = product2<0>( ptr,mask,prod );
        prod = product2<2>( ptr,prod );
        prod = product2<4>( ptr,prod );
        prod = product2<6>( ptr,prod );
        // Advance the pointers
        ptr += 8;
        masks++;
    }
    // Multiply two lanes together
    prod = _mm_mul_sd( prod,_mm_shuffle_pd( prod,prod,0b11 ) );
    return _mm_cvtsd_f64( prod );
}