Package jline.solvers.ldes

Class LNLDESResult

java.lang.Object
jline.solvers.SolverResult
jline.solvers.ldes.LNLDESResult
public class LNLDESResult extends SolverResult
Result container for LayeredNetwork LDES simulation. Metrics are indexed by LQN element type, in the 0-based index space of LayeredNetworkStruct: - Hosts: indices hshift to hshift+nhosts-1 (hshift = 0) - Tasks: indices tshift to tshift+ntasks-1 - Entries: indices eshift to eshift+nentries-1 - Activities: indices ashift to ashift+nacts-1

Calls have no room in that space -- cshift is nidx -- so the per-call metrics are separate vectors, indexed by the call's own 0-based index in 0..ncalls-1, the same one that keys lsn.calltype and that lsn.callsof lists.

  • Field Details

    • lsn

      public LayeredNetworkStruct lsn
      LQN structure reference

    • QLN

      public Matrix QLN
      Queue length per LQN element [1 x nidx]

    • ULN

      public Matrix ULN
      Utilization per LQN element [1 x nidx]

    • RLN

      public Matrix RLN
      Response time per LQN element [1 x nidx]

    • WLN

      public Matrix WLN
      Residence/waiting time per LQN element [1 x nidx]

    • TLN

      public Matrix TLN
      Throughput per LQN element [1 x nidx]

    • ALN

      public Matrix ALN
      Arrival rate per LQN element [1 x nidx]

    • ZLN

      public Matrix ZLN
      Mean think time of a task, at task indices and zero elsewhere [1 x nidx].

      The time a thread of the task spends holding no request, per completion: Z(t) = (N(t) - sum_k B(t,k)) / X(t), with the pool size, the occupancy and the throughput all totalled over the replicas. It is the think time SolverLN reaches by iterating updateThinkTimes, here observed from the sample path instead. A task with an unbounded thread pool has no pool for the law to close on and reports zero.

    • UCallLN

      public Matrix UCallLN
      Per-call occupancy of the callee's thread pool, in job units [1 x ncalls].

      U(c) is the mean number of threads of the called task that are held on behalf of call c -- the B(t,k) of the thread-pool Little's law X(t)*(Z(t)+z(t)) + sum_k B(t,k) = N(t), with the caller classes k being the calls that reach t. Summing this over the calls into a task and adding UEntryClassLN over its entries gives the task's own occupancy.

    • TCallLN

      public Matrix TCallLN
      Rate at which each call is dispatched [1 x ncalls].

      Counted where the CALLER issues it, so that an asynchronous call -- which nobody waits for and which therefore never returns -- still registers. This is the X(c) of the call-flow law X(c) = X(src(c))*y(c).

    • UEntryClassLN

      public Matrix UEntryClassLN
      Occupancy contributed by an entry's OWN request stream, in job units [1 x nentries], indexed by local entry index.

      A reference task cycles on its own entries and an open arrival drives an entry from outside; either way the resulting request holds a thread exactly as a call does, and so enters the thread-pool law as its own caller class. Zero for an entry reached only by calls.

    • entryRespTimeSamples

      public List<Double>[] entryRespTimeSamples
      Every per-request entry response time observed after warmup [1 x nentries], indexed by the entry's LOCAL index (0..nentries-1), null when the run kept none.

      RLN is the mean of these; this is the sample itself, which is what an empirical CDF has to be built from. A simulator must report what it OBSERVED: fitting a law to the mean says nothing about the tail, which is the whole reason to ask a simulator for a distribution.

    • QLNCI

      public Matrix QLNCI
      Queue length confidence interval half-widths [1 x nidx]

    • ULNCI

      public Matrix ULNCI
      Utilization confidence interval half-widths [1 x nidx]

    • RLNCI

      public Matrix RLNCI
      Response time confidence interval half-widths [1 x nidx]

    • TLNCI

      public Matrix TLNCI
      Throughput confidence interval half-widths [1 x nidx]

    • cacheTaskIdx

      public List<Integer> cacheTaskIdx
      CacheTask absolute LQN index for each cache read.

    • cacheItemEntryIdx

      public List<Integer> cacheItemEntryIdx
      ItemEntry absolute LQN index for each cache read.

    • cacheHitProb

      public List<Double> cacheHitProb
      True-hit probability (excludes delayed hits).

    • cacheMissProb

      public List<Double> cacheMissProb
      Miss probability.

    • cacheDelayedProb

      public List<Double> cacheDelayedProb
      Delayed-hit probability (0 when no retrieval system).

    • cacheReadRate

      public List<Double> cacheReadRate
      Read throughput (reads per unit time) into this cache.

  • Constructor Details

    • LNLDESResult

      public LNLDESResult()