如何将曼德博集合图像分为16个水平切片以提升并行计算速度？

Great question! Splitting the Mandelbrot set into horizontal slices is a perfect way to introduce parallelism because each slice’s calculations are completely independent—no slice needs data from another to finish computing. Let’s break this down step by step, with explanations and example code.

Your call compute_mandelbrot(-2.0, 1.0, 1.125, -1.125); defines the full bounds of the Mandelbrot set:

• X-axis range: From -2.0 (left edge) to 1.0 (right edge) → total width of 3.0
• Y-axis range: From 1.125 (top edge) to -1.125 (bottom edge) → total height of 2.25

Assuming you want to maintain the correct aspect ratio with your WIDTH = 100, let’s define the image height explicitly:

const int WIDTH = 100;
const int HEIGHT = 75; // 100 * (2.25/3.0) = 75, matches the set's aspect ratio

Your original function likely renders the entire image at once. We need to update it to accept a subset of the y-range and the corresponding image rows to draw into. Here’s an updated function signature and core logic (adjust to match your existing code):

// Renders a horizontal slice of the Mandelbrot set to a specific row range
void compute_mandelbrot(double x_min, double x_max, 
                        double y_slice_start, double y_slice_end,
                        int start_row, int end_row,
                        unsigned char* image_buffer) {
    // Iterate only over the rows assigned to this slice
    for (int row = start_row; row <= end_row; ++row) {
        // Map the current row to its corresponding y-coordinate in the slice
        double y = y_slice_start + (y_slice_end - y_slice_start) * (row - start_row) / (end_row - start_row);
        
        for (int col = 0; col < WIDTH; ++col) {
            // Map column to x-coordinate (same as full image calculation)
            double x = x_min + (x_max - x_min) * col / WIDTH;
            
            // Your existing Mandelbrot escape-time calculation here
            int escape_time = calculate_mandelbrot(x, y);
            
            // Write to the shared image buffer (row-major order: row * WIDTH + col)
            image_buffer[row * WIDTH + col] = escape_time % 256;
        }
    }
}

Note: calculate_mandelbrot refers to your existing code that computes the escape time for a single (x,y) point—keep this logic unchanged.

We’ll divide the image’s y-range and pixel rows into 16 equal (or nearly equal) parts, then launch a thread for each slice. Here’s how to implement this with C++ std::thread:

#include <vector>
#include <thread>

int main() {
    // Initialize a shared image buffer (row-major order)
    unsigned char* image_buffer = new unsigned char[WIDTH * HEIGHT]();
    
    // Full bounds of the Mandelbrot set
    const double x_min = -2.0;
    const double x_max = 1.0;
    const double y_max = 1.125; // Top of the image
    const double y_min = -1.125; // Bottom of the image
    
    const int num_slices = 16;
    const int rows_per_slice = HEIGHT / num_slices;
    std::vector<std::thread> threads;
    
    for (int i = 0; i < num_slices; ++i) {
        // Calculate row bounds for this slice
        int start_row = i * rows_per_slice;
        // Handle leftover rows if HEIGHT isn't divisible by 16
        int end_row = (i == num_slices - 1) ? HEIGHT - 1 : (i + 1) * rows_per_slice - 1;
        
        // Calculate y-range bounds for this slice
        double y_slice_start = y_max - (i * (y_max - y_min) / num_slices);
        double y_slice_end = y_max - ((i + 1) * (y_max - y_min) / num_slices);
        
        // Launch a thread to compute this slice
        threads.emplace_back(compute_mandelbrot,
                            x_min, x_max,
                            y_slice_start, y_slice_end,
                            start_row, end_row,
                            image_buffer);
    }
    
    // Wait for all threads to finish computing their slices
    for (auto& thread : threads) {
        thread.join();
    }
    
    // The image_buffer now contains the full Mandelbrot set—add code to save/display it
    
    delete[] image_buffer;
    return 0;
}

• No Locking Needed: Each thread writes to a unique section of the image buffer (non-overlapping rows), so there’s no risk of race conditions.
• Flexible Slicing: The code handles cases where HEIGHT isn’t perfectly divisible by 16 by adjusting the last slice to cover any remaining rows.
• Linear Mapping: We use linear interpolation to map pixel rows to the Mandelbrot set’s y-coordinates, just like in the full-image calculation—this ensures no distortion.

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