[RF] Make RooAbsCachedPdf's cache lookup key stable across Evaluator paths

In the Evaluator backend, the compile-time analytical-integral
construction, doEval, and analyticalIntegralWN each queried `_cacheMgr`
with a different (or null/empty) RooArgSet, so the heavy cache content
was rebuilt on the first fit step instead of reusing the slot populated
during NLL setup.

Pin a stable `_compiledNormSet` on the cloned pdf in compileForNormSet
for doEval to use, and let analyticalIntegralWN fall back to `anaVars`
when the stored `normSet2` is empty so its key mirrors
getAnalyticalIntegralWN's. All three paths now hit the same slot.

Fixes the stressRooFit -b cpu -n 47 slowdown vs the legacy backend
(RooIntegralMorph fit with setCacheAlpha(true)).

(cherry picked from commit 50854dc)

Author: guitargeek

roofit/roofitcore/inc/RooAbsCachedPdf.h

@@ -134,6 +134,14 @@ class RooAbsCachedPdf : public RooAbsPdf {
 
   bool _disableCache = false; ///< Flag to run object in passthrough (= non-caching mode)
 
+  /// Pinned at compileForNormSet() time on the cloned cache pdf, so that
+  /// doEval() looks up the same _cacheMgr slot that getAnalyticalIntegralWN()
+  /// populates while the surrounding RooNormalizedPdf is being constructed.
+  /// Without this, the two paths used different (or null) keys and the cache
+  /// was rebuilt on the first Evaluator step of every fit.
+  mutable RooArgSet _compiledNormSet;       ///<! stable normalization set for the compiled clone
+  mutable bool _hasCompiledNormSet = false; ///<! whether _compiledNormSet has been populated
+
   ClassDefOverride(RooAbsCachedPdf,2) // Abstract base class for cached p.d.f.s
 };
 

roofit/roofitcore/src/RooAbsCachedPdf.cxx

@@ -374,7 +374,13 @@ double RooAbsCachedPdf::analyticalIntegralWN(int code, const RooArgSet* normSet,
   RooArgSet *dummy(nullptr);
   const std::vector<int> codeList = _anaReg.retrieve(code-1,allVars,anaVars,normSet2,dummy) ;
 
-  PdfCacheElem* cache = getCache(normSet2?normSet2:anaVars,false) ;
+  // Mirror getAnalyticalIntegralWN's lookup key. If the caller passed a null
+  // normSet to getAnalyticalIntegralWN, the stored normSet2 is non-null but
+  // empty; use anaVars (content-equivalent to the original allVars) instead,
+  // so that analyticalIntegralWN and getAnalyticalIntegralWN both key the
+  // _cacheMgr lookup on the same content and hit the same slot.
+  const RooArgSet *cacheNset = (normSet2 && !normSet2->empty()) ? normSet2 : anaVars;
+  PdfCacheElem *cache = getCache(cacheNset, false);
   double ret = cache->pdf()->analyticalIntegralWN(codeList[0],normSet,rangeName) ;
 
   if (codeList[1]>0) {
@@ -391,7 +397,8 @@ double RooAbsCachedPdf::analyticalIntegralWN(int code, const RooArgSet* normSet,
 
 void RooAbsCachedPdf::doEval(RooFit::EvalContext &ctx) const
 {
-   getCachePdf(_normSet)->doEval(ctx);
+   const RooArgSet *nset = _hasCompiledNormSet ? &_compiledNormSet : _normSet;
+   getCachePdf(nset)->doEval(ctx);
 }
 
 
@@ -404,6 +411,17 @@ RooAbsCachedPdf::compileForNormSet(RooArgSet const &normSet, RooFit::Detail::Com
    std::unique_ptr<RooAbsPdf> pdfClone(static_cast<RooAbsPdf *>(this->Clone()));
    ctx.compileServers(*pdfClone, {});
 
+   // Pin a stable normalization set on the clone so that doEval() and the
+   // analytical integration path triggered inside RooNormalizedPdf below hit
+   // the same _cacheMgr slot. Otherwise the analytical-integral path keys the
+   // slot on its own (local) integration variable set while doEval keys it on
+   // the unset (null) _normSet of the clone, and the heavy cache content is
+   // rebuilt on the first Evaluator step of every fit.
+   auto *cachedClone = static_cast<RooAbsCachedPdf *>(pdfClone.get());
+   cachedClone->_compiledNormSet.removeAll();
+   cachedClone->_compiledNormSet.add(normSet);
+   cachedClone->_hasCompiledNormSet = true;
+
    auto newArg = std::make_unique<RooFit::Detail::RooNormalizedPdf>(*pdfClone, normSet);
 
    // The direct servers are the cloned pdf (already compiled above) and the