Package jline.api.fj

Class FJ_parallel

java.lang.Object
jline.api.fj.FJ_parallel
public final class FJ_parallel extends Object

  • Method Details

    • fj_respt_nosplit

      public static FJ_parallel.FJResptNosplitResult fj_respt_nosplit(int K, double lambda, double mu)
      Distributed no splitting: a job of K tasks goes in one piece to a single server chosen uniformly among the K, which is an M/E_K/1 queue and reduces to R = [ K - (K-1) rho/2 ] / (mu - lambda).

    • fj_respt_bulk

      public static FJ_parallel.FJResptBulkResult fj_respt_bulk(int K, double lambda, double mu, int c, int nmax)
      Centralized splitting as an M[K]/M/c bulk arrival system, solved by truncating the level chain. The request response time is the completion of the LAST of the K tasks: by PASTA the batch finds n tasks in system, its last task is the (n+K)-th in line, and under first come first served with c exponential servers it starts after max(0, n+K-c) departures, each an exponential of rate c mu.

    • fj_respt_bulk

      public static FJ_parallel.FJResptBulkResult fj_respt_bulk(int K, double lambda, double mu, int c)

    • fj_ism_green

      public static FJ_parallel.FJIsmGreenResult fj_ism_green(double lambda, double mu, int s, double[] c)
      Green's independent server model: a customer needs j servers at once with probability c(j) and releases them asynchronously as each of its j tasks completes at rate mu, so its own service is the maximum of j exponentials. E[B] is the j-th order statistic of s exponentials, because all s servers are busy whenever a customer enters service during a queueing period; E[D] is the initial delay of the customer that starts one; and the waiting-time transform factors into the equilibrium transform of D and the Pollaczek-Khinchine transform with service B, so the means add. Eq. (65) of the survey prints the inner sum of E[D] as starting at 1/(s mu) even though only i servers are busy; it is started at 1/(i mu) here, which is what the accompanying text prescribes.

    • fj_tsm_capacity

      public static FJ_parallel.FJTsmCapacityResult fj_tsm_capacity(int s, double[] f, int[] r, double[] x)
      Saturation throughput of the team service model. The apparent rate Lambda_max = s / sum_k f(k) r(k) x(k) is attainable only when the scheduler can pack jobs into execution states that leave no server idle; the attainable capacity is the optimum of max Lambda s.t. sum_j p_j n(j,k)/x(k) = Lambda f(k), sum_j p_j = 1, p >= 0 over the multisets of jobs whose total server demand is at most s. For the two-server two-class case with r = (1,2), strict first come first served cannot pack at all and reaches only the printed lambda_FCFS.

    • fj_serialization

      public static FJ_parallel.FJSerializationResult fj_serialization(double[] Rs, double R0, int M, double alpha)
      Blocking probability and pseudoserver delay of serialization phases: P_s(M) = 1 - [ 1 - R_s(M)/R(M) ]^(M-1), with the delay charged at the pseudoserver equal to alpha R_s(M).

    • fj_serialization

      public static FJ_parallel.FJSerializationResult fj_serialization(double[] Rs, double R0, int M)

    • fj_dag_makespan

      public static FJ_parallel.FJDagMakespanResult fj_dag_makespan(boolean[][] pred, double[][] rate)
      Makespan of a task system with precedence constraints. The chain whose state is the SET of completed tasks is acyclic, so it is swept level by level: task i among the k eligible completes at rate rate[i][k-1], the state is held for 1/T(S), and p(R) = sum p(S) b(S,R), D(R) = M(R) p(R) + sum b(S,R) D(S), started at p(empty) = 1. Making the rate depend on the concurrency is what couples the task system to the queueing network underneath it.