Quale è più veloce, scrivendo dati grezzi su un'unità o scrivendo su un file?

Question

Ho bisogno di scrivere dati nell'azionamento. Ho due opzioni:

1. scrivere settori prime (_ modifica (maniglia, pBuffer, dimensioni);)
2. scrittura in un file (fwrite (pBuffer, dimensioni, conteggio, pFile);)

.

Quale strada è più veloce?

Mi aspettavo che la funzione di scrittura del settore raw, _write, fosse più efficiente. Tuttavia, il mio risultato del test è fallito! fwrite è più veloce. _write costa più tempo.

Ho incollato il mio snippet; forse il mio codice è sbagliato. Mi puoi aiutare? In entrambi i casi va bene per me, ma credo che in scrittura prima è meglio, perché sembra che i dati dell'unità sono cifrati almeno ....

#define SSD_SECTOR_SIZE 512 
int g_pSddDevHandle = _open("\\\\.\\G:",_O_RDWR | _O_BINARY, _S_IREAD | _S_IWRITE); 
TIMER_START(); 
while (ulMovePointer < 1024 * 1024 * 1024) 
{ 
    _write(g_pSddDevHandle,szMemZero,SSD_SECTOR_SIZE); 
    ulMovePointer += SSD_SECTOR_SIZE; 
} 
TIMER_END(); 
TIMER_PRINT(); 
FILE * file = fopen("f:\\test.tmp","a+"); 
TIMER_START(); 
while (ulMovePointer < 1024 * 1024 * 1024) 
{ 
    fwrite(szMemZero,SSD_SECTOR_SIZE,1,file); 
    ulMovePointer += SSD_SECTOR_SIZE; 
} 
TIMER_END(); 
TIMER_PRINT(); 

Answer 1

Nel caso _write(), il valore di SSD_SECTOR_SIZE è importante. Nel caso fwrite, la dimensione di ogni scrittura sarà effettivamente BUFSIZ. Per ottenere un confronto migliore, assicurarsi che le dimensioni del buffer sottostante siano le stesse.

Tuttavia, questa è probabilmente solo una parte della differenza.

Nel caso fwrite, si sta misurando la velocità con cui è possibile ottenere i dati nella memoria. Non hai scaricato il buffer stdio nel sistema operativo e non hai chiesto al sistema operativo di svuotare i buffer nell'archivio fisico. Per fare un confronto più accurato, dovresti chiamare fflush() prima di fermare i timer.

Se effettivamente si desidera ottenere dati sul disco piuttosto che ottenere i dati nei buffer dei sistemi operativi, è necessario assicurarsi di chiamare fsync()/FlushFileBuffers() prima di arrestare il timer.

Altre differenze evidenti:

• Le unità sono diversi. Non so quanto sia diverso.

• La semantica di una scrittura su un dispositivo è diversa dalla semantica delle scritture su un file system; il file system può ritardare le scritture per migliorare le prestazioni fino a quando non viene esplicitamente detto di non farlo (ad esempio con un handle standard, una chiamata a FlushFileBuffers()); scrivere direttamente su un dispositivo non è necessariamente ottimizzato in questo modo. D'altra parte, il file system deve fare I extra/O per gestire i metadati (allocazione blocco, le voci di directory, ecc)

Ho il sospetto che si sta vedendo un diverso nella politica le cose come realmente veloci andare sul disco.Le prestazioni del disco raw possono essere molto veloci, ma sono necessarie grandi scritture e preferibilmente più operazioni in sospeso simultanee. È inoltre possibile evitare la copia del buffer utilizzando le opzioni corrette quando si apre l'handle.

Answer 2

Probabilmente perché una scrittura diretta non è tamponata. Quando chiami fwrite, stai facendo delle scritture bufferizzate che tendono ad essere più veloci nella maggior parte delle situazioni. Essenzialmente, ogni gestore di FILE* ha un buffer interno che viene scaricato periodicamente su disco quando diventa pieno, il che significa che si finisce per effettuare meno chiamate di sistema, dato che si scrive sul disco solo in blocchi più grandi.

Per dirla in un altro modo, nel tuo primo ciclo, stai effettivamente scrivendo i byte SSD_SECTOR_SIZE su disco durante ogni iterazione. Nel tuo secondo ciclo non lo sei. Si stanno scrivendo solo byte SSD_SECTOR_SIZE in un buffer di memoria, che, a seconda della dimensione del buffer, verrà svuotato solo ogni ennesima iterazione.