Performances Windows Fsync (FlushfileBuffers) avec de grands fichiers

Votre test indique une diminution exponentielle de la vitesse sur la synchronisation des exécutions car vous recréez le fichier à chaque fois. Dans ce cas, ce n'est plus une écriture purement séquentielle - chaque écriture augmente également le fichier, ce qui nécessite plusieurs cherchent à mettre à jour les métadonnées de fichier dans le système de fichiers. Si vous rencontrez tous ces travaux à l'aide d'un fichier préexistant entièrement attribué, vous verriez un résultat beaucoup plus rapide car aucune de ces mises à jour de métadonnées ne serait interférée.

J'ai rencontré un test similaire sur ma boîte Linux. Les résultats tout en recréant le fichier à chaque fois: p> xxx pré>

Les résultats à l'aide du fichier préexistant (évidemment, l'affaire Last_Byte n'est pas pertinente ici. En outre, le tout premier résultat a également dû créer le fichier): p> xxx pré>

(Notez que je n'ai utilisé que 10 000 morceaux pas de 25 000 morceaux, il ne s'agit donc que de 320 Mo, à l'aide d'un système de fichiers ext2. Je n'ai pas eu de plus grand ext2fs pratique, mon plus grand FS est XFS et il a refusé d'autoriser MMAP + I / O direct.) P>

Voici le code, si vous êtes intéressé: P>

#define _GNU_SOURCE 1

#include <malloc.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>

#define USE_MMAP    8
#define USE_DIRECT  4
#define USE_LAST    2
#define USE_SYNC    1

#define PAGE    4096
#define CHUNK   (8*PAGE)
#define NCHUNKS 10000
#define STATI   1000

#define FSIZE   (NCHUNKS*CHUNK)

main()
{
    int i, j, fd, rc, stc;
    char *data = valloc(CHUNK);
    char *map, *dst;
    char sfname[8];
    struct timeval start, end, stats[NCHUNKS/STATI+1];
    FILE *sfile;

    printf("mmap\tdirect\tlast\tsync\ttime\n");
    for (i=0; i<16; i++) {
        int oflag = O_CREAT|O_RDWR|O_TRUNC;

        if (i & USE_DIRECT)
            oflag |= O_DIRECT;
        fd = open("dummy", oflag, 0666);
        ftruncate(fd, FSIZE);
        if (i & USE_LAST) {
            lseek(fd, 0, SEEK_END);
            write(fd, data, 1);
            lseek(fd, 0, SEEK_SET);
        }
        if (i & USE_MMAP) {
            map = mmap(NULL, FSIZE, PROT_WRITE, MAP_SHARED, fd, 0);
            if (map == (char *)-1L) {
                perror("mmap");
                exit(1);
            }
            dst = map;
        }
        sprintf(sfname, "%x.csv", i);
        sfile = fopen(sfname, "w");
        stc = 1;
        printf("%d\t%d\t%d\t%d\t",
            (i&USE_MMAP)!=0, (i&USE_DIRECT)!=0, (i&USE_LAST)!=0, i&USE_SYNC);
        fflush(stdout);
        gettimeofday(&start, NULL);
        stats[0] = start;
        for (j = 1; j<=NCHUNKS; j++) {
            if (i & USE_MMAP) {
                memcpy(dst, data, CHUNK);
                if (i & USE_SYNC)
                    msync(dst, CHUNK, MS_SYNC);
                dst += CHUNK;
            } else {
                write(fd, data, CHUNK);
                if (i & USE_SYNC)
                    fdatasync(fd);
            }
            if (!(j % STATI)) {
                gettimeofday(&end, NULL);
                stats[stc++] = end;
            }
        }
        end.tv_usec -= start.tv_usec;
        if (end.tv_usec < 0) {
            end.tv_sec--;
            end.tv_usec += 1000000;
        }
        end.tv_sec -= start.tv_sec;
        printf(" %d.%06ds\n", (int)end.tv_sec, (int)end.tv_usec);
        if (i & USE_MMAP)
            munmap(map, FSIZE);
        close(fd);
        for (j=NCHUNKS/STATI; j>0; j--) {
            stats[j].tv_usec -= stats[j-1].tv_usec;
            if (stats[j].tv_usec < 0) {
                stats[j].tv_sec--;
                stats[j].tv_usec+= 1000000;
            }
            stats[j].tv_sec -= stats[j-1].tv_sec;
        }
        for (j=1; j<=NCHUNKS/STATI; j++)
            fprintf(sfile, "%d\t%d.%06d\n", j*STATI*CHUNK,
                (int)stats[j].tv_sec, (int)stats[j].tv_usec);
        fclose(sfile);
    }
}

Voici une version Windows de mon code synchtonisé. Je ne le faisais que dans une Virtualbox VM, donc je ne pense pas avoir de numéros utiles à titre de comparaison, mais vous pourriez lui donner un tir à comparer à vos numéros C # sur votre machine. Je passe Open_alway à Createfile, il va donc réutiliser le fichier existant. Changer ce drapeau pour créer_always si vous souhaitez tester à nouveau avec un fichier vide à chaque fois.

Une chose que j'ai remarquée, c'est que les résultats étaient beaucoup plus rapides la première fois que je rencontrais ce programme. Peut-être que NTFS n'est pas très efficace pour écraser les données existantes et les effets de fragmentation de fichiers apparaissent sur les exécutions suivantes. P>

#include <windows.h>
#include <stdio.h>

#define USE_MMAP    8
#define USE_DIRECT  4
#define USE_LAST    2
#define USE_SYNC    1

#define PAGE    4096
#define CHUNK   (8*PAGE)
#define NCHUNKS 10000
#define STATI   1000

#define FSIZE   (NCHUNKS*CHUNK)

static LARGE_INTEGER cFreq;

int gettimeofday(struct timeval *tv, void *unused)
{
    LARGE_INTEGER count;
    if (!cFreq.QuadPart) {
        QueryPerformanceFrequency(&cFreq);
    }
    QueryPerformanceCounter(&count);
    tv->tv_sec = count.QuadPart / cFreq.QuadPart;
    count.QuadPart %= cFreq.QuadPart;
    count.QuadPart *= 1000000;
    tv->tv_usec = count.QuadPart / cFreq.QuadPart;
    return 0;
}

main()
{
    int i, j, rc, stc;
    HANDLE fd;
    char *data = _aligned_malloc(CHUNK, PAGE);
    char *map, *dst;
    char sfname[8];
    struct timeval start, end, stats[NCHUNKS/STATI+1];
    FILE *sfile;
    DWORD len;

    printf("mmap\tdirect\tlast\tsync\ttime\n");
    for (i=0; i<16; i++) {
        int oflag = FILE_ATTRIBUTE_NORMAL;

        if (i & USE_DIRECT)
            oflag |= FILE_FLAG_NO_BUFFERING|FILE_FLAG_WRITE_THROUGH;
        fd = CreateFile("dummy", GENERIC_READ|GENERIC_WRITE, 0, NULL,
            OPEN_ALWAYS, oflag, NULL);
        SetFilePointer(fd, FSIZE, NULL, FILE_BEGIN);
        SetEndOfFile(fd);
        if (i & USE_LAST)
            WriteFile(fd, data, 1, &len, NULL);
        SetFilePointer(fd, 0, NULL, FILE_BEGIN);
        if (i & USE_MMAP) {
            HANDLE mh;
            mh = CreateFileMapping(fd, NULL, PAGE_READWRITE,
                0, FSIZE, NULL);
            map = MapViewOfFile(mh, FILE_MAP_WRITE, 0, 0,
                FSIZE);
            CloseHandle(mh);
            dst = map;
        }
        sprintf(sfname, "%x.csv", i);
        sfile = fopen(sfname, "w");
        stc = 1;
        printf("%d\t%d\t%d\t%d\t",
            (i&USE_MMAP)!=0, (i&USE_DIRECT)!=0, (i&USE_LAST)!=0, i&USE_SYNC);
        fflush(stdout);
        gettimeofday(&start, NULL);
        stats[0] = start;
        for (j = 1; j<=NCHUNKS; j++) {
            if (i & USE_MMAP) {
                memcpy(dst, data, CHUNK);
                FlushViewOfFile(dst, CHUNK);
                dst += CHUNK;
            } else {
                WriteFile(fd, data, CHUNK, &len, NULL);
            }
            if (i & USE_SYNC)
                FlushFileBuffers(fd);
            if (!(j % STATI)) {
                gettimeofday(&end, NULL);
                stats[stc++] = end;
            }
        }
        end.tv_usec -= start.tv_usec;
        if (end.tv_usec < 0) {
            end.tv_sec--;
            end.tv_usec += 1000000;
        }
        end.tv_sec -= start.tv_sec;
        printf(" %d.%06ds\n", (int)end.tv_sec, (int)end.tv_usec);
        if (i & USE_MMAP)
            UnmapViewOfFile(map);
        CloseHandle(fd);
        for (j=NCHUNKS/STATI; j>0; j--) {
            stats[j].tv_usec -= stats[j-1].tv_usec;
            if (stats[j].tv_usec < 0) {
                stats[j].tv_sec--;
                stats[j].tv_usec+= 1000000;
            }
            stats[j].tv_sec -= stats[j-1].tv_sec;
        }
        for (j=1; j<=NCHUNKS/STATI; j++)
            fprintf(sfile, "%d\t%d.%06d\n", j*STATI*CHUNK,
                (int)stats[j].tv_sec, (int)stats[j].tv_usec);
        fclose(sfile);
    }
}