#include <Writer.h>

Collaboration diagram for H5Utils::Writer< N, I >:

Public Types
using	consumer_type = Consumers<I>
using	input_type = I
template<typename T>
using	function_type = typename consumer_type::template function_type<T>
using	configuration_type = WriterConfiguration<N>

Public Member Functions
	Writer (H5::Group &group, const std::string &name, const Consumers< I > &consumers, const std::array< hsize_t, N > &extent=internal::uniform< N >(5), hsize_t batch_size=defaults::batch_size)
	Writer (H5::Group &group, const Consumers< I > &consumers, const WriterConfiguration< N > &=WriterConfiguration< N >())
	Writer (const Writer &)=delete
	Writer (Writer &&) noexcept
Writer &	operator= (Writer &)=delete
	~Writer ()
template<typename T>
void	fill (T)
void	flush ()
size_t	index () const

Private Member Functions
	Writer (Writer &&other, std::unique_lock< std::recursive_mutex > other_lock) noexcept

Private Attributes
const internal::DSParameters< I, N >	m_par
hsize_t	m_offset
hsize_t	m_buffer_rows
std::vector< internal::data_buffer_t >	m_buffer
std::vector< SharedConsumer< I > >	m_consumers
H5::DataSet	m_ds
H5::DataSpace	m_file_space
std::recursive_mutex	m_mutex

Detailed Description

template<size_t N, typename I>
class H5Utils::Writer< N, I >

Writer.

You'll have to specify the H5::Group to write the dataset to, the name of the new dataset, and the extent of the dataset.

To fill, use the fill(...) method.

Definition at line 352 of file Writer.h.

Member Typedef Documentation

◆ configuration_type

template<size_t N, typename I>

using H5Utils::Writer< N, I >::configuration_type = WriterConfiguration<N>

Definition at line 373 of file Writer.h.

◆ consumer_type

template<size_t N, typename I>

using H5Utils::Writer< N, I >::consumer_type = Consumers<I>

Definition at line 369 of file Writer.h.

◆ function_type

template<size_t N, typename I>

template<typename T>

using H5Utils::Writer< N, I >::function_type = typename consumer_type::template function_type<T>

Definition at line 372 of file Writer.h.

◆ input_type

template<size_t N, typename I>

using H5Utils::Writer< N, I >::input_type = I

Definition at line 370 of file Writer.h.

Constructor & Destructor Documentation

◆ Writer() [1/5]

template<size_t N, typename I>

Writer::Writer	(	H5::Group &	group,
		const std::string &	name,
		const Consumers< I > &	consumers,
		const std::array< hsize_t, N > &	extent = internal::uniform<N>(5),
		hsize_t	batch_size = defaults::batch_size )

Definition at line 387 of file Writer.h.

                                          :
    Writer<N,I>(
      group, consumers, WriterConfiguration<N>{
        .name = name, // name
        .extent = extent, // extent
        .batch_size = batch_size, // batch_size
        .chunks = extent, // chunks
        .deflate = defaults::deflate, // deflate
        .plist_callbacks = {} // plist_callbacks
      })
  {}

◆ Writer() [2/5]

template<size_t N, typename I>

Writer::Writer	(	H5::Group &	group,
		const Consumers< I > &	consumers,
		const WriterConfiguration< N > &	cfg = WriterConfiguration<N>() )

Definition at line 403 of file Writer.h.

                                                         :
    m_par(consumers.getConsumers(), cfg.extent,
          cfg.batch_size ? *cfg.batch_size : defaults::batch_size),
    m_offset(0),
    m_buffer_rows(0),
    m_consumers(consumers.getConsumers()),
    m_file_space(H5S_SIMPLE)
  {
    using internal::data_buffer_t;
    if (m_par.batch_size < 1) {
      throw std::logic_error("batch size must be > 0");
    }
    // create space
    H5::DataSpace space = internal::getUnlimitedSpace(
      internal::vec(cfg.extent));
 
    // create params
    H5::DSetCreatPropList params = internal::getChunckedDatasetParams(cfg);
    std::vector<data_buffer_t> default_value = internal::buildDefault(
      consumers.getConsumers());
    params.setFillValue(m_par.type, default_value.data());
 
    // create ds
    internal::throwIfExists(cfg.name, group);
    H5::CompType packed_type = buildWriteType(consumers.getConsumers());
    m_ds = group.createDataSet(cfg.name, packed_type, space, params);
    m_file_space = m_ds.getSpace();
    m_file_space.selectNone();
  }

◆ Writer() [3/5]

template<size_t N, typename I>

H5Utils::Writer< N, I >::Writer ( const Writer< N, I > & )

delete

◆ Writer() [4/5]

template<size_t N, typename I>

Writer::Writer ( Writer< N, I > && other )

noexcept

Definition at line 437 of file Writer.h.

                                             :
    Writer(std::move(other), std::unique_lock(other.m_mutex))
  {
  }

◆ ~Writer()

template<size_t N, typename I>

Writer::~Writer ( )

Definition at line 455 of file Writer.h.

                        {
    using namespace H5Utils;
    try {
      flush();
    } catch (H5::Exception& err) {
      internal::printDestructorError(err.getDetailMsg());
    } catch (std::exception& err) {
      internal::printDestructorError(err.what());
    }
  }

◆ Writer() [5/5]

template<size_t N, typename I>

Writer::Writer	(	Writer< N, I > &&	other,
		std::unique_lock< std::recursive_mutex >	other_lock )

privatenoexcept

Definition at line 443 of file Writer.h.

                                                                                 :
    m_par(other.m_par),
    m_offset(std::exchange(other.m_offset, 0)),
    m_buffer_rows(std::exchange(other.m_buffer_rows, 0)),
    m_buffer(std::exchange(other.m_buffer, {})),
    m_consumers(std::move(other.m_consumers)),
    m_ds(std::move(other.m_ds)),
    m_file_space(std::move(other.m_file_space))
  {
  }

Member Function Documentation

◆ fill()

template<size_t N, typename I>

template<typename T>

void Writer::fill ( T arg )

Definition at line 468 of file Writer.h.

                               {
    // lock witin a scope here to check the buffer size and
    // (potentially) flush, but we can release it to compute the
    // output array since that's thread local
    {
      std::lock_guard lock(m_mutex);
      if (m_buffer_rows == m_par.batch_size) {
        flush();
      }
    }
 
    // make some assertions to simplify debugging, the errors can be
    // pretty nasty wtih all these templates.
    typedef internal::CheckType<N, T, I> checkType;
    static_assert(
      checkType::depth >= N,
      "\n\n"
      " ** H5 Writer rank is greater than the depth of fill(...) input! **"
      " \n");
    static_assert(
      // Suppress cppcheck warning here. It reports that the condition
      // below is always true if `N = 0`. In N > 0 cases this
      // condition might be false though, so I consider this a
      // spurious warning.
      //
      //     <3 Dan Guest, 2024-07-16 <3
      //
      // cppcheck-suppress incorrectLogicOperator
      !(checkType::any_type && !checkType::ok_type),
      "\n\n"
      " ** H5 Writer input type matches fill(...), but rank is incorrect! **"
      " \n");
    static_assert(
      checkType::any_type,
      "\n\n"
      " ** H5 Writer input type doesn't match input for fill(...)! **"
      " \n");
 
    internal::DataFlattener<N, decltype(m_consumers), T> buf(
      m_consumers, std::move(arg), m_par.extent);
    hsize_t n_el = buf.element_offsets.size();
    std::vector<hsize_t> elements;
 
    // lock again here since we're done with the local stuff: there's
    // some access to class variables below which we need to do one
    // thread at a time.
    std::lock_guard lock(m_mutex);
    for (const auto& el_local: buf.element_offsets) {
      std::array<hsize_t, N+1> el_global;
      el_global[0] = m_offset + m_buffer_rows;
      std::copy(el_local.begin(), el_local.end(), el_global.begin() + 1);
      elements.insert(elements.end(), el_global.begin(), el_global.end());
    }
    if (n_el > 0) {
      m_file_space.selectElements(H5S_SELECT_APPEND, n_el, elements.data());
    }
    m_buffer.insert(m_buffer.end(), buf.buffer.begin(), buf.buffer.end());
    m_buffer_rows++;
  }

◆ flush()

template<size_t N, typename I>

void Writer::flush ( )

Definition at line 529 of file Writer.h.

                           {
    std::lock_guard lock(m_mutex);
    const hsize_t buffer_size = m_buffer_rows;
    if (buffer_size == 0) return;
 
    // extend the ds
    std::vector<hsize_t> total_dims{buffer_size + m_offset};
    total_dims.insert(total_dims.end(),
                      m_par.extent.begin(),
                      m_par.extent.end());
    m_ds.extend(total_dims.data());
    m_file_space.setExtentSimple(total_dims.size(), total_dims.data());
 
    // write out
    hsize_t n_buffer_pts = m_buffer.size() / m_consumers.size();
    assert(m_file_space.getSelectNpoints() >= 0);
    assert(static_cast<hsize_t>(m_file_space.getSelectNpoints())
           == n_buffer_pts);
    H5::DataSpace mem_space(1, &n_buffer_pts);
    m_ds.write(m_buffer.data(), m_par.type, mem_space, m_file_space);
    m_offset += buffer_size;
    m_buffer.clear();
    m_buffer_rows = 0;
    m_file_space.selectNone();
  }

◆ index()

template<size_t N, typename I>

size_t Writer::index ( ) const

Definition at line 556 of file Writer.h.

                                   {
    return m_buffer_rows + m_offset;
  }

The documentation for this class was generated from the following file:

Writer.h

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ configuration_type

◆ consumer_type

◆ function_type

◆ input_type

Constructor & Destructor Documentation

◆ Writer() [1/5]

◆ Writer() [2/5]

◆ Writer() [3/5]

◆ Writer() [4/5]

◆ ~Writer()

◆ Writer() [5/5]

Member Function Documentation

◆ fill()

◆ flush()

◆ index()

◆ operator=()

Member Data Documentation

◆ m_buffer

◆ m_buffer_rows

◆ m_consumers

◆ m_ds

◆ m_file_space

◆ m_mutex

◆ m_offset

◆ m_par