Comment utiliser STL pour le calcul distribué en C++ ?

Comment utiliser STL pour le calcul distribué en C++ ? En utilisant la parallélisation d'algorithmes STL, en travaillant avec des exécuteurs et en développant des cas pratiques tels que des pipelines de traitement d'images.

Comment utiliser STL pour l'informatique distribuée en C++

Introduction

L'informatique distribuée implique la répartition des tâches sur plusieurs nœuds informatiques pour augmenter la vitesse de traitement. La bibliothèque de modèles standard C++ (STL) fournit des outils de concurrence qui vous permettent de développer des applications informatiques distribuées.

Parallélisation des algorithmes STL

Vous pouvez paralléliser les algorithmes STL en utilisant les fonctions std::async et std::future. std::async démarre une tâche asynchrone, renvoyant un handle à l'objet std::future généré par la tâche. std::async 和 std::future 函数将 STL 算法并行化。std::async 启动一个异步任务，返回指向该任务生成的 std::future 对象的句柄。

// 计算无序向量中所有整数的总和
std::vector<int> numbers = {1, 2, 3, 4, 5};
int sum = 0;

// 并行化 for_each 算法
std::for_each(numbers.begin(), numbers.end(), [&](int n) {
  std::future<int> result = std::async(std::launch::async, [] { return n * n; });

  // 在另一个线程中执行的计算
  sum += result.get();
});

std::cout << "Sum: " << sum << std::endl;

Using Executors

执行器是并发性库的一部分，提供了跨线程池管理任务的抽象。可以使用 std::execution::parallel_unsequenced

// 查找向量中所有奇数
std::vector<int> numbers = {1, 2, 3, 4, 5};
std::vector<int> oddNumbers;

// 使用执行器上的 parallel_unsequenced 策略
std::execution::parallel_unsequenced(numbers.begin(), numbers.end(),
                                    [&](int n) { if (n % 2) oddNumbers.push_back(n); });

std::cout << "Odd numbers: ";
for (int n : oddNumbers) {
  std::cout << n << " ";
}
std::cout << std::endl;

Utilisation des exécuteurs

Les exécuteurs font partie de la bibliothèque de concurrence et fournissent une abstraction pour gérer les tâches dans les pools de threads. Les algorithmes STL peuvent être parallélisés sur l'exécuteur en utilisant la stratégie std::execution::parallel_unsequenced.

// 图像处理管道
struct ImageProcessingPipeline {
  // 调整大小
  std::vector<std::future<cv::Mat>> resizeTasks;

  // 转换
  std::vector<std::future<cv::Mat>> convertTasks;

  // 保存
  std::vector<std::future<void>> saveTasks;

  // 执行管道
  std::vector<cv::Mat> execute(const std::vector<cv::Mat>& images) {
    for (const cv::Mat& image : images) {
      // 并行化调整大小
      resizeTasks.emplace_back(std::async(std::launch::async,
                                         [&image] { return resize(image, 500, 500); }));
    }

    // 等待所有调整大小的任务完成
    for (auto& task : resizeTasks) task.get();

    // 并行化转换
    for (auto& resizedImage : resizeTasks) {
      convertTasks.emplace_back(
          std::async(std::launch::async, [&resizedImage] { return convert(resizedImage); }));
    }

    // 等待所有转换任务完成
    for (auto& task : convertTasks) task.get();

    // 并行化保存
    for (auto& convertedImage : convertTasks) {
      saveTasks.emplace_back(std::async(std::launch::async,
                                     [&convertedImage](const std::string& path) { return save(convertedImage, path); },
                                     "output/image_" + std::to_string(i) + ".jpg"));
    }

    // 等待所有保存任务完成
    for (auto& task : saveTasks) task.get();
  }
};

Cas pratique

Parallélisation du pipeline de traitement d'image

🎜🎜Imaginez que vous disposez d'un pipeline pour traiter les images, y compris les opérations de redimensionnement, de conversion et d'enregistrement d'image. En parallélisant ces opérations, vous pouvez augmenter considérablement le débit du pipeline. 🎜rrreee🎜En utilisant les outils de concurrence et les exécuteurs de STL, vous pouvez facilement développer des applications informatiques distribuées efficaces en C++. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!