# Python Flask worker memory profile
# Initial memory allocation
base_memory = 47 MB  # Flask app + dependencies + Python runtime

# Per-request memory overhead
request_overhead = 0.5 MB  # Request object, context, temporary data

# Memory growth pattern
# After 1000 requests: ~65 MB per worker
# After 10000 requests: ~95 MB per worker
# At sustained load: ~120 MB per worker (stabilizes)

# Maximum concurrent requests before performance degradation
max_concurrent_per_worker = 200  # Beyond this, latency increases significantly

// Node.js worker memory profile
// Initial memory allocation
const baseMemory = 35;  // MB: Express + Node.js runtime + V8 heap

// Per-request memory overhead
const requestOverhead = 0.3;  // MB: Request/response objects, closures

// Memory growth pattern
// After 1000 requests: ~48 MB per worker
// After 10000 requests: ~72 MB per worker  
// At sustained load: ~95 MB per worker (with periodic GC cycles)

// Maximum concurrent requests before performance degradation
const maxConcurrentPerWorker = 400;  // Event loop remains responsive

// V8 heap allocation strategy
const heapConfig = {
  oldSpaceSize: 512,  // MB: Long-lived objects
  newSpaceSize: 64,   // MB: Short-lived objects
  semiSpaceSize: 32   // MB: Survivor space for young generation
};

<?php
// PHP-FPM worker memory profile
// Initial memory allocation
$base_memory = 28;  // MB: PHP runtime + core extensions + OpCache

// Per-request memory overhead
$request_overhead = 0.4;  // MB: Request data, temporary variables

// Memory growth pattern
// After 1000 requests: ~42 MB per worker (OpCache fully warmed)
// After 10000 requests: ~68 MB per worker
// At sustained load: ~85 MB per worker

// Maximum concurrent requests before performance degradation
$max_concurrent_per_worker = 150;  // Process model limits

// OpCache configuration impact
$opcache_config = [
    'memory_consumption' => 128,  // MB
    'interned_strings_buffer' => 8,  // MB
    'max_accelerated_files' => 10000,
    'revalidate_freq' => 2  // seconds
];

import time
import numpy as np
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/cpu-intensive')
def complex_calculation():
    """CPU-intensive endpoint demonstrating GIL impact"""
    n = 10_000_000
    
    # Pure Python computation - GIL-limited
    result = sum(i ** 2 for i in range(n))
    
    # NumPy computation - releases GIL for C operations
    array_result = np.sum(np.arange(n) ** 2)
    
    return jsonify({
        'pure_python': result,
        'numpy_optimized': int(array_result)
    })

# Under load measurements:
# 1 concurrent request: ~25% CPU usage per core
# 4 concurrent requests: ~98% total CPU (24-25% per core)
# 8 concurrent requests: ~98% total CPU + queue backlog forms

@app.route('/io-intensive')
async def database_operation():
    """I/O-intensive endpoint - where Python shines with async"""
    import asyncio
    import aiohttp
    
    # Multiple async I/O operations
    async with aiohttp.ClientSession() as session:
        tasks = [
            session.get('http://api.example.com/data/{}'.format(i))
            for i in range(10)
        ]
        results = await asyncio.gather(*tasks)
    
    return jsonify({'results': len(results)})

# Under load measurements:
# 100 concurrent requests: ~45% CPU usage
# 500 concurrent requests: ~60% CPU usage
# Most time spent waiting for I/O, not computing

const express = require('express');
const cluster = require('cluster');
const os = require('os');
const { Worker } = require('worker_threads');

const app = express();

// CPU-intensive route - shows event loop blocking
app.get('/cpu-intensive', (req, res) => {
    const n = 10_000_000;
    let result = 0;
    
    // This blocks the event loop
    for (let i = 0; i < n; i++) {
        result += i ** 2;
    }
    
    res.json({ result });
});

// CPU measurements:
// 1 concurrent request: ~100% single core usage
// 2+ concurrent requests on same worker: significant latency increase
// Requests are processed serially on the event loop

// Proper CPU-intensive handling with worker threads
app.get('/cpu-intensive-worker', (req, res) => {
    const worker = new Worker(`
        const { parentPort, workerData } = require('worker_threads');
        let result = 0;
        for (let i = 0; i < workerData.n; i++) {
            result += i ** 2;
        }
        parentPort.postMessage(result);
    `, { 
        eval: true,
        workerData: { n: 10_000_000 }
    });
    
    worker.on('message', (result) => {
        res.json({ result });
    });
});

// I/O-intensive route - where Node.js shines
app.get('/io-intensive', async (req, res) => {
    const fetch = require('node-fetch');
    
    // Multiple concurrent I/O operations
    const promises = Array.from({ length: 10 }, (_, i) =>
        fetch(`http://api.example.com/data/${i}`)
    );
    
    const results = await Promise.all(promises);
    
    res.json({ count: results.length });
});

// CPU measurements:
// 100 concurrent requests: ~30% CPU usage
// 500 concurrent requests: ~45% CPU usage
// 1000 concurrent requests: ~55% CPU usage
// Event loop remains responsive throughout

<?php
// CPU-intensive endpoint with process isolation
function complexCalculation() {
    $n = 10_000_000;
    $result = 0;
    
    for ($i = 0; $i < $n; $i++) {
        $result += $i ** 2;
    }
    
    return json_encode(['result' => $result]);
}

// CPU measurements:
// 1 concurrent request: ~25% CPU (one core fully utilized)
// 4 concurrent requests: ~100% CPU (all cores utilized)
// 8 concurrent requests: ~100% CPU + queue forms at FPM level

// With PHP 8 JIT enabled
ini_set('opcache.jit', 'tracing');
ini_set('opcache.jit_buffer_size', '100M');

// JIT can provide 2-3x speedup for CPU-intensive code
// Measurement after JIT warmup:
// Same workload completes in ~40% less time

// I/O-intensive operation
function databaseOperation() {
    // Traditional blocking I/O
    $mysqli = new mysqli("localhost", "user", "password", "database");
    
    $results = [];
    for ($i = 0; $i < 10; $i++) {
        $result = $mysqli->query("SELECT * FROM data WHERE id = $i");
        $results[] = $result->fetch_assoc();
    }
    
    return json_encode($results);
}

// CPU measurements:
// 100 concurrent requests: ~60% CPU (waiting on I/O)
// 500 concurrent requests: ~75% CPU (I/O bottleneck apparent)
// Process blocking means less efficient I/O handling

// Node.js efficient database handling
const pool = mysql.createPool({
    connectionLimit: 20,
    host: 'localhost',
    user: 'user',
    password: 'password',
    database: 'testdb'
});

app.get('/users/:id', (req, res) => {
    pool.query('SELECT * FROM users WHERE id = ?', [req.params.id], (error, results) => {
        if (error) throw error;
        res.json(results[0]);
    });
});
// Event loop continues processing other requests while waiting for DB

# PyPy can provide 3-5x speedup for pure Python code
# No code changes needed, just use PyPy interpreter
# Benchmark: 2,800 req/s → 8,400 req/s for CPU-bound tasks

from sqlalchemy import create_engine
from sqlalchemy.pool import QueuePool

engine = create_engine(
    'postgresql://user:pass@localhost/db',
    poolclass=QueuePool,
    pool_size=20,
    max_overflow=10,
    pool_pre_ping=True  # Verify connections before use
)

from functools import lru_cache
import redis

# Application-level caching
@lru_cache(maxsize=1000)
def expensive_computation(n):
    return sum(i ** 2 for i in range(n))

# Distributed caching
redis_client = redis.Redis(host='localhost', port=6379, db=0)

@app.route('/cached-data/<key>')
def get_cached_data(key):
    # Check cache first
    cached = redis_client.get(key)
    if cached:
        return cached
    
    # Compute and cache
    result = expensive_database_query(key)
    redis_client.setex(key, 3600, result)  # 1 hour TTL
    return result

# For CPU-bound applications
workers = (2 * cpu_count()) + 1

# For I/O-bound applications
workers = (4 * cpu_count()) + 1

# Gunicorn configuration
gunicorn_config = {
    'workers': workers,
    'worker_class': 'sync',  # or 'gevent' for async
    'worker_connections': 1000,
    'max_requests': 1000,  # Restart workers to prevent memory leaks
    'max_requests_jitter': 100,
    'timeout': 30,
    'keepalive': 2
}

const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
    console.log(`Master ${process.pid} is running`);
    
    // Fork workers
    for (let i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
    
    // Restart crashed workers
    cluster.on('exit', (worker, code, signal) => {
        console.log(`Worker ${worker.process.pid} died`);
        cluster.fork();
    });
} else {
    // Workers share TCP connection
    const app = require('./app');
    app.listen(3000);
    console.log(`Worker ${process.pid} started`);
}

// Enable V8 optimizations
node --max-old-space-size=4096 \
     --optimize-for-size \
     --gc-interval=100 \
     app.js

// Avoid optimization killers
// ❌ Bad: arguments object, try-catch in hot paths
function badFunction() {
    try {
        return arguments[0] + arguments[1];
    } catch (e) {}
}

// ✅ Good: rest parameters, error handling at boundaries
function goodFunction(...args) {
    return args[0] + args[1];
}

// Handle promise rejections
process.on('unhandledRejection', (reason, promise) => {
    console.error('Unhandled Rejection:', reason);
    // Don't crash, but log for monitoring
});

// Avoid memory leaks in event listeners
const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.setMaxListeners(20);  // Prevent leak warnings

// Clean up resources properly
app.get('/resource', async (req, res) => {
    const resource = await acquireResource();
    try {
        const result = await processResource(resource);
        res.json(result);
    } finally {
        // Always clean up
        await resource.close();
    }
});

// Use PM2 for production
module.exports = {
    apps: [{
        name: 'api',
        script: './app.js',
        instances: 'max',  // Use all CPU cores
        exec_mode: 'cluster',
        max_memory_restart: '1G',
        error_file: './logs/err.log',
        out_file: './logs/out.log',
        merge_logs: true,
        env: {
            NODE_ENV: 'production'
        }
    }]
};

; php.ini OpCache settings
opcache.enable=1
opcache.memory_consumption=256
opcache.interned_strings_buffer=16
opcache.max_accelerated_files=20000
opcache.revalidate_freq=2
opcache.fast_shutdown=1
opcache.enable_cli=1

; PHP 8 JIT configuration
opcache.jit=tracing
opcache.jit_buffer_size=100M

; PHP-FPM pool configuration
[www]
pm = dynamic
pm.max_children = 50
pm.start_servers = 10
pm.min_spare_servers = 5
pm.max_spare_servers = 20
pm.max_requests = 500

; Performance tuning
request_terminate_timeout = 30s
rlimit_files = 4096
rlimit_core = 0

; For high-traffic sites
pm = static
pm.max_children = 100

<?php
// APCu for application caching
apcu_store('expensive_result', $result, 3600);
$cached = apcu_fetch('expensive_result');

// Redis for distributed caching
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

function getCachedData($key) {
    global $redis;
    
    $cached = $redis->get($key);
    if ($cached) {
        return json_decode($cached, true);
    }
    
    $data = expensiveOperation();
    $redis->setex($key, 3600, json_encode($data));
    return $data;
}

<?php
// PHP 8 features for better performance

// JIT-optimized code
function computeIntensive(int $n): int {
    $result = 0;
    for ($i = 0; $i < $n; $i++) {
        $result += $i ** 2;
    }
    return $result;
}

// Benchmark: PHP 7.4 vs PHP 8.0 with JIT
// PHP 7.4: 2,600 req/s
// PHP 8.0 (JIT off): 2,800 req/s
// PHP 8.0 (JIT on): 4,100 req/s (+57% improvement)

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

const clients = new Set();

wss.on('connection', (ws) => {
    clients.add(ws);
    console.log(`Connected clients: ${clients.size}`);
    
    ws.on('message', (message) => {
        // Broadcast to all clients efficiently
        clients.forEach((client) => {
            if (client.readyState === WebSocket.OPEN) {
                client.send(message);
            }
        });
    });
    
    ws.on('close', () => {
        clients.delete(ws);
    });
});

// Performance: Can handle 50,000+ concurrent connections on 8GB RAM

import pandas as pd
import numpy as np
from multiprocessing import Pool

def process_chunk(chunk):
    # Complex data transformations
    chunk['computed'] = chunk['value'].apply(lambda x: x ** 2)
    chunk['normalized'] = (chunk['value'] - chunk['value'].mean()) / chunk['value'].std()
    return chunk

def process_large_dataset(filename):
    # Read in chunks to manage memory
    chunks = pd.read_csv(filename, chunksize=100000)
    
    # Process in parallel
    with Pool(processes=4) as pool:
        processed_chunks = pool.map(process_chunk, chunks)
    
    # Combine results
    return pd.concat(processed_chunks)

# Performance: Can process 10GB+ datasets efficiently

<?php
// Modern PHP with Laravel-style routing and caching

Route::get('/posts/{slug}', function($slug) {
    return Cache::remember("post.$slug", 3600, function() use ($slug) {
        return Post::with(['author', 'comments'])
            ->where('slug', $slug)
            ->firstOrFail();
    });
});

// Performance: Handles 5000+ concurrent users with proper caching
// Benefit: Easy deployment, wide hosting support, mature CMS ecosystem