Unterschied zwischen fflush und fsync

ich dachte fsync() tut fflush() intern, also mit fsync() auf einem Stream ist OK. Aber ich erhalte ein unerwartetes Ergebnis, wenn ich unter Netzwerk-E/A ausgeführt werde.

Mein Codeschnipsel:

FILE* fp = fopen(file, "wb");
/* multiple fputs() calls like: */
fputs(buf, fp);
...
...
fputs(buf.c_str(), fp);
/* get fd of the FILE pointer */
fd = fileno(fp);
#ifndef WIN32
ret = fsync(fd);
#else
ret = _commit(fd);
fclose(fp);

Aber es scheint _commit() löscht die Daten nicht (ich habe es unter Windows versucht und die Daten wurden auf ein exportiertes Linux-Dateisystem geschrieben).

Als ich den Code geändert habe zu:

FILE* fp = fopen(file, "wb");
/* multiple fputs() calls like: */
fputs(buf, fp);   
...   
...
fputs(buf.c_str(), fp);
/* fflush the data */
fflush(fp);
fclose(fp);

es löscht die Daten.

Ich frage mich, ob _commit() macht das gleiche wie fflush(). Irgendwelche Eingänge?

fflush() arbeitet an FILE*es löscht nur die internen Puffer in der FILE* Ihrer Anwendung an das Betriebssystem.

fsync auf einer niedrigeren Ebene arbeitet, weist es das Betriebssystem an, seine Puffer auf die physischen Medien zu leeren.

Betriebssysteme speichern Daten, die Sie in eine Datei schreiben, stark. Wenn das Betriebssystem jeden Schreibvorgang erzwingen würde, um auf das Laufwerk zu gelangen, wären die Dinge so sehr langsam. fsync (unter anderem) können Sie steuern, wann die Daten auf das Laufwerk gelangen sollen.

Darüber hinaus arbeitet fsync/commit mit einem Dateideskriptor. Es hat keine Kenntnis von a FILE* und kann seine Puffer nicht leeren. FILE* lebt in Ihrer Anwendung, Dateideskriptoren leben normalerweise im Betriebssystemkernel.

Die Standard-C-Funktion fflush() und der POSIX-Systemaufruf fsync() sind konzeptionell etwas ähnlich. fflush() arbeitet mit C-Datei-Streams (FILE Objekte) und ist daher portabel.
fsync() arbeiten mit POSIX-Dateideskriptoren. Beide bewirken, dass gepufferte Daten an ein Ziel gesendet werden.

Auf einem POSIX-System jeder C-Dateistream hat einen zugehörigen Dateideskriptorund alle Operationen auf einem C-Dateistrom werden implementiert, indem bei Bedarf POSIX-Systemaufrufe delegiert werden, die auf dem Dateideskriptor arbeiten.

Man könnte meinen, dass ein Anruf an fflush auf einem POSIX-System würde a verursachen write aller Daten im Puffer des Dateistroms, gefolgt von einem Aufruf von fsync() für den Dateideskriptor dieses Dateistreams. Auf einem POSIX-System wäre es also nicht nötig, einem Aufruf zu folgen fflush mit einem Anruf bei fsync(fileno(fp)). Aber ist das der Fall: gibt es einen Aufruf dazu fsync aus fflush?

Nein, Anruf fflush auf einem POSIX-System bedeutet dies nicht fsync wird angerufen werden.

Der C-Standard für fflush sagt (Hervorhebung hinzugefügt) es

verursacht alle ungeschriebenen Daten für [the] Stream, der an die Hostumgebung geliefert werden soll geschrieben werden zur Datei

Sagen, dass die Daten sind sein geschrieben, anstatt das ist ist geschrieben impliziert, dass eine weitere Pufferung durch die Hostumgebung erlaubt ist. Diese Pufferung durch die “Host-Umgebung” könnte für eine POSIX-Umgebung die interne Pufferung umfassen fsync errötet. Eine genaue Lektüre des C-Standards legt also nahe, dass der Standard nicht erfordert, dass die POSIX-Implementierung aufgerufen wird fsync.

Das POSIX-Standardbeschreibung von fflush erklärt nicht, als ein Erweiterung der C-Semantikdas fsync wird genannt.

fflush() und fsync() kann verwendet werden, um sicherzustellen, dass Daten auf das Speichermedium geschrieben werden (aber es ist nicht immer möglich):

1. erste Benutzung fflush(fp) auf dem Ausgabestrom (fp sein FILE * erhalten von fopen oder einen der Standardstreams stdout oder stderr), um den Inhalt des Puffers, der dem Stream zugeordnet ist, in das Betriebssystem zu schreiben.
2. dann benutze fsync(fileno(fp)) um das Betriebssystem anzuweisen, seine eigenen Puffer auf die Speichermedien zu schreiben.

Beachte das aber fileno() und fsync() sind POSIX-Funktionen, die möglicherweise nicht auf allen Systemen verfügbar sind, insbesondere auf Microsoft-Legacy-Systemen, auf denen Alternativen genannt werden können _fileno(), _fsync() oder _commit()…

Ich könnte der Einfachheit halber sagen:

verwenden fsync() mit Nicht-Streaming-Dateien (ganzzahlige Dateideskriptoren)

verwenden fflush() mit Dateistreams.

Auch hier ist die Hilfe von Menschen:

int fflush(FILE *stream); // flush a stream, FILE* type

int fsync(int fd); // synchronize a file's in-core state with storage device
                    // int type

Verwenden Sie die Funktionen sync() oder fsync(), um die Festschreibung der letzten Änderungen auf der Festplatte zu erzwingen.

fsync() synchronisiert alle Daten und Metadaten der angegebenen Datei mit dem permanenten Speichergerät. Es sollte kurz vor dem Schließen der entsprechenden Datei aufgerufen werden.

synchronisieren () schreibt alle geänderten Dateien auf die Festplatte.

Ich denke, das folgende Dokument von Python (https://docs.python.org/2/library/os.html) verdeutlicht es sehr gut.

os.fsync(fd) Erzwingt das Schreiben einer Datei mit dem Dateideskriptor fd auf die Festplatte. Unter Unix ruft dies die native fsync()-Funktion auf; unter Windows die MS-Funktion _commit().

Wenn Sie mit einem Python-Dateiobjekt f beginnen, führen Sie zuerst f.flush() und dann os.fsync(f.fileno()) aus, um sicherzustellen, dass alle mit f verknüpften internen Puffer auf die Festplatte geschrieben werden.

Verfügbarkeit: Unix und Windows ab 2.2.3.