ProfileOrganizer (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.router.peermanager.ProfileOrganizer

```
public class ProfileOrganizer
extends Object
```
Categorizes peers into performance tiers (fast, high-capacity, well-integrated) based on historical metrics from PeerProfile. Requires periodic reorganize() calls to update peer classifications for optimal tunnel selection. Tier assignment during reorganize(): 1. All profiles are iterated in capacity order (via InverseCapacityComparator) 2. Expired/unreachable/low-bandwidth peers are filtered out 3. Speed, capacity, and integration thresholds are recalculated from the active set 4. Each surviving profile is evaluated via locked_promoteProfileToTiers() 5. If fast/high-cap tiers fall below minimum thresholds, fallback passes fill gaps (with selectability checks to prevent selecting unusable peers) Concurrency: ReentrantReadWriteLock protects all tier maps. reorganize() acquires the write lock; selection methods use the read lock. getOrCreateProfileNonblocking() uses try-lock escalation for lock-free reads.

Nested Class Summary
Nested Classes
Modifier and Type Class and Description
static class ProfileOrganizer.Slice
Defines peer selection slicing modes for tier-based peer organization.

Nested Classes
Modifier and Type	Class and Description
`static class`	`ProfileOrganizer.Slice` Defines peer selection slicing modes for tier-based peer organization.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`_defaultMaxFastPeers` _defaultMaxFastPeers.
`static int`	`_defaultMaxHighCapPeers` _defaultMaxHighCapPeers.
`static int`	`_defaultMaxProfiles` Runtime-adjustable default max profile count.
`static int`	`_defaultMinFastPeers` _defaultMinFastPeers.
`static int`	`_defaultMinHighCapPeers` _defaultMinHighCapPeers.
`static int`	`ABSOLUTE_MAX_PROFILES` ABSOLUTE_MAX_PROFILES.
`static double`	`ATTACK_THRESHOLD` Threshold below which the network is considered under attack
`static int`	`DEFAULT_LOSSY_MIN_PACKETS` Default minimum packet sample size (20 = full 5% bucket resolution).
`static int`	`DEFAULT_MAX_ROUTERINFO_AGE_HOURS` DEFAULT_MAX_ROUTERINFO_AGE_HOURS.
`static int`	`DEFAULT_MINIMUM_HIGH_CAPACITY_PEERS` DEFAULT_MINIMUM_HIGH_CAPACITY_PEERS.
`static int`	`MIN_MAX_PROFILES` MIN_MAX_PROFILES.
`static String`	`PROP_LOSSY_MIN_PACKETS` Config property for the minimum number of transmitted packets before a loss ratio is reported.
`static String`	`PROP_LOSSY_MODERATE_THRESHOLD` Config property for the decayed loss score above which a peer is de-prioritized in tier selection (soft signal, below the demotion threshold).
`static String`	`PROP_LOSSY_THRESHOLD` Config property for the loss ratio above which a peer is demoted from fast/high-cap tiers.
`static String`	`PROP_LOSSY_WINDOW` Config property for how long a reported loss ratio stays fresh.
`static String`	`PROP_MAX_PROFILES` Config property for the maximum number of peer profiles.
`static String`	`PROP_MAX_ROUTERINFO_AGE_HOURS` PROP_MAX_ROUTERINFO_AGE_HOURS.
`static String`	`PROP_MAXIMUM_FAST_PEERS` PROP_MAXIMUM_FAST_PEERS.
`static String`	`PROP_MAXIMUM_HIGH_CAPACITY_PEERS` PROP_MAXIMUM_HIGH_CAPACITY_PEERS.
`static String`	`PROP_MINIMUM_FAST_PEERS` PROP_MINIMUM_FAST_PEERS.
`static String`	`PROP_MINIMUM_HIGH_CAPACITY_PEERS` PROP_MINIMUM_HIGH_CAPACITY_PEERS.

Constructor Summary
Constructors
Constructor and Description
ProfileOrganizer(RouterContext context)
Creates a profile organizer with empty tier maps and registers performance tracking statistics for peer classification.

Constructors
Constructor and Description
`ProfileOrganizer(RouterContext context)` Creates a profile organizer with empty tier maps and registers performance tracking statistics for peer classification.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`PeerProfile`	`addProfile(PeerProfile profile)` Insert a fully-constructed profile into the organizer.
`(package private) static double`	`buildSuccessRatio(Rate er, Rate rr, Rate sr, Rate erC, Rate rrC, Rate srC)` Build-success ratio from the six TEN_MINUTES rates, 1.0 when any rate is missing or the window is empty.
`(package private) static int`	`clampMaxProfiles(int maxProfiles)` Clamps the configured max-profiles value into [100, ABSOLUTE_MAX_PROFILES].
`(package private) void`	`clearProfiles()` Remove all profiles and clear all tier maps.
`int`	`countActivePeers()` Count peers with any send or hear activity in the last 4 hours.
`int`	`countActivePeersInLastHour()` Count peers with activity (send, receive, or failure) within the last hour.
`int`	`countFastPeers()` Number of peers classified as fast tier.
`int`	`countHighCapacityPeers()` Number of peers classified as high-capacity tier.
`int`	`countNotFailingPeers()` Total number of peer profiles in memory (all tiers).
`void`	`demoteIfCongested(Hash peer)` Immediately demote a peer from fast/high-cap tiers if it has a congestion cap (D/E).
`void`	`demoteIfHighLatency(Hash peer)` Immediately demote a peer from fast/high-cap tiers if its capacityBonus is -30 (UI shows ✖ for high latency).
`(package private) void`	`demoteIfHighRTT(Hash peer, long responseTimeMs)` Immediately demote a peer from fast/high-cap tiers if its tunnel test RTT exceeds the low-latency threshold (timeout * 2), matching the PeerTestJob metric.
`void`	`demoteIfLossy(Hash peer)` Instantly remove a peer from the fast/high-capacity tiers when its decayed loss score exceeds the threshold, and mark it for loss probation.
`void`	`demoteIfNoTunnel(Hash peer)` Immediately demote a peer from fast/high-cap tiers if it has G cap (no tunnels).
`void`	`demoteIfStale(Hash peer)` Immediately demote a peer from fast/high-cap tiers if its RouterInfo is stale and it has no recent proof of life (fails isSelectable).
`void`	`demoteIfUnreachable(Hash peer)` Immediately demote a peer from fast/high-cap tiers when our transport connection to it failed during tunnel build (first hop unreachable).
`(package private) void`	`evictProfilesNotInNetdb()` Evict profiles for peers no longer in the network database.
`boolean`	`exportProfile(Hash profile, OutputStream out)` Write a peer profile to the given output stream for persistence.
`float`	`getAverageLossRatio()` Average loss ratio across the fast and high-capacity tiers with a fresh measurement, as a fraction (0.0 - 1.0).
`double`	`getCapacityThreshold()` Current minimum capacity value for the high-capacity peer tier.
`static int`	`getDefaultMaxFastPeers()`
`static int`	`getDefaultMaxHighCapPeers()`
`static int`	`getDefaultMaxProfilesValue()`
`static int`	`getDefaultMinFastPeers()`
`float`	`getFastAverageLossRatio()` Average loss ratio across the fast tier with a fresh measurement, as a fraction (0.0 - 1.0); 0.0 if none.
`double`	`getFastRTTThreshold()` Average tunnel test time (RTT in ms) of the peer at the fast-tier speed boundary from the last reorganize, or 0.0 if never reorganized.
`float`	`getHighCapAverageLossRatio()` Average loss ratio across the high-capacity tier with a fresh measurement, as a fraction (0.0 - 1.0); 0.0 if none.
`double`	`getIntegrationThreshold()` Current minimum integration value for the well-integrated peer tier.
`protected int`	`getMaximumFastPeers()` Maximum number of peers to keep in the fast tier, capped by active peers.
`protected int`	`getMaximumHighCapPeers()` Maximum number of peers to keep in the high-capacity tier, capped by active peers.
`float`	`getMedianLossRatio()` Median loss ratio of the union of the fast and high-capacity tiers with a fresh measurement, as a fraction (0.0 - 1.0); 0.0 if none.
`static int`	`getMinHighCapacityPeers()`
`protected int`	`getMinimumFastPeers()` Minimum number of peers to keep in the fast tier.
`protected int`	`getMinimumHighCapacityPeers()` Minimum number of peers to keep in the high-capacity tier.
`PeerProfile`	`getOrCreateProfileNonblocking(Hash peer)` Retrieve an existing profile or create a new one, without blocking on contention.
`PeerProfile`	`getProfile(Hash peer)` Retrieve the profile for a peer, or null if unknown.
`PeerProfile`	`getProfileNonblocking(Hash peer)` Retrieve the profile for a peer without blocking.
`double`	`getSpeedThreshold()` Current minimum speed value for the fast peer tier.
`int`	`getStoredProfileCount()` Last known number of profiles stored on disk, from the most recent load, cleanup, or purge in the persistence helper.
`double`	`getTunnelBuildSuccess()` Recent tunnel build success ratio, from router statistics.
`Hash`	`getUs()` Self-exclusion hash for this router instance.
`(package private) static boolean`	`hasRecentProofOfLife(PeerProfile profile, long now)` True if the peer has shown proof of life within `PROOF_OF_LIFE_WINDOW_MS`: a successful send, heard-from, or heard-about within the last hour.
`(package private) static boolean`	`hasRecentTierActivity(PeerProfile profile, long activeCutoff)` True if the peer showed recent activity within the given cutoff: a heard-from or successful send at or after the cutoff.
`(package private) static boolean`	`isEvictable(PeerProfile profile, Map<Hash,PeerProfile> fastPeers, Map<Hash,PeerProfile> highCapPeers, long activeThreshold, int fastPeerLimit, int highCapacityLimit)` Whether a profile is eligible for eviction under the profile cap: not protected by a fast/high-cap tier slot that still has room below its limit, and no send or heard-from activity within the active window.
`(package private) boolean`	`isExcludedFromProfiling(Hash peer)` Check if a peer should be excluded from profiling.
`(package private) static boolean`	`isExpiredProfile(PeerProfile profile, long now, long expireActive, long expirePassive, long expireGossip, long expireUntracked)` Whether a profile has expired from its activity tier and should be purged: no activity (send/heard/heard-about) within the tier's expiration window.
`boolean`	`isFast(Hash peer)` Check whether a peer is classified in the fast tier.
`boolean`	`isHighCapacity(Hash peer)` Check whether a peer is classified in the high-capacity tier.
`(package private) boolean`	`isLowBandwidthTier(Hash peer)` Check if a peer is in a low bandwidth tier (K, L, M, or Unknown).
`boolean`	`isLowBuildSuccess()` Whether recent tunnel build success is below the attack threshold.
`(package private) static boolean`	`isReliableBandwidthPeer(PeerProfile profile, long now, boolean established)` Reliability gate for high-bandwidth (O/P/X tier) selection: the peer must show a tunnel acceptance ratio of at least 0.3 AND evidence of recent activity — a successful peer test within 10 minutes, a heard- from/send-success within 30 minutes, or an established commSystem connection.
`boolean`	`isSelectable(Hash peer)` Whether the given peer is eligible for selection.
`(package private) static boolean`	`isStaleAbsentPeer(PeerProfile profile, long now, long absentThreshold)` Whether the peer's last activity (send, heard-from, or heard-about) is older than the absent threshold — i.e.
`boolean`	`isWellIntegrated(Hash peer)` Check whether a peer is classified in the well-integrated tier.
`static void`	`main(String[] args)` Command-line entry point; reads profile dump files and prints thresholds.
`(package private) static boolean`	`needsTierRestore(int currentSize, int oldSize)` Whether a shrunken tier needs restoration: below half its old size and the old size was substantial.
`(package private) boolean`	`passesTierGates(PeerProfile profile, double buildSuccess, long now)` Common gate for fast/high-cap tier fill passes: the peer must be selectable, have acceptable tunnel acceptance, no recent tunnel failures, and not be in loss probation.
`boolean`	`peerSendsBadReplies(Hash peer)` Check whether a peer sends an excessive rate of invalid or failed netDb lookup replies (potential misbehavior indicator).
`void`	`purgeStaleProfileFiles()` Remove stale profile files for peers outside the active set when over the cap.
`(package private) void`	`reorganize()` Run a standard reorganize round without coalescing or decay.
`(package private) void`	`reorganize(boolean shouldCoalesce, boolean shouldDecay)` Reorganizes peer profiles into performance-based tiers (fast, high-capacity, etc.) and expires stale entries.
`void`	`selectActiveNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Select from currently connected (established) not-failing peers.
`void`	`selectActiveNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask, MaskedIPSet ipSet)` Select from currently connected peers with IP-subnet diversity.
`void`	`selectAllNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, boolean onlyNotFailing)` Select from all not-failing peers randomly, falling through to general peers if the not-failing set is insufficient.
`Set<Hash>`	`selectAllPeers()` Gather the union of all peers from fast, high-capacity, and not-failing tiers.
`void`	`selectFastPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Select up to howMany fast-tier peers, filling shortfalls from high-capacity.
`void`	`selectFastPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask, MaskedIPSet ipSet)` Select fast-tier peers with IP-subnet diversity constraints.
`void`	`selectFastPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, SessionKey randomKey, ProfileOrganizer.Slice subTierMode, int mask, MaskedIPSet ipSet)` Select fast-tier peers deterministically sliced by a random key.
`void`	`selectHighBandwidthPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Select up to howMany peers from O/P/X bandwidth tiers (high shared bandwidth) that are not failing.
`void`	`selectHighBandwidthPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, boolean onlyNotFailing, int mask, MaskedIPSet ipSet)` Select high-bandwidth peers with tier-exclusion and IP-subnet diversity.
`void`	`selectHighCapacityPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Select high-capacity peers, filling shortfalls from not-failing peers.
`void`	`selectHighCapacityPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask, MaskedIPSet ipSet)` Select high-capacity peers with IP-subnet diversity.
`void`	`selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Select from not-failing peers, excluding high-capacity tier if requested.
`void`	`selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, boolean onlyNotFailing)` Select from not-failing peers, optionally excluding the high-capacity tier.
`void`	`selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, boolean onlyNotFailing, int mask, MaskedIPSet ipSet)` Full-parameter select from not-failing peers.
`void`	`selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask, MaskedIPSet ipSet)` Select from not-failing peers with IP-subnet diversity.
`static void`	`setDefaultMaxFastPeers(int val)`
`static void`	`setDefaultMaxHighCapPeers(int val)`
`static void`	`setDefaultMaxProfiles(int val)`
`static void`	`setDefaultMinFastPeers(int val)`
`static void`	`setMinHighCapacityPeers(int val)`
`void`	`setUs(Hash us)` Store the local router hash for self-exclusion from peer selection.
`(package private) boolean`	`skipsPromotion(PeerProfile profile, Hash peer, double buildSuccess)` Whether the peer should be skipped for tier promotion: not selectable, in a strict country, low tunnel acceptance, high-latency penalty, congested, or in loss probation.
`void`	`writeProfile(PeerProfile profile)` Persist the given profile to disk.

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

- Field Detail
  - _defaultMaxFastPeers
```
public static volatile int _defaultMaxFastPeers
```
    _defaultMaxFastPeers.
  - _defaultMaxHighCapPeers
```
public static volatile int _defaultMaxHighCapPeers
```
    _defaultMaxHighCapPeers.
  - _defaultMaxProfiles
```
public static volatile int _defaultMaxProfiles
```
    Runtime-adjustable default max profile count.
  - _defaultMinFastPeers
```
public static volatile int _defaultMinFastPeers
```
    _defaultMinFastPeers.
  - _defaultMinHighCapPeers
```
public static volatile int _defaultMinHighCapPeers
```
    _defaultMinHighCapPeers.
  - ABSOLUTE_MAX_PROFILES
```
public static final int ABSOLUTE_MAX_PROFILES
```
    ABSOLUTE_MAX_PROFILES.
    See Also:
    Constant Field Values
  - ATTACK_THRESHOLD
```
public static final double ATTACK_THRESHOLD
```
    Threshold below which the network is considered under attack
    See Also:
    Constant Field Values
  - DEFAULT_LOSSY_MIN_PACKETS
```
public static final int DEFAULT_LOSSY_MIN_PACKETS
```
    Default minimum packet sample size (20 = full 5% bucket resolution).
    See Also:
    Constant Field Values
  - DEFAULT_MAX_ROUTERINFO_AGE_HOURS
```
public static final int DEFAULT_MAX_ROUTERINFO_AGE_HOURS
```
    DEFAULT_MAX_ROUTERINFO_AGE_HOURS.
    See Also:
    Constant Field Values
  - DEFAULT_MINIMUM_HIGH_CAPACITY_PEERS
```
public static final int DEFAULT_MINIMUM_HIGH_CAPACITY_PEERS
```
    DEFAULT_MINIMUM_HIGH_CAPACITY_PEERS.
    See Also:
    Constant Field Values
  - MIN_MAX_PROFILES
```
public static final int MIN_MAX_PROFILES
```
    MIN_MAX_PROFILES.
    See Also:
    Constant Field Values
  - PROP_LOSSY_MIN_PACKETS
```
public static final String PROP_LOSSY_MIN_PACKETS
```
    Config property for the minimum number of transmitted packets before a loss ratio is reported.
    See Also:
    Constant Field Values
  - PROP_LOSSY_MODERATE_THRESHOLD
```
public static final String PROP_LOSSY_MODERATE_THRESHOLD
```
    Config property for the decayed loss score above which a peer is de-prioritized in tier selection (soft signal, below the demotion threshold). Default 10%: a peer can be consistently lossy without ever crossing the hard demotion bar, and this keeps such peers out of the preferred picks without evicting them.
    See Also:
    Constant Field Values
  - PROP_LOSSY_THRESHOLD
```
public static final String PROP_LOSSY_THRESHOLD
```
    Config property for the loss ratio above which a peer is demoted from fast/high-cap tiers.
    See Also:
    Constant Field Values
  - PROP_LOSSY_WINDOW
```
public static final String PROP_LOSSY_WINDOW
```
    Config property for how long a reported loss ratio stays fresh.
    See Also:
    Constant Field Values
  - PROP_MAX_PROFILES
```
public static final String PROP_MAX_PROFILES
```
    Config property for the maximum number of peer profiles.
    See Also:
    Constant Field Values
  - PROP_MAX_ROUTERINFO_AGE_HOURS
```
public static final String PROP_MAX_ROUTERINFO_AGE_HOURS
```
    PROP_MAX_ROUTERINFO_AGE_HOURS.
    See Also:
    Constant Field Values
  - PROP_MAXIMUM_FAST_PEERS
```
public static final String PROP_MAXIMUM_FAST_PEERS
```
    PROP_MAXIMUM_FAST_PEERS.
    See Also:
    Constant Field Values
  - PROP_MAXIMUM_HIGH_CAPACITY_PEERS
```
public static final String PROP_MAXIMUM_HIGH_CAPACITY_PEERS
```
    PROP_MAXIMUM_HIGH_CAPACITY_PEERS.
    See Also:
    Constant Field Values
  - PROP_MINIMUM_FAST_PEERS
```
public static final String PROP_MINIMUM_FAST_PEERS
```
    PROP_MINIMUM_FAST_PEERS.
    See Also:
    Constant Field Values
  - PROP_MINIMUM_HIGH_CAPACITY_PEERS
```
public static final String PROP_MINIMUM_HIGH_CAPACITY_PEERS
```
    PROP_MINIMUM_HIGH_CAPACITY_PEERS.
    See Also:
    Constant Field Values
- Constructor Detail
  - ProfileOrganizer
```
public ProfileOrganizer(RouterContext context)
```
    Creates a profile organizer with empty tier maps and registers performance tracking statistics for peer classification.
    Parameters:
    context - the router context providing config, stats, and log access
- Method Detail
  - addProfile
```
public PeerProfile addProfile(PeerProfile profile)
```
    Insert a fully-constructed profile into the organizer. The profile is added to the not-failing set and high-capacity tier if it meets the current capacity threshold.
    Parameters:
    profile - the profile to add
    Returns:
    the previous profile for the same peer, or null if none existed
  - buildSuccessRatio
```
static double buildSuccessRatio(Rate er,
                                Rate rr,
                                Rate sr,
                                Rate erC,
                                Rate rrC,
                                Rate srC)
```
    Build-success ratio from the six TEN_MINUTES rates, 1.0 when any rate is missing or the window is empty.
    Parameters:
    er - exploratory expire rate
    rr - exploratory reject rate
    sr - exploratory success rate
    erC - client expire rate
    rrC - client reject rate
    srC - client success rate
    Returns:
    the ratio in [0.0, 1.0], 1.0 when no data
  - clampMaxProfiles
```
static int clampMaxProfiles(int maxProfiles)
```
    Clamps the configured max-profiles value into [100, ABSOLUTE_MAX_PROFILES].
    Pure decision — no context access, safe for unit tests.
    Parameters:
    maxProfiles - the configured or default value
    Returns:
    the clamped value
  - clearProfiles
```
void clearProfiles()
```
    Remove all profiles and clear all tier maps. Package-private: only called from tests and router shutdown paths.
  - countActivePeers
```
public int countActivePeers()
```
    Count peers with any send or hear activity in the last 4 hours.
    Returns:
    active peer count (read-lock protected)
  - countActivePeersInLastHour
```
public int countActivePeersInLastHour()
```
    Count peers with activity (send, receive, or failure) within the last hour.
    Returns:
    recently active peer count (read-lock protected)
  - countFastPeers
```
public int countFastPeers()
```
    Number of peers classified as fast tier.
    Returns:
    fast peer count (read-lock protected)
  - countHighCapacityPeers
```
public int countHighCapacityPeers()
```
    Number of peers classified as high-capacity tier.
    Returns:
    high-capacity peer count (read-lock protected)
  - countNotFailingPeers
```
public int countNotFailingPeers()
```
    Total number of peer profiles in memory (all tiers).
    Returns:
    profile count (read-lock protected)
  - demoteIfCongested
```
public void demoteIfCongested(Hash peer)
```
    Immediately demote a peer from fast/high-cap tiers if it has a congestion cap (D/E). Sets capacityBonus = -30 so the UI reflects the demotion immediately. Non-blocking - only acts if the peer is currently in those tiers.
  - demoteIfHighLatency
```
public void demoteIfHighLatency(Hash peer)
```
    Immediately demote a peer from fast/high-cap tiers if its capacityBonus is -30 (UI shows ✖ for high latency). Non-blocking.
  - demoteIfHighRTT
```
void demoteIfHighRTT(Hash peer,
                     long responseTimeMs)
```
    Immediately demote a peer from fast/high-cap tiers if its tunnel test RTT exceeds the low-latency threshold (timeout * 2), matching the PeerTestJob metric. Uses the immediate test result rather than the smoothed average for instant action. Sets capacityBonus = -30 so the UI reflects the demotion immediately. Non-blocking - only acts if the peer is currently in those tiers.
  - demoteIfLossy
```
public void demoteIfLossy(Hash peer)
```
    Instantly remove a peer from the fast/high-capacity tiers when its decayed loss score exceeds the threshold, and mark it for loss probation. Called from the transport path via ProfileManagerImpl so a lossy peer is demoted as soon as its retransmit ratio crosses the bar, instead of waiting for the next reorganize cycle. Non-blocking: if a reorganize currently holds the write lock, the reorganize purge catches the peer instead.
    Parameters:
    peer - the peer
  - demoteIfNoTunnel
```
public void demoteIfNoTunnel(Hash peer)
```
    Immediately demote a peer from fast/high-cap tiers if it has G cap (no tunnels). Sets capacityBonus = -30 so the UI reflects the demotion immediately. Non-blocking - only acts if the peer is currently in those tiers.
  - demoteIfStale
```
public void demoteIfStale(Hash peer)
```
    Immediately demote a peer from fast/high-cap tiers if its RouterInfo is stale and it has no recent proof of life (fails isSelectable). Non-blocking — only acts if the peer is currently in those tiers.
  - demoteIfUnreachable
```
public void demoteIfUnreachable(Hash peer)
```
    Immediately demote a peer from fast/high-cap tiers when our transport connection to it failed during tunnel build (first hop unreachable). Uses a 3-strike threshold to avoid premature demotion — transient failures (e.g. pre-connect race) should not remove peers from tiers. Increments the tunnel failure count so the profile's long-term rating also reflects the issue.
  - evictProfilesNotInNetdb
```
void evictProfilesNotInNetdb()
```
    Evict profiles for peers no longer in the network database. Keeps profile files on disk — they'll be reloaded if the peer reappears. Acquires the write lock.
  - exportProfile
```
public boolean exportProfile(Hash profile,
                             OutputStream out)
                      throws IOException
```
    Write a peer profile to the given output stream for persistence.
    Parameters:
    profile - the router hash identifying the profile to export
    out - the destination stream for the serialized profile
    Returns:
    true if the profile was found and written, false if no profile exists
    Throws:
    IOException - on write errors
  - getAverageLossRatio
```
public float getAverageLossRatio()
```
    Average loss ratio across the fast and high-capacity tiers with a fresh measurement, as a fraction (0.0 - 1.0). Peers whose loss data is older than PROP_LOSSY_WINDOW are skipped; 0.0 if no fresh data. The tiers are the baseline because the threshold governs demotion FROM them: as lossy peers are evicted the average drops and the bar tightens. Used by the Tuner to adapt PROP_LOSSY_THRESHOLD to the network.
  - getCapacityThreshold
```
public double getCapacityThreshold()
```
    Current minimum capacity value for the high-capacity peer tier.
    Returns:
    the capacity threshold computed during the last reorganize
  - getDefaultMaxFastPeers
```
public static int getDefaultMaxFastPeers()
```
  - getDefaultMaxHighCapPeers
```
public static int getDefaultMaxHighCapPeers()
```
  - getDefaultMaxProfilesValue
```
public static int getDefaultMaxProfilesValue()
```
  - getDefaultMinFastPeers
```
public static int getDefaultMinFastPeers()
```
  - getFastAverageLossRatio
```
public float getFastAverageLossRatio()
```
    Average loss ratio across the fast tier with a fresh measurement, as a fraction (0.0 - 1.0); 0.0 if none. See getAverageLossRatio().
  - getFastRTTThreshold
```
public double getFastRTTThreshold()
```
    Average tunnel test time (RTT in ms) of the peer at the fast-tier speed boundary from the last reorganize, or 0.0 if never reorganized.
    Returns:
    the boundary RTT in ms
  - getHighCapAverageLossRatio
```
public float getHighCapAverageLossRatio()
```
    Average loss ratio across the high-capacity tier with a fresh measurement, as a fraction (0.0 - 1.0); 0.0 if none. See getAverageLossRatio().
  - getIntegrationThreshold
```
public double getIntegrationThreshold()
```
    Current minimum integration value for the well-integrated peer tier.
    Returns:
    the integration threshold computed during the last reorganize
  - getMaximumFastPeers
```
protected int getMaximumFastPeers()
```
    Maximum number of peers to keep in the fast tier, capped by active peers.
    Returns:
    the maximum fast peers
  - getMaximumHighCapPeers
```
protected int getMaximumHighCapPeers()
```
    Maximum number of peers to keep in the high-capacity tier, capped by active peers.
    Returns:
    the maximum high cap peers
  - getMedianLossRatio
```
public float getMedianLossRatio()
```
    Median loss ratio of the union of the fast and high-capacity tiers with a fresh measurement, as a fraction (0.0 - 1.0); 0.0 if none. The median is robust to the worst peers dragging the mean up, so the auto-tuned demotion threshold tracks the typical tier member. See getAverageLossRatio().
  - getMinHighCapacityPeers
```
public static int getMinHighCapacityPeers()
```
  - getMinimumFastPeers
```
protected int getMinimumFastPeers()
```
    Minimum number of peers to keep in the fast tier.
    Returns:
    the minimum fast peers
  - getMinimumHighCapacityPeers
```
protected int getMinimumHighCapacityPeers()
```
    Minimum number of peers to keep in the high-capacity tier.
    Returns:
    the minimum high capacity peers
  - getOrCreateProfileNonblocking
```
public PeerProfile getOrCreateProfileNonblocking(Hash peer)
```
    Retrieve an existing profile or create a new one, without blocking on contention. Uses try-lock escalation to avoid blocking the caller.
    Parameters:
    peer - the router hash to look up or create a profile for
    Returns:
    the existing or new profile, or null if the peer is excluded or lock contention
  - getProfile
```
public PeerProfile getProfile(Hash peer)
```
    Retrieve the profile for a peer, or null if unknown. Blocks on the reorganize read lock.
    Parameters:
    peer - the router hash to look up
    Returns:
    the existing profile, or null if none exists
  - getProfileNonblocking
```
public PeerProfile getProfileNonblocking(Hash peer)
```
    Retrieve the profile for a peer without blocking. Returns null immediately if the lock is contended.
    Parameters:
    peer - the router hash to look up
    Returns:
    the existing profile, or null if none exists or lock unavailable
  - getSpeedThreshold
```
public double getSpeedThreshold()
```
    Current minimum speed value for the fast peer tier.
    Returns:
    the speed threshold computed during the last reorganize
  - getStoredProfileCount
```
public int getStoredProfileCount()
```
    Last known number of profiles stored on disk, from the most recent load, cleanup, or purge in the persistence helper.
    Returns:
    the stored profile count, 0 if the store has never been scanned
  - getTunnelBuildSuccess
```
public double getTunnelBuildSuccess()
```
    Recent tunnel build success ratio, from router statistics.
    TEN_MINUTES window: a short window reacts quickly to network health changes, so the attack-mode gates below track the current situation instead of lifetime averages. When no data is available (stats not yet created at boot, or an empty window), the ratio is 1.0 — no data means neutral, not "under attack"; a missing-stat 0.0 put the router into permanent attack mode before stats existed.
    Returns:
    the tunnel build success in [0.0, 1.0], 1.0 when no data
  - getUs
```
public Hash getUs()
```
    Self-exclusion hash for this router instance.
    Returns:
    the local router hash, or null if not set
  - hasRecentProofOfLife
```
static boolean hasRecentProofOfLife(PeerProfile profile,
                                    long now)
```
    True if the peer has shown proof of life within PROOF_OF_LIFE_WINDOW_MS: a successful send, heard-from, or heard-about within the last hour. A null profile (never seen) is not evidence of life. Used to trust a RouterInfo that is older than the maximum age — the RouterInfo alone is not enough, the peer must have been active recently.
    Pure decision — no context access, safe for unit tests.
    Parameters:
    profile - the peer profile, null if none
    now - current time in ms
    Returns:
    whether the peer has recent proof of life
  - hasRecentTierActivity
```
static boolean hasRecentTierActivity(PeerProfile profile,
                                     long activeCutoff)
```
    True if the peer showed recent activity within the given cutoff: a heard-from or successful send at or after the cutoff. Used to keep stale peers out of the fast/high-cap tiers.
    Pure decision — no context access, safe for unit tests.
    Parameters:
    profile - the profile
    activeCutoff - earliest allowed activity timestamp in ms
    Returns:
    whether the peer has recent activity
  - isEvictable
```
static boolean isEvictable(PeerProfile profile,
                           Map<Hash,PeerProfile> fastPeers,
                           Map<Hash,PeerProfile> highCapPeers,
                           long activeThreshold,
                           int fastPeerLimit,
                           int highCapacityLimit)
```
    Whether a profile is eligible for eviction under the profile cap: not protected by a fast/high-cap tier slot that still has room below its limit, and no send or heard-from activity within the active window.
    Pure decision — no context access, safe for unit tests.
    Parameters:
    profile - the profile under consideration
    fastPeers - the current fast tier map
    highCapPeers - the current high-cap tier map
    activeThreshold - the activity window cutoff (now - 48h)
    fastPeerLimit - fast tier size threshold for protection
    highCapacityLimit - high-cap tier size threshold for protection
    Returns:
    whether the profile may be evicted
  - isExcludedFromProfiling
```
boolean isExcludedFromProfiling(Hash peer)
```
    Check if a peer should be excluded from profiling. Excludes low bandwidth tiers (K, L, M, Unknown) and G cap (no tunnels).
    Returns:
    true if the peer should not be profiled
  - isExpiredProfile
```
static boolean isExpiredProfile(PeerProfile profile,
                                long now,
                                long expireActive,
                                long expirePassive,
                                long expireGossip,
                                long expireUntracked)
```
    Whether a profile has expired from its activity tier and should be purged: no activity (send/heard/heard-about) within the tier's expiration window. Tiered expiration: Active > Passive > Gossip; profiles with no tunnel history are purged on the tighter untracked window regardless of tier. A profile with zero timestamps sits in the gossip tier.
    Pure decision — no context access, safe for unit tests.
    Parameters:
    profile - the profile
    now - current time in ms
    expireActive - active-tier window in ms
    expirePassive - passive-tier window in ms
    expireGossip - gossip-tier window in ms
    expireUntracked - untracked window in ms
    Returns:
    whether the profile is expired
  - isFast
```
public boolean isFast(Hash peer)
```
    Check whether a peer is classified in the fast tier.
    Parameters:
    peer - the router hash to check
    Returns:
    true if the peer is in the fast tier set
  - isHighCapacity
```
public boolean isHighCapacity(Hash peer)
```
    Check whether a peer is classified in the high-capacity tier.
    Parameters:
    peer - the router hash to check
    Returns:
    true if the peer is in the high-capacity tier set
  - isLowBandwidthTier
```
boolean isLowBandwidthTier(Hash peer)
```
    Check if a peer is in a low bandwidth tier (K, L, M, or Unknown).
    Returns:
    true if the peer should be excluded from profiling
  - isLowBuildSuccess
```
public boolean isLowBuildSuccess()
```
    Whether recent tunnel build success is below the attack threshold.
    Returns:
    whether low build success
  - isReliableBandwidthPeer
```
static boolean isReliableBandwidthPeer(PeerProfile profile,
                                       long now,
                                       boolean established)
```
    Reliability gate for high-bandwidth (O/P/X tier) selection: the peer must show a tunnel acceptance ratio of at least 0.3 AND evidence of recent activity — a successful peer test within 10 minutes, a heard- from/send-success within 30 minutes, or an established commSystem connection. Peers with no profile are not gated (no data yet).
    Pure decision — no context access, safe for unit tests.
    Parameters:
    profile - the peer profile (non-null)
    now - current time in ms
    established - whether commSystem has an established connection
    Returns:
    whether the peer passes the reliability gate
  - isSelectable
```
public boolean isSelectable(Hash peer)
```
    Whether the given peer is eligible for selection. Fetches the build success ratio once; per-peer callers should use isSelectable(Hash, double) with a value fetched once per scan.
    Returns:
    whether selectable
  - isStaleAbsentPeer
```
static boolean isStaleAbsentPeer(PeerProfile profile,
                                 long now,
                                 long absentThreshold)
```
    Whether the peer's last activity (send, heard-from, or heard-about) is older than the absent threshold — i.e. it has been absent from the netDb for at least that long. A peer that was never contacted (all-zero timestamps) counts as stale.
    Pure decision — no context access, safe for unit tests.
    Parameters:
    profile - the profile
    now - current time in ms
    absentThreshold - stale threshold in ms
    Returns:
    whether the peer is stale-absent
  - isWellIntegrated
```
public boolean isWellIntegrated(Hash peer)
```
    Check whether a peer is classified in the well-integrated tier.
    Parameters:
    peer - the router hash to check
    Returns:
    true if the peer is in the well-integrated tier set
  - main
```
public static void main(String[] args)
```
    Command-line entry point; reads profile dump files and prints thresholds.
  - needsTierRestore
```
static boolean needsTierRestore(int currentSize,
                                int oldSize)
```
    Whether a shrunken tier needs restoration: below half its old size and the old size was substantial. Prevents starvation when thresholds shift unfavorably.
    Pure decision — no context access, safe for unit tests.
    Parameters:
    currentSize - current tier size
    oldSize - pre-reorganize tier size
    Returns:
    whether the tier should be restored
  - passesTierGates
```
boolean passesTierGates(PeerProfile profile,
                        double buildSuccess,
                        long now)
```
    Common gate for fast/high-cap tier fill passes: the peer must be selectable, have acceptable tunnel acceptance, no recent tunnel failures, and not be in loss probation. Evaluation order preserves the original short-circuit chain (cheap pure checks before the netDb-backed selectability check is already handled by callers that test other cheap conditions first).
    No side effects — safe to evaluate without holding locks.
    Parameters:
    profile - the candidate profile
    buildSuccess - the build success ratio in [0.0, 1.0]
    now - current time in ms
    Returns:
    whether the peer passes the tier gates
  - peerSendsBadReplies
```
public boolean peerSendsBadReplies(Hash peer)
```
    Check whether a peer sends an excessive rate of invalid or failed netDb lookup replies (potential misbehavior indicator).
    Parameters:
    peer - the router hash to check
    Returns:
    true if the peer exceeds the bad-reply threshold in the last hour
  - purgeStaleProfileFiles
```
public void purgeStaleProfileFiles()
```
    Remove stale profile files for peers outside the active set when over the cap.
  - reorganize
```
void reorganize()
```
    Run a standard reorganize round without coalescing or decay. Equivalent to reorganize(false, false).
  - reorganize
```
void reorganize(boolean shouldCoalesce,
                boolean shouldDecay)
```
    Reorganizes peer profiles into performance-based tiers (fast, high-capacity, etc.) and expires stale entries.
    This method:
    - Coalesces and decays stats if requested and uptime conditions are met.
    - Filters out unreachable, inactive, or low-tier peers.
    - Recalculates dynamic thresholds for speed, capacity, and integration.
    - Rebuilds internal tier maps and the global profile ordering.
    - Expires profiles that haven't been active recently to bound memory usage.
    Memory Safety: To prevent unbounded memory growth (e.g., OOM after 8+ hours), this method ensures that expired profiles are removed from all data structures—even if the full reorganization is skipped due to lock contention. A best-effort expiration pass runs outside the write lock to mitigate leaks during high contention.
    Parameters:
    shouldCoalesce - if true, coalesce statistics for active profiles
    shouldDecay - if true and coalescing is performed, apply decay to historical stats
  - selectActiveNotFailingPeers
```
public void selectActiveNotFailingPeers(int howMany,
                                        Set<Hash> exclude,
                                        Set<Hash> matches)
```
    Select from currently connected (established) not-failing peers.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
  - selectActiveNotFailingPeers
```
public void selectActiveNotFailingPeers(int howMany,
                                        Set<Hash> exclude,
                                        Set<Hash> matches,
                                        int mask,
                                        MaskedIPSet ipSet)
```
    Select from currently connected peers with IP-subnet diversity.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
    mask - bitmask length for /n diversity restriction (0 to disable)
    ipSet - mutable set tracking already-selected subnets
  - selectAllNotFailingPeers
```
public void selectAllNotFailingPeers(int howMany,
                                     Set<Hash> exclude,
                                     Set<Hash> matches,
                                     boolean onlyNotFailing)
```
    Select from all not-failing peers randomly, falling through to general peers if the not-failing set is insufficient.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
    onlyNotFailing - if true, exclude peers already in high-capacity tier
  - selectAllPeers
```
public Set<Hash> selectAllPeers()
```
    Gather the union of all peers from fast, high-capacity, and not-failing tiers.
    Returns:
    a new set containing every tracked peer hash
  - selectFastPeers
```
public void selectFastPeers(int howMany,
                            Set<Hash> exclude,
                            Set<Hash> matches)
```
    Select up to howMany fast-tier peers, filling shortfalls from high-capacity.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
  - selectFastPeers
```
public void selectFastPeers(int howMany,
                            Set<Hash> exclude,
                            Set<Hash> matches,
                            int mask,
                            MaskedIPSet ipSet)
```
    Select fast-tier peers with IP-subnet diversity constraints. Falls through to high-capacity tier on shortfall.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
    mask - bitmask length for /n diversity restriction (0 to disable)
    ipSet - mutable set tracking already-selected subnets
  - selectFastPeers
```
public void selectFastPeers(int howMany,
                            Set<Hash> exclude,
                            Set<Hash> matches,
                            SessionKey randomKey,
                            ProfileOrganizer.Slice subTierMode,
                            int mask,
                            MaskedIPSet ipSet)
```
    Select fast-tier peers deterministically sliced by a random key. This enables different peers per tunnel to improve path diversity.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
    randomKey - key for deterministic sub-tier assignment
    subTierMode - slicing mode (SLICE_ALL to skip slicing)
    mask - bitmask length for /n diversity restriction (0 to disable)
    ipSet - mutable set tracking already-selected subnets
  - selectHighBandwidthPeers
```
public void selectHighBandwidthPeers(int howMany,
                                     Set<Hash> exclude,
                                     Set<Hash> matches)
```
    Select up to howMany peers from O/P/X bandwidth tiers (high shared bandwidth) that are not failing. Falls through to selectAllNotFailingPeers on shortfall.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
  - selectHighBandwidthPeers
```
public void selectHighBandwidthPeers(int howMany,
                                     Set<Hash> exclude,
                                     Set<Hash> matches,
                                     boolean onlyNotFailing,
                                     int mask,
                                     MaskedIPSet ipSet)
```
    Select high-bandwidth peers with tier-exclusion and IP-subnet diversity.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
    onlyNotFailing - if true, exclude peers already in high-capacity tier
    mask - bitmask length for /n diversity restriction (0 to disable)
    ipSet - mutable set tracking already-selected subnets
  - selectHighCapacityPeers
```
public void selectHighCapacityPeers(int howMany,
                                    Set<Hash> exclude,
                                    Set<Hash> matches)
```
    Select high-capacity peers, filling shortfalls from not-failing peers.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
  - selectHighCapacityPeers
```
public void selectHighCapacityPeers(int howMany,
                                    Set<Hash> exclude,
                                    Set<Hash> matches,
                                    int mask,
                                    MaskedIPSet ipSet)
```
    Select high-capacity peers with IP-subnet diversity.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
    mask - bitmask length for /n diversity restriction (0 to disable)
    ipSet - mutable set tracking already-selected subnets
  - selectNotFailingPeers
```
public void selectNotFailingPeers(int howMany,
                                  Set<Hash> exclude,
                                  Set<Hash> matches)
```
    Select from not-failing peers, excluding high-capacity tier if requested.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
  - selectNotFailingPeers
```
public void selectNotFailingPeers(int howMany,
                                  Set<Hash> exclude,
                                  Set<Hash> matches,
                                  boolean onlyNotFailing)
```
    Select from not-failing peers, optionally excluding the high-capacity tier.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
    onlyNotFailing - if true, exclude peers already in high-capacity tier
  - selectNotFailingPeers
```
public void selectNotFailingPeers(int howMany,
                                  Set<Hash> exclude,
                                  Set<Hash> matches,
                                  boolean onlyNotFailing,
                                  int mask,
                                  MaskedIPSet ipSet)
```
    Full-parameter select from not-failing peers.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
    onlyNotFailing - if true, exclude peers already in high-capacity tier
    mask - bitmask length for /n diversity restriction (0 to disable)
    ipSet - mutable set tracking already-selected subnets
  - selectNotFailingPeers
```
public void selectNotFailingPeers(int howMany,
                                  Set<Hash> exclude,
                                  Set<Hash> matches,
                                  int mask,
                                  MaskedIPSet ipSet)
```
    Select from not-failing peers with IP-subnet diversity.
    Parameters:
    howMany - target number of peers
    exclude - peers to exclude (may be null)
    matches - output set populated with selected peer hashes
    mask - bitmask length for /n diversity restriction (0 to disable)
    ipSet - mutable set tracking already-selected subnets
  - setDefaultMaxFastPeers
```
public static void setDefaultMaxFastPeers(int val)
```
  - setDefaultMaxHighCapPeers
```
public static void setDefaultMaxHighCapPeers(int val)
```
  - setDefaultMaxProfiles
```
public static void setDefaultMaxProfiles(int val)
```
  - setDefaultMinFastPeers
```
public static void setDefaultMinFastPeers(int val)
```
  - setMinHighCapacityPeers
```
public static void setMinHighCapacityPeers(int val)
```
  - setUs
```
public void setUs(Hash us)
```
    Store the local router hash for self-exclusion from peer selection.
  - skipsPromotion
```
boolean skipsPromotion(PeerProfile profile,
                       Hash peer,
                       double buildSuccess)
```
    Whether the peer should be skipped for tier promotion: not selectable, in a strict country, low tunnel acceptance, high-latency penalty, congested, or in loss probation. Mirrors the eligibility gates of locked_placeProfile().
    No side effects — safe to evaluate without holding locks.
    Parameters:
    profile - the profile under consideration
    peer - the peer hash
    buildSuccess - the tunnel build success ratio in [0.0, 1.0]
    Returns:
    whether promotion should be skipped
  - writeProfile
```
public void writeProfile(PeerProfile profile)
```
    Persist the given profile to disk.

Class ProfileOrganizer

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

_defaultMaxFastPeers

_defaultMaxHighCapPeers

_defaultMaxProfiles

_defaultMinFastPeers

_defaultMinHighCapPeers

ABSOLUTE_MAX_PROFILES

ATTACK_THRESHOLD

DEFAULT_LOSSY_MIN_PACKETS

DEFAULT_MAX_ROUTERINFO_AGE_HOURS

DEFAULT_MINIMUM_HIGH_CAPACITY_PEERS

MIN_MAX_PROFILES

PROP_LOSSY_MIN_PACKETS

PROP_LOSSY_MODERATE_THRESHOLD

PROP_LOSSY_THRESHOLD

PROP_LOSSY_WINDOW

PROP_MAX_PROFILES

PROP_MAX_ROUTERINFO_AGE_HOURS

PROP_MAXIMUM_FAST_PEERS

PROP_MAXIMUM_HIGH_CAPACITY_PEERS

PROP_MINIMUM_FAST_PEERS

PROP_MINIMUM_HIGH_CAPACITY_PEERS

Constructor Detail

ProfileOrganizer

Method Detail

addProfile

buildSuccessRatio

clampMaxProfiles

clearProfiles

countActivePeers

countActivePeersInLastHour

countFastPeers

countHighCapacityPeers

countNotFailingPeers

demoteIfCongested

demoteIfHighLatency

demoteIfHighRTT

demoteIfLossy

demoteIfNoTunnel

demoteIfStale

demoteIfUnreachable

evictProfilesNotInNetdb

exportProfile

getAverageLossRatio

getCapacityThreshold

getDefaultMaxFastPeers

getDefaultMaxHighCapPeers

getDefaultMaxProfilesValue

getDefaultMinFastPeers

getFastAverageLossRatio

getFastRTTThreshold

getHighCapAverageLossRatio

getIntegrationThreshold

getMaximumFastPeers

getMaximumHighCapPeers

getMedianLossRatio

getMinHighCapacityPeers

getMinimumFastPeers

getMinimumHighCapacityPeers

getOrCreateProfileNonblocking

getProfile

getProfileNonblocking

getSpeedThreshold

getStoredProfileCount

getTunnelBuildSuccess

getUs

hasRecentProofOfLife

hasRecentTierActivity

isEvictable

isExcludedFromProfiling

isExpiredProfile

isFast

isHighCapacity

isLowBandwidthTier