Heim > Backend-Entwicklung > C++ > Wie können C++-E/A-Vorgänge optimiert werden, um die Leistung zu verbessern?

Wie können C++-E/A-Vorgänge optimiert werden, um die Leistung zu verbessern?

WBOY
Freigeben: 2024-05-08 17:21:01
Original
821 Leute haben es durchsucht

Um die C++-I/O-Leistung zu verbessern, gibt es mehrere Ansätze: Verwenden Sie gepufferte I/O zum Gruppieren von Daten, um die Anzahl der Festplattenzugriffe zu reduzieren. Verwenden Sie den Systemaufruf mmap(), um Dateien direkt im Speicher abzubilden und so häufige Festplattenzugriffe zu vermeiden. Verwenden Sie parallele E/A, um E/A-Vorgänge gleichzeitig auf mehreren Threads oder Prozessen auszuführen und so den Durchsatz zu erhöhen.

如何优化C++ I/O操作以提高性能?

So optimieren Sie C++-E/A-Vorgänge, um die Leistung zu verbessern

E/A-Vorgänge sind entscheidend für die Leistung Ihrer Anwendung. In C++ gibt es mehrere Möglichkeiten, E/A-Vorgänge zu optimieren, um die Leistung zu verbessern.

1. Verwendung von gepufferter E/A

Bei gepufferter E/A werden Daten in große Blöcke gruppiert und dann von der Festplatte geschrieben oder gelesen. Dadurch wird die Anzahl der Festplattenzugriffe reduziert und dadurch die Leistung verbessert.

#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;
}
Nach dem Login kopieren

2. Mit dem Systemaufruf mmap()

mmap() können Sie Dateien direkt im Speicher abbilden. Dadurch werden häufige Festplattenzugriffe vermieden und die Leistung verbessert.

#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;
}
Nach dem Login kopieren

3. Parallele E/A verwenden

Parallele E/A umfasst die gleichzeitige Ausführung von E/A-Vorgängen für mehrere Threads oder Prozesse. Dies kann den Durchsatz verbessern und die Gesamtausführungszeit verkürzen.

#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;
}
Nach dem Login kopieren

Praktischer Fall

Das Folgende ist ein praktischer Fall der Optimierung von E/A-Vorgängen mit C++. Dieses Programm liest und schreibt große Datenmengen aus Dateien:

#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;
}
Nach dem Login kopieren

Führen Sie dieses Programm aus und Sie werden feststellen, dass die Verwendung von mmap() um ein Vielfaches schneller ist als gepufferte E/A.

Das obige ist der detaillierte Inhalt vonWie können C++-E/A-Vorgänge optimiert werden, um die Leistung zu verbessern?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Verwandte Etiketten:
Quelle:php.cn
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage