HLEM-VMP Allocation Algorithm

• HLEM-VMP is a virtual machine placement algorithm that uses sequential host filtering and entropy-based scoring to reduce VM preemptions.
• It integrates spot-aware penalties and lifecycle management to optimize reliability in dynamic, volatile spot pricing environments.
• The approach is validated with synthetic and trace-driven workloads, showing reduced interruption metrics and enhanced cost savings.

The HLEM-VMP allocation algorithm is a virtual machine placement heuristic adapted to efficiently schedule VMs in public cloud environments where dynamic pricing and spot instances introduce volatility, preemption, and reliability challenges. Originally proposed in prior research, HLEM-VMP has been extended to operate under spot market conditions using the CloudSim Plus simulation framework, which supports lifecycle modeling for interrupted, hibernated, and terminated spot instances. By combining resource-aware host filtering and a multi-resource entropy-based scoring methodology—along with a spot-aware penalty—the algorithm reduces the frequency and severity of spot VM interruptions compared to baseline approaches in both synthetic and trace-driven scenarios (Goldgruber et al., 22 Nov 2025).

1. Core Heuristic and Mathematical Formulation

HLEM-VMP consists of sequential host filtering and scoring phases. The host filtering phase uses the metric:

$$RsDiff_{i,j}(t) = R^{(1)}_j(t) - U^{(1)}_i(t) \times R_c$$

for a candidate host %%%%1%%%% and VM $v_j$, where $R^{(1)}_j(t)$ is the VM’s primary resource demand, $U^{(1)}_i(t)$ is the host’s current utilization for that resource, and $R_c$ is a resource conversion factor. A host is considered only if $RsDiff_{i,j}(t) > Thr_{cpu}$.

In the subsequent host load evaluation, available resource capacity $C^d_i(t)$ for dimension $d$ is normalized:

$$NC^d_i(t) = \frac{C^d_i - \min_k C^d_k}{\max_k C^d_k - \min_k C^d_k}$$

Proportion for host $i$, $p_{i d} = C^d_i / \sum_{k=1}^n C^d_k$, drives the computation of resource entropy:

$$e^d = -\frac{1}{\ln n} \sum_{i=1}^n p_{i d} \cdot \ln(p_{i d}), \quad g^d = 1 - e^d$$

Resource weight:

$w^d = \frac{g^d}{\sum_{d=1}^D g^d}$

Final host score:

$HS_i(t) = \sum_{d=1}^D w^d \cdot NC^d_i(t)$

The spot-aware variation introduces a penalty using spot load:

$$SL_i(t) = \sum_{d=1}^D w^d \cdot \left[\frac{C^{d\, spot}_i(t)}{C^{d\, total}_i(t)}\right]$$

Adjusted host score:

$$AHS_i(t) = HS_i(t) \cdot (1 + \alpha \cdot SL_i(t))$$

where $\alpha \in [0,1]$ tunes interruption risk aversion.

2. Algorithm Workflow and Design Patterns

Allocation proceeds as follows:

1. Host Filtering: For each host, the algorithm verifies VM fit and minimum resource surplus $(RsDiff_{i,j}(t))$.
2. Scoring: Hosts passing the filter are scored (HS or AHS depending on spot penalty) and sorted. The highest scoring host is selected for placement.
3. Spot Remediation: If no suitable host is found, the algorithm considers hosts where spot VMs can be deallocated or hibernated to make room, then repeats scoring.
4. Failure Handling: If no placement is possible even after spot capacity reclamation, the request fails.

The policy pattern enables HLEM-VMP’s encapsulation as DynamicAllocationHLEM and DynamicAllocationHLEMAdjusted classes, allowing for plug-and-play integration in CloudSim Plus. The listener pattern supports event hooks on host deallocation, VM interruption, and state transitions for runtime monitoring.

3. Spot Instance Lifecycle Management

HLEM-VMP operates within an extended simulation environment supporting comprehensive spot instance states:

• WAITING: VM is queued until allocation or timeout.
• RUNNING: VM operational with Cloudlets executing.
• INTERRUPTED: VM preempted, either hibernated (state persisted, jobs paused) or terminated (destroyed, jobs canceled) per interruptionBehavior.
• HIBERNATED: VM state off-host, awaiting recovery.
• TERMINATED: VM destroyed, Cloudlets canceled.
• RESUBMITTED: Previously interrupted requests re-enter the allocation queue.

DynamicVm and SpotInstance classes encapsulate state transitions, interruption parameters, and resubmission logic. DataCenterBrokerDynamic orchestrates VM queuing, event handling, and resubmission, while ExecutionHistory tracks VM-host execution intervals for post-simulation analysis.

4. Evaluation and Comparative Metrics

Performance of HLEM-VMP and its spot-aware variant is assessed using both synthetic infrastructure and large-scale trace-driven workloads (Google Cluster Trace 2011). The evaluation uses consistent random seeds and a mix of spot and on-demand VMs distributed over a heterogeneous host pool (small to extra-large) with differentiated resource profiles.

Metrics collected:

• Total spot interruptions (preemption count)
• Average interruption duration (seconds)
• Maximum interruption duration (seconds)
• Spot completion rate
• Cost savings (via simulated spot discount × runtime)

Comparative results:

Allocation Policy	Spot Interruptions	Avg Duration (s)	Max Duration (s)
First-Fit	286	22.81	64.87
HLEM-VMP	230	21.12	49.49
HLEM-VMPAdjusted (α)	205	25.20	45.65

On-demand VMs (non-preemptible) exhibit identical metrics across policies. This suggests the principal benefit and variation is strictly in spot instance reliability and runtime.

5. Implementation and Integration

Integration of HLEM-VMP into simulation environments utilizes the following steps:

• Add the cloudsimplus6-spot-instance dependency.
• Instantiate HostDynamic objects instead of HostSimple to enable dynamic deallocation for spot extension.
• Select DatacenterBrokerDynamic and DynamicAllocationHLEMAdjusted as broker and allocation policy.
• Configure SpotInstance parameters (interruptionBehavior, hibernationTimeout, minimumRunningTime).
• Register listeners for host deallocation and VM events.
• Implement clock tick listeners to handle periodic processing and VM placement retries.

Example Java instantiation:

CloudSim sim = new CloudSim(0.5); sim.terminateAt(70); // Host and datacenter setup List<Host> hosts = ...; // HostDynamic instances VmAllocationPolicy policy = new DynamicAllocationHLEMAdjusted(); Datacenter dc = new DatacenterSimple(sim, hosts, policy); // Broker setup DatacenterBrokerDynamic broker = new DatacenterBrokerDynamic(sim); ... // Spot VM creation and parameter setting SpotInstance spot = new SpotInstance(1000,2,true); spot.setRam(512).setBw(1000).setSize(10000); spot.setInterruptionBehavior(SpotInstance.InterruptionBehavior.HIBERNATE); spot.setMinimumRunningTime(5); spot.setHibernationTimeout(30); ... sim.start();

6. Practical Considerations and Extensibility

Researchers are advised to:

• Tune $\alpha$ in $AHS_i(t)$ to control interruption frequency versus duration—a higher value penalizes spot-saturated hosts, mitigating risk but potentially increasing queue times.
• Scale trace-driven experiments via parallelized cloudlet updates or coarse-grained time steps to offset computational intensity (one-day simulation may require several days of real time for large traces).
• Recognize that real-world spot price and interruption data are proprietary; use public sources (AWS Spot Advisor) or synthetic models for cost realism.
• Extend the architecture via subclassing DynamicAllocation to implement alternative interruption or predictive preemption policies.
• Ensure experimental reproducibility using fixed random seeds and TableBuilder-driven explicit reporting across algorithm variants.

A plausible implication is that the modular CloudSim Plus extensions facilitate further investigation of market-driven allocation policies, resilience mechanisms, and the trade-offs between cost savings and reliability in public cloud scheduling scenarios (Goldgruber et al., 22 Nov 2025).