C++の並列化と自動並列化によるパフォーマンス向上の具体的方法

#include <iostream>
#include <thread>

void print_message(const std::string& message) {
    std::cout << message << std::endl;
}

int main() {
    std::thread t1(print_message, "Hello from thread 1");
    std::thread t2(print_message, "Hello from thread 2");

    t1.join();
    t2.join();
    return 0;
}

#include <iostream>
#include <future>

int calculate_square(int x) {
    return x * x;
}

int main() {
    std::future<int> result = std::async(calculate_square, 5);

    std::cout << "Square of 5 is " << result.get() << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};

    std::for_each(std::execution::par, data.begin(), data.end(), [](int& n) { n *= 2; });

    for (const auto& n : data) {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <thread>
#include <future>
#include <algorithm>

void parallel_quick_sort(std::vector<int>& data) {
    if (data.size() <= 1) {
        return;
    }

    int pivot = data[data.size() / 2];
    std::vector<int> less, equal, greater;

    for (int x : data) {
        if (x < pivot) less.push_back(x);
        else if (x == pivot) equal.push_back(x);
        else greater.push_back(x);
    }

    auto handle_less = std::async(std::launch::async, parallel_quick_sort, std::ref(less));
    auto handle_greater = std::async(std::launch::async, parallel_quick_sort, std::ref(greater));

    handle_less.get();
    handle_greater.get();

    data.clear();
    data.insert(data.end(), less.begin(), less.end());
    data.insert(data.end(), equal.begin(), equal.end());
    data.insert(data.end(), greater.begin(), greater.end());
}

int main() {
    std::vector<int> data = {3, 6, 8, 10, 1, 2, 1};
    parallel_quick_sort(data);

    for (int x : data) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <thread>

void multiply_row_by_matrix(const std::vector<std::vector<int>>& mat1,
                            const std::vector<std::vector<int>>& mat2,
                            std::vector<std::vector<int>>& result,
                            int row) {
    int n = mat2[0].size();
    for (int j = 0; j < n; ++j) {
        result[row][j] = 0;
        for (int k = 0; k < mat1[0].size(); ++k) {
            result[row][j] += mat1[row][k] * mat2[k][j];
        }
    }
}

void parallel_matrix_multiply(const std::vector<std::vector<int>>& mat1,
                              const std::vector<std::vector<int>>& mat2,
                              std::vector<std::vector<int>>& result) {
    std::vector<std::thread> threads;
    int m = mat1.size();
    for (int i = 0; i < m; ++i) {
        threads.push_back(std::thread(multiply_row_by_matrix, std::cref(mat1), std::cref(mat2), std::ref(result), i));
    }

    for (auto& th : threads) {
        th.join();
    }
}

int main() {
    std::vector<std::vector<int>> mat1 = {{1, 2}, {3, 4}};
    std::vector<std::vector<int>> mat2 = {{5, 6}, {7, 8}};
    std::vector<std::vector<int>> result(2, std::vector<int>(2));

    parallel_matrix_multiply(mat1, mat2, result);

    for (const auto& row : result) {
        for (int x : row) {
            std::cout << x << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

#include <iostream>
#include <chrono>
#include <vector>
#include <thread>

void dummy_task() {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

int main() {
    auto start = std::chrono::high_resolution_clock::now();

    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(dummy_task);
    }
    for (auto& th : threads) {
        th.join();
    }

    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration = end - start;
    std::cout << "Execution time: " << duration.count() << " seconds" << std::endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <thread>
#include <numeric>
#include <future>

void parallel_sum(const std::vector<int>& data, int start, int end, std::promise<int>&& result) {
    int sum = std::accumulate(data.begin() + start, data.begin() + end, 0);
    result.set_value(sum);
}

int main() {
    std::vector<int> data(1000, 1);
    int num_threads = 4;
    int chunk_size = data.size() / num_threads;
    std::vector<std::future<int>> results;

    for (int i = 0; i < num_threads; ++i) {
        std::promise<int> result;
        results.push_back(result.get_future());
        std::thread(parallel_sum, std::cref(data), i * chunk_size, (i + 1) * chunk_size, std::move(result)).detach();
    }

    int total_sum = 0;
    for (auto& res : results) {
        total_sum += res.get();
    }

    std::cout << "Total sum: " << total_sum << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <thread>
#include <future>
#include <opencv2/opencv.hpp>

void apply_box_filter(const cv::Mat& src, cv::Mat& dst, int start_row, int end_row) {
    int filter_size = 3;
    int half = filter_size / 2;

    for (int i = start_row; i < end_row; ++i) {
        for (int j = 0; j < src.cols; ++j) {
            int sum = 0;
            for (int k = -half; k <= half; ++k) {
                for (int l = -half; l <= half; ++l) {
                    int x = std::min(std::max(i + k, 0), src.rows - 1);
                    int y = std::min(std::max(j + l, 0), src.cols - 1);
                    sum += src.at<uchar>(x, y);
                }
            }
            dst.at<uchar>(i, j) = sum / (filter_size * filter_size);
        }
    }
}

void parallel_box_filter(const cv::Mat& src, cv::Mat& dst, int num_threads) {
    std::vector<std::thread> threads;
    int chunk_size = src.rows / num_threads;

    for (int i = 0; i < num_threads; ++i) {
        int start_row = i * chunk_size;
        int end_row = (i == num_threads - 1) ? src.rows : (i + 1) * chunk_size;
        threads.emplace_back(apply_box_filter, std::cref(src), std::ref(dst), start_row, end_row);
    }

    for (auto& t : threads) {
        t.join();
    }
}

int main() {
    cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        std::cerr << "Error loading image" << std::endl;
        return -1;
    }

    cv::Mat dst = src.clone();
    int num_threads = 4;
    parallel_box_filter(src, dst, num_threads);

    cv::imwrite("filtered_image.jpg", dst);
    return 0;
}

#include <iostream>
#include <vector>
#include <thread>
#include <future>
#include <functional>

double f(double x) {
    return x * x;
}

double parallel_trapezoidal_rule(double a, double b, int n, int num_threads) {
    double h = (b - a) / n;
    double sum = 0.0;
    std::vector<std::future<double>> futures;

    auto integrate = [=](int start, int end) -> double {
        double local_sum = 0.0;
        for (int i = start; i < end; ++i) {
            double x1 = a + i * h;
            double x2 = a + (i + 1) * h;
            local_sum += 0.5 * (f(x1) + f(x2)) * h;
        }
        return local_sum;
    };

    int chunk_size = n / num_threads;
    for (int i = 0; i < num_threads; ++i) {
        int start = i * chunk_size;
        int end = (i == num_threads - 1) ? n : (i + 1) * chunk_size;
        futures.push_back(std::async(std::launch::async, integrate, start, end));
    }

    for (auto& fut : futures) {
        sum += fut.get();
    }

    return sum;
}

int main() {
    double a = 0.0;
    double b = 10.0;
    int n = 1000000;
    int num_threads = 4;

    double result = parallel_trapezoidal_rule(a, b, n, num_threads);
    std::cout << "Integral result: " << result << std::endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <thread>

void multiply_row_by_matrix(const std::vector<std::vector<double>>& A,
                            const std::vector<std::vector<double>>& B,
                            std::vector<std::vector<double>>& C,
                            int row) {
    int n = B[0].size();
    int k = A[0].size();
    for (int j = 0; j < n; ++j) {
        C[row][j] = 0;
        for (int l = 0; l < k; ++l) {
            C[row][j] += A[row][l] * B[l][j];
        }
    }
}

void parallel_matrix_multiply(const std::vector<std::vector<double>>& A,
                              const std::vector<std::vector<double>>& B,
                              std::vector<std::vector<double>>& C,
                              int num_threads) {
    std::vector<std::thread> threads;
    int m = A.size();

    for (int i = 0; i < num_threads; ++i) {
        for (int row = i; row < m; row += num_threads) {
            threads.emplace_back(multiply_row_by_matrix, std::cref(A), std::cref(B), std::ref(C), row);
        }
    }

    for (auto& th : threads) {
        th.join();
    }
}

int main() {
    std::vector<std::vector<double>> A = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    std::vector<std::vector<double>> B = {{1, 2}, {3, 4}, {5, 6}};
    std::vector<std::vector<double>> C(3, std::vector<double>(2, 0));
    int num_threads = 3;

    parallel_matrix_multiply(A, B, C, num_threads);

    for (const auto& row : C) {
        for (double val : row) {
            std::cout << val << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <queue>
#include <functional>

std::mutex mtx;
std::queue<std::function<void()>> task_queue;

void worker() {
    while (true) {
        std::function<void()> task;
        {
            std::lock_guard<std::mutex> lock(mtx);
            if (task_queue.empty()) break;
            task = std::move(task_queue.front());
            task_queue.pop();
        }
        task();
    }
}

int main() {
    int num_threads = 4;
    std::vector<std::thread> threads;

    // タスクを追加
    for (int i = 0; i < 10; ++i) {
        task_queue.push([i]() {
            std::cout << "Task " << i << " is being processed." << std::endl;
        });
    }

    // スレッドを開始
    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(worker);
    }

    // スレッドの終了を待つ
    for (auto& t : threads) {
        t.join();
    }

    return 0;
}