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` _defaultMaxProfiles.
`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_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_MAX_PROFILES` PROP_MAX_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) 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`	`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.
`double`	`getCapacityThreshold()` Current minimum capacity value for the high-capacity peer tier.
`static int`	`getDefaultMaxFastPeers()`
`static int`	`getDefaultMaxHighCapPeers()`
`static int`	`getDefaultMaxProfilesValue()`
`static int`	`getDefaultMinFastPeers()`
`double`	`getIntegrationThreshold()` Current minimum integration value for the well-integrated peer tier.
`protected int`	`getMaximumFastPeers()`
`protected int`	`getMaximumHighCapPeers()`
`static int`	`getMinHighCapacityPeers()`
`protected int`	`getMinimumFastPeers()`
`protected int`	`getMinimumHighCapacityPeers()`
`(package private) 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.
`double`	`getTunnelBuildSuccess()`
`Hash`	`getUs()` Self-exclusion hash for this router instance.
`(package private) boolean`	`isExcludedFromProfiling(Hash peer)` Check if a peer should be excluded from profiling.
`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()`
`boolean`	`isSelectable(Hash peer)`
`boolean`	`isWellIntegrated(Hash peer)` Check whether a peer is classified in the well-integrated tier.
`static void`	`main(String[] args)` main.
`boolean`	`peerSendsBadReplies(Hash peer)` Check whether a peer sends an excessive rate of invalid or failed netDb lookup replies (potential misbehavior indicator).
`void`	`purgeStaleProfileFiles()` purgeStaleProfileFiles.
`(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)` Set the local router hash for self-exclusion from peer selection.
`void`	`writeProfile(PeerProfile profile)` writeProfile.

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
```
    _defaultMaxProfiles.
  - _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_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_MAX_PROFILES
```
public static final String PROP_MAX_PROFILES
```
    PROP_MAX_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
  - 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.
  - 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
  - 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()
```
  - 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()
```
    Returns:
    the maximum fast peers
  - getMaximumHighCapPeers
```
protected int getMaximumHighCapPeers()
```
    Returns:
    the maximum high cap peers
  - getMinHighCapacityPeers
```
public static int getMinHighCapacityPeers()
```
  - getMinimumFastPeers
```
protected int getMinimumFastPeers()
```
    Returns:
    the minimum fast peers
  - getMinimumHighCapacityPeers
```
protected int getMinimumHighCapacityPeers()
```
    Returns:
    the minimum high capacity peers
  - getOrCreateProfileNonblocking
```
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
  - getTunnelBuildSuccess
```
public double getTunnelBuildSuccess()
```
    Returns:
    the tunnel build success
  - getUs
```
public Hash getUs()
```
    Self-exclusion hash for this router instance.
    Returns:
    the local router hash, or null if not set
  - 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
  - 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()
```
    Returns:
    whether low build success
  - isSelectable
```
public boolean isSelectable(Hash peer)
```
    Returns:
    whether selectable
  - 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)
```
    main.
  - 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()
```
    purgeStaleProfileFiles.
  - 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)
```
    Set the local router hash for self-exclusion from peer selection.
  - writeProfile
```
public void writeProfile(PeerProfile profile)
```
    writeProfile.

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_MAX_ROUTERINFO_AGE_HOURS

DEFAULT_MINIMUM_HIGH_CAPACITY_PEERS

MIN_MAX_PROFILES

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

clearProfiles

countActivePeers

countActivePeersInLastHour

countFastPeers

countHighCapacityPeers

countNotFailingPeers

demoteIfCongested

demoteIfHighLatency

demoteIfHighRTT

demoteIfNoTunnel

demoteIfStale

demoteIfUnreachable

evictProfilesNotInNetdb

exportProfile

getCapacityThreshold

getDefaultMaxFastPeers

getDefaultMaxHighCapPeers

getDefaultMaxProfilesValue

getDefaultMinFastPeers

getIntegrationThreshold

getMaximumFastPeers

getMaximumHighCapPeers

getMinHighCapacityPeers

getMinimumFastPeers

getMinimumHighCapacityPeers

getOrCreateProfileNonblocking

getProfile

getProfileNonblocking

getSpeedThreshold

getTunnelBuildSuccess

getUs

isExcludedFromProfiling

isFast

isHighCapacity

isLowBandwidthTier

isLowBuildSuccess

isSelectable

isWellIntegrated

main

peerSendsBadReplies

purgeStaleProfileFiles

reorganize

reorganize

selectActiveNotFailingPeers

selectActiveNotFailingPeers

selectAllNotFailingPeers

selectAllPeers

selectFastPeers

selectFastPeers

selectFastPeers

selectHighBandwidthPeers

selectHighBandwidthPeers

selectHighCapacityPeers