Simple way to get solver status

[lahwaacz]

The simple-solver example suggests to manually compute the residual norm to check if the solver has converged.

First, this is rather silly, because essentially all iterative solvers already have some internal knowledge if they converged or failed. There is no reason to recompute the residual just to check if the solver succeeded or failed. Even if I computed the residual norm and it was above my threshold, I wouldn't know if it failed due to exceeded iterations limit, time limit, numerical breakdown or something else. Is there a straightforward way to access the final solver status? I can see there is a custom-logger example, but that seems like an overkill to get just the final residual norm and iterations count.

Second, the comment is inaccurate as it says "you can measure the error of the solution", but the code computes just the residual and the true solution remains unknown.

[upsj]

We need to keep in mind the scope of our examples - they are supposed to show one limited use case. Loggers are indeed the currently intended way to access the final state of a solver or the "decisions" of stopping criteria. Alternatively, we could expose the Array<stop_status> from the solver workspace that contained the individual stopping statuses for each column. In terms of ergonomics, it's not really easy to use - auto status = exec->copy_val_to_host(solver->get_stopping_statuses().get_const_data())

The comment here describes the backward error: For the problem of finding x for given input b, the forward error is $x_{exact} - x_{computed}$, the backward error is $b_{exact} - b_{computed} = b - Ax_{computed} = r$

[lahwaacz]

I mean, can you provide an example here "on demand"? 😉 It does not have to be maintained in the examples directory, I'm sure it's still better than nothing for people who search the discussions in the future...

[lahwaacz]

I think that I figured it out. I should use the gko::log::Convergence and add it to the relevant criteria like in the iterative-refinement example.

Btw. it would be nice if there was a with_logger member so we could write something like

// Create the logger
auto logger = gko::share( gko::log::Convergence< ValueType >::create() );

// Create the solver
auto solver_factory =
      gko::solver::Cg< ValueType >::build()
         .with_criteria(
            gko::stop::Iteration::build()
               .with_max_iters( 1000 )
               .with_logger( logger )
               .on( exec ),
            gko::stop::ResidualNorm< ValueType >::build()
               .with_reduction_factor( 1e-11 )
               .with_logger( logger )
               .on( exec ) )
         .on( exec );

instead of

// Create the logger
auto logger = gko::share( gko::log::Convergence< ValueType >::create() );

// Create stopping criteria so we can add the logger
auto iter_stop = gko::share(
            gko::stop::Iteration::build()
               .with_max_iters( 1000 )
               .on( exec ) );
auto tol_stop = gko::share(
            gko::stop::ResidualNorm< ValueType >::build()
               .with_reduction_factor( 1e-11 )
               .on( exec ) );
iter_stop->add_logger( logger );
tol_stop->add_logger( logger );

// Create the solver
auto solver_factory =
      gko::solver::Cg< ValueType >::build()
         .with_criteria( iter_stop, tol_stop )
         .on( exec );

[upsj]

That's an awesome suggestion, we should definitely do this. That also makes injecting loggers into more complex hierarchies easier.

[lahwaacz]

One more related question: is it possible to easily get the quantity that is compared to the tolerance in the gko::stop::ResidualNorm and gko::stop::ImplicitResidualNorm criteria? The gko::log::Convergence logger provides get_residual, get_residual_norm and get_implicit_sq_resnorm members, but it does not provide the initial resnorm and rhs norm. When I use e.g. gko::stop::mode::rhs_norm, I would like to log the residual norm divided by the rhs_norm.