跨机器运行多线程矩阵乘法代码触发std::system_error错误求助

核心问题 #

你的代码一次性创建了65536个线程（256×256的矩阵，每个元素对应一个线程），这远远超出了容器环境的线程资源上限。桌面级CPU的系统默认资源限制相对宽松，因此在i7-1265U上能勉强运行，但Xeon容器通常会严格限制进程可创建的线程数、CPU配额，直接触发std::system_error（系统无法分配足够资源创建新线程）。

代码问题点 #

• 线程数量过载：线程创建、调度的开销远大于矩阵元素计算的开销，完全违背多线程优化的初衷。
• 无异常处理：未捕获线程创建时的异常，无法明确错误根源。
• 精度错误：helper函数中用int类型存储浮点乘法结果，会导致精度丢失。

修复方案 #

推荐方案：按CPU核心数拆分任务（替代海量线程） #

控制线程数量与CPU核心数匹配，将矩阵按行拆分给不同线程处理，既避免资源耗尽，又能真正利用多核心提升性能：

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

using namespace std;
using namespace std::chrono;

void fillRandom(float *arr, int size) {
    for (int i = 0; i < size; ++i) {
        arr[i] = static_cast<float>(rand()) / RAND_MAX * 10.0;
    }
}

// 单个线程负责处理连续的多行矩阵计算
void helper(float *c, float*a, float*b, int m, int n, int o, int start_row, int end_row) {
    for (int i = start_row; i < end_row; ++i) {
        for (int j = 0; j < n; ++j) {
            float t = 0.0f; // 修复精度问题：改用float存储结果
            for (int l = 0; l < o; ++l) {
                t += a[i * o + l] * b[l * n + j];
            }
            c[i * n + j] = t;
        }
    }
}

void matmul(float *a, float *b, float *c, int m, int n, int o) {
    vector<thread> threads;
    // 获取CPU核心数，作为线程数量基准
    int num_threads = thread::hardware_concurrency();
    num_threads = num_threads == 0 ? 4 : num_threads; // 兜底值

    int rows_per_thread = m / num_threads;
    int remaining_rows = m % num_threads;
    int current_row = 0;

    for (int i = 0; i < num_threads; ++i) {
        int rows = rows_per_thread + (i < remaining_rows ? 1 : 0);
        try {
            threads.emplace_back(helper, c, a, b, m, n, o, current_row, current_row + rows);
            current_row += rows;
        } catch (const system_error& e) {
            cerr << "线程创建失败: " << e.what() << endl;
            // 清理已创建的线程
            for (auto& th : threads) {
                if (th.joinable()) th.join();
            }
            throw;
        }
    }

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

int main(int argc, char *argv[]) {
    srand(static_cast<unsigned int>(time(nullptr)));

    int m = 256;
    int n = m;
    int repetitions = 10;

    float *a = new float[m * n];
    float *b = new float[m * n];
    float *c = new float[m * n];

    fillRandom(a, m * n);
    fillRandom(b, m * n);

    try {
        for (int rep = 0; rep < repetitions; ++rep) {
            auto start = high_resolution_clock::now();
            matmul(a, b, c, m, n, m);
            auto stop = high_resolution_clock::now();
            auto duration = duration_cast<milliseconds>(stop - start);
            cout << "第" << rep << "次运行耗时: " << duration.count() << " 毫秒" << endl;
        }
    } catch (const exception& e) {
        cerr << "程序异常: " << e.what() << endl;
    }

    delete[] a;
    delete[] b;
    delete[] c;

    return 0;
}

额外优化建议 #

• 线程池复用：如果需要频繁执行多线程任务，可以使用线程池（如Boost.ThreadPool或C++20的std::jthread结合任务队列），避免重复创建销毁线程的开销。
• 编译优化：编译时添加-O3参数，开启最高级别的优化，进一步提升矩阵计算效率。

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