Merge pull request #368 from JuliaRobotics/maint/1Q20/copyusd

update solver data by field and test

Author: dehann

src/services/DFGVariable.jl

@@ -224,7 +224,7 @@ end
 """
     $SIGNATURES
 
-Return full dictionary of PPEs in a variable, recommended to rather use CRUD: [`getPPE`](@ref), 
+Return full dictionary of PPEs in a variable, recommended to rather use CRUD: [`getPPE`](@ref),
 """
 getVariablePPEDict(vari::VariableDataLevel1) = getPPEDict(vari)
 
@@ -361,34 +361,67 @@ addVariableSolverData!(dfg::AbstractDFG, sourceVariable::DFGVariable, solvekey::
 """
     $(SIGNATURES)
 Update variable solver data if it exists, otherwise add it.
+
+Notes:
+- `useCopy=true` to copy solver data and keep separate memory.
+- Use `fields` to updated only a few VND.fields while adhering to `useCopy`.
+
+Related
+
+mergeVariableSolverData!
 """
-function updateVariableSolverData!(dfg::AbstractDFG, variablekey::Symbol, vnd::VariableNodeData, solvekey::Symbol=:default)::VariableNodeData
+function updateVariableSolverData!(dfg::AbstractDFG,
+                                   variablekey::Symbol,
+                                   vnd::VariableNodeData,
+                                   solvekey::Symbol=:default,
+                                   useCopy::Bool=true,
+                                   fields::Vector{Symbol}=Symbol[]  )::VariableNodeData
+    #
     #This is basically just setSolverData
     var = getVariable(dfg, variablekey)
     if !haskey(var.solverDataDict, solvekey)
         @warn "VariableNodeData '$(solvekey)' does not exist, adding"
     end
-    #for InMemoryDFGTypes, cloud would update here
-    var.solverDataDict[solvekey] = vnd
-    return vnd
-end
 
-"""
-    $(SIGNATURES)
-Update variable solver data if it exists, otherwise add it.
-NOTE: Copies the solver data.
-"""
-updateVariableSolverData!(dfg::AbstractDFG, sourceVariable::DFGVariable, solvekey::Symbol=:default) =
-    updateVariableSolverData!(dfg, sourceVariable.label, deepcopy(getSolverData(sourceVariable, solvekey)), solvekey)
+    # for InMemoryDFGTypes do memory copy or repointing, for cloud this would be an different kind of update.
+    usevnd = useCopy ? deepcopy(vnd) : vnd
+    # should just one, or many pointers be updated?
+    if haskey(var.solverDataDict, solvekey) && isa(var.solverDataDict[solvekey], VariableNodeData) && length(fields) != 0
+      # change multiple pointers inside the VND var.solverDataDict[solvekey]
+      for field in fields
+        destField = getfield(var.solverDataDict[solvekey], field)
+        srcField = getfield(usevnd, field)
+        if isa(destField, Array) && size(destField) == size(srcField)
+          # use broadcast (in-place operation)
+          destField .= srcField
+        else
+          # change pointer of destination VND object member
+          setfield!(var.solverDataDict[solvekey], field, srcField)
+        end
+      end
+    else
+      # change a single pointer in var.solverDataDict
+      var.solverDataDict[solvekey] = usevnd
+    end
 
-"""
-    $(SIGNATURES)
-Update variable solver data if it exists, otherwise add it.
-"""
-function updateVariableSolverData!(dfg::AbstractDFG, sourceVariables::Vector{<:DFGVariable}, solvekey::Symbol=:default)
+    return var.solverDataDict[solvekey]
+end
+
+updateVariableSolverData!(dfg::AbstractDFG,
+                          sourceVariable::DFGVariable,
+                          solvekey::Symbol=:default,
+                          useCopy::Bool=true,
+                          fields::Vector{Symbol}=Symbol[] ) =
+    updateVariableSolverData!(dfg, sourceVariable.label, getSolverData(sourceVariable, solvekey), solvekey, useCopy, fields)
+
+function updateVariableSolverData!(dfg::AbstractDFG,
+                                   sourceVariables::Vector{<:DFGVariable},
+                                   solvekey::Symbol=:default,
+                                   useCopy::Bool=true,
+                                   fields::Vector{Symbol}=Symbol[]  )
     #I think cloud would do this in bulk for speed
     for var in sourceVariables
-        updateVariableSolverData!(dfg, var.label, getSolverData(var, solvekey), solvekey)
+        updateVariableSolverData!(dfg, var.label, getSolverData(var, solvekey), solvekey, useCopy, fields)
     end
 end
 

test/iifInterfaceTests.jl

@@ -281,10 +281,6 @@ end
     #make a copy and simulate external changes
     newvar = deepcopy(var1)
     getVariablePPEDict(newvar)[:default] = MeanMaxPPE(:default, [150.0], [100.0], [50.0])
-    #update
-    # mergeUpdateVariableSolverData!(dfg, newvar)
-    # mergeVariableSolverData!(getVariable(dfg,getLabel(newvar)), newvar)
-    # mergeVariableData!(getVariable(dfg,getLabel(newvar)), newvar)
     mergeVariableData!(dfg, newvar)
 
     #Check if variable is updated
@@ -297,8 +293,6 @@ end
     # Confirm they're different
     @test getVariablePPEDict(newvar) != getVariablePPEDict(var1)
     # Persist it.
-    # mergeUpdateVariableSolverData!(dfg, newvar)
-    # mergeVariableSolverData!(getVariable(dfg, getLabel(newvar)), newvar)
     mergeVariableData!(dfg, newvar)
     # Get the latest
     var1 = getVariable(dfg, :a)
@@ -313,8 +307,7 @@ end
     #confirm delete
     @test symdiff(collect(keys(getVariablePPEDict(newvar))), [:second]) == Symbol[]
     # Persist it., and test
-    mergeVariableData!(dfg, newvar)
-    # mergeUpdateVariableSolverData!(dfg, newvar)  #357 #358
+    mergeVariableData!(dfg, newvar)  #357 #358
 
     # Get the latest and confirm they're the same, :second
     var1 = getVariable(dfg, :a)

test/testBlocks.jl

@@ -568,9 +568,30 @@ function  VSDTestBlock!(fg, v1)
 
     # Update update it
     @test updateVariableSolverData!(fg, :a, vnd, :parametric) == vnd
+    # test without deepcopy
+    @test updateVariableSolverData!(fg, :a, vnd, :parametric, false) == vnd
     # Bulk copy update x0
     @test updateVariableSolverData!(fg, [v1], :default) == nothing
 
+    altVnd = vnd |> deepcopy
+    keepVnd = getSolverData(getVariable(fg, :a), :parametric) |> deepcopy
+    altVnd.inferdim = -99.0
+    retVnd = updateVariableSolverData!(fg, :a, altVnd, :parametric, false, [:inferdim;])
+    @test retVnd == altVnd
+
+    fill!(altVnd.bw, -1.0)
+    retVnd = updateVariableSolverData!(fg, :a, altVnd, :parametric, false, [:bw;])
+    @test retVnd == altVnd
+
+    altVnd.inferdim = -98.0
+    @test retVnd != altVnd
+
+    # restore without copy
+    # @show vnd.inferdim
+    @test updateVariableSolverData!(fg, :a, keepVnd, :parametric, false, [:inferdim;:bw]) == vnd
+    @test getSolverData(getVariable(fg, :a), :parametric).inferdim !=  altVnd.inferdim
+    @test getSolverData(getVariable(fg, :a), :parametric).bw !=  altVnd.bw
+
     # Delete parametric from v1
     @test deleteVariableSolverData!(fg, :a, :parametric) == vnd