La Force d'écrire un fichier sur le disque

Je suis actuellement à la mise en œuvre d'une table de ping/pong schéma de mise en mémoire tampon en toute sécurité d'écrire un fichier sur le disque. Je suis à l'aide de C++/Boost sur un Linux/CentOS machine. Maintenant, je suis confronté au problème de la force réelle de l'écriture du fichier sur le disque. Est-il possible de le faire indépendamment de toutes les stratégies de mise en cache du système de fichiers (ext3/ext4) /, de SORTE que des règles personnalisées /RAID controller /contrôleur de disques durs ?

Est-il préférable d'utiliser de la plaine fread () et fwrite(), c++ ostream, ou pour renforcer le système de fichier?

J'ai entendu dire que simplement d'éliminer le fichier (fflush()) ne garantit pas la réelle écriture

OriginalL'auteur Gianluca Ghettini | 2012-11-13

c++disk fflush linux unix

5

fflush (FILE*), std::flush (IOStream) à la force de votre programme à envoyer à l'OS.

POSIX a
- sync(2) de demander à l'annexe à la rédaction de ses mémoires tampons, mais peut revenir avant que l'écrit est fait (Linux attend que les données sont à envoyer pour le matériel avant de revenir).
- fsync(2), qui est garanti à attendre pour les données à envoyer pour le matériel, mais a besoin d'un descripteur de fichier (vous pouvez en obtenir un à partir d'un FICHIER* avec fileno(3), je ne connais pas de méthode standard pour l'obtenir à partir d'une IOStream).
- O_SYNC comme un indicateur de open(2).
Dans tous les cas, le matériel peut avoir ses propres tampons (mais si il a le contrôle sur elle, une bonne mise en œuvre vais essayer de les éliminer aussi et ISTR que certains disques sont à l'aide de condensateurs, de sorte qu'ils sont en mesure de rincer quoi qu'il arrive au pouvoir) et des systèmes de fichiers réseau ont leur propre mise en garde.

Et pour le C++ flux il y a le manipulateur std::flush au lieu de fflush.
merci!!!! j'ai donc forcer le programme à commettre de système de fichiers de la première (fflush/chasse), puis à force de s'engager à un contrôleur de disque (sync). Pouvez-vous me montrer une preuve de concept?
c'est ce que j'ai voulu signifier par le trop laconique (f)flush, j'ai clarifié.
Je me sens obligé de souligner qu'aucun de ces garantit que les données sont écrites physiquement sur le disque. Il peut très bien être présent uniquement dans le cache du disque dur ou d'autres mystiques endroits à l'intérieur de votre ordinateur.
c'est exactement mon souci. Malheureusement, la désactivation de l'écriture de la mémoire cache de contrôleur RAID n'est pas une option en raison de la perte de performance. En outre, la solution doit être seul logiciel.

OriginalL'auteur AProgrammer
2

Vous pouvez utiliser fsync()/fdatasync() pour forcer(Note 1) les données sur le stockage.
Ceux requres un descripteur de fichier, de telle que donnée par exemple par open().
Le linux man ont plus spécifique à linux info, notamment sur la différence de fsync et fdatasync.

Si vous n'utilisez pas de fichier desciptors directement, de nombreuses abstractions contiendra des tampons internes résidant dans votre processus.

par exemple, si vous utilisez un FICHIER*, vous devez d'abord vider les données de votre application.
```
//... open and write data to a FILE *myfile
fflush(myfile);
fsync(fileno(myfile));
```
- Note 1: Ces appels à la force de l'OS, de façon à s'assurer que toutes les données dans tout système de cache est écrit pour le lecteur, et le lecteur reconnaît ce fait. De nombreux disques durs mensonge de l'OS à ce sujet, et peut farcir les données dans la mémoire cache sur le disque.
ce sujet de la fonction fclose()? ne nous en avons besoin, non?
Lorsque vous avez terminé avec le FICHIER*, pour fermer le fichier, puis utilisez la fonction fclose()
désolé, je veux dire lorsque vous utilisez directement les descripteurs de fichier; avons-nous besoin d'un explicite close(fd) appel?
Si vous utilisez un FICHIER*, utilisez la fonction fclose. Si vous utilisez filedescriptors utilisation close(). Si vous êtes en tirant le descripteur de fichier d'un FICHIER*, vous avez encore un FICHIER*, afin d'utiliser la fonction fclose (qui sera aussi fermer le descripteur de fichier )

OriginalL'auteur nos

Pas dans la norme C++. Vous aurez à utiliser une sorte de système spécifique
IO, comme open avec le O_SYNC drapeau sous Unix, et puis write.

Noter que c'est en partie implicite par le fait que ostream (et dans
C, FILE*) sont mis en mémoire tampon. Si vous ne savez pas exactement quand quelque chose est
écrits sur le disque, alors il ne fait pas beaucoup de sens afin d'insister sur le
l'intégrité transactionnelle de l'écriture. (Il ne devrait pas être trop dur à
la conception d'un streambuf qui seulement écrit lorsque vous faites explicite d'une chasse d'eau,
cependant.)

EDIT:

Comme un simple exemple:

class SynchronizedStreambuf : public std::streambuf
{
int myFd;
std::vector<char> myBuffer;
protected:
virtual int overflow( int ch );
virtual int sync();
public:
SynchronizedStreambuf( std::string const& filename );
~SynchronizedStreambuf();
};
int SynchronizedStreambuf::overflow( int ch )
{
if ( myFd == -1 ) {
return traits_type::eof();
} else if ( ch == traits_type::eof() ) {
return sync() == -1 ? traits_type::eof() : 0;
} else {
myBuffer.push_back( ch );
size_t nextPos = myBuffer.size();
myBuffer.resize( 1000 );
setp( &myBuffer[0] + nextPos, &myBuffer[0] + myBuffer.size() );
return ch;
}
}
int SynchronizedStreambuf::sync()
{
size_t toWrite = pptr() - &myBuffer[0];
int result = (toWrite == 0 || write( myFd, &myBuffer[0], toWrite ) == toWrite ? 0 : -1);
if ( result == -1 ) {
close( myFd );
setp( NULL, NULL );
myFd = -1;
} else {
setp( &myBuffer[0], &myBuffer[0] + myBuffer.size() );
}
return result;
}
SynchronizedStreambuf::SynchronizedStreambuf( std::string const& filename )
: myFd( open( filename.c_str(), O_WRONLY | O_CREAT | O_SYNC, 0664 ) )
{
}
SynchronizedStreambuf::~SynchronizedStreambuf()
{
sync();
close( myFd );
}

(Ce n'a été que superficiellement testé, mais l'idée de base est là.)

OriginalL'auteur James Kanze

Vous devez vous connecter pour publier un commentaire.