Tuner.BaseParam (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.router.Tuner.BaseParam

All Implemented Interfaces:
Tuner.TunableParam
Enclosing class:
Tuner
```
abstract static class Tuner.BaseParam
extends Object
implements Tuner.TunableParam
```
Base class for tunable params with history tracking and auto-revert.
Each param wraps a single router configuration value. The tuning loop reads an observed stat, computes a target, and applies it:
```
   observed = getObservedStat()
   target   = computeTarget(observed)
   target   = clamp(target, min, max)
   target   = dampenByHealth(target, current)
   target   = accelerateRollback(target, current, defaultValue)
   applyValue(target)
 
```
Min/max/step ranges are stored in autotune.config and can be changed at runtime via the console UI (no restart needed). Factory defaults are captured on first run and persisted for auto-revert when system health is degraded.
Thread safety: all fields are accessed only from the Tuner timer thread, except _override and _autoTuning which are set from the console form handler.

Field Summary

Fields
Modifier and Type	Field and Description
`protected Tuner.AutotuneConfig`	`_autotune` Autotune profile for this tunable parameter.
`protected boolean`	`_autoTuning` Whether autotuning is active for this parameter.
`protected RouterContext`	`_ctx` Router context.
`protected int`	`_defaultMax` Default maximum value from code or config.
`protected int`	`_defaultMin` Default minimum value from code or config.
`protected int`	`_defaultStep` Default step/increment size for adjustments.
`protected int`	`_defaultValue` Factory default: value before any tuning.
`protected String`	`_description` Human-readable label for display in the Tuner UI.
`protected boolean`	`_firstTick` True until first update() call — applies persisted value from autotune.config.
`protected Tuner.SystemHealth`	`_health` Health score and subsystem for autotune decisions.
`protected int`	`_historyCount` Number of valid entries in _valueHistory / _statHistory.
`protected int`	`_initialValue` Last known value (from persistence or runtime default).
`protected Log`	`_log` Class logger.
`protected int`	`_max` Current maximum value (may differ from default after tuning).
`protected int`	`_min` Current minimum value (may differ from default after tuning).
`protected String`	`_name` Internal config property key (e.g.
`protected int`	`_override` User-set override value, or Integer.MIN_VALUE if unset.
`protected String`	`_propPrefix` Config key prefix for property lookups.
`(package private) static Tuner.AutotuneConfig`	`_sharedAutotune` Shared instance — set once in Tuner constructor, used by all BaseParams
`protected double[]`	`_statHistory` Rolling window of recent stat values for trend analysis.
`protected String`	`_statName` Router stat name for observed value feedback.
`protected int`	`_step` Current step/increment size (may differ from default).
`protected String`	`_subsystem` Subsystem identifier this parameter belongs to.
`protected int[]`	`_valueHistory` Rolling window of recent tunable values for trend analysis.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`BaseParam(String name, String description, String subsystem, int defaultMin, int defaultMax, int defaultStep, String statName, RouterContext ctx)`
`protected`	`BaseParam(String name, String description, String subsystem, int defaultMin, int defaultMax, int defaultStep, String statName, RouterContext ctx, Tuner.AutotuneConfig autotune)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected abstract void`	`applyValue(int value)`
`protected static int`	`clamp(int current, int target, int step)` Move from current toward target, but at most one step per cycle.
`protected abstract int`	`computeTarget(double observed)`
`protected double`	`getAdditionalEventCount(RouterContext ctx, String statName)` Fetch the event count for an additional stat using the 60s period.
`protected double`	`getAdditionalEventCountHourly(RouterContext ctx, String statName)` Fetch the event count for an additional stat using the 1-hour period.
`protected double`	`getAdditionalStat(RouterContext ctx, String statName)` Fetch an additional stat value for cross-reference decisions.
`protected double`	`getAdditionalStat5Min(RouterContext ctx, String statName)` Fetch an additional stat value using the 5-minute average.
`protected double`	`getAdditionalStatHourly(RouterContext ctx, String statName)` Fetch an additional stat value using the 1-hour average.
`protected double`	`getAdditionalStatLong(RouterContext ctx, String statName)` Fetch an additional stat value using the 10-minute average.
`protected double`	`getBuildSuccessRate(RouterContext ctx)` Compute actual tunnel build success rate from event counts.
`protected double`	`getCoDelDropEventCount(RouterContext ctx, String prefix)` Fetch the total CoDel drop event count across all priority levels.
`int`	`getCurrentValue()` Current value.
`protected int`	`getDefaultMax(RouterContext ctx)` Effective default max — override for bandwidth-scaled params.
`protected int`	`getDefaultMin(RouterContext ctx)` Effective default min — override for bandwidth-scaled params.
`protected int`	`getDefaultStep(RouterContext ctx)` Effective default step — override for bandwidth-scaled params.
`int`	`getDefaultValue()` Default value.
`String`	`getDescription()` Param description.
`protected static int`	`getHeavyTransitThreshold(RouterContext ctx)` Transit bandwidth threshold for "heavy" — 80% of configured share bandwidth.
`int`	`getMax()` Maximum value.
`protected double`	`getMessageReceiverUtilization(RouterContext ctx)` UDP message receiver pool utilization (0.0-1.0).
`int`	`getMin()` Minimum value.
`String`	`getName()` Param name.
`protected double`	`getObservedRTT(RouterContext ctx, String primaryStat)` Fetch observed RTT, falling back to `udp.sendConfirmTime` when the primary stat has no events (lightly loaded router).
`protected abstract double`	`getObservedStat(RouterContext ctx)`
`protected double`	`getPacketHandlerUtilization(RouterContext ctx)` UDP packet handler pool utilization (0.0-1.0).
`protected double`	`getPumperUtilization(RouterContext ctx)` Tunnel pumper pool utilization (0.0-1.0).
`protected double`	`getReaderUtilization(RouterContext ctx)` NTCP reader pool utilization (0.0-1.0).
`protected abstract int`	`getRuntimeValue()`
`protected double`	`getSendFinisherUtilization(RouterContext ctx)` NTCP send finisher pool utilization (0.0-1.0).
`protected static int`	`getShareBps(RouterContext ctx)` Current share bandwidth in bytes per second.
`double[]`	`getStatHistory()` Sparkline stat history.
`int`	`getStep()` Step size.
`String`	`getSubsystem()` Subsystem name.
`protected static int`	`getSustainedHeavyTransitThreshold(RouterContext ctx)` Transit bandwidth threshold for "sustained heavy" — 50% of configured share.
`int[]`	`getValueHistory()` Sparkline value history.
`protected double`	`getWriterUtilization(RouterContext ctx)` NTCP writer pool utilization (0.0-1.0).
`boolean`	`isAutoTuning()` Whether auto-tuning is enabled.
`protected void`	`persistValue(RouterContext ctx, int value)` Persist a tuned value to autotune.config.
`protected static int`	`reclaimIfIdle(double utilization, int current, int min, double idleThreshold)` Reclaim parked threads from a thread pool that is massively under-utilized.
`protected void`	`recordHistory(double observed)` Record history.
`void`	`refreshDefault(RouterContext ctx)` Re-read the default value from autotune.config — live update after form save.
`void`	`refreshRanges(RouterContext ctx)` Re-read min/max/step from autotune.config — live update, no restart.
`(package private) void`	`setHealth(Tuner.SystemHealth health)` The current system health score for this update cycle.
`void`	`setOverride(int value)` Set a manual override value.
`Tuner.ParamSnapshot`	`snapshot()` Capture snapshot of current tunable state for display.
`void`	`update()` Main tuning loop for this param.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - _autotune
```
protected final Tuner.AutotuneConfig _autotune
```
    Autotune profile for this tunable parameter.
  - _autoTuning
```
protected volatile boolean _autoTuning
```
    Whether autotuning is active for this parameter.
  - _ctx
```
protected final RouterContext _ctx
```
    Router context.
  - _defaultMax
```
protected final int _defaultMax
```
    Default maximum value from code or config.
  - _defaultMin
```
protected final int _defaultMin
```
    Default minimum value from code or config.
  - _defaultStep
```
protected final int _defaultStep
```
    Default step/increment size for adjustments.
  - _defaultValue
```
protected int _defaultValue
```
    Factory default: value before any tuning. Persisted on first run for auto-revert.
  - _description
```
protected final String _description
```
    Human-readable label for display in the Tuner UI.
  - _firstTick
```
protected boolean _firstTick
```
    True until first update() call — applies persisted value from autotune.config.
  - _health
```
protected Tuner.SystemHealth _health
```
    Health score and subsystem for autotune decisions.
  - _historyCount
```
protected int _historyCount
```
    Number of valid entries in _valueHistory / _statHistory.
  - _initialValue
```
protected final int _initialValue
```
    Last known value (from persistence or runtime default). Used as tuning baseline.
  - _log
```
protected final Log _log
```
    Class logger.
  - _max
```
protected int _max
```
    Current maximum value (may differ from default after tuning).
  - _min
```
protected int _min
```
    Current minimum value (may differ from default after tuning).
  - _name
```
protected final String _name
```
    Internal config property key (e.g. "i2p.tunnel.socketConnectTimeout").
  - _override
```
protected volatile int _override
```
    User-set override value, or Integer.MIN_VALUE if unset.
  - _propPrefix
```
protected final String _propPrefix
```
    Config key prefix for property lookups.
  - _sharedAutotune
```
static volatile Tuner.AutotuneConfig _sharedAutotune
```
    Shared instance — set once in Tuner constructor, used by all BaseParams
  - _statHistory
```
protected final double[] _statHistory
```
    Rolling window of recent stat values for trend analysis.
  - _statName
```
protected final String _statName
```
    Router stat name for observed value feedback.
  - _step
```
protected int _step
```
    Current step/increment size (may differ from default).
  - _subsystem
```
protected final String _subsystem
```
    Subsystem identifier this parameter belongs to.
  - _valueHistory
```
protected final int[] _valueHistory
```
    Rolling window of recent tunable values for trend analysis.
- Constructor Detail
  - BaseParam
```
protected BaseParam(String name,
                    String description,
                    String subsystem,
                    int defaultMin,
                    int defaultMax,
                    int defaultStep,
                    String statName,
                    RouterContext ctx)
```
    Parameters:
    name - internal property key (e.g. "i2p.tunnel.socketConnectTimeout")
    description - human-readable label shown in Tuner UI (e.g. "Socket connect timeout (ms)") — keep short, include unit in parens; same convention for all new params
    subsystem - subsystem identifier (e.g. "i2ptunnel", "streaming")
  - BaseParam
```
protected BaseParam(String name,
                    String description,
                    String subsystem,
                    int defaultMin,
                    int defaultMax,
                    int defaultStep,
                    String statName,
                    RouterContext ctx,
                    Tuner.AutotuneConfig autotune)
```
    Parameters:
    subsystem - subsystem identifier (e.g. "i2ptunnel", "streaming")
- Method Detail
  - applyValue
```
protected abstract void applyValue(int value)
```
    Parameters:
    value - the tunable value to apply to router configuration
  - clamp
```
protected static int clamp(int current,
                           int target,
                           int step)
```
    Move from current toward target, but at most one step per cycle. Used by computeTarget() implementations to prevent large jumps.
    Parameters:
    current - the current runtime value
    target - the desired target value
    step - the maximum change per cycle
    Returns:
    current ± step, clamped to target
  - computeTarget
```
protected abstract int computeTarget(double observed)
```
    Parameters:
    observed - current stat value
    Returns:
    target tunable value
  - getAdditionalEventCount
```
protected double getAdditionalEventCount(RouterContext ctx,
                                         String statName)
```
    Fetch the event count for an additional stat using the 60s period.
    For event-count stats where addRateData(name, 1) is called, getAdditionalStat(net.i2p.router.RouterContext, java.lang.String) returns getAverageValue() which is always 1.0 when events exist. This method returns the raw event count instead, which is the correct metric for "how many events occurred".
    Parameters:
    ctx - the router context
    statName - the stat to query
    Returns:
    the event count in the last 60s, or NaN if not available
  - getAdditionalEventCountHourly
```
protected double getAdditionalEventCountHourly(RouterContext ctx,
                                               String statName)
```
    Fetch the event count for an additional stat using the 1-hour period.
    Parameters:
    ctx - the router context
    statName - the stat to query
    Returns:
    the event count in the last hour, or NaN if not available
  - getAdditionalStat
```
protected double getAdditionalStat(RouterContext ctx,
                                   String statName)
```
    Fetch an additional stat value for cross-reference decisions.
    Cross-reference stats are used alongside the primary stat to make more informed tuning decisions. For example, a streaming param might use transport.sendProcessingTime as its primary signal but also check jobQueue.jobLag to avoid increasing load when the CPU is already saturated.
    Parameters:
    ctx - the router context
    statName - the stat to query (e.g. "jobQueue.jobLag")
    Returns:
    the 60s rolling average, or NaN if not available
  - getAdditionalStat5Min
```
protected double getAdditionalStat5Min(RouterContext ctx,
                                       String statName)
```
    Fetch an additional stat value using the 5-minute average.
    Useful for medium-term decisions that need more signal than a 60s spike but faster reaction than a 1-hour trend. For example, retransmit ratio over 5 minutes filters out transient bursts while still catching sustained loss within a minute or two.
    Parameters:
    ctx - the router context
    statName - the stat to query
    Returns:
    the 5-minute rolling average, or NaN if not available
  - getAdditionalStatHourly
```
protected double getAdditionalStatHourly(RouterContext ctx,
                                         String statName)
```
    Fetch an additional stat value using the 1-hour average.
    Useful for less time-sensitive decisions where we want to confirm a trend rather than react to a short-term spike. For example, build success rate should be checked over an hour to avoid over-reacting to a brief network glitch.
    Parameters:
    ctx - the router context
    statName - the stat to query
    Returns:
    the 1-hour rolling average, or NaN if not available
  - getAdditionalStatLong
```
protected double getAdditionalStatLong(RouterContext ctx,
                                       String statName)
```
    Fetch an additional stat value using the 10-minute average.
    The 10-minute period is a medium-term signal — slower to react than the 60s period but less prone to gaps from brief idle windows. Use this as the first fallback when the 60s stat has no recent events, since most streaming stats are registered with both ONE_MINUTE and TEN_MINUTES rates.
    Parameters:
    ctx - the router context
    statName - the stat to query
    Returns:
    the 10-minute rolling average, or NaN if not available
  - getBuildSuccessRate
```
protected double getBuildSuccessRate(RouterContext ctx)
```
    Compute actual tunnel build success rate from event counts.
    The build success/failure/timeout stats are event-count markers (addRateData(name, 100, 0)), so getAdditionalStat(net.i2p.router.RouterContext, java.lang.String)
    BuildExecutor emits these stats as 0-100 integer percentages with addRateData(name, rate, 0). The eventDuration=0 parameter is not an event count delta — event count always increments by 1 per call. getAdditionalStat(net.i2p.router.RouterContext, java.lang.String) returns getAverageValue() = average of emitted rates, which is the correct success percentage. Do NOT use getAdditionalEventCount(net.i2p.router.RouterContext, java.lang.String) here — it returns the call count (always 1.0 when all three stats are emitted together), not the rate value.
    Parameters:
    ctx - the router context
    Returns:
    success rate as 0.0–1.0, or NaN if no build events
  - getCoDelDropEventCount
```
protected double getCoDelDropEventCount(RouterContext ctx,
                                        String prefix)
```
    Fetch the total CoDel drop event count across all priority levels.
    CoDelPriorityBlockingQueue emits per-priority stats with names like codel.UDP-Sender.drop.0, codel.UDP-Sender.drop.100, etc. This method sums the event counts across all priorities.
    Parameters:
    ctx - the router context
    prefix - the stat prefix (e.g. "codel.UDP-Sender.drop")
    Returns:
    the total drop event count, or NaN if no priorities have events
  - getCurrentValue
```
public int getCurrentValue()
```
    Current value.
    Specified by:
    getCurrentValue in interface Tuner.TunableParam
    Returns:
    the current value
  - getDefaultMax
```
protected int getDefaultMax(RouterContext ctx)
```
    Effective default max — override for bandwidth-scaled params. Called by refreshRanges() instead of _defaultMax.
    Returns:
    the default max
  - getDefaultMin
```
protected int getDefaultMin(RouterContext ctx)
```
    Effective default min — override for bandwidth-scaled params. Called by refreshRanges() instead of _defaultMin.
    Returns:
    the default min
  - getDefaultStep
```
protected int getDefaultStep(RouterContext ctx)
```
    Effective default step — override for bandwidth-scaled params. Called by refreshRanges() instead of _defaultStep.
    Returns:
    the default step
  - getDefaultValue
```
public int getDefaultValue()
```
    Default value.
    Returns:
    the default value
  - getDescription
```
public String getDescription()
```
    Param description.
    Specified by:
    getDescription in interface Tuner.TunableParam
    Returns:
    the description
  - getHeavyTransitThreshold
```
protected static int getHeavyTransitThreshold(RouterContext ctx)
```
    Transit bandwidth threshold for "heavy" — 80% of configured share bandwidth. Replaces the old hardcoded 50 KB/s which was far too low for any real router.
    Returns:
    the heavy transit threshold
  - getMax
```
public int getMax()
```
    Maximum value.
    Specified by:
    getMax in interface Tuner.TunableParam
    Returns:
    the max
  - getMessageReceiverUtilization
```
protected double getMessageReceiverUtilization(RouterContext ctx)
```
    UDP message receiver pool utilization (0.0-1.0).
    Returns:
    the message receiver utilization
  - getMin
```
public int getMin()
```
    Minimum value.
    Specified by:
    getMin in interface Tuner.TunableParam
    Returns:
    the min
  - getName
```
public String getName()
```
    Param name.
    Specified by:
    getName in interface Tuner.TunableParam
    Returns:
    the name
  - getObservedRTT
```
protected double getObservedRTT(RouterContext ctx,
                                String primaryStat)
```
    Fetch observed RTT, falling back to udp.sendConfirmTime when the primary stat has no events (lightly loaded router).
    The primary stat is typically a streaming-specific metric (e.g. stream.lifetimeRTT) which only fires when active streaming connections exist. On a lightly loaded router, this may be NaN. The fallback udp.sendConfirmTime is always available when any UDP traffic is present.
    Parameters:
    ctx - the router context
    primaryStat - the streaming-specific RTT stat name
    Returns:
    the observed RTT in ms, or NaN if neither stat has events
  - getObservedStat
```
protected abstract double getObservedStat(RouterContext ctx)
```
    Parameters:
    ctx - router context
    Returns:
    observed stat value for autotuning
  - getPacketHandlerUtilization
```
protected double getPacketHandlerUtilization(RouterContext ctx)
```
    UDP packet handler pool utilization (0.0-1.0).
    Returns:
    the packet handler utilization
  - getPumperUtilization
```
protected double getPumperUtilization(RouterContext ctx)
```
    Tunnel pumper pool utilization (0.0-1.0).
    Returns:
    the pumper utilization
  - getReaderUtilization
```
protected double getReaderUtilization(RouterContext ctx)
```
    NTCP reader pool utilization (0.0-1.0).
    Returns:
    the reader utilization
  - getRuntimeValue
```
protected abstract int getRuntimeValue()
```
    Returns:
    current runtime value read from router config
  - getSendFinisherUtilization
```
protected double getSendFinisherUtilization(RouterContext ctx)
```
    NTCP send finisher pool utilization (0.0-1.0).
    Returns:
    the send finisher utilization
  - getShareBps
```
protected static int getShareBps(RouterContext ctx)
```
    Current share bandwidth in bytes per second. Useful for params whose ranges should scale with bandwidth.
    Returns:
    the share bps
  - getStatHistory
```
public double[] getStatHistory()
```
    Description copied from interface: Tuner.TunableParam
    Sparkline stat history.
    Specified by:
    getStatHistory in interface Tuner.TunableParam
    Returns:
    rolling window of recent stat values
  - getStep
```
public int getStep()
```
    Step size.
    Specified by:
    getStep in interface Tuner.TunableParam
    Returns:
    the step
  - getSubsystem
```
public String getSubsystem()
```
    Subsystem name.
    Specified by:
    getSubsystem in interface Tuner.TunableParam
    Returns:
    the subsystem
  - getSustainedHeavyTransitThreshold
```
protected static int getSustainedHeavyTransitThreshold(RouterContext ctx)
```
    Transit bandwidth threshold for "sustained heavy" — 50% of configured share.
    Returns:
    the sustained heavy transit threshold
  - getValueHistory
```
public int[] getValueHistory()
```
    Description copied from interface: Tuner.TunableParam
    Sparkline value history.
    Specified by:
    getValueHistory in interface Tuner.TunableParam
    Returns:
    rolling window of recent tunable values
  - getWriterUtilization
```
protected double getWriterUtilization(RouterContext ctx)
```
    NTCP writer pool utilization (0.0-1.0).
    Returns:
    the writer utilization
  - isAutoTuning
```
public boolean isAutoTuning()
```
    Whether auto-tuning is enabled.
    Specified by:
    isAutoTuning in interface Tuner.TunableParam
    Returns:
    whether auto tuning
  - persistValue
```
protected void persistValue(RouterContext ctx,
                            int value)
```
    Persist a tuned value to autotune.config.
    Writes are throttled: the value is marked dirty and flushed to disk at most once per 5 minutes by Tuner.AutotuneConfig.save(). This avoids excessive I/O from params that change every cycle.
    Parameters:
    ctx - the router context
    value - the new value to persist
  - reclaimIfIdle
```
protected static int reclaimIfIdle(double utilization,
                                   int current,
                                   int min,
                                   double idleThreshold)
```
    Reclaim parked threads from a thread pool that is massively under-utilized. Returns the new (shrunk) thread count when the pool utilization is below idleThreshold and more than min threads are allocated, otherwise -1 (no change).
    Utilization is the ratio of threads actively doing work to the total pool size. When this sits near zero for an extended window the extra threads are just parked — there is no point keeping them around, so we shed one (or two, when extremely idle) to track demand.
    Parameters:
    utilization - current pool utilization (0.0–1.0), or NaN
    current - current thread count
    min - minimum thread count (floor)
    idleThreshold - utilization below which threads are reclaimed
    Returns:
    shrunk count, or -1 if no change
  - recordHistory
```
protected void recordHistory(double observed)
```
    Record history.
  - refreshDefault
```
public void refreshDefault(RouterContext ctx)
```
    Re-read the default value from autotune.config — live update after form save.
    Called once per tuning cycle. When a user saves a new default via the console form, this method picks it up and uses it as the auto-revert target.
  - refreshRanges
```
public void refreshRanges(RouterContext ctx)
```
    Re-read min/max/step from autotune.config — live update, no restart.
    Called once per tuning cycle before computeTarget(). Clamps loaded ranges to constructor limits to prevent stale config values from exceeding actual setter limits. Also clamps the persisted value to the new range if it was set before a code change lowered the max.
  - setHealth
```
void setHealth(Tuner.SystemHealth health)
```
    The current system health score for this update cycle.
  - setOverride
```
public void setOverride(int value)
```
    Set a manual override value. Disables auto-tuning until cleared.
    Called from the console form handler when a user manually sets a param value. Setting value < 0 re-enables auto-tuning. The override is applied immediately via applyValue(int) and persisted to autotune.config.
    Specified by:
    setOverride in interface Tuner.TunableParam
    Parameters:
    value - the override value, or < 0 to re-enable auto-tuning
  - snapshot
```
public Tuner.ParamSnapshot snapshot()
```
    Capture snapshot of current tunable state for display.
    Specified by:
    snapshot in interface Tuner.TunableParam
    Returns:
    a snapshot of this param
  - update
```
public void update()
```
    Main tuning loop for this param. Called once per cycle (60s).
    Sequence:
    1. Read observed stat via getObservedStat(net.i2p.router.RouterContext)
    2. Record value/stat history for sparklines
    3. Skip if auto-tuning disabled or stat unavailable
    4. Auto-revert to default if system health < 0.3
    5. Compute target via computeTarget(double)
    6. Apply health-based dampening (reduces step when degraded)
    7. Clamp to [min, max]
    8. Accelerate rollback when param diverges from default
    9. Call applyValue(int) and persistValue(net.i2p.router.RouterContext, int)
    Specified by:
    update in interface Tuner.TunableParam

Class Tuner.BaseParam

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

_autotune

_autoTuning

_ctx

_defaultMax

_defaultMin

_defaultStep

_defaultValue

_description

_firstTick

_health

_historyCount

_initialValue

_log

_max

_min

_name

_override

_propPrefix

_sharedAutotune

_statHistory

_statName

_step

_subsystem

_valueHistory

Constructor Detail

BaseParam

BaseParam

Method Detail

applyValue

clamp

computeTarget

getAdditionalEventCount

getAdditionalEventCountHourly

getAdditionalStat

getAdditionalStat5Min

getAdditionalStatHourly

getAdditionalStatLong

getBuildSuccessRate

getCoDelDropEventCount

getCurrentValue

getDefaultMax

getDefaultMin

getDefaultStep

getDefaultValue

getDescription

getHeavyTransitThreshold

getMax

getMessageReceiverUtilization

getMin

getName

getObservedRTT

getObservedStat

getPacketHandlerUtilization

getPumperUtilization

getReaderUtilization

getRuntimeValue

getSendFinisherUtilization

getShareBps

getStatHistory

getStep

getSubsystem

getSustainedHeavyTransitThreshold

getValueHistory

getWriterUtilization

isAutoTuning

persistValue

reclaimIfIdle

recordHistory

refreshDefault

refreshRanges

setHealth

setOverride

snapshot

update