H5Utils::Writer< N, I > Class Template Reference

Writer. More...

#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 &&)=default
Writer &	operator= (Writer &)=delete
	~Writer ()
template<typename T>
void	fill (T)
void	flush ()
size_t	index () const

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 351 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 372 of file Writer.h.

consumer_type

template<size_t N, typename I>

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

Definition at line 368 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 371 of file Writer.h.

input_type

template<size_t N, typename I>

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

Definition at line 369 of file Writer.h.

Constructor & Destructor Documentation

Writer() [1/4]

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 385 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/4]

template<size_t N, typename I>

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

Definition at line 401 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/4]

template<size_t N, typename I>

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

delete

Writer() [4/4]

template<size_t N, typename I>

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

default

~Writer()

template<size_t N, typename I>

Writer::~Writer

(

)

Definition at line 434 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());
    }
  }

Member Function Documentation

fill()

template<size_t N, typename I>

template<typename T>

void Writer::fill

(

T

arg

)

Definition at line 447 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 508 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 535 of file Writer.h.

                                   {
    return m_buffer_rows + m_offset;
  }

operator=()

template<size_t N, typename I>

Writer & H5Utils::Writer< N, I >::operator= ( Writer< N, I > & )

delete

Member Data Documentation

m_buffer

template<size_t N, typename I>

std::vector<internal::data_buffer_t> H5Utils::Writer< N, I >::m_buffer

private

Definition at line 377 of file Writer.h.

m_buffer_rows

template<size_t N, typename I>

hsize_t H5Utils::Writer< N, I >::m_buffer_rows

private

Definition at line 376 of file Writer.h.

m_consumers

template<size_t N, typename I>

std::vector<SharedConsumer<I> > H5Utils::Writer< N, I >::m_consumers

private

Definition at line 378 of file Writer.h.

m_ds

template<size_t N, typename I>

H5::DataSet H5Utils::Writer< N, I >::m_ds

private

Definition at line 379 of file Writer.h.

m_file_space

template<size_t N, typename I>

H5::DataSpace H5Utils::Writer< N, I >::m_file_space

private

Definition at line 380 of file Writer.h.

m_mutex

template<size_t N, typename I>

std::recursive_mutex H5Utils::Writer< N, I >::m_mutex

private

Definition at line 381 of file Writer.h.

m_offset

template<size_t N, typename I>

hsize_t H5Utils::Writer< N, I >::m_offset

private

Definition at line 375 of file Writer.h.

m_par

template<size_t N, typename I>

const internal::DSParameters<I,N> H5Utils::Writer< N, I >::m_par

private

Definition at line 374 of file Writer.h.

---

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

• Writer.h