ccw.varValsAll is Ref

Author: dehann

src/Deprecated.jl

@@ -257,7 +257,7 @@ function Base.getproperty(ccw::CommonConvWrapper, f::Symbol)
     # return SingleThreaded
   elseif f == :params
     error("CommonConvWrapper.params is deprecated, use .varValsAll instead")
-    return ccw.varValsAll
+    return ccw.varValsAll[]
   elseif f == :vartypes
     @warn "CommonConvWrapper.vartypes is deprecated, use typeof.(getVariableType.(ccw.fullvariables) instead" maxlog=3
     return typeof.(getVariableType.(ccw.fullvariables))

src/Factors/LinearRelative.jl

@@ -41,6 +41,10 @@ getDimension(::InstanceType{LinearRelative{N}}) where {N} = N
 # new and simplified interface for both nonparametric and parametric
 function (s::CalcFactor{<:LinearRelative})(z, x1, x2)
   # TODO convert to distance(distance(x2,x1),z) # or use dispatch on `-` -- what to do about `.-`
+  # if s._sampleIdx < 5
+  #   @info "LinearRelative" s._sampleIdx "$z" "$x1" "$x2" s.solvefor getLabel.(s.fullvariables)
+  #   @info "in variables" pointer(getVal(s.fullvariables[s.solvefor])) getVal(s.fullvariables[s.solvefor])[1]
+  # end
   return z .- (x2 .- x1)
 end
 

src/entities/FactorOperationalMemory.jl

@@ -85,7 +85,7 @@ Related
 Base.@kwdef struct CommonConvWrapper{
   T <: AbstractFactor, 
   VT <: Tuple,
-  TP <: Tuple, 
+  TP <: Base.RefValue{<:Tuple},
   CT,
   AM <: AbstractManifold,
   HR <: HypoRecipeCompute,

src/services/CalcFactor.jl

@@ -26,7 +26,7 @@ function CalcFactor(
   ccwl::CommonConvWrapper;
   factor = ccwl.usrfnc!,
   _sampleIdx = 0,
-  _legacyParams = ccwl.varValsAll,
+  _legacyParams = ccwl.varValsAll[],
   _allowThreads = true,
   cache = ccwl.dummyCache,
   fullvariables = ccwl.fullvariables,
@@ -211,6 +211,14 @@ function _resizePointsVector!(
   return vecP
 end
 
+function _checkVarValPointers(dfg::AbstractDFG, fclb::Symbol)
+  vars = getVariable.(dfg, getVariableOrder(dfg,fclb))
+  ptrsV = pointer.(getVal.(vars))
+  ccw = _getCCW(dfg, fclb)
+  ptrsC = pointer.(ccw.varValsAll[])
+  ptrsV, ptrsC
+end
+
 """
     $(SIGNATURES)
 
@@ -228,28 +236,33 @@ Notes
 - `P = getPointType(<:InferenceVariable)`
 """
 function _createVarValsAll(
-  Xi::Vector{<:DFGVariable};
+  variables::AbstractVector{<:DFGVariable};
   solveKey::Symbol = :default,
 )
   #
   # Note, NamedTuple once upon a time created way too much recompile load on repeat solves, #1564
-  varValsAll = map(var_i->getVal(var_i; solveKey), tuple(Xi...))
+  varValsAll = map(var_i->getVal(var_i; solveKey), tuple(variables...))
+
+  for (i,vv) in enumerate(varValsAll)
+    @assert pointer(vv) == pointer(getVal(variables[i]; solveKey)) "Developer check that ccw.varValsAll pointers go to same memory as getVal(variable)"
+  end
 
   # how many points
   LEN = length.(varValsAll)
   maxlen = maximum(LEN)
   # NOTE, forcing maxlen to N results in errors (see test/testVariousNSolveSize.jl) see #105
   # maxlen = N == 0 ? maxlen : N
 
-  # allow each variable to have a different number of points, which is resized during compute here
-  # resample variables with too few kernels (manifolds points)
-  SAMP = LEN .< maxlen
-  for i = 1:length(Xi)
-    if SAMP[i]
-      Pr = getBelief(Xi[i], solveKey)
-      _resizePointsVector!(varValsAll[i], Pr, maxlen)
-    end
-  end
+  # NOTE resize! moves the pointer!!!!!!
+    # # allow each variable to have a different number of points, which is resized during compute here
+    # # resample variables with too few kernels (manifolds points)
+  # SAMP = LEN .< maxlen
+  # for i = 1:length(variables)
+  #   if SAMP[i]
+  #     Pr = getBelief(variables[i], solveKey)
+  #     _resizePointsVector!(varValsAll[i], Pr, maxlen)
+  #   end
+  # end
 
   # TODO --rather define reusable memory for the proposal
   # we are generating a proposal distribution, not direct replacement for existing memory and hence the deepcopy.
@@ -429,7 +442,7 @@ function _createCCW(
   return CommonConvWrapper(;
     usrfnc! = usrfnc,
     fullvariables,
-    varValsAll = _varValsAll,
+    varValsAll = Ref(_varValsAll),
     dummyCache = userCache,
     manifold,
     partialDims,
@@ -498,8 +511,9 @@ function _beforeSolveCCW!(
   # set the 'solvefor' variable index -- i.e. which connected variable of the factor is being computed in this convolution. 
   # ccwl.varidx[] = findfirst(==(solvefor), getLabel.(variables))
   # everybody use maxlen number of points in belief function estimation
-  maxlen = maximum((N, length.(ccwl.varValsAll)...,))
+  maxlen = maximum((N, length.(ccwl.varValsAll[])...,))
 
+  ccwl.varValsAll[] = map(s->getVal(s; solveKey), tuple(variables...))
   ## PLAN B, make deep copy of ccwl.varValsAll[ccwl.varidx[]] just before the numerical solve 
 
   # maxlen, ccwl.varidx[] = _updateParamVec(variables, solvefor, ccwl.varValsAll, N; solveKey)
@@ -558,7 +572,7 @@ function _beforeSolveCCW!(
   _setCCWDecisionDimsConv!(ccwl, getDimension(getVariableType(Xi[ccwl.varidx[]])))
 
   solveForPts = getVal(Xi[ccwl.varidx[]]; solveKey)
-  maxlen = maximum([N; length(solveForPts); length(ccwl.varValsAll[ccwl.varidx[]])])  # calcZDim(ccwl); length(measurement[1])
+  maxlen = maximum([N; length(solveForPts); length(ccwl.varValsAll[][ccwl.varidx[]])])  # calcZDim(ccwl); length(measurement[1])
 
   # FIXME do not divert Mixture for sampling
   # update ccwl.measurement values

src/services/EvalFactor.jl

@@ -42,7 +42,7 @@ function calcVariableDistanceExpectedFractional(
   sfidx::Integer,
   certainidx::AbstractVector{<:Integer};
   kappa::Real = 3.0,
-  readonlyVarVals = ccwl.varValsAll[sfidx]
+  readonlyVarVals = ccwl.varValsAll[][sfidx]
 )
   #
   varTypes = getVariableType.(ccwl.fullvariables)
@@ -54,14 +54,14 @@ function calcVariableDistanceExpectedFractional(
 
   # get mean of all fractional variables
   # ccwl.params::Vector{Vector{P}}
-  uncertainidx = setdiff(1:length(ccwl.varValsAll), certainidx)
+  uncertainidx = setdiff(1:length(ccwl.varValsAll[]), certainidx)
   dists = zeros(length(uncertainidx) + length(certainidx))
 
   dims = manifold_dimension(getManifold(varTypes[sfidx]))
 
   uncMeans = zeros(dims, length(uncertainidx))
   for (count, i) in enumerate(uncertainidx)
-    u = mean(getManifold(varTypes[i]), ccwl.varValsAll[i])
+    u = mean(getManifold(varTypes[i]), ccwl.varValsAll[][i])
     uncMeans[:, count] .= getCoordinates(varTypes[i], u)
   end
   count = 0
@@ -79,7 +79,7 @@ function calcVariableDistanceExpectedFractional(
   # also check distance to certainidx for general scale reference (workaround heuristic)
   for cidx in certainidx
     count += 1
-    cerMeanPnt = mean(getManifold(varTypes[cidx]), ccwl.varValsAll[cidx])
+    cerMeanPnt = mean(getManifold(varTypes[cidx]), ccwl.varValsAll[][cidx])
     cerMean = getCoordinates(varTypes[cidx], cerMeanPnt)
     dists[count] = norm(refMean[1:dims] - cerMean[1:dims])
   end
@@ -145,7 +145,7 @@ function computeAcrossHypothesis!(
   sfidx::Int,
   maxlen::Int,
   mani::ManifoldsBase.AbstractManifold; # maniAddOps::Tuple;
-  destinationVarVals = deepcopy(ccwl.varValsAll[sfidx]),
+  destinationVarVals = deepcopy(ccwl.varValsAll[][sfidx]),
   spreadNH::Real = 5.0,
   inflateCycles::Int = 3,
   skipSolve::Bool = false,
@@ -263,7 +263,7 @@ function _calcIPCRelative(
   sfidx_active = sum(active_mask[1:sfidx])
 
   # build a view to the decision variable memory
-  activeParams = view(ccwl.varValsAll, activeids)
+  activeParams = view(ccwl.varValsAll[], activeids)
   activeVars = Xi[active_mask]
 
   # assume gradients are just done for the first sample values
@@ -320,8 +320,8 @@ function evalPotentialSpecific(
   needFreshMeasurements::Bool = true,    # superceeds over measurement
   solveKey::Symbol = :default,
   sfidx::Integer=findfirst(==(solvefor), getLabel.(variables)),
-  destinationVarVals = deepcopy(ccwl.varValsAll[sfidx]),
-  N::Int = 0 < length(measurement) ? length(measurement) : maximum(Npts.(getBelief.(Xi, solveKey))),
+  destinationVarVals = deepcopy(ccwl.varValsAll[][sfidx]),
+  N::Int = 0 < length(measurement) ? length(measurement) : maximum(Npts.(getBelief.(variables, solveKey))),
   spreadNH::Real = 3.0,
   inflateCycles::Int = 3,
   nullSurplus::Real = 0,
@@ -353,7 +353,7 @@ function evalPotentialSpecific(
   # addOps, d1, d2, d3 = buildHybridManifoldCallbacks(manis)
   mani = getManifold(variables[sfidx])
 
-  @assert destinationVarVals !== ccwl.varValsAll[ccwl.varidx[]] "destination of evalPotential for AbstractRelative not be ccwl.varValsAll[sfidx]"
+  @assert destinationVarVals !== ccwl.varValsAll[][ccwl.varidx[]] "destination of evalPotential for AbstractRelative not be ccwl.varValsAll[sfidx]"
   @assert destinationVarVals !== getVal(variables[ccwl.varidx[]]) "destination of evalPotential for AbstractRelative not be variable.VND.val"
 
   # perform the numeric solutions on the indicated elements
@@ -390,6 +390,7 @@ function evalPotentialSpecific(
   # return ccwl.varValsAll[sfidx], ipc
 end
 
+
 # TODO `measurement` might not be properly wired up yet
 # TODO consider 1051 here to inflate proposals as general behaviour
 function evalPotentialSpecific(

src/services/NumericalCalculations.jl

@@ -349,9 +349,9 @@ function _buildCalcFactorLambdaSample(
   # DevNotes, also see new `hyporecipe` approach (towards consolidation CCW CPT FMd CF...)
 
   # build a view to the decision variable memory
-  varValsHypo = ccwl.varValsAll[ccwl.hyporecipe.activehypo]
+  varValsHypo = ccwl.varValsAll[][ccwl.hyporecipe.activehypo]
   # tup = tuple(varParams...)
-  # nms = keys(ccwl.varValsAll)[cpt_.activehypo]
+  # nms = keys(ccwl.varValsAll[])[cpt_.activehypo]
   # varValsHypo = NamedTuple{nms,typeof(tup)}(tup)
 
   # prepare fmd according to hypo selection
@@ -474,7 +474,6 @@ end
 # should only be calling a new arg list according to activehypo at start of particle
 # Try calling an existing lambda
 # sensitive to which hypo of course , see #1024
-# need to shuffle content inside .cpt.fmd as well as .varValsAll accordingly
 #
 
 function _solveCCWNumeric!(

test/testCommonConvWrapper.jl

@@ -120,10 +120,10 @@ pts = approxConv(fg, getFactor(fg, :x0x1f1), :x1)
 
 ccw = IIF._getCCW(fg, :x0x1f1)
 
-ptr_ = ccw.varValsAll[ccw.varidx[]]
+ptr_ = ccw.varValsAll[][ccw.varidx[]]
 @cast tp1[i,j] := ptr_[j][i]
 @test 90.0 < Statistics.mean(tp1) < 110.0
-ptr_ = ccw.varValsAll[1]
+ptr_ = ccw.varValsAll[][1]
 @cast tp2[i,j] := ptr_[j][i]
 @test -10.0 < Statistics.mean(tp2) < 10.0
 
@@ -135,10 +135,10 @@ initVariable!(fg, :x1, [100*ones(1) for _ in 1:100])
 
 pts = approxConv(fg, getFactor(fg, :x0x1f1), :x0)
 
-ptr_ = ccw.varValsAll[1]
+ptr_ = ccw.varValsAll[][1]
 @cast tp1[i,j] := ptr_[j][i]
 @test -10.0 < Statistics.mean(tp1) < 10.0
-ptr_ = ccw.varValsAll[2]
+ptr_ = ccw.varValsAll[][2]
 @cast tp2[i,j] := ptr_[j][i]
 @test 90.0 < Statistics.mean(tp2) < 110.0
 

test/testMixtureLinearConditional.jl

@@ -111,8 +111,8 @@ f1_ = DFG.unpackFactor(fg_, pf1)
 @show typeof(f1)
 @show typeof(f1_)
 
-@show  typeof(getSolverData(f1).fnc.varValsAll);
-@show typeof(getSolverData(f1_).fnc.varValsAll);
+@show  typeof(getSolverData(f1).fnc.varValsAll[]);
+@show typeof(getSolverData(f1_).fnc.varValsAll[]);
 
 @test DFG.compareFactor(f1, f1_, skip=[:components;:labels;:timezone;:zone;:vartypes;:fullvariables;:particleidx;:varidx])
 

test/testMultiHypo3Door.jl

@@ -33,6 +33,8 @@ x3 = 40.0
 fg = initfg()
 getSolverParams(fg).N = n_samples
 getSolverParams(fg).gibbsIters = 5
+# forcefully work with ccw.varValsAll to check the pointers are pointing to getVal.(variables)
+getSolverParams(fg).graphinit = false
 
 # Place strong prior on locations of three "doors"
 addVariable!(fg, :l0, ContinuousScalar, N=n_samples)
@@ -54,10 +56,36 @@ addVariable!(fg, :x0, ContinuousScalar, N=n_samples)
 # Make first "door" measurement
 f1 = addFactor!(fg, [:x0; :l0; :l1; :l2; :l3], LinearRelative(Normal(0, meas_noise)), multihypo=[1.0; (1/4 for _=1:4)...])
 
+# check pointers before init
+a,b = IIF._checkVarValPointers(fg, getLabel(f1))
+for i in 1:length(a)
+  @test a[i] == b[i]
+end
+
+# do init (and check that the var pointers did not change)
+doautoinit!(fg ,:l0)
+doautoinit!(fg ,:l1)
+doautoinit!(fg ,:l2)
+doautoinit!(fg ,:l3)
+
+a_,b_ = IIF._checkVarValPointers(fg, getLabel(f1))
+for i in 1:length(a)
+  @test a_[i] == b_[i]
+end
+for i in 1:length(a)
+  @test a[i] == a_[i]
+end
+for i in 1:length(a)
+  @test b[i] == b_[i]
+end
+
+
 # make sure approxConv is as expected
 @test isInitialized.(fg, [:l0;:l1;:l2;:l3]) |> all
 X0 = approxConvBelief(fg, getLabel(f1), :x0)
-# smpls = sampleFactor(fg, f1.label,200)
+# smpls = sampleFactor(fg, f1.label,10)
+
+##
 
 # should have four equal sized peaks at landmark locations
 @test 0.1 < X0([l0])[1]