1
#!/bin/bash
2

3
# Host CPU optimization for Firecracker
4
echo "=== CPU Optimization ==="
5

6
# Check CPU information
7
echo "CPU Information:"
8
lscpu | grep -E "(Architecture|CPU\(s\)|Thread|Core|Socket|Vendor|Model name|CPU MHz|Cache|Flags)"
9

10
# Enable CPU performance governor
11
echo "Setting CPU governor to performance..."
12
for cpu in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do
13
    [ -f "$cpu" ] && echo performance | sudo tee "$cpu" > /dev/null
14
done
15

16
# Disable CPU frequency scaling
17
echo "Disabling CPU frequency scaling..."
18
echo 1 | sudo tee /sys/devices/system/cpu/intel_pstate/no_turbo 2>/dev/null || echo "Intel P-State not available"
19

20
# Set CPU affinity for optimal performance
21
set_cpu_affinity() {
22
    local vm_id=$1
23
    local cpu_list=$2
24

25
    # Find Firecracker process
26
    fc_pid=$(pgrep -f "firecracker.*${vm_id}")
27

28
    if [ -n "$fc_pid" ]; then
29
        echo "Setting CPU affinity for VM $vm_id (PID: $fc_pid) to CPUs: $cpu_list"
30
        taskset -cp "$cpu_list" "$fc_pid"
31

32
        # Set high priority
33
        sudo renice -10 -p "$fc_pid"
34

35
        # Set real-time scheduling (use with caution)
36
        # sudo chrt -r -p 50 "$fc_pid"
37
    else
38
        echo "Firecracker process for VM $vm_id not found"
39
    fi
40
}
41

42
# Optimize interrupt handling
43
echo "Optimizing interrupt handling..."
44
# Distribute interrupts across CPUs
45
echo 2 | sudo tee /proc/irq/default_smp_affinity
46

47
# Disable unnecessary kernel features
48
echo "Disabling unnecessary kernel features..."
49
echo 0 | sudo tee /proc/sys/kernel/watchdog
50
echo 0 | sudo tee /proc/sys/kernel/nmi_watchdog
51

52
# Configure CPU isolation (add to kernel command line)
53
cat << 'EOF'
54
To isolate CPUs for Firecracker workloads, add to GRUB_CMDLINE_LINUX_DEFAULT:
55
isolcpus=2-7 nohz_full=2-7 rcu_nocbs=2-7
56

57
Then update GRUB and reboot:
58
sudo update-grub
59
sudo reboot
60
EOF
61

62
echo "CPU optimization complete!"

1
#!/usr/bin/env python3
2
import os
3
import subprocess
4
import mmap
5
from pathlib import Path
6

7
class MemoryOptimizer:
8
    """Optimize memory settings for Firecracker performance"""
9

10
    def __init__(self):
11
        self.hugepage_sizes = ['1048576', '2048']  # 1GB and 2MB hugepages
12
        self.transparent_hugepages = Path('/sys/kernel/mm/transparent_hugepage')
13

14
    def configure_hugepages(self, num_1gb_pages=4, num_2mb_pages=512):
15
        """Configure hugepages for better memory performance"""
16

17
        print("=== Configuring Hugepages ===")
18

19
        # Configure 1GB hugepages
20
        hugepages_1g = Path('/sys/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages')
21
        if hugepages_1g.exists():
22
            try:
23
                with open(hugepages_1g, 'w') as f:
24
                    f.write(str(num_1gb_pages))
25
                print(f"✓ Configured {num_1gb_pages} x 1GB hugepages")
26
            except PermissionError:
27
                print("✗ Need root permissions to configure 1GB hugepages")
28

29
        # Configure 2MB hugepages
30
        hugepages_2m = Path('/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages')
31
        if hugepages_2m.exists():
32
            try:
33
                with open(hugepages_2m, 'w') as f:
34
                    f.write(str(num_2mb_pages))
35
                print(f"✓ Configured {num_2mb_pages} x 2MB hugepages")
36
            except PermissionError:
37
                print("✗ Need root permissions to configure 2MB hugepages")
38

39
        # Mount hugepages filesystem
40
        self._mount_hugepages()
41

42
    def _mount_hugepages(self):
43
        """Mount hugepages filesystems"""
44

45
        mount_points = [
46
            ('/mnt/huge-1G', '1GB', 'pagesize=1G'),
47
            ('/mnt/huge-2M', '2MB', 'pagesize=2M')
48
        ]
49

50
        for mount_point, size, option in mount_points:
51
            os.makedirs(mount_point, exist_ok=True)
52

53
            # Check if already mounted
54
            result = subprocess.run(['mount'], capture_output=True, text=True)
55
            if mount_point not in result.stdout:
56
                try:
57
                    subprocess.run([
58
                        'sudo', 'mount', '-t', 'hugetlbfs',
59
                        '-o', option, 'none', mount_point
60
                    ], check=True)
61
                    print(f"✓ Mounted {size} hugepages at {mount_point}")
62
                except subprocess.CalledProcessError:
63
                    print(f"✗ Failed to mount {size} hugepages")
64

65
    def configure_transparent_hugepages(self):
66
        """Configure transparent hugepages"""
67

68
        print("=== Configuring Transparent Hugepages ===")
69

70
        # Disable transparent hugepages for consistent performance
71
        thp_enabled = self.transparent_hugepages / 'enabled'
72
        thp_defrag = self.transparent_hugepages / 'defrag'
73

74
        settings = [
75
            (thp_enabled, 'never', 'THP enabled'),
76
            (thp_defrag, 'never', 'THP defrag')
77
        ]
78

79
        for setting_file, value, description in settings:
80
            if setting_file.exists():
81
                try:
82
                    with open(setting_file, 'w') as f:
83
                        f.write(value)
84
                    print(f"✓ Set {description} to {value}")
85
                except PermissionError:
86
                    print(f"✗ Need root permissions to configure {description}")
87

88
    def configure_memory_overcommit(self):
89
        """Configure memory overcommit settings"""
90

91
        print("=== Configuring Memory Overcommit ===")
92

93
        # Conservative overcommit for predictable performance
94
        overcommit_settings = [
95
            ('/proc/sys/vm/overcommit_memory', '2', 'Strict overcommit'),
96
            ('/proc/sys/vm/overcommit_ratio', '80', 'Overcommit ratio'),
97
            ('/proc/sys/vm/swappiness', '1', 'Swappiness'),
98
            ('/proc/sys/vm/vfs_cache_pressure', '50', 'VFS cache pressure')
99
        ]
100

101
        for setting_file, value, description in overcommit_settings:
102
            try:
103
                with open(setting_file, 'w') as f:
104
                    f.write(value)
105
                print(f"✓ Set {description} to {value}")
106
            except PermissionError:
107
                print(f"✗ Need root permissions to configure {description}")
108

109
    def optimize_numa_settings(self):
110
        """Optimize NUMA settings for Firecracker"""
111

112
        print("=== Optimizing NUMA Settings ===")
113

114
        # Check NUMA topology
115
        try:
116
            result = subprocess.run(['numactl', '--hardware'],
117
                                  capture_output=True, text=True, check=True)
118
            print("NUMA topology:")
119
            print(result.stdout)
120
        except (subprocess.CalledProcessError, FileNotFoundError):
121
            print("NUMA tools not available")
122
            return
123

124
        # Configure zone reclaim
125
        numa_settings = [
126
            ('/proc/sys/vm/zone_reclaim_mode', '0', 'Zone reclaim mode')
127
        ]
128

129
        for setting_file, value, description in numa_settings:
130
            try:
131
                with open(setting_file, 'w') as f:
132
                    f.write(value)
133
                print(f"✓ Set {description} to {value}")
134
            except PermissionError:
135
                print(f"✗ Need root permissions to configure {description}")
136

137
    def create_memory_pools(self, pool_size_mb=1024, num_pools=4):
138
        """Create pre-allocated memory pools for Firecracker VMs"""
139

140
        print(f"=== Creating Memory Pools ===")
141
        print(f"Creating {num_pools} memory pools of {pool_size_mb}MB each")
142

143
        pools = []
144
        pool_size = pool_size_mb * 1024 * 1024  # Convert to bytes
145

146
        for i in range(num_pools):
147
            try:
148
                # Create anonymous memory mapping
149
                pool = mmap.mmap(-1, pool_size, mmap.MAP_PRIVATE | mmap.MAP_ANONYMOUS)
150

151
                # Touch all pages to ensure allocation
152
                for offset in range(0, pool_size, 4096):
153
                    pool[offset] = 0
154

155
                pools.append(pool)
156
                print(f"✓ Created memory pool {i+1}")
157

158
            except Exception as e:
159
                print(f"✗ Failed to create memory pool {i+1}: {e}")
160

161
        return pools
162

163
    def run_optimization(self):
164
        """Run all memory optimizations"""
165

166
        self.configure_hugepages()
167
        self.configure_transparent_hugepages()
168
        self.configure_memory_overcommit()
169
        self.optimize_numa_settings()
170

171
        print("\n=== Memory Optimization Summary ===")
172
        self.print_memory_info()
173

174
    def print_memory_info(self):
175
        """Print current memory configuration"""
176

177
        # Memory information
178
        with open('/proc/meminfo', 'r') as f:
179
            meminfo = f.read()
180

181
        print("\nMemory Information:")
182
        for line in meminfo.split('\n'):
183
            if any(keyword in line for keyword in ['MemTotal', 'MemFree', 'HugePages', 'Hugepagesize']):
184
                print(f"  {line}")
185

186
        # Hugepages information
187
        hugepages_info = []
188
        hugepages_dir = Path('/sys/kernel/mm/hugepages')
189

190
        if hugepages_dir.exists():
191
            for size_dir in hugepages_dir.iterdir():
192
                if size_dir.is_dir():
193
                    try:
194
                        with open(size_dir / 'nr_hugepages', 'r') as f:
195
                            nr_pages = f.read().strip()
196
                        with open(size_dir / 'free_hugepages', 'r') as f:
197
                            free_pages = f.read().strip()
198

199
                        size = size_dir.name.replace('hugepages-', '').replace('kB', '')
200
                        hugepages_info.append(f"  {size}: {nr_pages} total, {free_pages} free")
201
                    except:
202
                        pass
203

204
        if hugepages_info:
205
            print("\nHugepages:")
206
            for info in hugepages_info:
207
                print(info)
208

209
if __name__ == '__main__':
210
    optimizer = MemoryOptimizer()
211
    optimizer.run_optimization()

1
#!/bin/bash
2

3
# Kernel optimization for Firecracker
4
echo "=== Kernel Optimization ==="
5

6
# Disable unnecessary kernel features
7
echo "Disabling unnecessary kernel features..."
8
kernel_settings=(
9
    # Disable audit subsystem
10
    "kernel.audit=0"
11
    # Disable printk rate limiting
12
    "kernel.printk_ratelimit=0"
13
    # Optimize scheduling
14
    "kernel.sched_migration_cost_ns=5000000"
15
    "kernel.sched_autogroup_enabled=0"
16
    # Optimize memory management
17
    "vm.dirty_ratio=15"
18
    "vm.dirty_background_ratio=5"
19
    "vm.dirty_expire_centisecs=12000"
20
    "vm.dirty_writeback_centisecs=1200"
21
    # Optimize network stack
22
    "net.core.rmem_max=67108864"
23
    "net.core.wmem_max=67108864"
24
    "net.core.rmem_default=262144"
25
    "net.core.wmem_default=262144"
26
    "net.core.netdev_max_backlog=5000"
27
    # Optimize file system
28
    "fs.file-max=2097152"
29
    "fs.nr_open=1048576"
30
)
31

32
# Apply kernel settings
33
for setting in "${kernel_settings[@]}"; do
34
    key=$(echo "$setting" | cut -d'=' -f1)
35
    value=$(echo "$setting" | cut -d'=' -f2)
36

37
    echo "Setting $key = $value"
38
    echo "$value" | sudo tee "/proc/sys/${key//./\/}" > /dev/null 2>&1 || echo "Failed to set $key"
39
done
40

41
# Make settings persistent
42
sudo tee -a /etc/sysctl.conf << 'EOF'
43

44
# Firecracker optimizations
45
kernel.audit=0
46
kernel.printk_ratelimit=0
47
kernel.sched_migration_cost_ns=5000000
48
kernel.sched_autogroup_enabled=0
49
vm.dirty_ratio=15
50
vm.dirty_background_ratio=5
51
vm.dirty_expire_centisecs=12000
52
vm.dirty_writeback_centisecs=1200
53
net.core.rmem_max=67108864
54
net.core.wmem_max=67108864
55
net.core.rmem_default=262144
56
net.core.wmem_default=262144
57
net.core.netdev_max_backlog=5000
58
fs.file-max=2097152
59
fs.nr_open=1048576
60
EOF
61

62
echo "Kernel optimization complete!"
63

64
# Create optimized kernel configuration
65
create_optimized_kernel_config() {
66
    cat > /tmp/firecracker_kernel_config << 'EOF'
67
# Firecracker optimized kernel configuration
68

69
# Minimal required features
70
CONFIG_64BIT=y
71
CONFIG_X86_64=y
72
CONFIG_SMP=y
73
CONFIG_HYPERVISOR_GUEST=y
74

75
# Virtualization support
76
CONFIG_PARAVIRT=y
77
CONFIG_PARAVIRT_SPINLOCKS=y
78
CONFIG_KVM_GUEST=y
79

80
# Essential drivers
81
CONFIG_VIRTIO=y
82
CONFIG_VIRTIO_PCI=y
83
CONFIG_VIRTIO_BLK=y
84
CONFIG_VIRTIO_NET=y
85
CONFIG_VIRTIO_CONSOLE=y
86
CONFIG_VIRTIO_VSOCKETS=y
87

88
# Memory management
89
CONFIG_TRANSPARENT_HUGEPAGE=n
90
CONFIG_HUGETLBFS=y
91
CONFIG_HUGETLB_PAGE=y
92

93
# Scheduler optimizations
94
CONFIG_PREEMPT_NONE=y
95
CONFIG_NO_HZ=y
96
CONFIG_NO_HZ_IDLE=y
97
CONFIG_HIGH_RES_TIMERS=y
98

99
# Disable unnecessary features
100
CONFIG_SUSPEND=n
101
CONFIG_HIBERNATION=n
102
CONFIG_ACPI=n
103
CONFIG_PCI=n
104
CONFIG_USB=n
105
CONFIG_SOUND=n
106
CONFIG_DRM=n
107
CONFIG_WIRELESS=n
108
CONFIG_BLUETOOTH=n
109

110
# Security
111
CONFIG_SECURITY=y
112
CONFIG_SECCOMP=y
113
CONFIG_SECCOMP_FILTER=y
114

115
# Networking (minimal)
116
CONFIG_NET=y
117
CONFIG_INET=y
118
CONFIG_NETFILTER=y
119

120
# File systems
121
CONFIG_EXT4_FS=y
122
CONFIG_PROC_FS=y
123
CONFIG_SYSFS=y
124
CONFIG_TMPFS=y
125
CONFIG_9P_FS=y
126
CONFIG_9P_VIRTIO=y
127

128
# Disable debug features for performance
129
CONFIG_DEBUG_KERNEL=n
130
CONFIG_SLUB_DEBUG=n
131
CONFIG_DEBUG_INFO=n
132
CONFIG_FRAME_POINTER=n
133
CONFIG_STACK_TRACER=n
134
CONFIG_FUNCTION_TRACER=n
135
EOF
136

137
    echo "Optimized kernel config created at /tmp/firecracker_kernel_config"
138
}
139

140
create_optimized_kernel_config

1
#!/usr/bin/env python3
2
import json
3
import psutil
4
import subprocess
5
from pathlib import Path
6

7
class FirecrackerVMMOptimizer:
8
    """Optimize Firecracker VMM process for performance"""
9

10
    def __init__(self):
11
        self.firecracker_processes = []
12
        self.optimization_configs = {}
13

14
    def find_firecracker_processes(self):
15
        """Find all running Firecracker processes"""
16

17
        processes = []
18
        for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
19
            try:
20
                if proc.info['name'] == 'firecracker':
21
                    processes.append({
22
                        'pid': proc.info['pid'],
23
                        'cmdline': ' '.join(proc.info['cmdline'])
24
                    })
25
            except (psutil.NoSuchProcess, psutil.AccessDenied):
26
                continue
27

28
        self.firecracker_processes = processes
29
        return processes
30

31
    def optimize_process_scheduling(self, pid, priority=-10, scheduler='normal'):
32
        """Optimize process scheduling parameters"""
33

34
        try:
35
            proc = psutil.Process(pid)
36

37
            # Set process priority
38
            proc.nice(priority)
39
            print(f"✓ Set nice level to {priority} for PID {pid}")
40

41
            # Set I/O priority
42
            try:
43
                subprocess.run(['sudo', 'ionice', '-c', '1', '-n', '2', '-p', str(pid)],
44
                             check=True)
45
                print(f"✓ Set I/O priority to real-time class for PID {pid}")
46
            except subprocess.CalledProcessError:
47
                print(f"⚠ Failed to set I/O priority for PID {pid}")
48

49
            # Set CPU affinity (optional)
50
            if scheduler == 'isolated':
51
                # Bind to specific CPUs (adjust based on your system)
52
                isolated_cpus = [2, 3, 4, 5]  # Example isolated CPUs
53
                proc.cpu_affinity(isolated_cpus)
54
                print(f"✓ Set CPU affinity to {isolated_cpus} for PID {pid}")
55

56
        except (psutil.NoSuchProcess, psutil.AccessDenied) as e:
57
            print(f"✗ Failed to optimize PID {pid}: {e}")
58

59
    def configure_firecracker_limits(self, vm_id):
60
        """Configure optimal resource limits for Firecracker VM"""
61

62
        config = {
63
            "machine-config": {
64
                "vcpu_count": 2,
65
                "mem_size_mib": 512,
66
                # Enable memory balloon for dynamic allocation
67
                "balloon": {
68
                    "amount_mib": 256,
69
                    "deflate_on_oom": True,
70
                    "stats_polling_interval_s": 1
71
                }
72
            },
73
            "cpu-config": {
74
                # Use CPU template for better performance
75
                "cpu_template": "T2"
76
            },
77
            # Configure rate limiters for predictable performance
78
            "network-interfaces": [
79
                {
80
                    "iface_id": "eth0",
81
                    "guest_mac": "AA:FC:00:00:00:01",
82
                    "host_dev_name": "tap0",
83
                    "rx_rate_limiter": {
84
                        "bandwidth": {
85
                            "size": 125000000,  # 1Gbps
86
                            "refill_time": 100
87
                        },
88
                        "ops": {
89
                            "size": 50000,
90
                            "refill_time": 100
91
                        }
92
                    },
93
                    "tx_rate_limiter": {
94
                        "bandwidth": {
95
                            "size": 125000000,  # 1Gbps
96
                            "refill_time": 100
97
                        },
98
                        "ops": {
99
                            "size": 50000,
100
                            "refill_time": 100
101
                        }
102
                    }
103
                }
104
            ],
105
            "drives": [
106
                {
107
                    "drive_id": "rootfs",
108
                    "path_on_host": f"/var/lib/firecracker/{vm_id}/rootfs.ext4",
109
                    "is_root_device": True,
110
                    "is_read_only": False,
111
                    "rate_limiter": {
112
                        "bandwidth": {
113
                            "size": 104857600,  # 100MB/s
114
                            "refill_time": 100
115
                        },
116
                        "ops": {
117
                            "size": 10000,
118
                            "refill_time": 100
119
                        }
120
                    }
121
                }
122
            ],
123
            # Enable metrics for monitoring
124
            "metrics": {
125
                "metrics_path": f"/tmp/firecracker-metrics-{vm_id}.json"
126
            },
127
            # Optimize logging
128
            "logger": {
129
                "level": "Warn",  # Reduce logging overhead
130
                "log_path": f"/var/log/firecracker-{vm_id}.log",
131
                "show_level": False,
132
                "show_log_origin": False
133
            }
134
        }
135

136
        self.optimization_configs[vm_id] = config
137
        return config
138

139
    def generate_optimized_config(self, vm_id, output_path=None):
140
        """Generate optimized Firecracker configuration file"""
141

142
        config = self.configure_firecracker_limits(vm_id)
143

144
        if output_path is None:
145
            output_path = f"/tmp/firecracker-optimized-{vm_id}.json"
146

147
        with open(output_path, 'w') as f:
148
            json.dump(config, f, indent=2)
149

150
        print(f"✓ Generated optimized config for VM {vm_id}: {output_path}")
151
        return output_path
152

153
    def apply_runtime_optimizations(self, socket_path, optimizations):
154
        """Apply runtime optimizations via Firecracker API"""
155

156
        import requests_unixsocket
157
        session = requests_unixsocket.Session()
158
        base_url = f'http+unix://{socket_path.replace("/", "%2F")}'
159

160
        # Apply CPU optimizations
161
        if 'cpu_template' in optimizations:
162
            response = session.put(
163
                f'{base_url}/cpu-config',
164
                json={'cpu_template': optimizations['cpu_template']}
165
            )
166
            if response.status_code == 204:
167
                print("✓ Applied CPU template optimization")
168
            else:
169
                print(f"✗ Failed to apply CPU template: {response.status_code}")
170

171
        # Apply memory balloon configuration
172
        if 'balloon' in optimizations:
173
            response = session.put(
174
                f'{base_url}/balloon',
175
                json=optimizations['balloon']
176
            )
177
            if response.status_code == 204:
178
                print("✓ Applied memory balloon optimization")
179
            else:
180
                print(f"✗ Failed to apply balloon config: {response.status_code}")
181

182
        # Configure rate limiters for existing interfaces
183
        if 'network_rate_limits' in optimizations:
184
            for iface_id, limits in optimizations['network_rate_limits'].items():
185
                response = session.patch(
186
                    f'{base_url}/network-interfaces/{iface_id}',
187
                    json=limits
188
                )
189
                if response.status_code == 204:
190
                    print(f"✓ Applied network rate limits for {iface_id}")
191
                else:
192
                    print(f"✗ Failed to apply network rate limits for {iface_id}")
193

194
    def monitor_performance_metrics(self, metrics_path, duration=60):
195
        """Monitor Firecracker performance metrics"""
196

197
        import time
198

199
        print(f"Monitoring performance for {duration} seconds...")
200

201
        start_time = time.time()
202
        metrics_history = []
203

204
        while time.time() - start_time < duration:
205
            try:
206
                if Path(metrics_path).exists():
207
                    with open(metrics_path, 'r') as f:
208
                        metrics = json.load(f)
209
                        metrics['timestamp'] = time.time()
210
                        metrics_history.append(metrics)
211

212
                time.sleep(1)
213

214
            except (json.JSONDecodeError, FileNotFoundError):
215
                time.sleep(1)
216
                continue
217

218
        # Analyze metrics
219
        self._analyze_metrics(metrics_history)
220
        return metrics_history
221

222
    def _analyze_metrics(self, metrics_history):
223
        """Analyze collected performance metrics"""
224

225
        if not metrics_history:
226
            print("No metrics collected")
227
            return
228

229
        print("\n=== Performance Analysis ===")
230

231
        # Network metrics
232
        if 'net' in metrics_history[-1]:
233
            net_metrics = metrics_history[-1]['net']
234
            print(f"Network Events: RX={net_metrics.get('rx_queue_event_count', 0)}, "
235
                  f"TX={net_metrics.get('tx_queue_event_count', 0)}")
236

237
        # Block I/O metrics
238
        if 'block' in metrics_history[-1]:
239
            block_metrics = metrics_history[-1]['block']
240
            print(f"Block I/O: Reads={block_metrics.get('read_count', 0)}, "
241
                  f"Writes={block_metrics.get('write_count', 0)}")
242

243
        # vCPU metrics
244
        if 'vcpu' in metrics_history[-1]:
245
            for vcpu_id, vcpu_data in metrics_history[-1]['vcpu'].items():
246
                exits = vcpu_data.get('exit_io_in', 0) + vcpu_data.get('exit_io_out', 0)
247
                print(f"{vcpu_id}: VM exits={exits}")
248

249
    def run_optimization_suite(self):
250
        """Run complete optimization suite"""
251

252
        print("=== Firecracker VMM Optimization Suite ===")
253

254
        # Find running Firecracker processes
255
        processes = self.find_firecracker_processes()
256
        print(f"Found {len(processes)} Firecracker processes")
257

258
        # Optimize each process
259
        for proc in processes:
260
            print(f"\nOptimizing PID {proc['pid']}...")
261
            self.optimize_process_scheduling(proc['pid'])
262

263
        # Generate optimized configurations
264
        for i in range(3):  # Generate configs for example VMs
265
            vm_id = f"vm{i:03d}"
266
            config_path = self.generate_optimized_config(vm_id)
267
            print(f"Generated config for {vm_id}: {config_path}")
268

269
if __name__ == '__main__':
270
    optimizer = FirecrackerVMMOptimizer()
271
    optimizer.run_optimization_suite()

1
#!/bin/bash
2

3
# Storage I/O optimization for Firecracker
4
echo "=== Storage I/O Optimization ==="
5

6
# Configure I/O scheduler
7
configure_io_scheduler() {
8
    local device=$1
9
    local scheduler=${2:-mq-deadline}
10

11
    echo "Configuring I/O scheduler for $device to $scheduler"
12

13
    if [ -f "/sys/block/$device/queue/scheduler" ]; then
14
        echo "$scheduler" | sudo tee "/sys/block/$device/queue/scheduler"
15
        echo "✓ Set $device scheduler to $scheduler"
16
    else
17
        echo "✗ Device $device not found"
18
    fi
19
}
20

21
# Optimize block device settings
22
optimize_block_device() {
23
    local device=$1
24

25
    echo "Optimizing block device settings for $device"
26

27
    # Set queue depth
28
    echo 32 | sudo tee "/sys/block/$device/queue/nr_requests"
29

30
    # Enable NCQ (Native Command Queuing)
31
    echo 31 | sudo tee "/sys/block/$device/queue/nr_requests"
32

33
    # Optimize read-ahead
34
    echo 512 | sudo tee "/sys/block/$device/queue/read_ahead_kb"
35

36
    # Enable write caching (if safe)
37
    echo "write back" | sudo tee "/sys/block/$device/queue/write_cache" 2>/dev/null || true
38

39
    # Optimize rotational settings (for SSDs)
40
    echo 0 | sudo tee "/sys/block/$device/queue/rotational"
41

42
    echo "✓ Optimized $device settings"
43
}
44

45
# Configure storage devices
46
for device in sda sdb nvme0n1 nvme1n1; do
47
    if [ -d "/sys/block/$device" ]; then
48
        configure_io_scheduler "$device" "mq-deadline"
49
        optimize_block_device "$device"
50
    fi
51
done
52

53
echo "Storage optimization complete!"

1
#!/usr/bin/env python3
2
import os
3
import json
4
import subprocess
5
from pathlib import Path
6

7
class IOOptimizer:
8
    """Advanced I/O optimization for Firecracker"""
9

10
    def __init__(self):
11
        self.block_devices = self._discover_block_devices()
12
        self.nvme_devices = self._discover_nvme_devices()
13

14
    def _discover_block_devices(self):
15
        """Discover available block devices"""
16

17
        devices = []
18
        sys_block = Path('/sys/block')
19

20
        for device_path in sys_block.iterdir():
21
            if device_path.is_dir() and not device_path.name.startswith('loop'):
22
                devices.append(device_path.name)
23

24
        return devices
25

26
    def _discover_nvme_devices(self):
27
        """Discover NVMe devices"""
28

29
        devices = []
30
        for device in self.block_devices:
31
            if device.startswith('nvme'):
32
                devices.append(device)
33

34
        return devices
35

36
    def optimize_nvme_devices(self):
37
        """Optimize NVMe devices for Firecracker workloads"""
38

39
        print("=== NVMe Optimization ===")
40

41
        for device in self.nvme_devices:
42
            device_path = f'/dev/{device}'
43

44
            # Set optimal queue depth
45
            self._set_nvme_queue_depth(device, 32)
46

47
            # Configure interrupt coalescing
48
            self._configure_nvme_interrupts(device)
49

50
            # Enable write caching
51
            self._enable_write_cache(device_path)
52

53
            print(f"✓ Optimized NVMe device {device}")
54

55
    def _set_nvme_queue_depth(self, device, depth=32):
56
        """Set NVMe queue depth"""
57

58
        queue_file = f'/sys/block/{device}/queue/nr_requests'
59

60
        try:
61
            with open(queue_file, 'w') as f:
62
                f.write(str(depth))
63
            print(f"  ✓ Set queue depth to {depth} for {device}")
64
        except (IOError, OSError) as e:
65
            print(f"  ✗ Failed to set queue depth for {device}: {e}")
66

67
    def _configure_nvme_interrupts(self, device):
68
        """Configure NVMe interrupt settings"""
69

70
        # Find NVMe PCI device
71
        try:
72
            result = subprocess.run([
73
                'lspci', '-D', '-d', '::0108'  # NVMe controller class
74
            ], capture_output=True, text=True, check=True)
75

76
            for line in result.stdout.strip().split('\n'):
77
                if line:
78
                    pci_id = line.split()[0]
79
                    self._optimize_pci_device_interrupts(pci_id)
80

81
        except subprocess.CalledProcessError:
82
            print(f"  ⚠ Could not find PCI info for {device}")
83

84
    def _optimize_pci_device_interrupts(self, pci_id):
85
        """Optimize PCI device interrupt settings"""
86

87
        # This is a simplified example - actual implementation would be more complex
88
        irq_path = f'/proc/irq'
89

90
        try:
91
            # Find device IRQs
92
            result = subprocess.run([
93
                'grep', '-l', pci_id.replace(':', ''),
94
                f'{irq_path}/*/actions'
95
            ], capture_output=True, text=True, check=False)
96

97
            for irq_file in result.stdout.strip().split('\n'):
98
                if irq_file:
99
                    irq_num = irq_file.split('/')[3]
100
                    # Set interrupt affinity (simplified)
101
                    smp_affinity_file = f'{irq_path}/{irq_num}/smp_affinity'
102
                    if os.path.exists(smp_affinity_file):
103
                        with open(smp_affinity_file, 'w') as f:
104
                            f.write('f')  # Use all CPUs
105
                        print(f"  ✓ Set interrupt affinity for IRQ {irq_num}")
106

107
        except Exception as e:
108
            print(f"  ⚠ Could not optimize interrupts for {pci_id}: {e}")
109

110
    def _enable_write_cache(self, device_path):
111
        """Enable write cache for device"""
112

113
        try:
114
            subprocess.run([
115
                'hdparm', '-W', '1', device_path
116
            ], check=True, capture_output=True)
117
            print(f"  ✓ Enabled write cache for {device_path}")
118
        except (subprocess.CalledProcessError, FileNotFoundError):
119
            print(f"  ⚠ Could not enable write cache for {device_path}")
120

121
    def create_optimized_filesystem(self, device_path, fs_type='ext4', mount_point=None):
122
        """Create optimized filesystem for Firecracker images"""
123

124
        print(f"Creating optimized {fs_type} filesystem on {device_path}")
125

126
        if fs_type == 'ext4':
127
            # Create ext4 with optimizations
128
            cmd = [
129
                'mkfs.ext4',
130
                '-F',  # Force creation
131
                '-O', '^has_journal',  # Disable journaling for performance
132
                '-E', 'lazy_itable_init=0,lazy_journal_init=0',
133
                '-m', '1',  # Reduce reserved blocks
134
                '-b', '4096',  # 4KB block size
135
                device_path
136
            ]
137
        elif fs_type == 'xfs':
138
            # Create XFS with optimizations
139
            cmd = [
140
                'mkfs.xfs',
141
                '-f',  # Force creation
142
                '-d', 'agcount=8',  # Allocation groups
143
                '-l', 'size=64m',  # Log size
144
                '-b', 'size=4096',  # Block size
145
                device_path
146
            ]
147
        else:
148
            print(f"Unsupported filesystem type: {fs_type}")
149
            return False
150

151
        try:
152
            subprocess.run(cmd, check=True, capture_output=True)
153
            print(f"✓ Created {fs_type} filesystem on {device_path}")
154

155
            if mount_point:
156
                self._mount_with_optimizations(device_path, mount_point, fs_type)
157

158
            return True
159

160
        except subprocess.CalledProcessError as e:
161
            print(f"✗ Failed to create filesystem: {e}")
162
            return False
163

164
    def _mount_with_optimizations(self, device_path, mount_point, fs_type):
165
        """Mount filesystem with performance optimizations"""
166

167
        os.makedirs(mount_point, exist_ok=True)
168

169
        if fs_type == 'ext4':
170
            mount_options = [
171
                'noatime',  # Don't update access times
172
                'nodiratime',  # Don't update directory access times
173
                'data=writeback',  # Fastest journaling mode
174
                'barrier=0',  # Disable barriers (use only with UPS/reliable power)
175
                'commit=60'  # Commit every 60 seconds
176
            ]
177
        elif fs_type == 'xfs':
178
            mount_options = [
179
                'noatime',
180
                'nodiratime',
181
                'allocsize=64m',  # Allocation size
182
                'largeio',  # Large I/O operations
183
                'inode64'  # 64-bit inodes
184
            ]
185
        else:
186
            mount_options = ['noatime', 'nodiratime']
187

188
        try:
189
            subprocess.run([
190
                'mount',
191
                '-o', ','.join(mount_options),
192
                device_path, mount_point
193
            ], check=True)
194
            print(f"✓ Mounted {device_path} at {mount_point} with optimizations")
195
        except subprocess.CalledProcessError as e:
196
            print(f"✗ Failed to mount {device_path}: {e}")
197

198
    def benchmark_storage(self, device_path, test_size='1G'):
199
        """Benchmark storage performance"""
200

201
        print(f"=== Benchmarking {device_path} ===")
202

203
        # Sequential write test
204
        print("Running sequential write test...")
205
        try:
206
            result = subprocess.run([
207
                'dd', 'if=/dev/zero', f'of={device_path}',
208
                f'bs=1M', f'count={test_size[:-1]}',
209
                'oflag=direct', 'conv=fdatasync'
210
            ], capture_output=True, text=True, check=True)
211

212
            # Parse dd output for throughput
213
            for line in result.stderr.split('\n'):
214
                if 'bytes' in line and 'copied' in line:
215
                    print(f"  Sequential write: {line}")
216

217
        except subprocess.CalledProcessError as e:
218
            print(f"  ✗ Sequential write test failed: {e}")
219

220
        # Sequential read test
221
        print("Running sequential read test...")
222
        try:
223
            result = subprocess.run([
224
                'dd', f'if={device_path}', 'of=/dev/null',
225
                f'bs=1M', f'count={test_size[:-1]}',
226
                'iflag=direct'
227
            ], capture_output=True, text=True, check=True)
228

229
            for line in result.stderr.split('\n'):
230
                if 'bytes' in line and 'copied' in line:
231
                    print(f"  Sequential read: {line}")
232

233
        except subprocess.CalledProcessError as e:
234
            print(f"  ✗ Sequential read test failed: {e}")
235

236
        # Random I/O test with fio (if available)
237
        self._run_fio_benchmark(device_path)
238

239
    def _run_fio_benchmark(self, device_path):
240
        """Run fio benchmark if available"""
241

242
        try:
243
            # Check if fio is available
244
            subprocess.run(['which', 'fio'], check=True, capture_output=True)
245

246
            # Create fio job file
247
            fio_job = f'''
248
[global]
249
ioengine=libaio
250
direct=1
251
group_reporting
252
time_based
253
runtime=30
254
filename={device_path}
255

256
[random-read]
257
stonewall
258
rw=randread
259
bs=4k
260
iodepth=32
261
numjobs=1
262

263
[random-write]
264
stonewall
265
rw=randwrite
266
bs=4k
267
iodepth=32
268
numjobs=1
269
'''
270

271
            with open('/tmp/firecracker_fio.job', 'w') as f:
272
                f.write(fio_job)
273

274
            print("Running fio benchmark...")
275
            result = subprocess.run([
276
                'fio', '/tmp/firecracker_fio.job'
277
            ], capture_output=True, text=True, check=True)
278

279
            # Parse fio output for IOPS and bandwidth
280
            for line in result.stdout.split('\n'):
281
                if 'IOPS=' in line or 'BW=' in line:
282
                    print(f"  {line.strip()}")
283

284
        except (subprocess.CalledProcessError, FileNotFoundError):
285
            print("  ⚠ fio not available for detailed benchmarking")
286

287
    def run_io_optimization(self):
288
        """Run complete I/O optimization suite"""
289

290
        print("=== I/O Optimization Suite ===")
291

292
        # Optimize NVMe devices
293
        if self.nvme_devices:
294
            self.optimize_nvme_devices()
295
        else:
296
            print("No NVMe devices found")
297

298
        # Print optimization recommendations
299
        self._print_recommendations()
300

301
    def _print_recommendations(self):
302
        """Print I/O optimization recommendations"""
303

304
        print("\n=== I/O Optimization Recommendations ===")
305
        print("1. Use NVMe SSDs for best performance")
306
        print("2. Configure RAID 0 for multiple drives (if redundancy not required)")
307
        print("3. Use ext4 without journaling for maximum performance")
308
        print("4. Mount with noatime and nodiratime options")
309
        print("5. Use O_DIRECT for database workloads")
310
        print("6. Configure appropriate I/O scheduler (mq-deadline for SSDs)")
311
        print("7. Set optimal queue depth (32-128 for NVMe)")
312
        print("8. Align partitions to 4K boundaries")
313

314
if __name__ == '__main__':
315
    optimizer = IOOptimizer()
316
    optimizer.run_io_optimization()