estimate memory

Author: GiggleLiu

docs/src/performancetips.md

@@ -49,6 +49,17 @@ julia> sizeof(TruncatedPoly{5,Float64,Float64})
 48
 ```
 
+One can use [`estimate_memory`](@ref) to get a good estimation of peak memory in bytes.
+```julia
+julia> estimate_memory(problem, GraphPolynomial(; method=:finitefield))
+297616
+
+julia> estimate_memory(problem, GraphPolynomial(; method=:polynomial))
+71427840
+```
+It means one only needs 298 KB memory to find the graph polynomial with the finite field approach,
+but needs 71 MB memory to find the graph polynomial using the [`Polynomial`](@ref) type.
+
 !!! note
     * The actual run time memory can be several times larger than the size of the maximum tensor.
     There is no constant bound for the factor, an empirical value for it is 3x.

docs/src/ref.md

@@ -105,6 +105,7 @@ getixsv
 getiyv
 timespace_complexity
 timespacereadwrite_complexity
+estimate_memory
 @ein_str
 GreedyMethod
 TreeSA

src/interfaces.jl

@@ -392,19 +392,29 @@ Memory estimation in number of bytes to compute certain `property` of a `problem
 `T` is the base type.
 """
 function estimate_memory(problem::GraphProblem, property::AbstractProperty; T=Float64)
-    if property isa SingleConfigMax{true} || property isa SingleConfigMin{true}
-        # TODO: fix this
-        @warn "The estimation of memory might be unreliable for the bounded computation of a single solution due to the caching."
-    end
-    estimate_memory(tensor_element_type(T, length(labels(problem)), nflavor(problem), property), problem)
+    _estimate_memory(tensor_element_type(T, length(labels(problem)), nflavor(problem), property), problem)
+end
+function estimate_memory(problem::GraphProblem, ::Union{SingleConfigMax{true},SingleConfigMin{true}}; T=Float64)
+    tc, sc, rw = timespacereadwrite_complexity(problem.code, _size_dict(problem))
+    # caching all tensors is equivalent to counting the total number of writes
+    return ceil(Int, exp2(rw - 1)) * sizeof(Tropical{T})
+end
+function estimate_memory(problem::GraphProblem, ::GraphPolynomial{:polynomial}; T=Float64)
+    # this is the upper bound
+    return peak_memory(problem.code, _size_dict(problem)) * (sizeof(T) * length(labels(problem)))
+end
+
+function _size_dict(problem)
+    lbs = labels(problem)
+    nf = nflavor(problem)
+    return Dict([lb=>nf for lb in lbs])
 end
-function estimate_memory(::Type{ET}, problem::GraphProblem) where ET
+
+function _estimate_memory(::Type{ET}, problem::GraphProblem) where ET
     if !isbitstype(ET) && !(ET <: Mod)
         @warn "Target tensor element type `$ET` is not a bits type, the estimation of memory might be unreliable."
     end
-    lbs = labels(problem)
-    nf = nflavor(problem)
-    return peak_memory(problem.code, Dict([lb=>nf for lb in lbs])) * sizeof(ET)
+    return peak_memory(problem.code, _size_dict(problem)) * sizeof(ET)
 end
 
 for (PROP, ET) in [(:SizeMax, :(Tropical{T})), (:SizeMin, :(Tropical{T})),

test/interfaces.jl

@@ -192,6 +192,7 @@ end
         @show property
         ET = GraphTensorNetworks.tensor_element_type(Float32, 10, 2, property)
         @test eltype(solve(gp, property, T=Float32)) <: ET
+        @test estimate_memory(gp, property) isa Integer
     end
     @test GraphTensorNetworks.tensor_element_type(Float32, 10, 2, GraphPolynomial(method=:polynomial)) == Polynomial{Float32, :x}
     @test sizeof(GraphTensorNetworks.tensor_element_type(Float32, 10, 2, GraphPolynomial(method=:fitting))) == 4
@@ -201,4 +202,8 @@ end
     @test GraphTensorNetworks.tensor_element_type(Float32, 10, 2, SingleConfigMin(;bounded=true)) == Tropical{Float32}
 
     @test estimate_memory(gp, SizeMax()) * 2 == estimate_memory(gp, CountingMax())
+    @test estimate_memory(gp, SingleConfigMax(bounded=true)) > estimate_memory(gp, SingleConfigMax(bounded=false))
+    @test estimate_memory(gp, ConfigsMax(bounded=true)) == estimate_memory(gp, SingleConfigMax(bounded=false))
+    @test estimate_memory(gp, GraphPolynomial(method=:fitting); T=Float32) * 4 == estimate_memory(gp, GraphPolynomial(method=:fft))
+    @test estimate_memory(gp, GraphPolynomial(method=:finitefield)) * 10 == estimate_memory(gp, GraphPolynomial(method=:polynomial); T=Float32)
 end