Allows multiple RC objects to be added to this one with variable
parameter length
This operation expects a list of RC objects thus it is optimally used
when the RC objects are stored in a List anyways.
This function copies the contents of the depGroupExtension list to
the array representing the influence group and ensures that all newly
added members of the influence group know their group membership.
The background network load expected to be simulated between the
appliance's hosting repository and the PM that hosts the VM while the VM
runs its tasks.
if the notificaiton process is underway, then to be removed listeners are
registered here (they will still receive notifications in the current
notification round as their de-registration is actually a result of the
current notification round)
a comparator for timed objects based on next events and back preference
(those objects will be specified smaller that have an earlier next event
- if nextevents are the same then backpreference decides betwen events)
The number of ticks it is expected to take that renders both
underProcessing and toBeProcessed as 0 (i.e., the time when the initially
specified amount of resources are completely utilized).
This function is called when the resource consumption cannot be
handled properly - if a consumption is suspended (allowing its
migration to some other consumers/providers then this function is
not called.
stores the newly transferred storage object into the VM's disk field,
and then continues with the next step in the VM state management
(represented with the event setup)
Defines a power draw model that always returns an instantaneous power draw
value equivalent to the minimum consumption set for the current power state.
This class simplifies the implementation of consumption events and provides
basic functions to determine if a resource consumption has already been
completed (either with a failure or success).
handles the event aggregations, actual subscriptions to timed events and
dispatches the events if Timed notifies for time instance at which the
non-recurring events should be fired
Improves the performance of deferred events significantly if multiple
events should occur at once
Direct energy meters can monitor a single resource spreader and can convert
their processed consumption values to a continuously updated energy figure.
Allows to determine the background network load expected to be simulated
between the appliance's hosting repository and the PM that hosts the VM
while the VM runs its tasks.
Retrieves the number of ticks it is expected to take that renders both
underProcessing and toBeProcessed as 0 (i.e., the time when the initially
specified amount of resources are completely utilized).
If it is unknown whether we are a provider or a consumer (this is usually
the case in the generic resource spreader class or anyone outsed the
actual provider/consumer implementations) then it is useful to figure out
the counter part who also participates in the same resource consumption
processing operation.
Manages the increment of the hashCounter and offers the latest hash code
for new objects
WARNING: as this function does not check if a hash value is
already given or not there might be hash collisions if there are so many
resource spreaders created that the hashcounter overflows.
Calling this function should return an object which knows what to do in
case a new host registration/deregistration happens on the parent IaaS
service.
Defines to do the following when a new host is (de)registered to the
parent IaaSService:
if the current event is a registration event then the function
creates and locally registers a new capacity change manager for the newly
registered pms
if the current event is a deregistration event then the function
cancels the capacity management for all deregistered pms
Allows the reading of the beginning time instance of the metering session
If there were several metering sessions done by this meter, then this
function reports the time instance when a hypothetical single continuous
metering session would have started
Calling this function should return an object that knows the necessary
actions to take when the IaaS's VM scheduler alarms us for overutilized
infrastructure.
Defines to do the following when VM requests arrive:
check if there is already a PM under preparation (if there is one
then does nothing)
if there are no PM that is currently prepared then starts to prepare
one for accepting VM requests.
The function gets that particular resource spreader from the given
resource consumption object that is the same kind (i.e.,
provider/consumer) as the resource spreader that calls for this function.
Returns the total amount of resources processed (i.e., via all past and
present resource consumption objects) by this resource spreader object at
the time instance this call is made.
A helper field to show if the consumer/providerLimit fields are under
update by MaxMinFairSpreader.assignProcessingPower()
WARNING: this is necessary for the internal behavior of
MaxMinFairSpreader
inbws -
Variable in class hu.mta.sztaki.lpds.cloud.simulator.io.NetworkNode
Models the incoming network connections of this network node
The list of repositories under direct control of this IaaS service - this
is for internal purposes the list is writeable
The order of internal repositories is not guaranteed
The actual writable list of the running machine set maintained behind
this IaaSService
WARNING: The order of internal running machines is not guaranteed
This function is actually calling the subclass's scheduler implementation
and handles the management of minimum scheduler requirements and resets
the free resource aggregate
Defines a power draw model that interpolates the returned instantaneous power
draw values between the minimum and maximum power draw values from the power
state.
This is the recommended length for how long a resource allocation will be
kept before it becomes invalid in case the allocation is made for a VM
migration.
minConsumption -
Variable in class hu.mta.sztaki.lpds.cloud.simulator.energy.powermodelling.PowerState
creates an object that holds the exact copy of the current virtual
appliance with a different id
Please note this copy is not going to be registered in any repositories
(unlike the other VA), nor will it be used by any virtual machines.
if the notificaiton process is underway, then new listeners are
registered here (they will not receive notifications in the current
notification round as their registration is actually a result of the
current notification round)
Defines a power draw model that either uses the LinearConsumptionModel to
determine the power draw of uses 0W power draw value if there is no load
specified.
if there are some external activities that could lead to influence
group changes this field will be turned to true
the tick function then ensures it to return to false once it has
completed its management operations on the influence groups
The constructor of the delayer, it allows the specification of the
tasks (that represent the boot/shutdown or similar operations) to be
done before the power state can be achieved.
This class is strongly connected with the physical machine's class, the
two are collaborating to allow a fluid and minimal hassle operation of
allocating resources on a PM.
if the power state of the resource spreader changes then the meter is
readjusted for the new power state - this usually means the meter
collects all uncolledted resource consumption related information from
the spreader
This function allows the simplified creation of singletransfer objects
for modeling the operation of writing data to the disk/network of this
node from its memory.
Q
queue -
Variable in class hu.mta.sztaki.lpds.cloud.simulator.iaas.vmscheduling.Scheduler
The queue of the scheduler.
queuedRC -
Variable in class hu.mta.sztaki.lpds.cloud.simulator.iaas.vmscheduling.QueueingData
A single VM should have this much resources allocated to it
queuedRepo -
Variable in class hu.mta.sztaki.lpds.cloud.simulator.iaas.vmscheduling.QueueingData
The repository that is storing the VM's virtual appliance.
queuedVMs -
Variable in class hu.mta.sztaki.lpds.cloud.simulator.iaas.vmscheduling.QueueingData
This function allows the simplified creation of singletransfer objects
for modeling the operation of reading data from the disk/network of this
node to its memory.
Constructor of a freqsyncer to be used when neither the provider nor
the consumer of a resource consumption belongs to an already existing
influence group.
This iterator alters the restart operator so it no longer resets the pointer
of the PM iterator but instead it marks the last PM encountered during the
previous iteration.
The base class for all VM schedulers, provides the foundational logic and
simplifies the implementation of VM schedulers by allowing them to mainly
focus on their scheduling logic.
Implementing this interface allows the implementor to receive events from
the scheduler about cases when it believes the infrastructure is not
sufficient for its needs.
Data for custom schedulers (e.g., like specific placement requirements -
please put me on this machine and this machine only), if null then there
is no data.
Allows to set the background network load expected to be simulated
between the appliance's hosting repository and the PM that hosts the VM
while the VM runs its tasks.
If there are not enough resources for the VM currently, to recover from
this state (and allow the VM to be rescheduled) just issue a destroy
command on the VM
Allows to set the current processing power of this resource spreader
WARNING: this is not intended to be used for altering the
performance of the spreader while it participates in resource consumption
processing
Simultaneously updates the real limit (the instantaneous processing limit
determined by the low level scheduler of the unified resoruce sharing
model of DISSECT-CF) value as well as the halfreallimit field.
Allows to set a new resource allocation for the VM
This function will notify the resource allocation about the acquiration
of the resources by utilizing the use function!
This class offers a VM scheduler that keeps the VM request queue in order and
always places those VM requests first that have the smallest resource
demands.
terminates the metering session for the aggregation and ensures that we
no longer consider capacity changes for the PM as they don't need to be
reflected in the metering results anymore
Implementation of Algorithm 1 from
"DISSECT-CF: a simulator to foster energy-aware scheduling in infrastructure clouds"
Manages the influence group's growth and decomposition.
tick(long) -
Method in class hu.mta.sztaki.lpds.cloud.simulator.Timed
This function will be called on all timed objects which asked for a
recurring event notification at a given time instance.
The remaining unprocessed entities (e.g., remaining bytes of a transfer)
NOTE: as this consumption is generic, it is actually the
provider/consumer pair that determines what is the unit of this field
offers a convenient human readable output for debugging energy meters and
their readings where both the metered resource and its currently reported
total consumpiton is printed out
toString() -
Method in class hu.mta.sztaki.lpds.cloud.simulator.energy.powermodelling.PowerState
A convenient and compact way to represent the main characteristics of
this power state.
Provides a nice formatted output of the resource consumption showing how
much processing is under way, how much is still held back and what is the
current real limit set by the scheduler.
A message to show if the scheduler/first fit scheduler implementation
would try to use previously unused List operations that were not
implmeneted so far.
A helper field to show if the particular resource consumption still
participates in the scheduling process or if it has already finalized its
realLimit value.
The number of resource consumptions for which this spreader still did not
assign temporal resource utilization limits - see: p(c,s,t) in the paper
titled
"DISSECT-CF: a simulator to foster energy-aware scheduling in infrastructure clouds"
.
The currently processing entities (e.g., a network buffer)
NOTE: as this consumption is generic, it is actually the
provider/consumer pair that determines what is the unit of this field
If a resource consumption is not supposed to be limited by anything but
the actual resource providers/consumers then this limit could be used in
its constructor.
unsubscribe() -
Method in class hu.mta.sztaki.lpds.cloud.simulator.Timed
after some deferred events are dispatched, this function actually
determines the next occurrence of a deferred event (and readjusts the
notification frequency for Timed) or if there are no further events
registered, the function cancels the notifications
Provides a unified update method for the hard processing limit (which
will become the minimum of the provider's/consumer's per tick processing
power) of this consumption.
Calls out to the low level scheduler of the group to assign
processing limits for each consumption in the group and to identify
the completion time of the earliest terminating consumption.
Provides an implementation of the eventsetup class for the startup
procedure which is modelled with a single taks that utilizes a single
core of the VM for a specified amount of time (in ticks)