focal (2) diststream.2rheolef.gz

NAME

       diststream - i/o streams in distributed environment (rheolef-7.1)

DESCRIPTION

       The idiststream and odiststream classes provide a stream input and output interface for parallel and
       distributed codes. The main difference Recall that, with the usual std::istream and std::ostream, any i/o
       operation are executed on all processes: e.g. the output is printed many times. In contrast, idiststream
       and odiststream manage nicely the distributed environment.

       For small data, e.g. int, double or string, a specific processor is selected for i/o operations. For
       large data, the i/o operations are delegated to a specific class member functions when available.

       For convenience, the standard streams cin, cout, clog and cerr are extended as din, dout, dlog and derr,
       respectively.

FILE SUFFIXES

       Finally, optional suffix extension to the file name is automatically handled:

           odiststream foo("NAME", "suffix");

       is similar

           ofstream foo("NAME.suffix").

       Conversely,

           irheostream foo("NAME","suffix");

       is similar to

           ifstream foo("NAME.suffix").

FILE SEARCH

       Recursive search in a directory list is provided for finding the input file. However, we look at a search
       path environment variable RHEOPATH in order to find NAME while the suffix is assumed. Moreover, gzip
       compressed files, ending with the .gz suffix are handled, and decompression is done automatically on the
       fly in that case.

COMPRESSION

       File compression/decompresion is handled on the fly, thanks to the gzip library. The data compression is
       assumed by default for output: it can be deactivated while opening a file by an optional argument:

           odiststream foo("NAME", "suffix", io::nogz);

APPEND MODE

       An existing file, possibly compressed, can be reopen in append mode. New results will be appended at the
       end of an existing file:

           odiststream foo("NAME", "suffix", io::app);

FLUSH

       The flush member function is nicely handled in compression mode: this feature allows intermediate results
       to be available during long computations. Buffers are flushed and data are available in the output file.

IMPLEMENTATION

       This documentation has been generated from file linalg/lib/diststream.h

       class idiststream {
       public:
         typedef std::size_t size_type;

       // allocators/deallocators:

         idiststream();
         idiststream (std::istream& is, const communicator& comm = communicator());
         idiststream (std::string filename, std::string suffix = "",
                    const communicator& comm = communicator());
         ~idiststream();

       // modifiers:

         void open (std::string filename, std::string suffix = "",
                    const communicator& comm = communicator());
         void close();

       // accessors:

         const communicator& comm() const { return _comm; }
         bool good() const;
         operator bool() const { return good(); }
         static size_type io_proc();

       };

       class odiststream {
       public:
         typedef std::size_t size_type;

       // allocators/deallocators:

         odiststream();
         odiststream (std::string filename, std::string suffix = "",
                     io::mode_type mode = io::out, const communicator& comm = communicator());
         odiststream (std::string filename,
                     io::mode_type mode, const communicator& comm = communicator());
         odiststream (std::string filename, std::string suffix, const communicator& comm);
         odiststream (std::string filename, const communicator& comm);
         odiststream(std::ostream& os, const communicator& comm = communicator());
         ~odiststream();

       // modifiers:

          void open (std::string filename, std::string suffix = "",
                    io::mode_type mode = io::out, const communicator& comm = communicator());
          void open (std::string filename,
                    io::mode_type mode, const communicator& comm = communicator());
          void open (std::string filename, std::string suffix,
                    const communicator& comm);
          void open (std::string filename, const communicator& comm);
          void flush();
          void close();

       // accessors:

          const communicator& comm() const { return _comm; }
          bool good() const;
          operator bool() const { return good(); }
          static size_type io_proc();

       };

AUTHOR

       Pierre  Saramito  <Pierre.Saramito@imag.fr>

COPYRIGHT

       Copyright   (C)  2000-2018  Pierre  Saramito  <Pierre.Saramito@imag.fr> GPLv3+: GNU GPL version 3 or
       later  <http://gnu.org/licenses/gpl.html>.  This  is  free  software:  you  are free to change and
       redistribute it.  There is NO WARRANTY, to the extent permitted by law.