WorkloadLublin99 (GridSim 5.0 beta API Specification)

The main purpose of this class is to create a realistic simulation environment where your jobs are competing with others. This class is responsible for creating jobs according to the workload model generator presented by Lublin and Feitelson.

Details on how the distributions have been implemented and how their parameters can be configured are described below. Please note that the following text was extracted from the C implementation of the model performed by Uri Lublin and Dror Feitelson:

The load generated can be changed by changing the values of the model parameters. Remember to set the number-of-nodes' parameters to fit your system. I distinguish between the two different types (batch or interactive) if the useJobType in the constructors is set to true. The program starts by initialising the model's parameters (according to the following constants definitions -- parameters values). Notice that if job type is set to true, there are different values to batch-parameters and interactive-parameters, and if this flag is false then they both get the same value (and the arbitrary type interactive). The workload calculates for each job its arrival arrival time (using 2 gamma distributions), number of nodes (using a two-stage-uniform distribution), runtime (using the number of nodes and hyper-gamma distribution) and type.

Some definitions:

'l' - the mean load of the system
'r' - the mean runtime of a job
'ri' - the runtime of job 'i'
'n' - the mean number of nodes of a job
'ni' - the number of nodes of job 'i'
'a' - the mean inter-arrival time of a job
'ai' - the arrival time (from the beginning of the simulation) of job 'i'
'P' - the number of nodes in the system (the system's size).

Given ri,ni,ai,N or r,n,a,N we can calculate the expected load on the system

           sum(ri * ni)  
 load =  ---------------
           P * max(ai)

We can calculate an approximation (exact if 'ri' and 'ni' are independent)

                     r * n
 approximate-load = -------
                     P * a

The model controls the r,m,a. One can change them by changing the values of the model's parameters.

----------------------
Changing the runtime:
----------------------
Let g ~ gamma(alpha,beta) then the expectation and variation of g are:
E(g) = alpha*beta ; Var(g) = alpha*(beta^2)
so the coefficient of variation is CV = sqrt(Var(g))/E(g) = 1/sqrt(alpha). One who wishes to enlarge the gamma random value without changing the CV can set a larger value to the parameter beta . If one wishes that the CV will change he may set a larger value to alpha parameter. Let hg ~ hyper-gamma(a1,b1,a2,b2,p) then the expectation and variation are:
E(hg) = p*a1*b1 + (1-p)*a2*b2
Var(hg) = p^2*a1*b1^2 + (1-p)^2*a2*b2^2
One who wishes to enlarge the hyper-gamma (or the runtime) random value may do that using one (or more) of the three following ways:

enlarge the first gamma.
and/or enlarge the second gamma.
and/or set a smaller value to the 'p' parameter.(parameter p of hyper-gamma is the proportion of the first gamma). since in my model 'p' is dependent on the number of nodes (p=pa*nodes+pb) this is done by diminishing 'pa' and/or diminishing 'pb' such that 'p' will be smaller. Note that changing 'pa' affects the correlation between the number of nodes a job needs and its runtime.

Use setRunTimeParameters(int, double, double, double, double, double, double) in order to change the runtime parameters of jobs.

------------------------
Changing the correlation between the number of nodes a job needs and its runtime:
------------------------
The parameter 'pa' is responsible for that correlation. Since its negative as the number of nodes get larger so is the runtime. One who wishes no correlation between the nodes-number and the runtime should set 'pa' to be 0 or a small negative number close to 0. One who wishes to have strong such a correlation should set 'pa' to be not so close to 0 , for example -0.05 or -0.1 . Note that this affect the runtime which will be larger. One can take care of that by changing the other runtime parameters (a1,b1,a2,b2,pb).

-----------------------------
Changing the number of nodes:
-----------------------------
Let u ~ uniform(a,b) then the expectation of u is E(u) = (a+b)/2.
Let tsu ~ two-stage-uniform(Ulow,Umed,Uhi,Uprob) then the expectation of tsu is E(tsu) = Uprob*(Ulow+Umed)/2 + (1-Uprob)*(Umed+Uhi)/2 = = (Uprob*Ulow + Umed + (1-Uprob)*Uhi)/2.

'Ulow' is the log2 of the minimal number of nodes a job may run on.
'Uhi' is the log2 of the system size.
'Umed' is the changing point of the cdf function and should be set to 'Umed' = 'Uhi' - 2.5. ('2.5' could be change between 1.5 to 3.5).

For example if the system size is 8 (Uhi = log2(8) = 3) it makes no sense to set Umed to be 0 or 0.5 . In this case I would set Umed to be 1.5 , and maybe set Ulow to be 0.8 , so the probability of 2 would not be too small. 'Uprob' is the proportion of the first uniform (Ulow,Umed) and should be set to a value between 0.7 to 0.95.
One who wishes to enlarge the mean number of nodes may do that using one of the two following ways:

set a smaller value to 'prob'
and/or enlarge 'uMed'

Remember that changing the mean number of nodes will affect on the runtime too.

Use setParallelJobProbabilities(int, double, double, double, double) to change the number of nodes and probability of parallel jobs.
Use setPower2Probability(int, double) to change the probability of power of two jobs.
Use setSerialProbability(int, double) to change the probability for serial or sequential jobs.

--------------------------
Changing the arrival time:
--------------------------
The arrival time is calculated in two stages:

First stage: calculate the proportion of number of jobs arrived at every time interval (bucket). this is done using the gamma(anum,bnum) cdf and the CYCLIC_DAY_START. The weights array holds the points of all the buckets.
Second stage: for each job calculate its inter-arrival time: Generate a random value from the gamma(aarr,barr). The exponential of the random value is the points we have. While we have less points than the current bucket , "pay" the appropriate number of points and move to the next bucket (updating the next-arrival-time).

The parameters 'aarr' and 'barr' represent the inter-arrival-time in the rush hours. The parameters 'anum' and 'bnum' represent the number of jobs arrived (for every bucket). The proportion of bucket 'i' is: cdf (i+0.5 , anum , bnum) - cdf(i-0.5 , anum , bnum). We calculate this proportion for each i from BUCKETS to (24+BUCKETS) , and the buckets (their indices) that are larger than or equal to 24 are move cyclically to the right place:

 (24 --> 0 , 25 --> 1 , ... , (24+BUCKETS) --> BUCKETS)

One who wishes to change the mean inter-arrival time may do that in the following way:
- enlarge the rush-hours-inter-arrival time. This is done by enlarging the value of aarr or barr according to the wanted change of the CV. One who wishes to change the daily cycle may change the values of 'anum' and/or 'bnum'

Use setInterArrivalTimeParameters(int, double, double, double, double, double) to change the inter-arrival parameters.

For more information on the workload model implemented here, please read the following paper:
Uri Lublin and Dror G. Feitelson, The Workload on Parallel Supercomputers: Modeling the Characteristics of Rigid Jobs. J. Parallel & Distributed Comput. 63(11), pp. 1105-1122, Nov 2003.

Since:: 5.0
Author:: Marcos Dias de Assuncao
See Also:: GridSim.init(int, Calendar, boolean)

Field Summary
`static double`	`A1`
`static double`	`A1_ACTIVE`
`static double`	`A1_BATCH` The parameters for the running time The running time is computed using hyper-gamma distribution.
`static double`	`A2`
`static double`	`A2_ACTIVE`
`static double`	`A2_BATCH`
`static double`	`AARR`
`static double`	`AARR_ACTIVE`
`static double`	`AARR_BATCH`
`static double`	`ANUM`
`static double`	`ANUM_ACTIVE`
`static double`	`ANUM_BATCH`
`static double`	`ARAR`
`static double`	`ARAR_ACTIVE`
`static double`	`ARAR_BATCH`
`static double`	`B1`
`static double`	`B1_ACTIVE`
`static double`	`B1_BATCH`
`static double`	`B2`
`static double`	`B2_ACTIVE`
`static double`	`B2_BATCH`
`static double`	`BARR`
`static double`	`BARR_ACTIVE`
`static double`	`BARR_BATCH`
`static int`	`BATCH_JOBS` Represents batch jobs
`static double`	`BNUM`
`static double`	`BNUM_ACTIVE`
`static double`	`BNUM_BATCH`
`static int`	`INTERACTIVE_JOBS` Represents interactive jobs
`static double`	`PA`
`static double`	`PA_ACTIVE`
`static double`	`PA_BATCH`
`static double`	`PB`
`static double`	`PB_ACTIVE`
`static double`	`PB_BATCH`
`static double`	`POW2_PROB`
`static double`	`POW2_PROB_ACTIVE` The default proportion of interactive jobs with power 2 number of nodes
`static double`	`POW2_PROB_BATCH` The default proportion of batch jobs with power 2 number of nodes
`protected Random`	`random`
`static double`	`SERIAL_PROB`
`static double`	`SERIAL_PROB_ACTIVE` The default proportion of interactive serial jobs
`static double`	`SERIAL_PROB_BATCH` The default proportion of batch serial jobs
`static double`	`UHI`
`static double`	`UHI_ACTIVE` UHi is the default log2 of the maximal size of an interactive job in the system (system's size)
`static double`	`UHI_BATCH` UHi is the default log2 of the maximal size of a batch job in the system (system's size)
`static double`	`ULOW`
`static double`	`ULOW_ACTIVE` ULow, UMed, UHi and Uprob are the parameters for the two-stage-uniform which is used to calculate the number of nodes for parallel jobs.
`static double`	`ULOW_BATCH` ULow, UMed, UHi and Uprob are the parameters for the two-stage-uniform which is used to calculate the number of nodes for parallel jobs.
`static double`	`UMED`
`static double`	`UMED_ACTIVE` Default UMed for interactive jobs.
`static double`	`UMED_BATCH` Default UMed for batch jobs.
`static double`	`UPROB`
`static double`	`UPROB_ACTIVE` Default UProb for interactive jobs.
`static double`	`UPROB_BATCH` Default UProb for batch jobs.
`(package private) double[][]`	`weights`

Constructor Summary
`WorkloadLublin99(int rating, boolean jobType, long seed)` Create a new workload model object.

Method Summary
`ArrayList<WorkloadJob>`	`generateWorkload()` Generates jobs according to the model.
`double[]`	`getInterArrivalTimeParameters(int jobType)` Returns the parameters for the inter-arrival time The inter-arriving time is calculated using two gamma distributions.
`double`	`getParallelJobUHi(int jobType)` Gets the log2 of the maximal size of a job in the system (system's size)
`double`	`getParallelJobULow(int jobType)` Gets the the log2 of the minimal size of job in the system (you can add or subtract 0.2 to give less/more probability to the minimal size).
`double`	`getParallelJobUMed(int jobType)` Gets the medium size of parallel jobs in the system.
`double`	`getParallelJobUProb(int jobType)` Gets the probability of the job being a parallel job
`double`	`getPower2Probability(int jobType)` Gets the probability for power of two jobs
`double[]`	`getRunTimeParameters(int jobType)` Gets the runtime parameters.
`double`	`getSerialProbability(int jobType)` Gets the probability for serial jobs
`int`	`getStartHour()` Gets the hour of the day when the simulation should start
`boolean`	`setGridletFileSize(int size)` Sets a Gridlet file size (in byte) for sending to/from a resource.
`boolean`	`setInterArrivalTimeParameters(int jobType, double aarr, double barr, double anum, double bnum, double arar)` Sets the parameters for the inter-arrival time.
`boolean`	`setMaximumWorkloadDuration(double duration)` Sets the maximum time duration of the workload.
`boolean`	`setNumJobs(int numJobs)` Sets the maximum number of jobs to be generated by this workload model
`boolean`	`setParallelJobProbabilities(int jobType, double uLow, double uMed, double uHi, double uProb)` Sets the parameters for the two-stage-uniform which is used to calculate the number of nodes for parallel jobs.
`boolean`	`setPower2Probability(int jobType, double prob)` Sets the probability for power of two jobs
`boolean`	`setRunTimeParameters(int jobType, double a1, double a2, double b1, double b2, double pa, double pb)` Sets the parameters for the running time The running time is computed using hyper-gamma distribution.
`boolean`	`setSerialProbability(int jobType, double prob)` Sets the probability for serial jobs
`boolean`	`setStartHour(int start)` Sets the hour of the day when the simulation should start

Methods inherited from class Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

random

protected Random random

INTERACTIVE_JOBS

public static final int INTERACTIVE_JOBS

Represents interactive jobs

See Also:: Constant Field Values

BATCH_JOBS

public static final int BATCH_JOBS

Represents batch jobs

See Also:: Constant Field Values

SERIAL_PROB_BATCH

public static final double SERIAL_PROB_BATCH

The default proportion of batch serial jobs

See Also:: Constant Field Values

POW2_PROB_BATCH

public static final double POW2_PROB_BATCH

The default proportion of batch jobs with power 2 number of nodes

See Also:: Constant Field Values

ULOW_BATCH

public static final double ULOW_BATCH

ULow, UMed, UHi and Uprob are the parameters for the two-stage-uniform which is used to calculate the number of nodes for parallel jobs. ULow is the default log2 of the minimal size of job in the system for batch jobs.

See Also:: Constant Field Values

UHI_BATCH

public static final double UHI_BATCH

UHi is the default log2 of the maximal size of a batch job in the system (system's size)

See Also:: Constant Field Values

UMED_BATCH

public static final double UMED_BATCH

Default UMed for batch jobs. Note that UMed should be in [UHi-1.5 , UHi-3.5]

See Also:: Constant Field Values

UPROB_BATCH

public static final double UPROB_BATCH

Default UProb for batch jobs. Note that Uprob should be in [0.7 - 0.95]

See Also:: Constant Field Values

SERIAL_PROB_ACTIVE

public static final double SERIAL_PROB_ACTIVE

The default proportion of interactive serial jobs

See Also:: Constant Field Values

POW2_PROB_ACTIVE

public static final double POW2_PROB_ACTIVE

The default proportion of interactive jobs with power 2 number of nodes

See Also:: Constant Field Values

ULOW_ACTIVE

public static final double ULOW_ACTIVE

See Also:: Constant Field Values

UHI_ACTIVE

public static final double UHI_ACTIVE

UHi is the default log2 of the maximal size of an interactive job in the system (system's size)

See Also:: Constant Field Values

UMED_ACTIVE

public static final double UMED_ACTIVE

Default UMed for interactive jobs. Note that UMed should be in [UHi-1.5 , UHi-3.5]

See Also:: Constant Field Values

UPROB_ACTIVE

public static final double UPROB_ACTIVE

Default UProb for interactive jobs. Note that Uprob should be in [0.7 - 0.95]

See Also:: Constant Field Values

A1_BATCH

public static final double A1_BATCH

The parameters for the running time The running time is computed using hyper-gamma distribution. The parameters a1,b1,a2,b2 are the parameters of the two gamma distributions The p parameter of the hyper-gamma distribution is calculated as a straight (linear) line p = pa*nodes + pb. 'nodes' will be calculated in the program, here we defined the 'pa','pb' parameters.

See Also:: Constant Field Values

B1_BATCH

public static final double B1_BATCH

See Also:: Constant Field Values

A2_BATCH

public static final double A2_BATCH

See Also:: Constant Field Values

B2_BATCH

public static final double B2_BATCH

See Also:: Constant Field Values

PA_BATCH

public static final double PA_BATCH

See Also:: Constant Field Values

PB_BATCH

public static final double PB_BATCH

See Also:: Constant Field Values

A1_ACTIVE

public static final double A1_ACTIVE

See Also:: Constant Field Values

B1_ACTIVE

public static final double B1_ACTIVE

See Also:: Constant Field Values

A2_ACTIVE

public static final double A2_ACTIVE

See Also:: Constant Field Values

B2_ACTIVE

public static final double B2_ACTIVE

See Also:: Constant Field Values

PA_ACTIVE

public static final double PA_ACTIVE

See Also:: Constant Field Values

PB_ACTIVE

public static final double PB_ACTIVE

See Also:: Constant Field Values

AARR_BATCH

public static final double AARR_BATCH

See Also:: Constant Field Values

BARR_BATCH

public static final double BARR_BATCH

See Also:: Constant Field Values

ANUM_BATCH

public static final double ANUM_BATCH

See Also:: Constant Field Values

BNUM_BATCH

public static final double BNUM_BATCH

See Also:: Constant Field Values

ARAR_BATCH

public static final double ARAR_BATCH

See Also:: Constant Field Values

AARR_ACTIVE

public static final double AARR_ACTIVE

See Also:: Constant Field Values

BARR_ACTIVE

public static final double BARR_ACTIVE

See Also:: Constant Field Values

ANUM_ACTIVE

public static final double ANUM_ACTIVE

See Also:: Constant Field Values

BNUM_ACTIVE

public static final double BNUM_ACTIVE

See Also:: Constant Field Values

ARAR_ACTIVE

public static final double ARAR_ACTIVE

See Also:: Constant Field Values

SERIAL_PROB

public static final double SERIAL_PROB

See Also:: Constant Field Values

POW2_PROB

public static final double POW2_PROB

See Also:: Constant Field Values

ULOW

public static final double ULOW

See Also:: Constant Field Values

UMED

public static final double UMED

See Also:: Constant Field Values

UHI

public static final double UHI

See Also:: Constant Field Values

UPROB

public static final double UPROB

See Also:: Constant Field Values

A1

public static final double A1

See Also:: Constant Field Values

B1

public static final double B1

See Also:: Constant Field Values

A2

public static final double A2

See Also:: Constant Field Values

B2

public static final double B2

See Also:: Constant Field Values

PA

public static final double PA

See Also:: Constant Field Values

PB

public static final double PB

See Also:: Constant Field Values

AARR

public static final double AARR

See Also:: Constant Field Values

BARR

public static final double BARR

See Also:: Constant Field Values

ANUM

public static final double ANUM

See Also:: Constant Field Values

BNUM

public static final double BNUM

See Also:: Constant Field Values

ARAR

public static final double ARAR

See Also:: Constant Field Values

weights

double[][] weights

Constructor Detail

WorkloadLublin99

public WorkloadLublin99(int rating,
                        boolean jobType,
                        long seed)

Create a new workload model object.
NOTE:

Parameters:: rating - the resource's PE rating; jobType - useJobType us if we should differ between batch and interactive jobs or not. If the value is true, then we use both batch and interactive values for the parameters and the output sample includes both interactive and batch jobs. We choose the type of the job to be the type whose next job arrives to the system first (smaller next arrival time). If the value is false, then we use the "whole sample" parameters. The output sample includes jobs from the same type (arbitrarily we choose batch). We force the type to be interactive by setting the next arrival time of interactive jobs to be Long.MAX_VALUE -- always larger than the batchs's next arrival.; seed - seed used by the random number generator
Throws:: IllegalArgumentException - if resource PE rating <= 0
Pre Condition:: rating > 0
Post Condition:: $none

Method Detail

setSerialProbability

public boolean setSerialProbability(int jobType,
                                    double prob)

Sets the probability for serial jobs

Parameters:: jobType - the type of jobs; prob - the probability
Returns:: true if the probability has been set, or false otherwise.
See Also:: INTERACTIVE_JOBS, BATCH_JOBS

getSerialProbability

public double getSerialProbability(int jobType)

Gets the probability for serial jobs

Parameters:: jobType - the type of jobs
Returns:: prob the probability; -1 if an error occurs.
See Also:: INTERACTIVE_JOBS, BATCH_JOBS

setPower2Probability

public boolean setPower2Probability(int jobType,
                                    double prob)

Sets the probability for power of two jobs

Parameters:: jobType - the type of jobs; prob - the probability
Returns:: true if the probability has been set, or false otherwise.
See Also:: INTERACTIVE_JOBS, BATCH_JOBS

getPower2Probability

public double getPower2Probability(int jobType)

Gets the probability for power of two jobs

Parameters:: jobType - the type of jobs
Returns:: prob the probability; -1 if an error occurs.
See Also:: INTERACTIVE_JOBS, BATCH_JOBS

setParallelJobProbabilities

public boolean setParallelJobProbabilities(int jobType,
                                           double uLow,
                                           double uMed,
                                           double uHi,
                                           double uProb)

Sets the parameters for the two-stage-uniform which is used to calculate the number of nodes for parallel jobs.

Parameters:: jobType - the type of jobs; uLow - is the log2 of the minimal size of job in the system (you can add or subtract 0.2 to give less/more probability to the minimal size).; uMed - should be in [uHi-1.5 , uHi-3.5]; uHi - is the log2 of the maximal size of a job in the system (system's size); uProb - should be in [0.7 - 0.95]
Returns:: true if the probabilities have been set, or false otherwise.
See Also:: INTERACTIVE_JOBS, BATCH_JOBS

getParallelJobUProb

public double getParallelJobUProb(int jobType)

Gets the probability of the job being a parallel job

Parameters:: jobType - the type of jobs
Returns:: the value of uProb; -1 if an error occurs.
See Also:: INTERACTIVE_JOBS, BATCH_JOBS

getParallelJobUHi

public double getParallelJobUHi(int jobType)

Gets the log2 of the maximal size of a job in the system (system's size)

Parameters:: jobType - the type of jobs
Returns:: the value of uHi; -1 if an error occurs.
See Also:: INTERACTIVE_JOBS, BATCH_JOBS

getParallelJobUMed

public double getParallelJobUMed(int jobType)

Gets the medium size of parallel jobs in the system. It is log2 of the size.

Parameters:: jobType - the type of jobs
Returns:: the value of uMed; -1 if an error occurs.
See Also:: INTERACTIVE_JOBS, BATCH_JOBS

getParallelJobULow

public double getParallelJobULow(int jobType)

Gets the the log2 of the minimal size of job in the system (you can add or subtract 0.2 to give less/more probability to the minimal size).

Parameters:: jobType - the type of jobs
Returns:: the value of uLow; -1 if an error occurs.
See Also:: INTERACTIVE_JOBS, BATCH_JOBS

setRunTimeParameters

public boolean setRunTimeParameters(int jobType,
                                    double a1,
                                    double a2,
                                    double b1,
                                    double b2,
                                    double pa,
                                    double pb)

Sets the parameters for the running time The running time is computed using hyper-gamma distribution. The parameters a1,b1,a2,b2 are the parameters of the two gamma distributions The p parameter of the hyper-gamma distribution is calculated as a straight (linear) line p = pa*nodes + pb. * 'nodes' will be calculated in the program, here we defined the 'pa','pb' parameters.

Parameters:: jobType - the type of jobs; a1 - hyper-gamma distribution parameter.; a2 - hyper-gamma distribution parameter.; b1 - hyper-gamma distribution parameter.; b2 - hyper-gamma distribution parameter.; pa - hyper-gamma distribution parameter.; pb - hyper-gamma distribution parameter.
Returns:: true if the parameters have been set, or false otherwise.

getRunTimeParameters

public double[] getRunTimeParameters(int jobType)

Gets the runtime parameters. That is, it returns the parameters used for the hyper-gamma distribution. For more detail on the parameters, please check the paper that describes the model.

Parameters:: jobType - the type of jobs
Returns:: an array where:
array[0] = a1 - hyper-gamma distribution parameter.
array[1] = a2 - hyper-gamma distribution parameter.
array[2] = b1 - hyper-gamma distribution parameter.
array[3] = b2 - hyper-gamma distribution parameter.
array[4] = pa - hyper-gamma distribution parameter.
array[5] = pb - hyper-gamma distribution parameter.
The method will return null if an error occurs.

setInterArrivalTimeParameters

public boolean setInterArrivalTimeParameters(int jobType,
                                             double aarr,
                                             double barr,
                                             double anum,
                                             double bnum,
                                             double arar)

Sets the parameters for the inter-arrival time.
The inter-arrival time is calculated using two gamma distributions. gamma(aarr,barr) represents the inter-arrival time for the rush hours. It is independent on the hour the job arrived at. The cdf of gamma(bnum,anum) represents the proportion of number of jobs which arrived at each time interval (bucket). The inter-arrival time is calculated using both gammas. Since gamma(aarr,barr) represents the arrival-time at the rush time, we use a constant, ARAR (Arrive-Rush-All-Ratio), to set the alpha parameter (the new aarr) so it will represent the arrive-time at all hours of the day.

Parameters:: jobType - the type of job for which the inter-arrival parameters will be modified.; aarr - the first parameter for gamma(aarr,barr) distribution; barr - the second parameter for gamma(aarr,barr) distribution; anum - the first parameter for gamma(bnum,anum) distribution; bnum - the second parameter for gamma(bnum,anum) distribution; arar - Arrive-Rush-All-Ratio
Returns:: true if the parameters have been set; false if they have not been set.

getInterArrivalTimeParameters

public double[] getInterArrivalTimeParameters(int jobType)

Returns the parameters for the inter-arrival time The inter-arriving time is calculated using two gamma distributions. gamma(aarr,barr) represents the inter_arrival time for the rush hours. It is independent on the hour the job arrived at. The cdf of gamma(bnum,anum) represents the proportion of number of jobs which arrived at each time interval (bucket). The inter-arrival time is calculated using both gammas Since gamma(aarr,barr) represents the arrive-time at the rush time, we use a constant, ARAR (Arrive-Rush-All-Ratio), to set the alpha parameter (the new aarr) so it will represent the arrive-time at all hours of the day.

Parameters:: jobType - the type of jobs
Returns:: an array where:
array[0] = aarr - gamma distribution parameter.
array[1] = barr - gamma distribution parameter.
array[2] = anum - gamma distribution parameter.
array[3] = bnum - gamma distribution parameter.
The method will return null if an error occurs.

setNumJobs

public boolean setNumJobs(int numJobs)

Sets the maximum number of jobs to be generated by this workload model

Parameters:: numJobs - the number of jobs
Returns:: true if the number of jobs has been set; false otherwise.

setMaximumWorkloadDuration

public boolean setMaximumWorkloadDuration(double duration)

Sets the maximum time duration of the workload. The workload will create jobs whose time of submission is less or equals to workloadDuration. The workload model will stop when it approaches workloadDuration.

Parameters:: duration - the maximum duration of the workload.
Returns:: true if the duration has been set; false otherwise.

getStartHour

public int getStartHour()

Gets the hour of the day when the simulation should start

Returns:: the start hour (between 0 and 23)

setStartHour

public boolean setStartHour(int start)

Sets the hour of the day when the simulation should start

Parameters:: start - the start hour to set (between 0 and 23)
Returns:: true if set; false otherwise.

setGridletFileSize

public boolean setGridletFileSize(int size)

Sets a Gridlet file size (in byte) for sending to/from a resource.

Parameters:: size - a Gridlet file size (in byte)
Returns:: true if it is successful, false otherwise
Pre Condition:: size > 0
Post Condition:: $none

generateWorkload

public ArrayList<WorkloadJob> generateWorkload()

Generates jobs according to the model.

Specified by:: generateWorkload in interface WorkloadModel

Returns:: the list of jobs generated; null in case of failure.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

GridSim 5.0 beta

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

The University of Melbourne, Australia, 2009

gridsim.parallel.util Class WorkloadLublin99