sarimahsan101/hpc-dataset

HPC Dataset

Dataset Description

The HPC Dataset is a specialized tabular dataset designed for the detection of cache-based side-channel attacks in virtualized environments. It captures low-level Hardware Performance Counter (HPC) metrics sampled at high frequency (200ms intervals) to distinguish between benign VM workloads and active adversarial attacks attempting to leak sensitive data via shared cache infrastructure (e.g., Prime+Probe, Flush+Reload).

By incorporating varied background workloads (idle, web_server, db_queries) and engineered temporal features, this dataset provides a robust foundation for training and evaluating machine learning-based intrusion detection systems (IDS) tailored for cloud and hypervisor security.

Dataset Summary

• Format: Tabular data (CSV/Parquet)
• Sampling Rate: 200ms per window
• Features: 14 (3 Metadata, 6 Raw Counters, 5 Engineered/Temporal)
• Target Variable: label (Binary: 0 = SAFE, 1 = ATTACK)
• Class Balance: Balanced dataset (50% SAFE, 50% ATTACK) distributed equally across all workload types to prevent model bias.

Supported Tasks

• Tabular Classification: Training models (e.g., XGBoost, Random Forest, Neural Networks) to classify time windows as benign or malicious.
• Anomaly Detection: Identifying sudden deviations in cache behavior using statistical thresholds or isolation algorithms.

Column Explanations

The dataset consists of 16 columns, logically grouped into metadata, raw hardware counters, engineered temporal features, and ground-truth labels.

Metadata & Context

Column Name	Data Type	Description
window_id	Integer	A unique, sequential identifier for each 200ms time window. Resets per recording session.
timestamp	Float	The Unix timestamp marking the start of the measurement window. Consecutive rows are exactly ~0.2 seconds apart.
workload_type	String	The specific task running inside the victim Virtual Machine during the window. Values: idle, web_server, db_queries. Included to ensure the model generalizes across different baseline resource usages.

Raw Hardware Performance Counters (HPCs)

Note: All raw counters represent the total count of events observed within the 200ms window.

Column Name	Data Type	Description
llc_load_misses	Integer	Last Level Cache Load Misses. The number of memory load instructions that missed the LLC and had to fetch from main memory. This is the primary signal for side-channel attacks, as attackers force victims' data out of the shared cache.
cache_references	Integer	Total Cache Accesses. The total number of instructions that accessed any level of the CPU cache. Serves as a baseline for overall cache activity and a key attack signal.
branch_misses	Integer	Branch Predictor Failures. The number of times the CPU branch predictor guessed incorrectly. Acts as a secondary signal, as attack patterns can disrupt normal execution flow.
instructions	Integer	Retired Instructions. The total number of CPU instructions successfully executed. Used primarily as a normalization feature to account for varying workload intensities.
cycles	Integer	CPU Cycles Elapsed. The total number of CPU clock cycles during the window. Used alongside instructions to calculate IPC (Instructions Per Cycle) for normalization.
mem_loads	Integer	Memory Load Instructions. The total number of load instructions retired. A supporting signal that helps contextualize memory access patterns.

Engineered & Temporal Features

Column Name	Data Type	Description
llc_miss_rate_change	Float	The percentage change in LLC misses compared to the previous 200ms window. Engineered to highlight sudden spikes indicative of an active cache eviction attack.
cache_ref_rate_change	Float	The percentage change in total cache references compared to the previous window. Engineered to detect abnormal surges in probing activity.
llc_mean_5w	Float	The rolling mean of llc_load_misses over the last 5 windows (1 second). Provides temporal smoothing to separate short-lived attack spikes from gradual workload shifts.
llc_std_5w	Float	The rolling standard deviation of llc_load_misses over the last 5 windows. Captures the variance of cache misses; attacks typically cause high variance compared to stable workloads.
cache_mean_5w	Float	The rolling mean of cache_references over the last 5 windows (1 second). Provides a smoothed baseline of overall cache traffic.

Labels

Column Name	Data Type	Description
label	Integer	The binary classification target. 0 = SAFE (Benign), 1 = ATTACK (Adversarial side-channel activity).
label_text	String	Human-readable string mapping of the label column (SAFE or ATTACK). Dropped during model training, kept for readability and visualization.

Class Distribution & Workload Breakdown

The dataset is carefully balanced to prevent classifier bias. Both the SAFE and ATTACK classes constitute 50% of the dataset.

Furthermore, the attacks are distributed uniformly across the victim's workload states:

Workload Type	SAFE Samples	ATTACK Samples
idle	Balanced	Balanced
web_server	Balanced	Balanced
db_queries	Balanced	Balanced

This ensures that the detection model learns to identify the attack based on HPC anomalies rather than simply associating high cache usage with the db_queries workload.

Dataset Creation

Data Collection: Data was gathered by running controlled cache-based side-channel attack scenarios against a victim Virtual Machine. During execution, hardware performance counters were polled via the perf subsystem (or hypervisor-equivalent APIs) at strict 200ms intervals.

Feature Engineering: To make the dataset immediately usable for ML models and to capture the behavioral aspect of the attack (sudden spikes), rolling statistics (mean, standard deviation over 1 second) and rate-of-change features were calculated and appended to the raw counter data.

Usage Example (Hugging Face Datasets)

from datasets import load_dataset

# Load the dataset
dataset = load_dataset("sarimahsan101/hpc-dataset")

# Access the pandas dataframe
df = dataset["train"].to_pandas()

# Separate features (X) and labels (y)
feature_cols = [
    'llc_load_misses', 'cache_references', 'branch_misses', 
    'instructions', 'cycles', 'mem_loads', 'llc_miss_rate_change', 
    'cache_ref_rate_change', 'llc_mean_5w', 'llc_std_5w', 'cache_mean_5w'
]

X = df[feature_cols]
y = df['label']

# Example: Train a simple classifier
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier()
clf.fit(X, y)

Considerations for Use

• Environmental Specificity: HPC values are highly dependent on the specific CPU microarchitecture (e.g., Intel Skylake vs. AMD Zen). Models trained on this dataset should be re-calibrated or fine-tuned if deployed on different hardware.
• High Frequency Noise: Because the sampling window is small (200ms), natural OS scheduling jitter can cause minor anomalies. The inclusion of the rolling mean/std features helps mitigate this, but users should be aware of potential false positives in highly volatile environments.