Merge pull request #2786 from GET-R3AL/Application-Profile-Fix

Fix Application Profile graph slowdown with projected effects

Author: DarkFenX

eos/modifiedAttributeDict.py

@@ -32,6 +32,7 @@
 minLimitAttrKeyCache = {}
 maxLimitAttrKeyCache = {}
 resistanceCache = {}
+resAttrNameCache = {}
 
 
 def getAttrDefault(key, fallback=None):
@@ -48,6 +49,19 @@ def getAttrDefault(key, fallback=None):
     return default
 
 
+def getAttrNameByID(attrID):
+    # Resolve a resistance attribute ID to its name. Attribute metadata is
+    # immutable gamedata, so memoize it: gamedata query caching is disabled
+    # globally, and this runs in the hot getExtended() loop used by the graph
+    # projected-effect calculations (see minLimitAttrKeyCache above).
+    try:
+        return resAttrNameCache[attrID]
+    except KeyError:
+        attrInfo = getAttributeInfo(attrID)
+        name = resAttrNameCache[attrID] = None if attrInfo is None else attrInfo.attributeName
+        return name
+
+
 def getResistanceAttrID(modifyingItem, effect):
     # If it doesn't exist on the effect, check the modifying module's attributes.
     # If it's there, cache it and return
@@ -314,16 +328,16 @@ def __calculateValue(self, key, extraMultipliers=None, preIncAdj=None, multAdj=N
             minLimitKey = minLimitAttrKeyCache[key]
         except KeyError:
             attrInfo = getAttributeInfo(key)
-            if attrInfo is None:
-                cappingId = minLimitAttrKeyCache[key] = None
-            else:
-                cappingId = attrInfo.minAttributeID
+            cappingId = None if attrInfo is None else attrInfo.minAttributeID
             if cappingId is None:
                 minLimitKey = None
             else:
                 cappingAttrInfo = getAttributeInfo(cappingId)
                 minLimitKey = None if cappingAttrInfo is None else cappingAttrInfo.name
-                minLimitAttrKeyCache[key] = minLimitKey
+            # Always memoize the result (including None): attribute metadata is
+            # immutable, and getExtended() recomputes this in a hot loop. Missing
+            # the None case here re-queried the DB on every extended attr lookup.
+            minLimitAttrKeyCache[key] = minLimitKey
         if minLimitKey:
             minLimitValue = self[minLimitKey]
             minLimitValue = minLimitValue.value if hasattr(minLimitValue, "value") else minLimitValue
@@ -334,16 +348,13 @@ def __calculateValue(self, key, extraMultipliers=None, preIncAdj=None, multAdj=N
             maxLimitKey = maxLimitAttrKeyCache[key]
         except KeyError:
             attrInfo = getAttributeInfo(key)
-            if attrInfo is None:
-                cappingId = maxLimitAttrKeyCache[key] = None
-            else:
-                cappingId = attrInfo.maxAttributeID
+            cappingId = None if attrInfo is None else attrInfo.maxAttributeID
             if cappingId is None:
                 maxLimitKey = None
             else:
                 cappingAttrInfo = getAttributeInfo(cappingId)
                 maxLimitKey = None if cappingAttrInfo is None else cappingAttrInfo.name
-                maxLimitAttrKeyCache[key] = maxLimitKey
+            maxLimitAttrKeyCache[key] = maxLimitKey
 
         if maxLimitKey:
             maxLimitValue = self[maxLimitKey]
@@ -375,11 +386,11 @@ def __calculateValue(self, key, extraMultipliers=None, preIncAdj=None, multAdj=N
                     if not resAttrID:
                         multipliers.append(mult)
                         continue
-                    resAttrInfo = getAttributeInfo(resAttrID)
-                    if not resAttrInfo:
+                    resAttrName = getAttrNameByID(resAttrID)
+                    if not resAttrName:
                         multipliers.append(mult)
                         continue
-                    resMult = self.fit.ship.itemModifiedAttributes[resAttrInfo.attributeName]
+                    resMult = self.fit.ship.itemModifiedAttributes[resAttrName]
                     if resMult is None or resMult == 1:
                         multipliers.append(mult)
                         continue

graphs/data/fitApplicationProfile/calc/launcher.py

@@ -20,7 +20,7 @@
 import math
 from bisect import bisect_right
 
-from .projected import getProjectedParamsAtDistance
+from .projected import getProjectedParamsAtDistance, getSampleStep
 
 
 # =============================================================================
@@ -577,7 +577,7 @@ def _updateParamsWithCache(baseTgtSpeed, baseTgtSigRadius, projectedCache, dista
 
 
 def calculateTransitions(chargeData, baseTgtSpeed, baseTgtSigRadius,
-                         projectedCache, maxDistance=300000, resolution=100):
+                         projectedCache, maxDistance=300000, resolution=None):
     """
     Calculate distances where optimal missile ammo changes.
 
@@ -595,6 +595,11 @@ def calculateTransitions(chargeData, baseTgtSpeed, baseTgtSigRadius,
     if not chargeData:
         return []
 
+    # Scale the scan step with range so long-range fits don't do 25x the work
+    # for no extra fidelity (falls back to the fine 100m step for short ranges).
+    if resolution is None:
+        resolution = getSampleStep(maxDistance)
+
     transitions = []
     currentCharge = None
 

graphs/data/fitApplicationProfile/calc/optimize_ammo.py

@@ -22,7 +22,7 @@
 from logbook import Logger
 
 from .turret import calculateAppliedVolley
-from .projected import getProjectedParamsAtDistance
+from .projected import getProjectedParamsAtDistance, getSampleStep
 
 
 pyfalog = Logger(__name__)
@@ -111,7 +111,7 @@ def _updateTrackingWithCache(baseTrackingParams, projectedCache, distance):
 
 def calculateTransitions(chargeData, turretBase, baseTrackingParams,
                          projectedCache,
-                         maxDistance=300000, resolution=100):
+                         maxDistance=300000, resolution=None):
     """
     Calculate distances where optimal ammo changes.
 
@@ -135,6 +135,11 @@ def calculateTransitions(chargeData, turretBase, baseTrackingParams,
     if not chargeData:
         return []
 
+    # Scale the scan step with range so long-range fits don't do 25x the work
+    # for no extra fidelity (falls back to the fine 100m step for short ranges).
+    if resolution is None:
+        resolution = getSampleStep(maxDistance)
+
     transitions = []
     currentCharge = None
 

graphs/data/fitApplicationProfile/calc/projected.py

@@ -39,6 +39,40 @@
 )
 
 
+# =============================================================================
+# Distance Sample Step
+# =============================================================================
+
+def getSampleStep(maxDistance, minStep=100, targetPoints=300):
+    """
+    Pick a distance-scan step that scales with the range being scanned.
+
+    Several hot loops (ammo transition scanning, segment plotting) sample the
+    curve at a fixed interval from 0 to the fit's max effective range. With a
+    hardcoded step, cost grows linearly with range - a 250km fit does 25x the
+    work of a 10km fit for no extra visual fidelity.
+
+    This keeps the fine step for short-range fits (no accuracy change for the
+    common case) and coarsens it for long-range fits so the number of sampled
+    points stays roughly bounded by targetPoints.
+
+    Args:
+        maxDistance: Range to be scanned (m)
+        minStep: Finest step; also the step used for short ranges (m)
+        targetPoints: Approximate upper bound on the number of scan points
+
+    Returns:
+        Step size in meters (always a multiple of minStep, >= minStep)
+    """
+    if not maxDistance or maxDistance <= 0:
+        return minStep
+    step = maxDistance / targetPoints
+    if step <= minStep:
+        return minStep
+    # Round up to a multiple of minStep so steps stay on tidy boundaries
+    return int(math.ceil(step / minStep) * minStep)
+
+
 # =============================================================================
 # Distance-Keyed Projected Cache
 # =============================================================================

graphs/data/fitApplicationProfile/getter.py

@@ -42,7 +42,8 @@
     getVolleyAtDistance
 )
 from .calc.projected import (
-    buildProjectedCache
+    buildProjectedCache,
+    getSampleStep
 )
 from .calc.launcher import (
     getAllMultipliers as getLauncherMultipliers,
@@ -747,7 +748,7 @@ def _getCommonData(self, miscParams, src, tgt):
             baseTgtSpeed=tgtSpeed,
             baseTgtSigRadius=tgtSigRadius,
             maxDistance=maxEffectiveRange,
-            resolution=100,  # 100m intervals
+            resolution=getSampleStep(maxEffectiveRange),
             existingCache=existingCache
         )
 
@@ -908,6 +909,10 @@ def getSegments(self, xRange, miscParams, src, tgt):
         # Generate segments
         segments = []
 
+        # Scale plotting resolution with the visible range so long-range fits
+        # don't sample thousands of points (falls back to 100m for short ranges).
+        step = getSampleStep(maxX - minX)
+
         for i, transition in enumerate(validTransitions):
             transDist, _, ammoName, _ = transition
             segStart = max(transDist, minX)
@@ -921,8 +926,7 @@ def getSegments(self, xRange, miscParams, src, tgt):
             if segStart >= segEnd:
                 continue
 
-            # Generate points at fixed 100m resolution for performance
-            step = 100
+            # Generate points at the range-scaled resolution for performance
             xs, ys = [], []
             x = segStart
             while x <= segEnd: