KuMo

AbstractAlgorithm

An abstract supertype for algorithms.

AbstractJob

An abstract supertype for jobs.

AbstractRequests

An abstract supertype for job requests.

AbstractResource

An abstract supertype for resources in a cloud morphing architecture. Any type MyResource <: AbstractResource needs to either:

• have a field capacity::T where T <: Number,
• implement a capacity(r::MyResource) method.

Optionally, one can implement a specific pseudo_cost(r::MyResource, charge) method.

AdditiveNode{T1 <: Number, T2 <: Number} <: AbstractNode

A node structure where the default pseudo-cost is translated by the value in the param field.

ConvexLink <: KuMo.AbstractLink

Link structure with a convex pseudo-cost function.

Data

Structure to store the information related to some Data. Currently, only the location of such data is stored.

DirectedTopology{N<:AbstractNode,L<:AbstractLink}

A structure to store the topology of a network. Beside the graph structure itself, it also stores the kinds of all nodes and links.

EqualLoadBalancingNode{T <: Number} <: AbstractNode

Node structure with an equal load balancing (monotonic) pseudo-cost function.

FlatLink <: KuMo.AbstractLink

Link structure with a constant pseudo-cost function.

FlatNode{T <: Number} <: AbstractNode

Node structure with a constant pseudo-cost function.

FreeLink <: AbstractLink

The pseudo-cost of such links is always zero.

IdleStateNode{T1 <: Number, T2 <: Number} <: AbstractNode

Node structure that stays iddle until a bigger system load than the default node. The param field is used to set the activation threshold.

Job <: AbstractJob

The most generic job type.

Arguments:

• backend::Int: size of the backend data to be sent from data location to the server
• containers::Int: number of containers required to execute the job
• duration::Float64: job duration
• frontend::Int: size of the frontend data to be sent from the user location to the server

Link{T <: Number} <: AbstractLink

Default link structure with an equal load balancing (monotonic) pseudo-cost function.

MultiplicativeNode{T1 <: Number, T2 <: Number} <: AbstractNode

A node structure where the default pseudo-cost is multiplied by the value in the param field.

Node{T <: Number} <: AbstractNode

Default node structure, defined by its maximal capacity and the default convex pseudo-cost function.

PremiumNode{T1 <: Number, T2 <: Number} <: AbstractNode

A node structure for premium resources. The param field set the premium threshold.

ShortestPath <: AbstractAlgorithm

A ShortestPath algorithm.

SnapShot

A structure to take snapshot from the state of network and its resources at a specific instant.

Arguments:

• state::State: state at instant
• total::Float64: total load at instant
• selected::Int: selected node at instant; value is zero if load is removed
• duration::Float64: duration of all the actions taken during corresponding to the state of this snap
• solving_time::Float64: time taken specifically by the solving algorithm (<: AbstractAlgorithm)
• instant::Float64

State

A structure to store the state of the different resources, e.g. nodes and links, during a simulation.

Arguments:

• links::SparseMatrixCSC{Float64, Int64}: sparse matrice with the links loads
• nodes::SparseVector{Float64, Int64}: sparse vector with the nodes loads
• State(n): inner constructor given the number of nodes n
• State(links, nodes): inner constructor given the links and nodes of an existing state

Topology{N<:AbstractNode,L<:AbstractLink}

A structure to store the topology of a network. Beside the graph structure itself, it also stores the kinds of all nodes and links.

User{R<:AbstractRequests}

A structure to store a user information. A user is defined as a location (node id).

add_load!(state, links, containers, v, n)

Adds load to a given state.

Arguments:

• state
• links: the load increase to be added on links
• containers: the containers load to be added to v
• v: node selected to execute a task
• n: amount of available nodes

capacity(r::R) where {R<:AbstractResource}

Return the capacity of a resource r.

clean(snaps)

Clean the snapshots by merging snaps occurring at the same time.

cond_minmax(x, y, b)

Return the min of x and y if b is false, and the max of x and y otherwise.

data(location)

Construct data at location. If the location is a collection, a random location is chosen.

post_simulate(s, snapshots, verbose, output)

Post-simulation process that covers cleaning the snapshots and producing an output.

Arguments:

• s: simulated scenario
• snapshots: resulting snapshots (before cleaning)
• verbose: if set to true, prints information about the output and the snapshots
• output: output path

post_simulate(s, snapshots, verbose, output)

Post-simulation process that covers cleaning the snapshots and producing an output.

Arguments:

• s: simulated scenario
• snapshots: resulting snapshots (before cleaning)
• verbose: if set to true, prints information about the output and the snapshots
• output: output path

graph(topo::Topology, algorithm::AbstractAlgorithm)

Creates an appropriate digraph using Graph.jl based on a topology and the requirement of an algorithm.

init_execution(::BatchSimulation)

Initialize a synchronous batch simulation.

init_execution(::InteractiveRun)

Initialize an interactive run.

inner_queue(g, u, j, nodes, capacities, state, ::ShortestPath, ii = 0; lck = ReentrantLock(), demands = nothing, links)

DOCSTRING

Arguments:

• g: a graph representing the topology of the network
• u: user location
• j: requested job
• nodes: nodes capacities
• capacities: links capacities
• state: current state of the network
• algo: ShortestPath <: AbstractAlgorithm
• ii: a counter to measure the progress in the simulation
• lck: a lck for asynchronous simulation
• demands: not needed for ShortestPath algorithm
• links: description of the links topology

insert_sorted!(w, val, it = iterate(w))

Insert element in a sorted collection.

Arguments:

• w: sorted collection
• val: value to be inserted
• it: optional iterator

job(backend::Int, containers::Int, data_location::Int, duration::Float64, frontend::Int)

Method to create new jobs.

job_distributions(; backend, container, data_locations, duration, frontend)

Construct a dictionary with random distributions to generate new jobs. Beside data_locations, the other arguments should be a 2-tuple defining normal distributions as in the Distributions.jl package.

Arguments:

• backend
• container
• data_locations: a collection/range of possible data location
• duration
• frontend

make_df(snapshots::Vector{SnapShot}, topo; verbose = true)

Make a DataFrame from the raw snapshots.

Arguments:

• snapshots: A collection of snapshots
• topo: topology of the network
• verbose: if set to true, it will print a description of the snapshots in the terminal

marks(df::DataFrame)

Returns a 4-tuple (a, b, c, d) that marks the start and end of the nodes and links columns in the dataframe.

• (a, b) mark the start and end indices of the nodes columns
• (c, d) mark the start and end indices of the links columns

param(r::R) where {R<:AbstractResource}

Default accessor for an optional parameter for R. If no param field exists, returns nothing.

pseudo_cost(cap, charge, resource, param...)
pseudo_cost(r::<:AbstractResource, charge)

Methods to compute the pseudo-cost of various resources.

pseudo_cost(r::R, charge) where {R<:AbstractResource}

Compute the pseudo-cost of r given its charge.

push_snap!(snapshots, state, total, selected, duration, solving_time, instant, n)

Add a snapshot to an existing collection of snapshots.

Arguments:

• snapshots: collection of snapshots
• state: current state
• total: load
• selected: node where a request is executed
• duration: duration of the whole resource allocation for the request
• solving_time: time taken specifically by the solving algorithm (<: AbstractAlgorithm)
• instant: instant when the request is received
• n: number of available nodes

rand_job(jd::Dict)

Create a random job given a job_distribution dictionary.

rem_load!(state, links, containers, v, n)

Removes load from a given state.

Arguments:

• state
• links: the load increase to be removed from links
• containers: the containers load to be removed from v
• v: node where a task is endind
• n: amount of available nodes

retrieve_path(u, v, paths)

Retrieves the path from u to v.

Arguments:

• u: source vertex
• v: target vertex
• paths: list of shortest paths within a network

user(location)

Construct a user at location. If the location is a collection, a random location is chosen.

valid_load(s, task, g, capacities, state, algo, demands, ii = 0)

Compute the best load allocation and return if it is a valid one.

Arguments:

• s: scenario being simulated
• task: task being requested
• g: graph of the network topology
• capacities: capacities of the network
• state: current state of resources
• algo: algo used for computing the best allocation cost
• demands: if algo is KuMoFlowExt.MinCostFlow, demands are required
• ii: a counter to measure the approximative progress of the simulation

vtx(algorithm::AbstractAlgorithm)

Return the number of additional vertices required by the algorithm used to allocate resources in the network.