Logs the final residuals and iteration counts for a batch solver. More...

#include <ginkgo/core/log/batch_logger.hpp>

Inheritance diagram for gko::batch::log::BatchConvergence< ValueType >:

Collaboration diagram for gko::batch::log::BatchConvergence< ValueType >:

Public Types
using	real_type = remove_complex< ValueType >

using	mask_type = gko::log::Logger::mask_type

Public Types inherited from gko::log::Logger
using	mask_type = gko::uint64

Public Member Functions
void	on_batch_solver_completed (const array< int > &iteration_count, const array< real_type > &residual_norm) const override

const array< int > &	get_num_iterations () const noexcept

const array< real_type > &	get_residual_norm () const noexcept

Public Member Functions inherited from gko::log::Logger
template<size_type Event, typename... Params>
std::enable_if_t< Event==0 &&(0< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==1 &&(1< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==2 &&(2< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==3 &&(3< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==4 &&(4< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==5 &&(5< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==6 &&(6< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==7 &&(7< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==8 &&(8< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==9 &&(9< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==10 &&(10< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==11 &&(11< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==12 &&(12< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==13 &&(13< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==14 &&(14< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==15 &&(15< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==16 &&(16< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==17 &&(17< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==18 &&(18< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==19 &&(19< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==20 &&(20< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==21 &&(21< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==22 &&(22< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==23 &&(23< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==24 &&(24< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==25 &&(25< event_count_max)>	on (Params &&... params) const

template<size_type Event, typename... Params>
std::enable_if_t< Event==26 &&(26< event_count_max)>	on (Params &&... params) const

virtual bool	needs_propagation () const
	Returns true if this logger, when attached to an Executor, needs to be forwarded all events from objects on this executor.

Static Public Member Functions
static std::unique_ptr< BatchConvergence >	create (const mask_type &enabled_events=gko::log::Logger::batch_solver_completed_mask)
	Creates a convergence logger. More...

Additional Inherited Members
Static Public Attributes inherited from gko::log::Logger
static constexpr size_type	event_count_max = sizeof(mask_type) * byte_size
	Maximum amount of events (bits) with the current implementation.

static constexpr mask_type	all_events_mask = ~mask_type{0}
	Bitset Mask which activates all events.

static constexpr size_type	allocation_started { 0 }

static constexpr mask_type	allocation_started_mask {mask_type{1} << 0 }

static constexpr size_type	allocation_completed { 1 }

static constexpr mask_type	allocation_completed_mask {mask_type{1} << 1 }

static constexpr size_type	free_started { 2 }

static constexpr mask_type	free_started_mask {mask_type{1} << 2 }

static constexpr size_type	free_completed { 3 }

static constexpr mask_type	free_completed_mask {mask_type{1} << 3 }

static constexpr size_type	copy_started { 4 }

static constexpr mask_type	copy_started_mask {mask_type{1} << 4 }

static constexpr size_type	copy_completed { 5 }

static constexpr mask_type	copy_completed_mask {mask_type{1} << 5 }

static constexpr size_type	operation_launched { 6 }

static constexpr mask_type	operation_launched_mask {mask_type{1} << 6 }

static constexpr size_type	operation_completed { 7 }

static constexpr mask_type	operation_completed_mask {mask_type{1} << 7 }

static constexpr size_type	polymorphic_object_create_started { 8 }

static constexpr mask_type	polymorphic_object_create_started_mask {mask_type{1} << 8 }

static constexpr size_type	polymorphic_object_create_completed { 9 }

static constexpr mask_type	polymorphic_object_create_completed_mask {mask_type{1} << 9 }

static constexpr size_type	polymorphic_object_copy_started { 10 }

static constexpr mask_type	polymorphic_object_copy_started_mask {mask_type{1} << 10 }

static constexpr size_type	polymorphic_object_copy_completed { 11 }

static constexpr mask_type	polymorphic_object_copy_completed_mask {mask_type{1} << 11 }

static constexpr size_type	polymorphic_object_deleted { 12 }

static constexpr mask_type	polymorphic_object_deleted_mask {mask_type{1} << 12 }

static constexpr size_type	linop_apply_started { 13 }

static constexpr mask_type	linop_apply_started_mask {mask_type{1} << 13 }

static constexpr size_type	linop_apply_completed { 14 }

static constexpr mask_type	linop_apply_completed_mask {mask_type{1} << 14 }

static constexpr size_type	linop_advanced_apply_started { 15 }

static constexpr mask_type	linop_advanced_apply_started_mask {mask_type{1} << 15 }

static constexpr size_type	linop_advanced_apply_completed { 16 }

static constexpr mask_type	linop_advanced_apply_completed_mask {mask_type{1} << 16 }

static constexpr size_type	linop_factory_generate_started { 17 }

static constexpr mask_type	linop_factory_generate_started_mask {mask_type{1} << 17 }

static constexpr size_type	linop_factory_generate_completed { 18 }

static constexpr mask_type	linop_factory_generate_completed_mask {mask_type{1} << 18 }

static constexpr size_type	criterion_check_started { 19 }

static constexpr mask_type	criterion_check_started_mask {mask_type{1} << 19 }

static constexpr size_type	criterion_check_completed { 20 }

static constexpr mask_type	criterion_check_completed_mask {mask_type{1} << 20 }

static constexpr size_type	iteration_complete {21}

static constexpr mask_type	iteration_complete_mask {mask_type{1} << 21}

static constexpr size_type	polymorphic_object_move_started { 22 }

static constexpr mask_type	polymorphic_object_move_started_mask {mask_type{1} << 22 }

static constexpr size_type	polymorphic_object_move_completed { 23 }

static constexpr mask_type	polymorphic_object_move_completed_mask {mask_type{1} << 23 }

static constexpr size_type	batch_linop_factory_generate_started { 24 }

static constexpr mask_type	batch_linop_factory_generate_started_mask {mask_type{1} << 24 }

static constexpr size_type	batch_linop_factory_generate_completed { 25 }

static constexpr mask_type	batch_linop_factory_generate_completed_mask {mask_type{1} << 25 }

static constexpr size_type	batch_solver_completed {26}

static constexpr mask_type	batch_solver_completed_mask {mask_type{1} << 26}

static constexpr mask_type	executor_events_mask
	Bitset Mask which activates all executor events. More...

static constexpr mask_type	operation_events_mask
	Bitset Mask which activates all operation events. More...

static constexpr mask_type	polymorphic_object_events_mask
	Bitset Mask which activates all polymorphic object events. More...

static constexpr mask_type	linop_events_mask
	Bitset Mask which activates all linop events. More...

static constexpr mask_type	linop_factory_events_mask
	Bitset Mask which activates all linop factory events. More...

static constexpr mask_type	batch_linop_factory_events_mask
	Bitset Mask which activates all batch linop factory events. More...

static constexpr mask_type	criterion_events_mask
	Bitset Mask which activates all criterion events. More...

Detailed Description

template<typename ValueType = default_precision>
class gko::batch::log::BatchConvergence< ValueType >

Logs the final residuals and iteration counts for a batch solver.

The purpose of this logger is to give simple access to standard data generated by the solver once it has converged.

Note: The final logged residuals are the implicit residuals that have been computed within the solver process. Depending on the solver algorithm, this may be significantly different from the true residual (||b - Ax||).

Member Function Documentation

◆ create()

template<typename ValueType = default_precision>

static std::unique_ptr<BatchConvergence> gko::batch::log::BatchConvergence< ValueType >::create ( const mask_type & enabled_events = gko::log::Logger::batch_solver_completed_mask )

inlinestatic

Creates a convergence logger.

This dynamically allocates the memory, constructs the object and returns an std::unique_ptr to this object. TODO: See if the objects can be pre-allocated beforehand instead of being copied in the on_<> event

Parameters

exec	the executor
enabled_events	the events enabled for this logger. By default all events.

Returns: an std::unique_ptr to the the constructed object

◆ get_num_iterations()

template<typename ValueType = default_precision>

const array<int>& gko::batch::log::BatchConvergence< ValueType >::get_num_iterations ( ) const

inlinenoexcept

Returns: The number of iterations for entire batch

◆ get_residual_norm()

template<typename ValueType = default_precision>

const array<real_type>& gko::batch::log::BatchConvergence< ValueType >::get_residual_norm ( ) const

inlinenoexcept

Returns: The residual norms for the entire batch.

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

ginkgo/core/log/batch_logger.hpp

Public Types

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

template<typename ValueType = default_precision> class gko::batch::log::BatchConvergence< ValueType >

Member Function Documentation

◆ create()

◆ get_num_iterations()

◆ get_residual_norm()

template<typename ValueType = default_precision>
class gko::batch::log::BatchConvergence< ValueType >