dist_file_io.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
#include <kernel/base_header.hpp>
#include <kernel/util/binary_stream.hpp>
#include <kernel/util/exception.hpp>
#include <kernel/util/string.hpp>
#include <kernel/util/dist.hpp>
 
#include <sstream>
 
namespace FEAT
{
  class DistFileIO
  {
  public:
    static constexpr std::uint64_t magic_combined = 0x4644433354414546ull;
 
    static void read_common(std::stringstream& stream, const String& filename, const Dist::Comm& comm, int root_rank = 0);
 
    static void read_common(std::stringstream& stream, const String& filename)
    {
      Dist::Comm comm(Dist::Comm::world());
      read_common(stream, filename, comm);
    }
 
    static void read_common(BinaryStream& stream, const String& filename, const Dist::Comm& comm, int root_rank = 0);
 
    static void read_common(BinaryStream& stream, const String& filename)
    {
      Dist::Comm comm(Dist::Comm::world());
      read_common(stream, filename, comm);
    }
 
    static void read_sequence(std::stringstream& stream, const String& pattern, const Dist::Comm& comm);
 
    static void read_sequence(std::stringstream& stream, const String& pattern)
    {
      Dist::Comm comm(Dist::Comm::world());
      read_sequence(stream, pattern, comm);
    }
 
 
    static void read_sequence(BinaryStream& stream, const String& pattern, const Dist::Comm& comm);
 
    static void read_sequence(BinaryStream& stream, const String& pattern)
    {
      Dist::Comm comm(Dist::Comm::world());
      read_sequence(stream, pattern, comm);
    }
 
    static void write_sequence(std::stringstream& stream, const String& pattern, const Dist::Comm& comm, bool truncate = true);
 
    static void write_sequence(std::stringstream& stream, const String& pattern, bool truncate = true)
    {
      Dist::Comm comm(Dist::Comm::world());
      write_sequence(stream, pattern, comm, truncate);
    }
 
    static void write_sequence(BinaryStream& stream, const String& pattern, const Dist::Comm& comm, bool truncate = true);
 
    static void write_sequence(BinaryStream& stream, const String& pattern, bool truncate = true)
    {
      Dist::Comm comm(Dist::Comm::world());
      write_sequence(stream, pattern, comm, truncate);
    }
 
    static void read_ordered(void* buffer, const std::size_t size, const String& filename, const Dist::Comm& comm);
 
    static void read_ordered(void* buffer, const std::size_t size, const String& filename)
    {
      Dist::Comm comm(Dist::Comm::world());
      read_ordered(buffer, size, filename, comm);
    }
 
    static void write_ordered(const void* buffer, const std::size_t size, const String& filename, const Dist::Comm& comm, bool truncate = true);
 
    static void write_ordered(const void* buffer, const std::size_t size, const String& filename, bool truncate = true)
    {
      Dist::Comm comm(Dist::Comm::world());
      write_ordered(buffer, size, filename, comm, truncate);
    }
 
    static void write_ordered(BinaryStream& stream, const String& filename, const Dist::Comm& comm, bool truncate = true)
    {
      write_ordered(stream.data(), std::size_t(stream.size()), filename, comm, truncate);
    }
 
    static void write_ordered(BinaryStream& stream, const String& filename, bool truncate = true)
    {
      Dist::Comm comm(Dist::Comm::world());
      write_ordered(stream.data(), std::size_t(stream.size()), filename, comm, truncate);
    }
 
    static void read_combined(std::vector<char>& common, std::vector<char>& buffer,
      const String& filename, const Dist::Comm& comm, int root_rank = 0, bool bcast_common = true);
 
    static void read_combined(BinaryStream& common, BinaryStream& buffer,
      const String& filename, const Dist::Comm& comm, int root_rank = 0, bool bcast_common = true)
    {
      read_combined(common.container(), buffer.container(), filename, comm, root_rank, bcast_common);
    }
 
    static void write_combined(const std::vector<char>& common, const std::vector<char>& buffer,
      const String& filename, const Dist::Comm& comm, int root_rank = 0);
 
    static void write_combined(const BinaryStream& common, const BinaryStream& buffer,
      const String& filename, const Dist::Comm& comm, int root_rank = 0)
    {
      write_combined(common.container(), buffer.container(), filename, comm, root_rank);
    }
 
  protected:
    static String _rankname(const String& pattern, int rank);
    static void _read_file(std::stringstream& stream, const String& filename);
    static void _read_file(BinaryStream& stream, const String& filename);
    static void _write_file(std::stringstream& stream, const String& filename, bool truncate);
    static void _write_file(BinaryStream& stream, const String& filename, bool truncate);
  }; // class DistFileIO
} // namespace FEAT