A system represents of the entire system which is the target of optimization.

A system is a single object irrespective of the number or type of entities or layers that are in the scope of the optimization. It can be used to model and describe a wide set of entities like:

• An N-layers application

• A single micro-service

• A single (or a collection of) batch job(s)

A System is made of one or more components. Each component represents one of the elements in the system, whose parameters are involved in the optimization or whose metrics are collected to evaluate the results of such optimization.

Construct

A system is described by the following properties:

• The full micro-services stack of an application

• a name that uniquely identifies the system

• a description that clarifies what the system refers to

The construct to be used to define a system is described on the System template page.

Commands

A system is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI displays systems (depending on the user privileges on the defined workspaces) in a specific top-level menu.

This section provides a definition of Akamas' key concepts and terms and also provides references to the related construct properties, commands, and user interfaces.

A parameter is a property of the system that can be applied and tuned to change the system's behavior. Akamas optimizes systems by changing parameters to achieve the stated goal while respecting the defined constraints.

Examples of a parameter include:

• Configuration knobs (e.g. JVM garbage collection type)

• Resource settings (e.g. amount of memory allocated to a Spark job)

• Algorithms settings (e.g. learning rate of a neural network)

• Architectural properties (e.g. how many caching layers in an enterprise application)

• Type of resources (e.g. AWS EC2 instance or EBS volume type)

• Any other thing (e.g. amount of sugar in your cookies)

The following table describes the parameter types:

Construct

A parameter is described by the following properties:

• a name that uniquely identifies the parameter

• a description that clarifies the semantics of the parameter

• a unit that defines the unit of measurement used by the parameter

Although users can create parameters with any name, we suggest using the naming convention context_parameter where

• context refers to the technology or more general environment in which that metric is defined (e.g. elasticsearch, jvm, mysql, spark)

• parameter is the parameter name in the original context (e.g. gcType, numberOfExecutors)

This makes it possible to identify parameters more easily and avoid any potential name clash.

The construct to be used to define a parameter is described on the Parameter template page.

User Interface

Parameters are displayed in the Akamas UI when drilling down to each system component.

For each optimization study, the optimization scope is the set of parameters that Akamas can change to achieve the defined optimization goal.

A metric is a measured property of a system.

Examples of a metric include:

• the response time of an application

• the utilization of a CPU

• the amount of time spent in garbage collection

• the cost of a cloud service

Metrics are used to both specify the optimization (e.g. minimize the heap size while keeping response time < 1000 and error rate <= 10% of a baseline value), and to assess the behavior of the system with respect to each specific configuration applied.

Construct

A metric is described by the following properties:

• a name that uniquely identifies the metric

• a description that clarifies the semantics of the metric

• a unit that defines the unit of measurement used by the metric

The construct to be used to define a metric is described on the page.

User Interface

Metrics are displayed in the Akamas UI when drilling down to each system component.

and are represented in metric charts for each specific optimization study

A telemetry provider is a software object that represents a data source of metrics. A is a specific instance of a telemetry provider that refers to a specific data source.

Examples of telemetry providers are:

• monitoring tools (e.g. Prometheus or Dynatrace)

• load testing tools (e.g. LoadRunner or Neoload)

• CSV files

A telemetry provider is a platform-wide entity that can be reused across systems to ease the integration with metrics sources.

Akamas provides a number of out-of-the-box . Custom telemetry providers can also be created.

Construct

The construct to be used to define a telemetry provider is described on the page.

Commands

A telemetry provider is an that can be managed via CLI using the

User Interface

The Akamas UI shows systems in a specific top-level menu.

This guide provides a describing Akamas key concepts with their associated construct templates, command line commands, and user interfaces.

This guide also provides references to:

• structure and operators

• metric mapping

• metrics and parameters

• to administer Akamas, manage users, authenticate and manage its resources

An optimization pack is a software object that provides a convenient facility for encapsulating all the knowledge (e.g. metrics, parameters with their default values and domain ranges) required to apply Akamas optimizations to a set of entities associated with the same technology.

Notice that while optimization packs are very convenient for modeling systems and creating studies, it is not required for these entities to be covered by an optimization pack.

Akamas provides a library of out-the-box optimization packs and new custom optimization packs can be easily added (no coding is required).

Construct

An optimization pack needs to include the entities that encapsulate technology-specific information related to the supported component types:

• supported component types

• parameters and metrics for each component type

• supported telemetry providers (optional)

Commands

An optimization pack is an that can be managed via CLI using the

User Interface

The Akamas UI shows systems in a specific top-level menu.

An optimization pack encapsulates one or more of the following technology-specific elements:

• Component Types: these represent the type of the component(s) included, each with its associated parameters and metrics

• Telemetry Providers: that define where to collect metrics

An optimization pack enables Akamas users to optimize a technology without necessarily being an expert in that technology and to code their knowledge about a technology or a specific application to be reused in multiple optimization studies to ease the modeling process.

The optimization goal defines the objective of an to be achieved by changing the system parameters to modify the system behavior while also satisfying any defined optimization constraints on the system metrics, possibly representing SLOs.

Construct

A goal is defined by:

• an optimization objective: either maximize or minimize

• a scoring function (scalar): either a single metric or a formula defined by one or more metrics

One or more constraints can be associated with a goal

• a formula defined on one or more metrics, referring to either absolute values (absolute constraints) or relative to a baseline value (relative constraints)

Notice that relative constraints are only supported by while absolute constraints are supported by both offline and .

Goals and constraints are not an as they are defined as part of an optimization study. The construct to be used to define a goal and its constraints are described in the page of the section.

Commands

Goals and constraints are not an and are always defined as part of an optimization study.

User Interface

Goals and constraints are displayed in the Akamas UI when drilling down each optimization study.

The detail of the formula used to define the goal may also be displayed:

An optimization study (or study for short) represents an optimization initiative aimed at optimizing a goal on a target system. A study instructs Akamas about the space to explore and the KPIs used to evaluate whether a con configuration is good or bad

Akamas supports two types of optimizations:

• Offline Optimization Studies are optimization studies where the workload is simulated by leveraging a load-testing tool.

• Live Optimization Studies are applied to systems that need to be optimized in production with respect to varying workloads observed while running live. For example, a microservices application can be optimized live by having Kubernetes and JVM parameters dynamically tuned for multiple microservices so as to minimize costs while matching response time objectives.

Construct

A study is described by the following properties

• system: the system under optimization

• parameters: the set of parameters being optimized

• metrics: the set of metrics to be collected

• workflow: the workflow describing tasks to perform experiments/trials

• goal: the desired optimization goal to be achieved

• constraints: the optimization constraints that any configuration needs to satisfy

• steps: the steps that are executed to run specific configurations (e.g. the baseline) and run the optimization

The construct to be used to define an optimization is described on the Study template page.

Commands

An optimization study is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI shows optimization studies in 2 specific top-level menus: one for offline optimization studies and another for live optimization studies.

A KPI is a metric that is worth considering when analyzing the result of an offline optimization study, looking for (sub)optimal configurations generated by Akamas AI to be applied.

Akamas automatically considers any metric referred to in the defined optimization goal and constraints for an offline optimization study as a KPI. Moreover, any other metrics of the system component can be specified as a KPI for an offline optimization study.

Construct

A KPI is defined as follows (from the UI or the CLI):

KPIs are not an Akamas resource as they are defined as part of an optimization study. The construct to define KPIs is described on the KPIs page of the Study template section.

Commands

KPIs are not an Akamas resource and are always defined as part of an optimization study.

User Interface

The number and first KPIs are displayed in the Akamas UI in the header of each offline optimization study.

The full list of KPIs is displayed by drilling down to the KPIs section.

From this section, it is possible to modify the list of KPIs and change their names and other attributes.

Live Optimization studies are where the workload is real: the system that needs to be optimized operates with respect to varying workloads observed while running live.

Live optimization studies are typically used to optimize systems in production environments. For example, a microservices application can be optimized while running in production by having Kubernetes and JVM parameters dynamically tuned for multiple microservices so as to minimize costs while matching response time objectives.

The following figure represents the iterative process associated with offline optimizations:

The following 5 phases can be identified for each iteration:

3. Recommend Conf: Akamas provides a recommendation for parameter configuration based on the observed behavior under the specific workload context and leveraging the Akamas AI

4. Human Approval: this is an optional step as there are two operational modes:

   • autonomous mode: no human intervention is required

   • human-approval mode: recommendations need to be approved by users before configuration changes get applied - recommendations can be changed by users

Notice that configurations can be applied by Akamas via integrations with native interfaces (e.g. Kubectl), by leveraging any orchestration and automation tool in place (e.g. OpenShift), or by triggering a pull request to a configuration repository (e.g. Git). This can be applied to either the entire target system or to a canary deployment.

Safety Policies

Commands

User Interface

The Akamas UI shows live optimization studies in a specific top-level menu.

The details and results of an offline optimization study are displayed when drilling down.

A component represents an element of a system. Typically, systems are made up of different entities and layers which can be modeled by components. In other words, a system can be considered a collection of related components.

Notice that a component is a black-box definition of each entity involved in an optimization study, so detailed modeling of the entities being involved in the optimization is not required. The only relevant elements are the parameters that are involved in the optimization and the metrics that are collected to evaluate the results of such an optimization.

Notice that only the entities that are directly involved in the optimization need to be modeled and defined within Akamas. An entity is involved in an optimization study if it is optimized or monitored by Akamas, where "optimized" means that Akamas is optimizing at least one of its parameters, and "monitored" means that Akamas is monitoring at least one of its metrics.

Construct

A component is described by the following mandatory properties (other properties can be defined but are not mandatory):

• a name that uniquely identifies the component within the system

• a description that clarifies what the component refers to

• a component type that identifies the technology of the component (see component type)

In general, a component contains a set of each of the following:

• parameter(s) in the scope of the optimization

• metric(s) needed to define the optimization goal

• metric(s) needed to define the optimization constraints

• metric(s) that are not needed to either define the optimization goal or constraints, and hence not used by Akamas to perform the optimization, but are collected in order to support the analysis (and which can be possibly added at a later time as part of optimization goal or constraint when refining the optimization).

The construct to be used to define a component is described on the Component template page.

Commands

A component is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI shows more details about components by drilling down their respective system.

Offline optimization studies are optimization studies where the workload is simulated by leveraging a load-testing tool.

Offline optimization studies are typically used to optimize systems in pre-production environments, with respect to planned and what-if scenarios that cannot be directly run in production. Scenarios include new application releases, planned technology changes (e.g. new JVM or DB), cloud migration or new provider, expected workload growth, and resilience under failure scenarios (from chaos engineering).

The following figure represents the iterative process associated with offline optimizations:

The following 5 phases can be identified for each iteration (also known as experiment):

1. Apply configuration: Akamas applies the parameter configuration (one or more parameters) to the target system by leveraging a set of workflow operators

2. Apply workload: Akamas triggers a workload on the target system by also leveraging a set of workflow operators

3. Collect KPIs: Akamas collects the metrics related to the target system - only those metrics that are specified by each telemetry instance defined in the system

4. Score vs goal: Akamas scores the applied parameter configuration against the defined goal and constraints - the score is the value of the goal function

5. Recommend Conf: Akamas AI engine identifies the configuration for the next iteration until a termination condition for the study is met (e.g. number of experiments).

Thanks to its patented AI (reinforcement learning) algorithms, Akamas can find the optimal configuration without having to explore all the possible configurations.

Trials

For each experiment, Akamas allows multiple trials to be executed. A trial is a repetition of the same experiment to reduce the impact of noise on the result of an experiment.

Environments can be noisy for several reasons such as:

• External conditions (e.g. background jobs, "noisy neighbors" in the cloud)

• Measurement errors (e.g. monitoring tools not always 100% accurate)

This approach is consistent with scientific and engineering practices, where the strategy to minimize the impact of noise is to repeat the same experiment multiple times.

Steps

An offline optimization study can include multiple steps.

Typically there are at least two steps:

• Baseline step: a single experiment that is run by applying the already deployed configuration before the Akamas optimization is applied - the results of this experiment are used as a reference (baseline) for assessing the optimization and as such is a mandatory step for each study

• Optimize step: a defined number of experiments used to identify the optimal configuration by leveraging Akamas AI.

Other steps are:

• Bootstrap step: imported experiments from other optimization studies

• Preset step: a single experiment with a defined configuration

The steps to be executed can be specified when defining an offline optimization study.

Commands

An offline optimization study is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI shows offline optimization studies in a specific top-level menu.

The details and results of an offline optimization study are displayed when drilling down (there are multiple tabs and sections).

A telemetry instance is an instance of a that collects data from a specific instance of the data source.

A telemetry instance is an instance of a telemetry provider, providing the required information on how to connect and collect a given set of metrics from a specific data source.

While telemetry providers are platform-wide entities, telemetry instances are defined at each system level.

Construct

The construct to be used to define a telemetry instance is described on the page.

Commands

A telemetry provider is an that can be managed via CLI using the

User Interface

Telemetry instances are displayed in the Akamas UI when drilling down each system component.

This section describes all the structures that can be used to define resources and objects in Akamas.

A workflow is a set of tasks that run in sequence to evaluate a configuration as part of an optimization study. A task is a single action performed within a workflow.

Workflows allow you to automate Akamas optimization studies, by automatically executing a sequence of tasks such as initializing an environment, triggering load testing, restoring a database, applying configurations, and much more.

These are examples of common tasks:

• Launch remote commands via SSH

• Apply parameter values in configuration files

• Execute Spark jobs via spark-submit API

• Start performance tests by integrating with external tools such as Neoload

Workflows are first-class entities that can be defined globally and then used in multiple optimization studies.

Akamas provides several workflow operators that can be used to perform tasks in a workflow. Some operators are general-purpose, such as those executing a command or script on a specific host, while others provide native integrations with specific technologies and tools, such as Spark History Server or load testing tools.

Construct

The construct to be used to define a workflow is described on the Workflow template page.

Commands

A telemetry provider is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI shows systems in a specific top-level menu.

The list of tasks is displayed when drilling down to each specific workflow.

Parameters are defined using a YAML manifest with the following structure:

parameters:
  - name: jvm_heap_size
    description: the size of the heap of the jvm
    unit: megabytes
    restart: false
  - name: jvm_survival_ratio
    description:  the ratio of the two survivor spaces in the jvm gc

with the following properties:

Notice that parameter definitions are shared across all the workspaces on the same Akamas installation, and require an account with administrative privileges to manage them.

Example

The following represents a set of parameters for a JVM component

parameters:
  - name: jvm_maxHeapSize
    description: Maximum heap size
    unit: megabytes
    restart: true
  - name: jvm_newRatio
    description: Ratio of old/new generation sizes
    restart: true
  - name: jvm_maxTenuringThreshold
    description: Maximum value for tenuring threshold
    restart: true
  - name: jvm_survivorRatio
    description: Ratio of eden/survivor space size
    restart: true
  - name: jvm_concurrentGCThreads
    description: Number of threads concurrent garbage collection will use
    unit: threads
    restart: true
  - name: jvm_gcType
    description: Type of the garbage collection algorithm
    restart: true

The following represents a set of CPU-related parameters for the Linux operating system

parameters:
  # CPU Related
  - name: os_cpu_sched_min_granularity_ns
    description: Target minimum scheduler period in which a single task will run
    unit: nanoseconds
    restart: false
  - name: os_cpu_sched_wakeup_granularity_ns
    unit: nanoseconds
    description: desc
    restart: false
  - name: os_cpu_sched_migration_cost_ns
    unit: nanoseconds
    description: desc
    restart: false
  - name: os_cpu_sched_child_runs_first
    description: desc
    restart: false
  - name: os_cpu_sched_latency_ns
    unit: nanoseconds
    description: desc
    restart: false
  - name: os_cpu_sched_autogroup_enabled
    description: desc
    restart: false
  - name: os_cpu_sched_nr_migrate
    description: desc
    restart: false

Metrics are defined using a YAML manifest with the following structure:

and properties:

Supported units of measure

The supported units of measure for metrics are:

Choosing the correct metric unit

The most important thing when designing custom optimization packs is to choose the correct unit of measure for every metric. In the previous paragraph you were given a full listing of the supported units of measure and the way they are scaled by Akamas UI (e.g. you may notice that, when viewing study or optimization charts memory bytes are scaled to megabytes or gigabytes, whenever needed). There is another scaling involved and this happens inside telemetry providers. Akamas integrates with several telemetry providers (such as Neoload, Loadrunner, Dynatrace, etc). The purpose of these Akamas providers is to mask the differences between scaling units used by the various telemetry providers (again: Neoload, Loadrunner, etc) and to perform a specific scaling on these measures in order to guarantee that all metrics are homogeneous when they are finally fed to the Akamas engine.

Let's take Akamas provider for Dynatrace, for example. Here's a snippet of the internal metrics mapping between Dynatrace and Akamas:

This means that values coming from Dynatrace metric builtin:service.response.time will be mapped to Akamas metric requests_response_time but since Dynatrace returns microseconds with that metric, Akamas provider code will scale it multiplying by 0.001 to convert it to nanoseconds. Similarly, values coming from Dynatrace metric builtin:service.errors.total.rate which are percent values but range from 0 to 100, must be scaled (scale factor is 0,01) in order to convert them to domain [0.0, 1.0] used by Akamas

So when designing a custom optimization pack you should make sure that:

• memory unit is bytes

• cpu unit is CPUs when real hardware is involved

• cpu unit is millicores when docker/Kubernetes containers are involved

• cpu utilization unit is percent (100% being 1.00)

• throughput unit is XXX/sec (e.g.: bytes/sec, responses/sec, collections/sec)

• temporal unit for CPU-related metrics is nanoseconds

• temporal unit for web-related metrics is milliseconds

• temporal unit for human-related metric is seconds (unless otherwise noted by the telemetry provider)

Telemetry Providers are defined using a YAML manifest with the following structure:

with the following properties:

Refer to the page which describes the out-of-the-box Telemetry Providers that are created automatically at Akamas install time.

Components are defined using a YAML manifest with the following structure:

and properties:

Examples

Example of a component for OpenJDK11:

Example of a component for the Linux operating system:

Component types are defined using a YAML manifest with the following structure:

and properties for the general section:

The parameter section describes the relationship between the component type and already defined parameters with the following properties:

The metric section describes the relationship between the component type and already defined metrics with the following properties:

Notice that component type definitions are shared across all the workspaces on the same Akamas installation, and require an account with administrative privileges to manage them.

Examples

Example of a component for the Cassandra component type:

Example of a component for the Linux operating component type:

Systems are defined using a YAML manifest with the following structure:

with the following properties:

Example

The following represents a system (for Cassandra related system)

A workspace is a virtual environment that groups systems, workflows, and studies to restrict user access to them: a user can access these resources only when granted the required permissions to that workspace.

Akamas defines two user roles according to the assigned permission on the workspace:

• Contributors (write permission) can create and manage workspace resources (studies, telemetry instances, systems, and workflows) and can also do exports/imports, view all global resources (Optimization Packs, and Telemetry Providers), and see remaining credits;

• Viewers (read permission) can only access optimization results but cannot create or modify workspace resources.

Workspaces and accesses are managed by users with administrative privileges. A user with administrator privileges can manage licenses, users, workspaces, and install/deinstall Optimization Packs, and Telemetry Providers.

Workspaces can be defined according to different criteria, such as:

• By department (e.g. Performance, Development)

• By initiative (e.g. Poc, Training)

• By application (e.g. Registry, Banking..)

A workspace is described by the following property:

• a name that uniquely identifies the workspace

Commands

A workspace is an that can be managed via CLI using the See also this page devoted to commands on .

User Interface

The workspace a study belongs to is always displayed. Filters can be used to select only studies belonging to specific workspaces

The Windowing field in a study specifies the windowing policy to be adopted to score the experiments of an optimization study.

The two available windowing strategies have different structures:

• Trim windowing: trim the temporal interval of a trial, both from the start and the end of a specified temporal amount - this is the default strategy

• Stability windowing: discard temporal intervals in which a given metric is not stable and selects the temporal interval in which a metric is maximized or minimized.

In case the windowing strategy is not specified, the entire time window is considered.

The MetricSelection field in a study specifies the metrics of the system. Such selection has only the purpose to specify which metrics need to be tracked while running the study and does not affect the optimization.

In case this selection is not specified, all metrics are considered.

A metrics selection can either assume the value of all to indicate that all the available metrics of the system of the study should be tracked, or can assume the value of a list of the names of metrics of the system that should be tracked prepended with the name of the component.

Example

The following fragment is an example:

metricsSelection:
  - application.response_time
  - application.error_rate
  - jvm1.gc_time

A component type is a blueprint for a component that describes the type of entity the component refers to. In Akamas, a component needs to be associated with a component type, from which the component inherits its metrics and parameters.

Component types are platform entities (i.e.: shared among all the users) usually provided off the shelf and shipped within the Optimization Packs. Typically, different component types within the same optimization pack are used to model different versions/releases of the same technology.

Akamas users with appropriate privileges can create custom component types and optimization packs, as described on the Creating custom optimization pack page.

Construct

A component type is described by the following mandatory properties (other properties can be defined but are not mandatory):

• a name that uniquely identifies the component type within the system

• a description that clarifies what the component type refers to

• a parameter definitions array (more on Parameters later)

• a metrics array (more on Metrics later)

The construct to be used to define a component type is described on the Component type template page.

Commands

A component type is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

When visualizing system components the component type is displayed.

The following figure shows the out-of-the-box JVM component types related to the JVM optimization pack.

Optimization studies are defined using a YAML manifest with the following structure:

system: 1
name: Optimizing the e-shop application
goal:
  objective: maximize
  function:
    formula: payments_per_sec
    variables:
      payments_per_sec:
        metric: eshop_payments
        labels:
          componentName: eshop

workflow: eshop_jmeter_test
steps:
  - name: baseline
    type: baseline
    values:
      tomcat.maxThreads: 1024
      jvm.maxHeap: 2048
      jvm.garbageCollectorType: G1GC
      postgres.shared_buffers: 4096

with the following mandatory properties:

Some of these optional properties depend on whether the study is an offline or live optimization study.

Number of trials

It is possible to perform more than one trial per experiment in order to validate the score of a configuration under test, e.g. to take into account noisy environments.

The following fragment of the YAML definition of a study sets the number of trials to 3:

numberOfTrials: 3

Notice: This is a global property of the study which can be overwritten for each step.

Trial aggregation

The trial aggregation policy defines how trial scores are aggregated to form experiment scores.

There are three different types of strategies to aggregate trial scores:

• AVG: the score of an experiment is the average of the scores of its trials - this is the default

• MIN: the score of an experiment is the minimum among the scores of its trials

• MAX: the score of an experiment is the maximum among the scores of its trial

The following fragment of the YAML definition of a study sets the trial aggregation to MAX:

trialAggregation: MAX # other possible values are AVG, MIN

Examples

The following system refers to an offline optimization study for a system modeling an e-commerce service, where a windowing strategy is specified:

system: "bde4f259-9a51-4c67-87aa-3c5bc599c6b9" # id of the system to optimize with the actions defined in this study
workflow: "eshop_jmeter_test" # name of the workflow to use to perform trials
name: Optimizing the e-shop application # name of the study
goal: # the performance goal to achieve
  objective: "maximize"
  function:
    formula: "eshop.payments_per_second"
windowing: # the temporal window in which to compute the score of a trial
  type: "trim"
  trim: ["10s", "0s"] # use the duration of the trial minus 0s from start and end to compute the score of the trial
parametersSelection: "all" # use all available configuration parameters
metricsSelection: "all" # gather all metrics
steps: # the steps to conduct to perform experiments and trials
  - name: "my_baseline" # do first a baseline with the provided configuration
    type: "baseline"
    values:
      jvm.maxHeap: 2048
      jvm.gcType: "-XX:+UseParallelGC"
  - name: my_optimization # then do 20 optimization experiments of 2 trials each
    type: optimize
    numberOfExperiments: 200
    numberOfTrials: 2

The following offline study refers to a tuning initiative for a Cassandra-based system (ID 2)

system: 2
name: Optimizing the cassandra - team 2
goal:
  objective: minimize
  function:
    formula: read_response_time_p90
    variables:
      read_response_time_p90:
        metric: read_response_time_p90
        labels:
          componentName: cassandra

windowing:
  type: trim
  trim: [5m, 1m]

workflow: cassandra_workflow
parametersSelection:
  - name: cassandra_jvm.jvm_maxHeapSize
  - name: cassandra.cassandra_concurrentReads
  - name: cassandra.cassandra_concurrentWrites
  - name: cassandra.cassandra_fileCacheSizeInMb
  - name: cassandra.cassandra_memtableCleanupThreshold
  - name: cassandra.cassandra_concurrentCompactors

steps:
  - name: baseline_step
    type: baseline
    values:
      cassandra_jvm.jvm_maxHeapSize: 1024
      cassandra.cassandra_concurrentReads: 32
      cassandra.cassandra_concurrentWrites: 32
      cassandra.cassandra_fileCacheSizeInMb: 512
      cassandra.cassandra_memtableCleanupThreshold: 0.11
      cassandra.cassandra_concurrentCompactors: 2

  - name: optimization_step
    type: optimize
    optimizer: CALABI
    numberOfExperiments: 50

The following offline study is for tuning another Cassandra-based system (ID 3) by acting only on JVM and Linux parameters

system: 3
name: Optimizing a Cassandra NoSQL database version 3 (jvm + os parameters)
goal:
  objective: minimize
  function:
    formula: (x1+x2)/2
    variables:
      x1:
        metric: write_response_time_p90
        labels:
          componentName: cassandra_team1
      x2:
        metric: read_response_time_p90
        labels:
          componentName: cassandra_team1

windowing:
  type: trim
  trim: [8m,2m]

numberOfTrials: 2
workflow: cassandra_workflow_jvm_os

parametersSelection:
  - name: JVM1.jvm_maxHeapSize
  - name: JVM1.jvm_newRatio
  - name: JVM1.jvm_survivorRatio
  - name: JVM1.jvm_maxTenuringThreshold
  - name: JVM1.jvm_gcType
  - name: JVM1.jvm_concurrentGCThreads
  - name: os1.os_cpuSchedMinGranularity
  - name: os1.os_cpuSchedWakeupGranularity
  - name: os1.os_CPUSchedMigrationCost
  - name: os1.os_CPUSchedChildRunsFirst
  - name: os1.os_CPUSchedLatency

steps:
  - name: baseline_step
    type: baseline
    values:
      JVM_team1.jvm_maxHeapSize: 1024
      JVM_team1.jvm_newRatio: 2
      JVM_team1.jvm_survivorRatio: 8
      JVM_team1.jvm_maxTenuringThreshold: 15
      JVM_team1.jvm_gcType: UseConcMarkSweepGC
      JVM_team1.jvm_concurrentGCThreads: 8
      os_team1.os_cpuSchedMinGranularity: 3000000
      os_team1.os_cpuSchedWakeupGranularity: 4000000
      os_team1.os_CPUSchedMigrationCost: 500000
      os_team1.os_CPUSchedChildRunsFirst: 0
      os_team1.os_CPUSchedLatency: 24000000

  - name: optimization_sobol
    type: optimize
    optimizer: SOBOL
    numberOfExperiments: 3

  - name: optimization_calabi
    type: optimize
    optimizer: CALABI
    numberOfExperiments: 50

Telemetry instances are defined using a YAML manifest with the following structure:

provider: Provider Name
name: My Telemetry Instance
config:
  providerSpecificConfig1: "<value>"
  providerSpecificConfig2: 123
metrics:
- name: metric_name
  datasourceName: datsource_metric_name
  defaultValue: 1.23
  labels:
    - label1
    - label2
  staticLabels:
    staticLabel1: staticValue1
    staticLabel2: staticValue2

with the following properties for the global section

and the metrics section

Workflow are defined using a YAML manifest with the following structure:

name: "insert_workflow_name_here"
tasks:
# these are the tasks that will be executed sequentially to complete a trial (configure the system under tests with the parameters optimized by Akamas )
- name: "insert_here_name_of_task"
  # an operator specifies which type of task should be used
  operator: "insert_here_which_operator_to_use_for_the_task"
  # each operator accepts different arguments necessary to specify how it should behave
  arguments:
	...

with the following properties:

The full list of Operators and related options is provided on the Workflow Operators pages.

Example

A workflow for the java-based renaissance benchmark application

name: renaissance-optimize

tasks:
- name: Configure Benchmark
  operator: FileConfigurator
  arguments:
    source:
      hostname: benchmark
      username: akamas
      password: akamas
      path: launch_benchmark.sh.templ
    target:
      hostname: benchmark
      username: akamas
      password: akamas
      path: launch_benchmark.sh

- name: Launch Benchmark
  operator: Executor
  arguments:
    command: "bash launch_benchmark.sh"
    host:
      hostname: benchmark
      username: akamas
      password: akamas

- name: Parse Output
  operator: Executor
  arguments:
    command: "bash parse_output.sh"
    host:
      hostname: benchmark
      username: akamas
      password: akamas

Optimization goals and constraints are defined using a YAML manifest with the following structure:

goal:
  objective: "minimize"
  function:
    formula: "jvm1.response_time + jvm2.response_time"
  constraints:
    absolute:
      - name: heap_used
        formula: jvm1.heap_used <= 3221225472
    relativeToBaseline:
      - name: memory_used
        formula: jvm1.memory_used <= 80%

where:

Function

The function field of the Goal of a Study details the characteristics of the function Akamas should minimize or maximize to reach the desired performance objective.

The function field has the following structure:

function:
  formula: "jvm1.response_time / sqrt(x:max)"
  variables:
    x:
      metric: "throughput"
      labels:
        componentName: "jvm2"

Where:

Formula

The formula field represents the mathematical expression of the performance objective for the Study and contains variables and operators with the following characteristics:

• Valid operators are: + - * / ^ sqrt(variable) log(variable) max(variable1, variable2) min(variable1, variable2)

• Valid variables are in the form:

  • <component_name>.<metric_name>, which correspond directly to metrics of Components of the System under test

  • <variable_name>, which should match variables specified in the variables field

Each metric that is directly or indirectly part of the formula of the function of the Goal is aggregated by default by average; more specifically, Akamas computes the average of each metric within the time window specified by the windowing strategy of the Study. Variables in the formula can be expanded with an aggregation in the form of <variable>:<aggreggation>. A list of available aggregations is available in the section Aggregations.

Variables

The variables field contains the specification of additional variables present in the formula, variables that can offer more flexibility with respect to directly specifying each metric of each Component in the formula.

Notice: each subfield of variables specifies a variable with its characteristics, the name of the subfield is the name of the variable.

The variable subfield has the following structure:

It is possible to use the notation <component_name>.<metric_name> in the metric field to automatically filter the metric’s data point by that component name is applied.

Constraints

The constraints field specifies constraints on the metrics of the system under test. For a configuration to be valid with respect to the defined goal, such constraints must be satisfied. Constraints can be defined as absolute or relativeToBaseline.

Each constraint has the form of:

mathematical_operationcomparison_operatorvalue_to_compare

where valid mathematical operations include:

• + - * / ^

• min max

• sqrt log (log is a natural logarithm)

valid comparison operators include:

• > < <= >=

• == != (equality, inequality)

and valid values to compare include:

• absolute values (e.g, 104343)

• percentage values relative to the baseline (e.g, 20%)

As an example, you could define an absolute constraint with the following snippet:

goal:
  objective: "minimize"
  function:
    formula: "jvm.response_time"
  constraints:
    absolute:
      - name: heap_used
        formula: jvm.heap_used <= 3221225472

Relative constraints can be defined by adding other constraints under the relativeToBaseline section. In the example below, for the configuration to be considered valid, it's required that the metric jvm.memory_used does not exceed by 80% the value measured in the baseline.

goal:
  objective: "minimize"
  function:
    formula: "jvm.response_time"
  constraints:
    absolute:
      - name: heap_used
        formula: jvm.heap_used <= 3221225472
    relativeToBaseline:
      - name: memory_used
        formula: jvm.memory_used <= 80%