4000 * 400,000 = 1,6 Go si vous êtes disque dur n'est pas un SSD, vous êtes susceptible d'obtenir ~100 Mo/s lecture séquentielle. C'est 16 secondes juste en I/O.

puisque vous ne donnez pas de détails sur le code spécifique que vous utilisez ou comment vous devez analyser ces fichiers (avez-vous besoin de le lire ligne par ligne, Le système a-t-il beaucoup de mémoire vive?pourriez-vous lire l'ensemble du fichier dans un grand tampon de mémoire vive, puis l'analyser? Il y a peu que vous puissiez faire pour accélérer le processus.

Les fichiers cartographiés en mémoire n'offrent aucune amélioration de performance lors de la lecture séquentielle d'un fichier. Il serait peut-être préférable d'analyser manuellement de grands segments pour trouver de nouvelles lignes plutôt que d'utiliser "getline".

EDIT après avoir fait un peu d'apprentissage (merci @sehe). Voici la solution de mappage de mémoire que j'utiliserais probablement.

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <errno.h>

int main() {
    char* fName = "big.txt";
    //
    struct stat sb;
    long cntr = 0;
    int fd, lineLen;
    char *data;
    char *line;
    // map the file
    fd = open(fName, O_RDONLY);
    fstat(fd, &sb);
    //// int pageSize;
    //// pageSize = getpagesize();
    //// data = mmap((caddr_t)0, pageSize, PROT_READ, MAP_PRIVATE, fd, pageSize);
    data = mmap((caddr_t)0, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
    line = data;
    // get lines
    while(cntr < sb.st_size) {
        lineLen = 0;
        line = data;
        // find the next line
        while(*data != '\n' && cntr < sb.st_size) {
            data++;
            cntr++;
            lineLen++;
        }
        /***** PROCESS LINE *****/
        // ... processLine(line, lineLen);
    }
    return 0;
}

Neil Kirk, malheureusement je ne peux pas répondre à votre commentaire (pas assez de réputation) mais j'ai fait un test de performance sur ifstream un stringstream et la performance, la lecture d'un fichier texte ligne par ligne, est exactement le même.

std::stringstream stream;
std::string line;
while(std::getline(stream, line)) {
}

cela prend 1426ms sur un fichier de 106MO.

std::ifstream stream;
std::string line;
while(ifstream.good()) {
    getline(stream, line);
}

cela prend 1433ms sur le même fichier.

le code suivant est plus rapide à la place:

const int MAX_LENGTH = 524288;
char* line = new char[MAX_LENGTH];
while (iStream.getline(line, MAX_LENGTH) && strlen(line) > 0) {
}

This prend 884ms sur le même fichier. C'est juste un peu délicat puisque vous devez définir la taille maximale de votre tampon (i.e. longueur maximale pour chaque ligne dans le fichier d'entrée).

avez-vous de lire tous les fichiers en même temps? (au début de votre application, par exemple)

si vous le faites, envisagez de paralléliser l'opération.

dans les deux cas, envisagez d'utiliser des flux binaires, ou pour les blocs de données.

Utiliser Random file access ou utiliser binary mode . pour séquentielle, c'est grand, mais encore cela dépend de ce que vous lisez.

comme quelqu'un avec un peu d'arrière-plan dans la programmation compétitive, je peux vous dire: au moins pour des choses simples comme le parsing entier le coût principal en C est le verrouillage des flux de fichiers (qui est par défaut fait pour le multi-threading). Utilisez plutôt les versions unlocked_stdio ( fgetc_unlocked() , fread_unlocked() ). Pour C++, la règle courante est d'utiliser std::ios::sync_with_stdio(false) mais je ne sais pas si c'est aussi rapide que unlocked_stdio .

pour référence voici mon code d'analyse standard. C'est un lot plus rapide que scanf, comme je l'ai dit principalement en raison de ne pas verrouiller le flux. Pour moi, il était aussi rapide que le meilleur mmap codé à la main ou les versions tamponnées personnalisées que j'avais utilisées auparavant, sans la dette de maintenance insensée.

int readint(void)
{
        int n, c;
        n = getchar_unlocked() - '0';
        while ((c = getchar_unlocked()) > ' ')
                n = 10*n + c-'0';
        return n;
}

(Note: celui-ci ne fonctionne que s'il y a précisément un caractère non numérique entre deux entiers).

et bien sûr éviter l'allocation de mémoire si possible...