Copier un fichier de manière saine, sûre et efficace

Question

Je cherche un bon moyen de copier un fichier (binaire ou texte). J'ai écrit plusieurs exemples, tous fonctionnent. Mais je veux entendre l'avis de programmeurs chevronnés.

Il me manque de bons exemples et je cherche une méthode qui fonctionne avec C++.

ANSI-C-WAY

#include <iostream>
#include <cstdio>    // fopen, fclose, fread, fwrite, BUFSIZ
#include <ctime>
using namespace std;

int main() {
    clock_t start, end;
    start = clock();

    // BUFSIZE default is 8192 bytes
    // BUFSIZE of 1 means one chareter at time
    // good values should fit to blocksize, like 1024 or 4096
    // higher values reduce number of system calls
    // size_t BUFFER_SIZE = 4096;

    char buf[BUFSIZ];
    size_t size;

    FILE* source = fopen("from.ogv", "rb");
    FILE* dest = fopen("to.ogv", "wb");

    // clean and more secure
    // feof(FILE* stream) returns non-zero if the end of file indicator for stream is set

    while (size = fread(buf, 1, BUFSIZ, source)) {
        fwrite(buf, 1, size, dest);
    }

    fclose(source);
    fclose(dest);

    end = clock();

    cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
    cout << "CPU-TIME START " << start << "\n";
    cout << "CPU-TIME END " << end << "\n";
    cout << "CPU-TIME END - START " << end - start << "\n";
    cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";

    return 0;
}

POSIX-WAY (K&R utilisent ceci dans "The C programming language", plus bas niveau)

#include <iostream>
#include <fcntl.h>   // open
#include <unistd.h>  // read, write, close
#include <cstdio>    // BUFSIZ
#include <ctime>
using namespace std;

int main() {
    clock_t start, end;
    start = clock();

    // BUFSIZE defaults to 8192
    // BUFSIZE of 1 means one chareter at time
    // good values should fit to blocksize, like 1024 or 4096
    // higher values reduce number of system calls
    // size_t BUFFER_SIZE = 4096;

    char buf[BUFSIZ];
    size_t size;

    int source = open("from.ogv", O_RDONLY, 0);
    int dest = open("to.ogv", O_WRONLY | O_CREAT /*| O_TRUNC/**/, 0644);

    while ((size = read(source, buf, BUFSIZ)) > 0) {
        write(dest, buf, size);
    }

    close(source);
    close(dest);

    end = clock();

    cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
    cout << "CPU-TIME START " << start << "\n";
    cout << "CPU-TIME END " << end << "\n";
    cout << "CPU-TIME END - START " << end - start << "\n";
    cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";

    return 0;
}

KISS-C++-Streambuffer-WAY

#include <iostream>
#include <fstream>
#include <ctime>
using namespace std;

int main() {
    clock_t start, end;
    start = clock();

    ifstream source("from.ogv", ios::binary);
    ofstream dest("to.ogv", ios::binary);

    dest << source.rdbuf();

    source.close();
    dest.close();

    end = clock();

    cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
    cout << "CPU-TIME START " << start << "\n";
    cout << "CPU-TIME END " << end << "\n";
    cout << "CPU-TIME END - START " <<  end - start << "\n";
    cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";

    return 0;
}

COPIER-ALGORITHME-C++-WAY

#include <iostream>
#include <fstream>
#include <ctime>
#include <algorithm>
#include <iterator>
using namespace std;

int main() {
    clock_t start, end;
    start = clock();

    ifstream source("from.ogv", ios::binary);
    ofstream dest("to.ogv", ios::binary);

    istreambuf_iterator<char> begin_source(source);
    istreambuf_iterator<char> end_source;
    ostreambuf_iterator<char> begin_dest(dest); 
    copy(begin_source, end_source, begin_dest);

    source.close();
    dest.close();

    end = clock();

    cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
    cout << "CPU-TIME START " << start << "\n";
    cout << "CPU-TIME END " << end << "\n";
    cout << "CPU-TIME END - START " <<  end - start << "\n";
    cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";

    return 0;
}

PROPRE TAMPON-C++-WAY

#include <iostream>
#include <fstream>
#include <ctime>
using namespace std;

int main() {
    clock_t start, end;
    start = clock();

    ifstream source("from.ogv", ios::binary);
    ofstream dest("to.ogv", ios::binary);

    // file size
    source.seekg(0, ios::end);
    ifstream::pos_type size = source.tellg();
    source.seekg(0);
    // allocate memory for buffer
    char* buffer = new char[size];

    // copy file    
    source.read(buffer, size);
    dest.write(buffer, size);

    // clean up
    delete[] buffer;
    source.close();
    dest.close();

    end = clock();

    cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
    cout << "CPU-TIME START " << start << "\n";
    cout << "CPU-TIME END " << end << "\n";
    cout << "CPU-TIME END - START " <<  end - start << "\n";
    cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";

    return 0;
}

LINUX-WAY // nécessite un noyau >= 2.6.33

#include <iostream>
#include <sys/sendfile.h>  // sendfile
#include <fcntl.h>         // open
#include <unistd.h>        // close
#include <sys/stat.h>      // fstat
#include <sys/types.h>     // fstat
#include <ctime>
using namespace std;

int main() {
    clock_t start, end;
    start = clock();

    int source = open("from.ogv", O_RDONLY, 0);
    int dest = open("to.ogv", O_WRONLY | O_CREAT /*| O_TRUNC/**/, 0644);

    // struct required, rationale: function stat() exists also
    struct stat stat_source;
    fstat(source, &stat_source);

    sendfile(dest, source, 0, stat_source.st_size);

    close(source);
    close(dest);

    end = clock();

    cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
    cout << "CPU-TIME START " << start << "\n";
    cout << "CPU-TIME END " << end << "\n";
    cout << "CPU-TIME END - START " <<  end - start << "\n";
    cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";

    return 0;
}

Environnement

• GNU/LINUX (Archlinux)
• Noyau 3.3
• GLIBC-2.15, LIBSTDC++ 4.7 (GCC-LIBS), GCC 4.7, Coreutils 8.16
• Utilisation de RUNLEVEL 3 (multi-utilisateur, réseau, terminal, pas d'interface graphique)
• INTEL SSD-Postville 80 GB, rempli jusqu'à 50%.
• Copie d'un fichier OGG-VIDEO de 270 MB

Étapes de la reproduction

 1. $ rm from.ogg
 2. $ reboot                           # kernel and filesystem buffers are in regular
 3. $ (time ./program) &>> report.txt  # executes program, redirects output of program and append to file
 4. $ sha256sum *.ogv                  # checksum
 5. $ rm to.ogg                        # remove copy, but no sync, kernel and fileystem buffers are used
 6. $ (time ./program) &>> report.txt  # executes program, redirects output of program and append to file

Résultats (TEMPS CPU utilisé)

Program  Description                 UNBUFFERED|BUFFERED
ANSI C   (fread/frwite)                 490,000|260,000  
POSIX    (K&R, read/write)              450,000|230,000  
FSTREAM  (KISS, Streambuffer)           500,000|270,000 
FSTREAM  (Algorithm, copy)              500,000|270,000
FSTREAM  (OWN-BUFFER)                   500,000|340,000  
SENDFILE (native LINUX, sendfile)       410,000|200,000  

La taille du fichier ne change pas.
sha256sum donnent les mêmes résultats.
Le fichier vidéo est toujours lisible.

Questions

• Quelle méthode préférez-vous ?

• Connaissez-vous de meilleures solutions ?

• Voyez-vous des erreurs dans mon code ?

• Connaissez-vous une raison d'éviter une solution ?

• FSTREAM (KISS, Streambuffer)
  J'aime beaucoup celle-ci, car elle est vraiment courte et simple. Pour autant que je sache, l'opérateur << est surchargé pour rdbuf() et ne convertit rien. Est-ce exact ?

Merci

Mise à jour 1
J'ai modifié la source de tous les échantillons de manière à ce que l'ouverture et la fermeture des descripteurs de fichier soient incluses dans la mesure de clock() . Il n'y a pas d'autres changements significatifs dans le code source. Les résultats n'ont pas changé ! J'ai aussi utilisé temps pour revérifier mes résultats.

Mise à jour 2
L'échantillon C de l'ANSI a été modifié : l'état de la while-loop n'appelle plus feof() Au lieu de cela, j'ai déménagé fread() dans la condition. Il semble que le code s'exécute maintenant 10.000 fois plus vite.

Mesure modifiée : Les anciens résultats étaient toujours mis en mémoire tampon, car je répétais l'ancienne ligne de commande rm to.ogv && sync && time ./programme pour chaque programme plusieurs fois. Maintenant, je redémarre le système pour chaque programme. Les résultats non bufferisés sont nouveaux et ne montrent aucune surprise. Les résultats sans tampon n'ont pas vraiment changé.

Si je ne supprime pas l'ancienne copie, les programmes réagissent différemment. Écraser un fichier existant tamponné est plus rapide avec POSIX et SENDFILE, tous les autres programmes sont plus lents. Peut-être que les options tronqué o créer ont un impact sur ce comportement. Mais écraser des fichiers existants avec la même copie n'est pas un cas d'utilisation réel.

Effectuer la copie avec cp prend 0,44 seconde sans tampon et 0,30 seconde avec tampon. Donc cp est un peu plus lent que l'échantillon POSIX. Pour moi, tout va bien.

J'ajouterai peut-être aussi des échantillons et des résultats de mmap() et _copy_file()_ de boost::filesystem.

Mise à jour 3
J'ai mis cela aussi sur une page de blog et je l'ai étendu un peu. Y compris splice() qui est une fonction de bas niveau du noyau Linux. Peut-être que d'autres échantillons avec Java suivront. http://www.ttyhoney.com/blog/?page_id=69

Answer 1

Copier un fichier d'une manière sensée :

#include <fstream>

int main()
{
    std::ifstream  src("from.ogv", std::ios::binary);
    std::ofstream  dst("to.ogv",   std::ios::binary);

    dst << src.rdbuf();
}

La lecture est tellement simple et intuitive qu'elle vaut le coût supplémentaire. Si nous le faisions souvent, il vaudrait mieux se rabattre sur les appels du système d'exploitation au système de fichiers. Je suis sûr que boost possède une méthode de copie de fichier dans sa classe de système de fichiers.

Il existe une méthode C pour interagir avec le système de fichiers :

#include <copyfile.h>

int
copyfile(const char *from, const char *to, copyfile_state_t state, copyfile_flags_t flags);

Answer 2

Avec C++17, la manière standard de copier un fichier sera d'inclure la fonction <filesystem> l'en-tête et l'utilisation :

bool copy_file( const std::filesystem::path& from,
                const std::filesystem::path& to);

bool copy_file( const std::filesystem::path& from,
                const std::filesystem::path& to,
                std::filesystem::copy_options options);

La première forme est équivalente à la seconde avec copy_options::none utilisés comme options (voir également copy_file ).

Le site filesystem a été développée à l'origine comme boost.filesystem et finalement fusionné avec ISO C++ à partir de C++17.

Answer 3

Il y en a trop !

La mémoire tampon de type "ANSI C" est redondante, puisqu'un fichier de type FILE est déjà mis en mémoire tampon. (La taille de ce tampon interne est ce que BUFSIZ définit en fait).

Le "OWN-BUFFER-C++-WAY" sera lent car il passe à travers fstream qui effectue un grand nombre de répartitions virtuelles et maintient des tampons internes pour chaque objet de flux. (La méthode "COPY-ALGORITHM-C++-WAY" ne souffre pas de ce problème, car la méthode streambuf_iterator contourne la couche de flux).

Je préfère la "COPY-ALGORITHM-C++-WAY", mais sans construire une fstream , il suffit de créer le nu std::filebuf les cas où aucun formatage réel n'est nécessaire.

Pour les performances brutes, il n'y a pas mieux que les descripteurs de fichiers POSIX. C'est laid mais portable et rapide sur toutes les plateformes.

La méthode Linux semble être incroyablement rapide - peut-être le système d'exploitation a-t-il laissé la fonction revenir avant la fin des E/S ? Dans tous les cas, ce n'est pas assez portable pour de nombreuses applications.

EDIT : Ah, "Linux natif" peut améliorer les performances en entrelaçant les lectures et les écritures avec des E/S asynchrones. Laisser les commandes s'empiler peut aider le pilote de disque à décider quand il est préférable de chercher. Vous pouvez essayer Boost Asio ou pthreads pour comparer. Quant à l'expression "impossible de battre les descripteurs de fichiers POSIX" c'est vrai si vous faites quelque chose avec les données, et pas seulement les copier aveuglément.

Answer 4

Je veux faire le très note importante que la méthode LINUX utilisant sendfile() a un problème majeur dans la mesure où elle ne peut pas copier des fichiers d'une taille supérieure à 2GB ! Je l'avais implémentée suite à cette question et je rencontrais des problèmes car je l'utilisais pour copier des fichiers HDF5 de plusieurs Go.

http://man7.org/linux/man-pages/man2/sendfile.2.html

sendfile() transférera au maximum 0x7ffff000 (2,147,479,552) octets, renvoyant le nombre d'octets réellement transférés. (Ceci est vrai sur systèmes 32 bits et 64 bits).

Answer 5

Qt dispose d'une méthode pour copier des fichiers :

#include <QFile>
QFile::copy("originalFile.example","copiedFile.example");

Notez que pour utiliser cette fonction, vous devez installer Qt (instructions aquí ) et l'inclure dans votre projet (si vous utilisez Windows et que vous n'êtes pas administrateur, vous pouvez télécharger Qt aquí à la place). Voir aussi cette réponse .