ATLAS Offline Software: H5Utils::Writer< N, I > Class Template Reference

ATLAS Offline Software

Loading...

Searching...

No Matches

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

Detailed Description

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

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 350 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 371 of file Writer.h.

◆ consumer_type

template<size_t N, typename I>

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

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

◆ input_type

template<size_t N, typename I>

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

Definition at line 368 of file Writer.h.

Constructor & Destructor Documentation

◆ Writer() [1/4]

template<size_t N, typename I>

H5Utils::Writer< N, I >::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 383 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>

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

Definition at line 399 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>

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

Definition at line 432 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 H5Utils::Writer< N, I >::fill ( T arg )

Definition at line 445 of file Writer.h.

                               {
    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;
    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 H5Utils::Writer< N, I >::flush ( )

Definition at line 495 of file Writer.h.

                           {
    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 H5Utils::Writer< N, I >::index ( ) const

Definition at line 521 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 376 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 375 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 377 of file Writer.h.

◆ m_ds

template<size_t N, typename I>

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

private

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

◆ m_offset

template<size_t N, typename I>

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

private

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

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

Writer.h