Class MulticloudPathComparison

java.lang.Object
com.eqixiac.equinix.design.value.savings.MulticloudPathComparison
public class MulticloudPathComparison extends Object
The cloud-to-cloud section of a SavingsEstimate: the monthly cost of moving traffic between two clouds over each of three paths, and the sustained rate at which the flat-fee native path costs the same as the per-GB Equinix path. Present only when the calculator was given a peer cloud (SavingsCalculator.Builder.toCloud(...)).

Beta: the native path models products that reached general availability in 2026; see RateCard.multicloudLink.

The three paths (EgressPath) and what each total contains
PathFixed monthlyData transfer monthly
INTERNETnoneinternet egress from each cloud on its own direction's volume
PRIVATEtwo Fabric virtual connections, the optional Cloud Router, and the CSP interconnect-port reference figure for both cloudsprivate egress from each cloud on its own direction's volume
MULTICLOUD_INTERCONNECTthe two providers' flat link fees the link's per-GB rate (zero where the provider publishes zero)

A path total is null when any of its inputs is unpriced or its inputs span more than one currency; getNotes() names the missing input. A null total is not a zero cost. All non-null amounts are in getCurrency().

Break-even

getBreakEvenSustainedMbps() is computed by breakEvenSustainedMbps(BigDecimal, BigDecimal, BigDecimal, BigDecimal) from the quotes actually resolved for this estimate. It is a property of the prices, not of the declared volumes. It is null when any input is unpriced, the currencies differ, or no break-even exists.

  • Field Details

    • SECONDS_PER_MONTH

      public static final long SECONDS_PER_MONTH
      Seconds in the 730-hour month used throughout.
      See Also:

    • MEGABITS_PER_GB

      public static final int MEGABITS_PER_GB
      Megabits per decimal gigabyte: 8 bits per byte x 1000 MB per GB.
      See Also:

  • Constructor Details

    • MulticloudPathComparison

      public MulticloudPathComparison()

  • Method Details

    • breakEvenSustainedMbps

      public Optional<BigDecimal> breakEvenSustainedMbps()
      getBreakEvenSustainedMbps() as an Optional.
      Returns:
      the break-even rate in Mbps, or empty when it could not be computed

    • breakEvenSustainedMbps

      public static Optional<BigDecimal> breakEvenSustainedMbps(BigDecimal nativeFixedMonthly, BigDecimal perGbPathFixedMonthly, BigDecimal perGbSumPerGbPath, BigDecimal perGbSumNative)
      The break-even sustained rate between a flat-fee native link and a per-GB path.

      Model. Traffic is symmetric: g GB per month in each direction. Each cloud bills egress on the traffic leaving it.

      perGbPath(g) = perGbPathFixedMonthly + g x perGbSumPerGbPath
native(g)    = nativeFixedMonthly    + g x perGbSumNative

g*           = (nativeFixedMonthly - perGbPathFixedMonthly) / (perGbSumPerGbPath - perGbSumNative)
mbpsEachWay  = g* x 8000 Mb/GB / (730 h x 3600 s/h)
result       = 2 x mbpsEachWay

      perGbSum* is the sum of the two clouds' per-GB rates on that path (A's rate for the A-to-Z direction plus Z's rate for the Z-to-A direction). The result is the total of both directions; divide by two for the rate in each direction. One month is 730 hours and one GB is 109 bytes.

      Worked example with the figures the calculator uses for AWS us-east-1 to Google Cloud us-east4 at 10 Gbps, path tier 1, on the bundled reference data alone (no Cloud Router): native = (12.33 + 19.00) USD/h x 730 h = 22,870.90 USD (multicloud bundle, retrieved 2026-09-21); Equinix path fixed = two reference 10G Fabric connections 2 x 350 + AWS Direct Connect 10G hosted connection 2.48 USD/h x 730 h = 1,810.40 + Google Cloud 10G Partner Interconnect VLAN attachment 2.36 USD/h x 730 h = 1,722.80, total 4,233.20 USD (reference bundle, retrieved 2026-11-12); Equinix per-GB 0.02 + 0.0186 = 0.0386 USD; native per-GB 0. Then g* = (22,870.90 - 4,233.20) / 0.0386 = 482,842 GB each way = 1,469.9 Mbps each way = 2,939.7 Mbps in total (the figure MulticloudSavingsTest asserts).

      The two cost lines cross when the fixed-cost difference and the per-GB difference have the same sign. Both positive is the usual case: the native path is cheaper above g*. Both negative (native fixed fee below the per-GB path's fixed cost, native per-GB rate above the per-GB path's rate) is a crossing with the opposite sense: the per-GB path is cheaper above g*. dominatesAtEveryVolume(BigDecimal, BigDecimal, BigDecimal, BigDecimal) states which case applies, and the nativeCheaperAboveBreakEven field of an instance records the sense for the break-even it carries. When the signs differ (or one delta is zero) one path costs the same or less at every volume and there is no break-even.

      All four arguments must be in one currency; the caller is responsible for that.

      Parameters:
      nativeFixedMonthly - the native link's flat monthly fee, both sides
      perGbPathFixedMonthly - the per-GB path's fixed monthly cost
      perGbSumPerGbPath - the two clouds' per-GB rates on the per-GB path, summed
      perGbSumNative - the two clouds' per-GB rates on the native link, summed
      Returns:
      the break-even rate in Mbps (both directions summed), scale 1; empty when an argument is null or when the two cost lines do not cross at a positive volume, that is when the native fixed fee does not exceed the per-GB path's fixed cost while the per-GB path's rate is at or above the native rate (the native path is then cheaper or equal at every volume), or when the native fixed fee is at or above the per-GB path's fixed cost while the per-GB path's rate does not exceed the native rate (the per-GB path is then cheaper or equal at every volume)

    • nativeCheaperAboveBreakEven

      public static boolean nativeCheaperAboveBreakEven(BigDecimal nativeFixedMonthly, BigDecimal perGbPathFixedMonthly)
      Whether the native path costs less than the per-GB path above the break-even rate that breakEvenSustainedMbps(BigDecimal, BigDecimal, BigDecimal, BigDecimal) returns for the same arguments: true when the native fixed fee exceeds the per-GB path's fixed cost (the per-GB path then wins at low volume and loses at high volume), false when it is below it (the reverse). Meaningful only when that method returns a value.
      Parameters:
      nativeFixedMonthly - the native link's flat monthly fee, both sides
      perGbPathFixedMonthly - the per-GB path's fixed monthly cost
      Returns:
      true when nativeFixedMonthly > perGbPathFixedMonthly
      Throws:
      NullPointerException - if either argument is null

    • dominatesAtEveryVolume

      public static Optional<EgressPath> dominatesAtEveryVolume(BigDecimal nativeFixedMonthly, BigDecimal perGbPathFixedMonthly, BigDecimal perGbSumPerGbPath, BigDecimal perGbSumNative)
      Which path costs the same or less at every volume when the cost lines do not cross. Defined only when breakEvenSustainedMbps(BigDecimal, BigDecimal, BigDecimal, BigDecimal) returns empty for the same non-null arguments.
      Parameters:
      nativeFixedMonthly - the native link's flat monthly fee, both sides
      perGbPathFixedMonthly - the per-GB path's fixed monthly cost
      perGbSumPerGbPath - the two clouds' per-GB rates on the per-GB path, summed
      perGbSumNative - the two clouds' per-GB rates on the native link, summed
      Returns:
      EgressPath.MULTICLOUD_INTERCONNECT when the native path costs the same or less at every volume, EgressPath.PRIVATE when the per-GB path does; empty when the lines cross (a break-even exists) or an argument is null