Display storage allocated in the stats

src/bicgstab.jl

@@ -191,6 +191,7 @@ kwargs_bicgstab = (:c, :M, :N, :ldiv, :atol, :rtol, :itmax, :timemax, :verbose,
     if rNorm == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       solver.warm_start = false
@@ -208,6 +209,7 @@ kwargs_bicgstab = (:c, :M, :N, :ldiv, :atol, :rtol, :itmax, :timemax, :verbose,
     if next_ρ == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = false, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "Breakdown bᴴc = 0"
       solver.warm_start = false
@@ -281,6 +283,7 @@ kwargs_bicgstab = (:c, :M, :N, :ldiv, :atol, :rtol, :itmax, :timemax, :verbose,
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = false
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/bilq.jl

@@ -185,6 +185,7 @@ kwargs_bilq = (:c, :transfer_to_bicg, :M, :N, :ldiv, :atol, :rtol, :itmax, :time
       stats.niter = 0
       stats.solved = true
       stats.inconsistent = false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       solver.warm_start = false
@@ -200,6 +201,7 @@ kwargs_bilq = (:c, :transfer_to_bicg, :M, :N, :ldiv, :atol, :rtol, :itmax, :time
       stats.niter = 0
       stats.solved = false
       stats.inconsistent = false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "Breakdown bᴴc = 0"
       solver.warm_start = false
@@ -414,6 +416,7 @@ kwargs_bilq = (:c, :transfer_to_bicg, :M, :N, :ldiv, :atol, :rtol, :itmax, :time
     stats.niter = iter
     stats.solved = solved_lq || solved_cg
     stats.inconsistent = false
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/bilqr.jl

@@ -187,6 +187,7 @@ kwargs_bilqr = (:transfer_to_bicg, :atol, :rtol, :itmax, :timemax, :verbose, :hi
       stats.niter = 0
       stats.solved_primal = false
       stats.solved_dual = false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "Breakdown bᴴc = 0"
       solver.warm_start = false
@@ -489,6 +490,7 @@ kwargs_bilqr = (:transfer_to_bicg, :atol, :rtol, :itmax, :timemax, :verbose, :hi
     stats.niter = iter
     stats.solved_primal = solved_primal
     stats.solved_dual = solved_dual
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/block_gmres.jl

@@ -351,6 +351,7 @@ kwargs_block_gmres = (:M, :N, :ldiv, :restart, :reorthogonalization, :atol, :rto
     # Update stats
     stats.niter = iter
     stats.solved = solved
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/block_krylov_solvers.jl

@@ -99,7 +99,7 @@ for (KS, fun, nsol, nA, nAt, warm_start) in [
 end
 
 function ksizeof(attribute)
-  if isa(attribute, Vector{<:AbstractVector}) && !isempty(attribute)
+  if isa(attribute, Vector) && isa(eltype(attribute), Vector) && !isempty(attribute)
     # A vector of vectors is a vector of pointers in Julia.
     # All vectors inside a vector have the same size in Krylov.jl
     size_attribute = sizeof(attribute) + length(attribute) * ksizeof(attribute[1])
@@ -109,16 +109,28 @@ function ksizeof(attribute)
   return size_attribute
 end
 
-function sizeof(stats_solver :: Union{KrylovStats, KrylovSolver, BlockKrylovSolver})
-  type = typeof(stats_solver)
-  nfields = fieldcount(type)
-  storage = 0
-  for i = 1:nfields
-    field_i = getfield(stats_solver, i)
-    size_i = ksizeof(field_i)
-    storage += size_i
+# function sizeof(stats_solver :: Union{KrylovStats, KrylovSolver, BlockKrylovSolver})
+#   type = typeof(stats_solver)
+#   nfields = fieldcount(type)
+#   storage::Int = 0
+#   for i = 1:nfields
+#     field_name = fieldname(type, i)
+#     field_type::DataType = fieldtype(type, field_name)
+#     field = getfield(stats_solver, field_name)
+#     storage += ksizeof(field)::Int
+#   end
+#   return storage
+# end
+
+@generated function Base.sizeof(stats_solver::T) where T <: Union{KrylovStats, KrylovSolver, BlockKrylovSolver}
+  nfields = fieldcount(T)
+  quote
+    storage = 0
+    Base.Cartesian.@nexprs $nfields i -> begin
+     storage += ksizeof(getfield(stats_solver, i))
+    end
+    return storage
   end
-  return storage
 end
 
 """

src/car.jl

@@ -184,6 +184,7 @@ kwargs_car = (:M, :ldiv, :atol, :rtol, :itmax, :timemax, :verbose, :history, :ca
     if rNorm == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       solver.warm_start = false
@@ -259,6 +260,7 @@ kwargs_car = (:M, :ldiv, :atol, :rtol, :itmax, :timemax, :verbose, :history, :ca
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = inconsistent
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/cg.jl

@@ -169,6 +169,7 @@ kwargs_cg = (:M, :ldiv, :radius, :linesearch, :atol, :rtol, :itmax, :timemax, :v
     if γ == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       solver.warm_start = false
@@ -272,6 +273,7 @@ kwargs_cg = (:M, :ldiv, :radius, :linesearch, :atol, :rtol, :itmax, :timemax, :v
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = inconsistent
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/cg_lanczos.jl

@@ -168,6 +168,7 @@ kwargs_cg_lanczos = (:M, :ldiv, :check_curvature, :atol, :rtol, :itmax, :timemax
       stats.solved = true
       stats.Anorm = zero(T)
       stats.indefinite = false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       solver.warm_start = false
@@ -268,6 +269,7 @@ kwargs_cg_lanczos = (:M, :ldiv, :check_curvature, :atol, :rtol, :itmax, :timemax
     stats.solved = solved
     stats.Anorm = sqrt(Anorm2)
     stats.indefinite = indefinite
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/cg_lanczos_shift.jl

@@ -158,6 +158,7 @@ kwargs_cg_lanczos_shift = (:M, :ldiv, :check_curvature, :atol, :rtol, :itmax, :t
     if β == 0
       stats.niter = 0
       stats.solved = true
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       return solver
@@ -277,6 +278,7 @@ kwargs_cg_lanczos_shift = (:M, :ldiv, :check_curvature, :atol, :rtol, :itmax, :t
     # Update stats. TODO: Estimate Anorm and Acond.
     stats.niter = iter
     stats.solved = solved
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/cgls.jl

@@ -162,6 +162,7 @@ kwargs_cgls = (:M, :ldiv, :radius, :λ, :atol, :rtol, :itmax, :timemax, :verbose
     if bNorm == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       history && push!(rNorms, zero(T))
@@ -238,6 +239,7 @@ kwargs_cgls = (:M, :ldiv, :radius, :λ, :atol, :rtol, :itmax, :timemax, :verbose
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = false
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/cgne.jl

@@ -169,6 +169,7 @@ kwargs_cgne = (:N, :ldiv, :λ, :atol, :rtol, :itmax, :timemax, :verbose, :histor
     if rNorm == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       return solver
@@ -247,6 +248,7 @@ kwargs_cgne = (:N, :ldiv, :λ, :atol, :rtol, :itmax, :timemax, :verbose, :histor
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = inconsistent
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/cgs.jl

@@ -186,6 +186,7 @@ kwargs_cgs = (:c, :M, :N, :ldiv, :atol, :rtol, :itmax, :timemax, :verbose, :hist
     if rNorm == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       solver.warm_start = false
@@ -197,6 +198,7 @@ kwargs_cgs = (:c, :M, :N, :ldiv, :atol, :rtol, :itmax, :timemax, :verbose, :hist
     if ρ == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = false, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "Breakdown bᴴc = 0"
       solver.warm_start =false
@@ -285,6 +287,7 @@ kwargs_cgs = (:c, :M, :N, :ldiv, :atol, :rtol, :itmax, :timemax, :verbose, :hist
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = false
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/cr.jl

@@ -180,6 +180,7 @@ kwargs_cr = (:M, :ldiv, :radius, :linesearch, :γ, :atol, :rtol, :itmax, :timema
     if ρ == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       history && push!(ArNorms, zero(T))
@@ -223,6 +224,7 @@ kwargs_cr = (:M, :ldiv, :radius, :linesearch, :γ, :atol, :rtol, :itmax, :timema
           (verbose > 0) && @printf(iostream, "nonpositive curvature detected: pᴴAp = %8.1e and rᴴAr = %8.1e\n", pAp, ρ)
           stats.solved = solved
           stats.inconsistent = false
+          stats.storage = sizeof(solver)
           stats.timer = ktimer(start_time)
           stats.status = "nonpositive curvature"
           return solver
@@ -388,6 +390,7 @@ kwargs_cr = (:M, :ldiv, :radius, :linesearch, :γ, :atol, :rtol, :itmax, :timema
         stats.niter = iter
         stats.solved = solved
         stats.inconsistent = false
+        stats.storage = sizeof(solver)
         stats.timer = ktimer(start_time)
         stats.status = "solver encountered numerical issues"
         solver.warm_start = false
@@ -418,6 +421,7 @@ kwargs_cr = (:M, :ldiv, :radius, :linesearch, :γ, :atol, :rtol, :itmax, :timema
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = false
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/craig.jl

@@ -220,6 +220,7 @@ kwargs_craig = (:M, :N, :ldiv, :transfer_to_lsqr, :sqd, :λ, :btol, :conlim, :at
     if β₁ == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       return solver
@@ -400,6 +401,7 @@ kwargs_craig = (:M, :N, :ldiv, :transfer_to_lsqr, :sqd, :λ, :btol, :conlim, :at
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = inconsistent
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/craigmr.jl

@@ -207,6 +207,7 @@ kwargs_craigmr = (:M, :N, :ldiv, :sqd, :λ, :atol, :rtol, :itmax, :timemax, :ver
       stats.solved, stats.inconsistent = true, false
       history && push!(rNorms, β)
       history && push!(ArNorms, zero(T))
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       return solver
@@ -235,6 +236,7 @@ kwargs_craigmr = (:M, :N, :ldiv, :sqd, :λ, :atol, :rtol, :itmax, :timemax, :ver
       stats.solved, stats.inconsistent = true, false
       history && push!(rNorms, β)
       history && push!(ArNorms, zero(T))
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a minimum least-squares solution"
       return solver
@@ -392,6 +394,7 @@ kwargs_craigmr = (:M, :N, :ldiv, :sqd, :λ, :atol, :rtol, :itmax, :timemax, :ver
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = inconsistent
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/crls.jl

@@ -157,6 +157,7 @@ kwargs_crls = (:M, :ldiv, :radius, :λ, :atol, :rtol, :itmax, :timemax, :verbose
     if bNorm == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       history && push!(ArNorms, zero(T))
@@ -263,6 +264,7 @@ kwargs_crls = (:M, :ldiv, :radius, :λ, :atol, :rtol, :itmax, :timemax, :verbose
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = false
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/crmr.jl

@@ -168,6 +168,7 @@ kwargs_crmr = (:N, :ldiv, :λ, :atol, :rtol, :itmax, :timemax, :verbose, :histor
     if bNorm == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       history && push!(ArNorms, zero(T))
@@ -239,6 +240,7 @@ kwargs_crmr = (:N, :ldiv, :λ, :atol, :rtol, :itmax, :timemax, :verbose, :histor
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = inconsistent
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/diom.jl

@@ -175,6 +175,7 @@ kwargs_diom = (:M, :N, :ldiv, :reorthogonalization, :atol, :rtol, :itmax, :timem
     if rNorm == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       solver.warm_start = false
@@ -332,6 +333,7 @@ kwargs_diom = (:M, :N, :ldiv, :reorthogonalization, :atol, :rtol, :itmax, :timem
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = false
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/dqgmres.jl

@@ -175,6 +175,7 @@ kwargs_dqgmres = (:M, :N, :ldiv, :reorthogonalization, :atol, :rtol, :itmax, :ti
     if rNorm == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       solver.warm_start = false
@@ -334,6 +335,7 @@ kwargs_dqgmres = (:M, :N, :ldiv, :reorthogonalization, :atol, :rtol, :itmax, :ti
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = false
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver

src/fgmres.jl

@@ -185,6 +185,7 @@ kwargs_fgmres = (:M, :N, :ldiv, :restart, :reorthogonalization, :atol, :rtol, :i
     if β == 0
       stats.niter = 0
       stats.solved, stats.inconsistent = true, false
+      stats.storage = sizeof(solver)
       stats.timer = ktimer(start_time)
       stats.status = "x = 0 is a zero-residual solution"
       solver.warm_start = false
@@ -384,6 +385,7 @@ kwargs_fgmres = (:M, :N, :ldiv, :restart, :reorthogonalization, :atol, :rtol, :i
     stats.niter = iter
     stats.solved = solved
     stats.inconsistent = inconsistent
+    stats.storage = sizeof(solver)
     stats.timer = ktimer(start_time)
     stats.status = status
     return solver