# Single-threaded CPU test with sysbench
sysbench cpu --threads=1 --cpu-max-prime=20000 run

# Multi-threaded test
sysbench cpu --threads=8 --cpu-max-prime=20000 run

# Install and run stream benchmark
apt install -y stream
stream

# Sequential write test
dd if=/dev/zero of=/tmp/testfile bs=1M count=1024 conv=fdatasync

# Random read with fio
fio --name=randread --ioengine=libaio --iodepth=16 \
    --rw=randread --bs=4k --direct=1 \
    --size=1G --numjobs=4 --runtime=60 \
    --group_reporting --filename=/tmp/fio_randread

# Random write with fio
fio --name=randwrite --ioengine=libaio --iodepth=16 \
    --rw=randwrite --bs=4k --direct=1 \
    --size=1G --numjobs=4 --runtime=60 \
    --group_reporting --filename=/tmp/fio_randwrite

# Install iperf3
apt install -y iperf3

# Server side (on another machine)
iperf3 -s

# Client side
iperf3 -c <server_ip> -t 30

git clone https://github.com/kdlucas/byte-unixbench.git
cd byte-unixbench/UnixBench
make
./Run

You are a senior Linux performance engineer. Analyze the following VPS benchmark results and identify bottlenecks and tuning recommendations.

[HARDWARE INFO]
- CPU: {cpu_model} ({cores} cores, {threads} threads)
- Memory: {mem_total} GB
- Disk: {disk_type} ({disk_size})
- Network: {network_speed} Mbps

[CPU BENCHMARKS]
- Single-threaded: {single_core_score}
- Multi-threaded: {multi_core_score}

[MEMORY BANDWIDTH]
- Copy: {mem_copy_speed} MB/s
- Scale: {mem_scale_speed} MB/s
- Add: {mem_add_speed} MB/s
- Triad: {mem_triad_speed} MB/s

[DISK I/O]
- Sequential write: {seq_write_speed} MB/s (IOPS: {seq_write_iops})
- Random read: {rand_read_iops} IOPS (latency: {rand_read_lat}ms)
- Random write: {rand_write_iops} IOPS (latency: {rand_write_lat}ms)

[NETWORK]
- Download: {net_down} Mbps
- Upload: {net_up} Mbps

[CURRENT SYSTEM STATE]
- Load average: {load_avg}
- Current CPU frequency: {cpu_freq} MHz
- I/O scheduler: {io_scheduler}
- CPU governor: {cpu_governor}

Please analyze:
1. Which subsystem is the current bottleneck?
2. How does this compare to typical benchmarks for similar VPS specs?
3. Provide specific, executable tuning commands with estimated improvement percentages

# Check current governor
cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor

# Set to performance mode for web/database servers
echo performance | tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

# Make persistent via systemd
cat > /etc/systemd/system/cpu-governor.service << 'EOF'
[Unit]
Description=Set CPU frequency governor to performance
After=multi-user.target

[Service]
Type=oneshot
ExecStart=/bin/sh -c 'echo performance > /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor'

[Install]
WantedBy=multi-user.target
EOF

systemctl enable cpu-governor.service

# Check current scheduler
cat /sys/block/vda/queue/scheduler

# NVMe SSD: use none
echo none | tee /sys/block/vda/queue/scheduler

# Regular SSD: mq-deadline
echo mq-deadline | tee /sys/block/vda/queue/scheduler

# HDD: bfq if supported
echo bfq | tee /sys/block/vda/queue/scheduler

# Create /etc/sysctl.d/99-network-tuning.conf
cat >> /etc/sysctl.d/99-network-tuning.conf << 'EOF'
# TCP connection optimization
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.tcp_max_tw_buckets = 1048576
net.ipv4.tcp_fin_timeout = 15
net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_intvl = 30
net.ipv4.tcp_keepalive_probes = 5

# TCP window scaling
net.ipv4.tcp_window_scaling = 1
net.ipv4.tcp_congestion_control = bbr

# Memory allocation optimization
net.core.rmem_default = 262144
net.core.rmem_max = 16777216
net.core.wmem_default = 262144
net.core.wmem_max = 16777216

# File descriptors
fs.file-max = 2097152
EOF

# Apply all sysctl settings
sysctl --system

# Create /etc/sysctl.d/99-memory-tuning.conf
cat >> /etc/sysctl.d/99-memory-tuning.conf << 'EOF'
# Reduce swappiness (minimize disk swapping)
vm.swappiness = 10

# Improve inode cache utilization
vm.vfs_cache_pressure = 50

# Transparent Huge Pages (THP) optimization
# Disable THP for database workloads to reduce latency spikes
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag
EOF

# Persist THP settings via systemd
cat > /etc/systemd/system/disable-thp.service << 'EOF'
[Unit]
Description=Disable Transparent Huge Pages
DefaultDependencies=no
After=local-fs.target
Before=sysinit.target

[Service]
Type=oneshot
ExecStart=/bin/sh -c 'echo never > /sys/kernel/mm/transparent_hugepage/enabled; echo never > /sys/kernel/mm/transparent_hugepage/defrag'

[Install]
WantedBy=multi-user.target
EOF

systemctl enable disable-thp.service

# /etc/security/limits.conf
cat >> /etc/security/limits.conf << 'EOF'
* soft nofile 65536
* hard nofile 65536
root soft nofile 65536
root hard nofile 65536
EOF

# systemd service limits
cat >> /etc/systemd/system.conf << 'EOF'
DefaultLimitNOFILE=65536
EOF

# auto-tune-workflow.yaml
name: "vps-auto-tune"
interval: "0 2 * * *"  # Daily at 2 AM
steps:
  - name: "run_benchmarks"
    action: |
      Execute full benchmark suite:
      1. sysbench cpu --threads=4 run
      2. fio random read/write tests
      3. sysbench memory run
      4. Record current load and temperature
      Save results as JSON

  - name: "compare_baseline"
    action: |
      Compare against historical baselines:
      1. Percentage change per metric vs last week
      2. Any performance regression trends
      3. Metrics deviating from expected ranges

  - name: "suggest_tuning"
    action: |
      Generate tuning recommendations:
      1. Root causes for any regressions
      2. Recommended kernel parameter adjustments
      3. Estimated performance improvement
      4. Rollback plan if needed

  - name: "apply_with_safety"
    action: |
      Safely apply tuning:
      1. Create backup snapshot of current params
      2. Apply changes incrementally
      3. Re-run relevant benchmarks after each change
      4. Auto-rollback if performance degrades
      5. Only keep changes with positive ROI

#!/bin/bash
# safe-tune.sh — Safe execution script for AI tuning

BACKUP_DIR="/var/backups/sysctl-$(date +%Y%m%d-%H%M%S)"
LOG_FILE="/var/log/auto-tune.log"

# Layer 1: Backup current configuration
mkdir -p "$BACKUP_DIR"
sysctl -a > "$BACKUP_DIR/current_sysctl.txt"
cp /etc/sysctl.d/*.conf "$BACKUP_DIR/" 2>/dev/null

# Layer 2: Canary deployment (test with small changes first)
echo "[$(date)] Starting canary tuning..." | tee -a "$LOG_FILE"

TEMP_CONF=$(mktemp)
cat > "$TEMP_CONF" << 'EOF'
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535
EOF

sysctl -p "$TEMP_CONF"

sleep 5
CURRENT_LOAD=$(cat /proc/loadavg | awk '{print $1}')
echo "[$(date)] Post-canary load: $CURRENT_LOAD" | tee -a "$LOG_FILE"

# Layer 3: Full apply or rollback
if [ "$(echo "$CURRENT_LOAD < 2.0" | bc -l)" -eq 1 ]; then
    echo "[$(date)] Load normal, applying full tuning..." | tee -a "$LOG_FILE"
    sysctl --system
else
    echo "[$(date)] Load abnormal, rolling back..." | tee -a "$LOG_FILE"
    sysctl --system 2>/dev/null
    cp "$BACKUP_DIR/current_sysctl.txt" /tmp/rollback.txt
fi

rm -f "$TEMP_CONF"
echo "[$(date)] Tuning flow complete" | tee -a "$LOG_FILE"

# Schedule regular performance snapshots
cat > /usr/local/bin/perf-snapshot.sh << 'EOF'
#!/bin/bash
TIMESTAMP=$(date +%Y-%m-%d_%H:%M:%S)
LOG="/var/log/perf-history/$TIMESTAMP.csv"

mkdir -p /var/log/perf-history

echo "timestamp,load_avg_1m,cpu_freq,memory_used_pct,disk_io_read,disk_io_write" >> "$LOG"
echo "$TIMESTAMP,$(cat /proc/loadavg | awk '{print $1}'),$(cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq),$(free | awk '/Mem:/ {printf "%.1f", $3/$2 * 100}'),$(iostat -x 1 1 | grep vda | awk '{print $6}'),$(iostat -x 1 1 | grep vda | awk '{print $8}')" >> "$LOG"
EOF

chmod +x /usr/local/bin/perf-snapshot.sh

# Run hourly
(crontab -l 2>/dev/null; echo "0 * * * * /usr/local/bin/perf-snapshot.sh") | crontab -

scenario: web_server
priority: low_latency
tuning:
  - net.core.somaxconn: 65535
  - net.ipv4.tcp_tw_reuse: 1
  - net.ipv4.tcp_max_syn_backlog: 65535
  - vm.swappiness: 5
  - fs.file-max: 1048576

scenario: database
priority: throughput
tuning:
  - vm.dirty_ratio: 40
  - vm.dirty_background_ratio: 10
  - vm.swappiness: 1
  - kernel.shmmax: 68719476736
  - net.ipv4.tcp_congestion_control: bbr

scenario: container_host
priority: isolation
tuning:
  - kernel.panic: 10
  - kernel.pid_max: 4194304
  - net.ipv4.ip_local_port_range: 1024 65535
  - fs.inotify.max_user_watches: 524288
  - vm.max_map_count: 262144