Comment optimiser les opérations d’E/S C++ pour améliorer les performances ?

Pour améliorer les performances d'E/S C++, il existe plusieurs approches : Utiliser les E/S mises en mémoire tampon pour regrouper les données afin de réduire le nombre d'accès au disque. Utilisez l'appel système mmap() pour mapper les fichiers directement en mémoire afin d'éviter les accès fréquents au disque. Utilisez des E/S parallèles pour effectuer des opérations d’E/S simultanément sur plusieurs threads ou processus afin d’augmenter le débit.

Comment optimiser les opérations d'E/S C++ pour améliorer les performances

Les opérations d'E/S sont essentielles aux performances de votre application. En C++, il existe plusieurs façons d’optimiser les opérations d’E/S afin d’améliorer les performances.

1. Utilisation des E/S tamponnées

Les E/S tamponnées impliquent de regrouper les données en gros morceaux, puis de les écrire ou de les lire à partir du disque. Cela réduit le nombre d'accès au disque, améliorant ainsi les performances.

#include <iostream>
#include <fstream>
#include <vector>

int main() {
  std::vector<int> data(1000000);
  std::ofstream file("data.bin", std::ios::binary);
  // 缓冲 1 MB 的数据
  file.rdbuf()->pubsetbuf(nullptr, 1024 * 1024);

  // 写入数据
  file.write((char*)&data[0], data.size() * sizeof(int));
  file.close();

  return 0;
}

2. L'utilisation de l'appel système mmap()

mmap() vous permet de mapper des fichiers directement en mémoire. Cela évite les accès fréquents au disque, améliorant ainsi les performances.

#include <sys/mman.h>
#include <fcntl.h>

int main() {
  // 打开文件
  int fd = open("data.bin", O_RDWR);
  // 将文件映射到内存
  void* data = mmap(nullptr, 1000000 * sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  
  // 操作数据
  ...

  // 取消映射
  munmap(data, 1000000 * sizeof(int));
  close(fd);

  return 0;
}

3. Utiliser les E/S parallèles

Les E/S parallèles impliquent d'effectuer des opérations d'E/S sur plusieurs threads ou processus simultanément. Cela peut améliorer le débit et réduire le temps d’exécution global.

#include <thread>
#include <vector>

int main() {
  std::vector<std::thread> threads;
  for (int i = 0; i < 4; i++) {
    threads.emplace_back([] {
      // 执行 I/O 操作
    });
  }

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

  return 0;
}

Cas pratique

Ce qui suit est un cas pratique d'optimisation des opérations d'E/S à l'aide de C++. Ce programme lit et écrit de grandes quantités de données à partir de fichiers :

#include <iostream>
#include <fstream>
#include <vector>
#include <chrono>

using namespace std;

int main() {
  // 数据量
  const int dataSize = 1000000;

  // 使用缓冲 I/O
  {
    vector<int> data(dataSize);
    ofstream file("data.bin", ios::binary);
    file.rdbuf()->pubsetbuf(nullptr, 1024 * 1024);

    // 记录时间
    auto start = chrono::high_resolution_clock::now();
    // 写入数据
    file.write((char*)&data[0], data.size() * sizeof(int));
    auto end = chrono::high_resolution_clock::now();

    // 计算执行时间
    auto duration = chrono::duration_cast<chrono::milliseconds>(end - start);
    cout << "Buffered I/O duration: " << duration.count() << " ms" << endl;
  }

  // 使用 mmap()
  {
    vector<int> data(dataSize);
    int fd = open("data.bin", O_RDWR);
    void* dataPtr = mmap(nullptr, dataSize * sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

    // 记录时间
    auto start = chrono::high_resolution_clock::now();
    // 写入数据
    memcpy(dataPtr, &data[0], data.size() * sizeof(int));
    auto end = chrono::high_resolution_clock::now();

    // 取消映射
    munmap(dataPtr, dataSize * sizeof(int));
    close(fd);

    // 计算执行时间
    auto duration = chrono::duration_cast<chrono::milliseconds>(end - start);
    cout << "mmap() duration: " << duration.count() << " ms" << endl;
  }

  return 0;
}

Exécutez ce programme et vous remarquerez que l'utilisation de mmap() est plusieurs fois plus rapide que les E/S mises en mémoire tampon.

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!