基于C（最新GCC/Clang）的CPU端数组无循环模式更新优化问题

Hey Danil, let's work through this performance issue you're hitting with large texture updates. Since you need to avoid shaders and keep your contiguous texture array intact, here are targeted optimizations for GCC/Clang that will speed up clearing the blue channel (index 2 in each RGBA pixel):

1. Let the Compiler Auto-Vectorize Your Loop #

First, let's simplify your original loop to make it easier for the compiler to optimize—your double loop adds unnecessary overhead, so we'll flatten it to a single loop over all pixels:

// Simplified loop: directly iterate over each pixel
for (size_t i = 0; i < width * height; ++i) {
    texture[i * 4 + 2] = 0; // No need for sizeof(uint8_t) since it's always 1
}

Compile with these flags to unlock the compiler's full optimization power:

• -O3: Enables highest-level optimizations
• -march=native: Tailors code to your CPU's specific instruction set
• -ftree-vectorize: Explicitly enables loop vectorization (already included in -O3, but explicit is safer for consistency)

Modern GCC/Clang will automatically convert this loop into SIMD instructions (like SSE/AVX) that handle multiple pixels at once—this alone can give you a 4-8x speedup over your original double loop, with minimal code changes.

2. Manual SIMD Implementation (For Maximum Control) #

If you want to squeeze every bit of performance out of your CPU, you can manually use SIMD intrinsics supported by GCC/Clang. This lets you directly manipulate 128-bit (SSE) or 256-bit (AVX2) registers to clear 8 or 16 blue channels in one go.

SSE Version (Works on Almost All x86/x86_64 CPUs) #

#include <emmintrin.h>

void clear_blue_sse(uint8_t* texture, size_t width, size_t height) {
    const size_t total_pixels = width * height;
    const size_t batch_size = 8; // SSE handles 8 pixels per iteration
    const size_t aligned_pixels = (total_pixels / batch_size) * batch_size;

    // Mask: only target the blue channel (3rd byte in each 4-byte RGBA block)
    __m128i blue_mask = _mm_setr_epi8(0x00, 0x00, 0xFF, 0x00,
                                      0x00, 0x00, 0xFF, 0x00,
                                      0x00, 0x00, 0xFF, 0x00,
                                      0x00, 0x00, 0xFF, 0x00);
    __m128i zero = _mm_setzero_si128();

    uint8_t* ptr = texture;
    for (size_t i = 0; i < aligned_pixels; i += batch_size) {
        // Load 8 pixels (32 bytes) into a SIMD register
        __m128i pixels = _mm_loadu_si128((__m128i*)ptr);
        // Clear only the blue channel: keep other channels, set blue to 0
        pixels = _mm_andnot_si128(blue_mask, pixels);
        // Write the modified pixels back to memory
        _mm_storeu_si128((__m128i*)ptr, pixels);
        ptr += batch_size * 4; // Move to next batch of 8 pixels
    }

    // Handle remaining pixels that don't fit into a full SIMD batch
    for (size_t i = aligned_pixels; i < total_pixels; ++i) {
        texture[i * 4 + 2] = 0;
    }
}

AVX2 Version (For CPUs Supporting AVX2, e.g., Intel Haswell+) #

For even higher throughput, use AVX2 to handle 16 pixels per iteration:

#include <immintrin.h>

void clear_blue_avx2(uint8_t* texture, size_t width, size_t height) {
    const size_t total_pixels = width * height;
    const size_t batch_size = 16; // AVX2 handles 16 pixels per iteration
    const size_t aligned_pixels = (total_pixels / batch_size) * batch_size;

    __m256i blue_mask = _mm256_setr_epi8(0x00, 0x00, 0xFF, 0x00,
                                         0x00, 0x00, 0xFF, 0x00,
                                         0x00, 0x00, 0xFF, 0x00,
                                         0x00, 0x00, 0xFF, 0x00,
                                         0x00, 0x00, 0xFF, 0x00,
                                         0x00, 0x00, 0xFF, 0x00,
                                         0x00, 0x00, 0xFF, 0x00,
                                         0x00, 0x00, 0xFF, 0x00);
    __m256i zero = _mm256_setzero_si256();

    uint8_t* ptr = texture;
    for (size_t i = 0; i < aligned_pixels; i += batch_size) {
        __m256i pixels = _mm256_loadu_si256((__m256i*)ptr);
        pixels = _mm256_andnot_si256(blue_mask, pixels);
        _mm256_storeu_si256((__m256i*)ptr, pixels);
        ptr += batch_size * 4;
    }

    // Cleanup remaining pixels
    for (size_t i = aligned_pixels; i < total_pixels; ++i) {
        texture[i * 4 + 2] = 0;
    }
}

Compile SSE code with -msse2 and AVX2 code with -mavx2 (along with -O3 -march=native).

3. Pointer-Strided Loop (Clean & Optimizable) #

Another readable approach is to directly iterate over only the blue channel bytes using a pointer with a step of 4. This is simpler than manual SIMD and still gets optimized well by the compiler:

void clear_blue_strided(uint8_t* texture, size_t width, size_t height) {
    uint8_t* blue_ptr = texture + 2; // Start at the first blue channel
    const size_t total_blue = width * height;

    for (size_t i = 0; i < total_blue; ++i) {
        *blue_ptr = 0;
        blue_ptr += 4; // Jump to the next blue channel
    }
}

With -O3 -march=native, this loop will be vectorized just like the first approach, giving similar performance with more intuitive code.

Which Should You Choose? #

• If code simplicity is key: Go with the first simplified loop (option 1). It's easy to maintain, and the compiler does all the heavy lifting.
• If you need maximum performance: Use the manual SIMD implementation (option 2) tailored to your CPU's architecture.
• If you prefer a more "direct" approach: Option 3's strided loop is a great middle ground between simplicity and performance.

All these methods keep your texture array contiguous, so you can still use memcpy to send it to the GPU without any changes.

内容的提问来源于stack exchange，提问作者Danil S