c++ - utiliza - tension de seguridad 24v

¿C++ de la escritura de archivos de corriente utiliza un búfer?

Question

A continuación hay dos programas que escriben 50,000,000 de bytes en un archivo.

El primer programa, escrito en C, utiliza un búfer, que una vez rellenado con un valor arbitrario, escribe en el disco y luego repite ese proceso hasta que se escriben todos los 50,000,000 de bytes. Noté que a medida que aumentaba el tamaño del buffer, el programa tardaba menos tiempo en ejecutarse. Por ejemplo, en BUFFER_SIZE = 1, el programa tardó ~ 88.0463 segundos, mientras que en BUFFER_SIZE = 1024, el programa solo tardó ~ 1.7773 segundos. El mejor momento que grabé fue cuando BUFFER_SIZE = 131072. Como el BUFFER_SIZE aumentó más que eso, noté que comenzó a tomar un poco más de tiempo.

El segundo programa, escrito en C ++, utiliza ofstream para escribir un byte a la vez. Para mi sorpresa, el programa solo tardó ~ 1.87 segundos en ejecutarse. Esperaba que tardara un minuto más o menos, como el programa C con BUFFER_SIZE = 1. Obviamente, C ++ ofstream maneja la escritura de archivos de forma diferente a lo que pensaba. De acuerdo con mis datos, está funcionando de manera muy similar al archivo C con BUFFER_SIZE = 512. ¿Utiliza algún tipo de memoria intermedia detrás de escena?

Aquí está el programa C:

const int NVALUES = 50000000; //#values written to the file
const char FILENAME[] = "/tmp/myfile";
const int BUFFER_SIZE = 8192; //# bytes to fill in buffer before writing

main()
{
    int fd;  //File descriptor associated with output file
    int i;
    char writeval = ''/0'';
    char buffer[BUFFER_SIZE];

    //Open file for writing and associate it with the file descriptor
    //Create file if it does not exist; if it does exist truncate its size to 0
    fd = open(FILENAME, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR);

    for(i=0;i<NVALUES;i++)
    {
        //Package bytes into BUFFER_SIZE chunks 
                //and write a chunk once it is filled
        buffer[i%BUFFER_SIZE] = writeval;
        if((i%BUFFER_SIZE == BUFFER_SIZE-1 || i == NVALUES-1))
            write(fd, buffer, i%BUFFER_SIZE+1);

    }

    fsync(fd);

    close(fd);
}

Aquí está el programa C ++:

int main()
{
    ofstream ofs("/tmp/iofile2");
    int i;

    for(i=0; i<50000000; i++)
        ofs << ''/0'';

    ofs.flush();
    ofs.close();

    return 0;
}

Gracias por tu tiempo.

Answer 1

Por this , ofstream tiene un puntero de filebuf interno, se puede leer a través de la función rdbuf , que apunta a un objeto streambuf , que es el siguiente:

streambuf objetos streambuf generalmente están asociados con una secuencia de caracteres específica, desde la cual leen y escriben datos a través de un buffer de memoria interna. El búfer es una matriz en memoria que se espera que se sincronice cuando sea necesario con el contenido físico de la secuencia de caracteres asociada.

En negrita los bits importantes, parece que hace uso de un buffer, pero no sé o no he descubierto qué tipo de buffer es.

Answer 2

Sí, ostreams usa un buffer de flujo, alguna subclase de una instanciación de la plantilla basic_streambuf. La interfaz de basic_streambuf está diseñada para que una implementación pueda almacenar en búfer si hay una ventaja en eso.

Sin embargo, este es un problema de calidad de implementación. Las implementaciones no están obligadas a hacer esto, pero cualquier implementación competente lo hará.

Puede leerlo al respecto en el capítulo 27 de la norma ISO, aunque tal vez una fuente más legible sea The C ++ Standard Library: A Tutorial and Reference ( búsqueda en google ).

Answer 3

Sí, todas las operaciones de flujo se almacenan en búfer, aunque por defecto la salida estándar de entrada, salida y error no es tal que las interacciones con el C IO sean menos sorprendentes.

Como ya se streambuf , hay un streambuf clase base que se usa detrás de escena. Se proporciona con su propio búfer, cuyo tamaño es un detalle de implementación.

Puede comprobar (experimentalmente) cuánto es este búfer usando streambuf::in_avail , suponiendo que los valores de entrada filestream y outputtream se configuran con el mismo tamaño de búfer ...

Hay otras dos operaciones que puede hacer aquí que podrían ser de su interés:

• puede cambiar el objeto streambuf utilizado por una secuencia para cambiar a una versión personalizada
• puedes cambiar el buffer utilizado por el objeto streambuf

ambos deben hacerse inmediatamente después de crear la transmisión o después de un flush , para evitar que se pierdan algunos datos ...

Para ilustrar el cambio del búfer, consulte streambuf::putsetbuf :

#include <fstream>
#include <vector>

int main () {
  std::vector<char> vec(512);

  std::fstream fs;
  fs.rdbuf()->pubsetbuf(&vec.front(), vec.size());

  // operations with file stream here.
  fs << "Hello, World!/n";

  // the stream is automatically closed when the scope ends, so fs.close() is optional
  // the stream is automatically flushed when it is closed, so fs.flush() is optional

  return 0;
}

Ahora puedes repetir los experimentos que hiciste en C para encontrar el punto ideal :)