##########################################
HLO Allocation Engine
##########################################

.. contents::
  :local:
  :depth: 1

The HLO Allocation Engine is the component of the High Level Orchestrator (HLO) that uses the service definition and the data of the HLO Data Aggregator to return a valid and optimized allocation of the service on an IE.

The HLO Allocation Engine of Siemens for now provides a Reinforcement Learning (RL) model based on a neural network in a MLOps pipeline. The MLOps pipeline filters the incoming data from the HLO Data Aggregator and provides it to the RL model. The RL model decides where to place the service based on the data and pre-training of the neural network. The RL model returns a numeric value. The MLOps pipeline maps this numeric value to an IE.

.. image:: rl.png
   :alt: Reinforcement Learning visualized

.. image:: mlops_pipeline.png
   :alt: Machine Learning Operations Pipeline

Prerequisities
==============

The HLO Allocation Engine is based on docker images and docker compose. Please make sure to have all dependencies installed.

Installation
============

.. code-block:: bash

   docker compose up --force-recreate

Configuration options
=====================

Developer guide
===============

Communications and Interactions
-------------------------------

The HLO Allocation Engine waits for the input of the Data Aggregation and Alert System. It sends an allocation to the HLO Deployment Engine as shown in the following Figure:

.. image:: hlo_allocation_engine.png
   :alt: HLO Allocation Engine

.. list-table:: Messages exchanged and Primitives definition
   :header-rows: 1

   * - Messages exchanged
     - Primitives definition
   * - .. code-block::

         syntax = "proto3";

         import "hlo.proto";

         message ServiceComponentRequirement {
             ServiceComponent service_component_definition = 2;
             repeated InfrastructureElement infrastructure_element_candidates = 1;
         }

         message HLOAllocatorInput {
             repeated ServiceComponentRequirement service_component_requirements  = 1;
         }

         message ServiceComponentAllocation {
             InfrastructureElement old_allocated_infrastructure_element = 1;
             ServiceComponent new_allocated_service_component = 2;
         }

         message HLODeploymentEngineOutput {
             repeated ServiceComponentAllocation service_component_allocations = 1;
         }
     - .. code-block::

         syntax = "proto3";

         message Domain {
             string id = 1;
         }

         message Service {
             string id = 1;
         }

         message LowLevelOrchestrator {
             string id = 1;
             string orchestration_type = 3;
             Domain domain = 2;
         }

         message InfrastructureElement {
             string id = 1;
             float total_ram = 2;
             float cpu_cores = 3;
             float avg_power_consumption = 4;
             bool real_time_capable = 5;
             float current_ram = 6;
             float current_cpu_usage = 7;
             float current_power_consumption = 8;
             Domain domain = 9;
             LowLevelOrchestrator low_level_orchestrator = 10;
         }

         message Port {
             int32 number = 1;
         }

         message ServiceComponent {
             string id = 1;
             string image = 2;
             repeated Port ports = 3;
             Service service = 4;
             ServiceComponentConstraints service_component_constraints = 5;
             optional InfrastructureElement infrastructure_element = 6;
         }

         message ServiceComponentConstraints {
             map<string, float> constraints = 1;
         }

Authors
=======

- Buschmann, Philippe (philippe.buschmann@siemens.com) - Reinforcement Learning model
- Pfab, Korbinian (korbinian.pfab@siemens.com) - MLOps pipeline
- aerOS Team - Component communication, interaction and integration efforts