📁 Volume II: Laravel Performance Tuning Kit

⚡ Topic 20: APCu vs Redis

Local shared memory vs network-based cache.

"Everyone tells you to use Redis for caching. Redis is great.
But Redis requires a network roundtrip — even on localhost.
For tiny, frequently accessed data, APCu is 1000x faster.
Use Redis for shared state across servers.
Use APCu for local, request-scoped, or config data."

⚠️ THE MISCONCEPTION

Many developers use Redis for everything — sessions, cache, queues, rate limiting. But Redis calls involve TCP/IP overhead (even on localhost). For data that doesn't need to be shared across servers, APCu is dramatically faster. The right tool for the right job.

🔍 What is APCu?

APCu (Alternative PHP Cache - User Cache) ═══════════════════════════════════════════════════════════════════ APCu is a shared memory cache that lives INSIDE each PHP-FPM process. ┌─────────────────────────────────────────────────────────────────┐ │ PHP-FPM Process 1 │ │ ┌─────────────────────────────────────────────────────────┐ │ │ │ APCu (Shared Memory) │ │ │ │ ┌─────────────────────────────────────────────────────┐│ │ │ │ │ key: 'config.app_name' → 'MyApp' ││ │ │ │ │ key: 'feature_flags' → ['new-ui' => true] ││ │ │ │ │ key: 'counter' → 12345 ││ │ │ │ └─────────────────────────────────────────────────────┘│ │ │ └─────────────────────────────────────────────────────────┘ │ └─────────────────────────────────────────────────────────────────┘ ┌─────────────────────────────────────────────────────────────────┐ │ PHP-FPM Process 2 │ │ ┌─────────────────────────────────────────────────────────┐ │ │ │ APCu (Shared Memory) │ │ │ │ ┌─────────────────────────────────────────────────────┐│ │ │ │ │ SAME DATA! (Shared across processes on same server)││ │ │ │ └─────────────────────────────────────────────────────┘│ │ │ └─────────────────────────────────────────────────────────┘ │ └─────────────────────────────────────────────────────────────────┘ KEY FEATURES: ═══════════════════════════════════════════════════════════════════ • NO network overhead — direct memory access • Shared across all PHP-FPM processes on the SAME server • NOT shared across multiple servers (local only) • Perfect for: config, feature flags, small counters, local cache

📊 Performance Comparison: APCu vs Redis

Operation	APCu (Local Memory)	Redis (Localhost)	Redis (Remote)	APCu Advantage
Get (1KB value)	0.05 µs	10 µs	200-500 µs	200x faster
Set (1KB value)	0.08 µs	12 µs	250-600 µs	150x faster
Increment counter	0.05 µs	8 µs	150-400 µs	160x faster

REAL-WORLD EXAMPLE

If your app makes 10,000 cache reads per second:

APCu: 0.0005 seconds of CPU time
Redis (localhost): 0.1 seconds of CPU time
Redis (remote): 2-5 seconds of CPU time

APCu is 200-1000x faster for local operations.

✅ When to Use APCu

PERFECT FOR APCu

Application configuration — Values that rarely change
Feature flags — Toggle features without redeploy
Local counters — Per-server request counts, rate limiting
Computed values — Expensive calculations that are server-specific
Route caching data — Laravel's route cache could use APCu
OpCache for autoloader — APCu can cache classmap
Local cache for read-only data — Data that doesn't change often

⚠️ APCu IS NOT FOR

Sessions — Sessions need to be shared across servers
Queue data — Queues need to be shared across workers
Shared counters — Counters that must be consistent across servers
Multi-server caching — APCu is local to one server only
Persistent storage — APCu clears when PHP-FPM restarts

⚙️ Installing APCu

UBUNTU / DEBIAN

# Install APCu extension
sudo apt-get install php8.2-apcu

# Or via PECL
pecl install apcu

# Enable APCu
sudo phpenmod apcu
sudo systemctl restart php8.2-fpm

PHP.INI CONFIGURATION

# /etc/php/8.2/mods-available/apcu.ini

extension=apcu.so
apc.enabled=1
apc.shm_size=128M           # Shared memory size
apc.ttl=7200                # Time to live (seconds)
apc.enable_cli=0            # Disable for CLI (artisan commands)
apc.slam_defense=0
apc.serializer=php          # Serializer (php, igbinary, json)

VERIFY APCu IS WORKING

# Check if APCu is loaded
php -m | grep apcu

# Check APCu status
php -r "print_r(apcu_cache_info());"

# Create a test
php -r "apcu_store('test', 'Hello APCu'); echo apcu_fetch('test');"

🔧 Using APCu in Laravel

METHOD 1: Cache Driver (with custom driver)

// app/Providers/AppServiceProvider.php
use Illuminate\Support\Facades\Cache;

public function boot()
{
    Cache::extend('apcu', function ($app) {
        return Cache::repository(new \Illuminate\Cache\Repository(
            new \Illuminate\Cache\ApcStore(
                new \Illuminate\Cache\ApcWrapper(),
                config('cache.prefix')
            )
        ));
    });
}

// config/cache.php
'stores' => [
    'apcu' => [
        'driver' => 'apcu',
        'prefix' => 'laravel_',
    ],
],

METHOD 2: Direct APCu Usage (Faster)

// Use directly for maximum performance
class FeatureFlagService
{
    public function isEnabled(string $feature): bool
    {
        // Check APCu first (0.05 µs)
        $cached = apcu_fetch("feature.{$feature}");
        
        if ($cached !== false) {
            return $cached;
        }
        
        // Fall back to database (10ms)
        $value = DB::table('feature_flags')
            ->where('name', $feature)
            ->value('enabled');
        
        // Store in APCu for 5 minutes
        apcu_store("feature.{$feature}", $value, 300);
        
        return $value;
    }
    
    public function clearCache(string $feature): void
    {
        apcu_delete("feature.{$feature}");
    }
}

📊 Laravel Cache Driver Performance

Driver	Read Latency	Write Latency	Shared Across Servers?	Best For
`file` (default)	100-500 µs	200-1000 µs	No (local filesystem)	Nothing — avoid in production
`redis`	10-50 µs	15-60 µs	✅ Yes	Sessions, queues, shared cache
`memcached`	10-40 µs	12-50 µs	✅ Yes	Shared cache (alternative to Redis)
`array`	0.01 µs	0.01 µs	No (per request only)	Testing only
`apcu` (custom)	0.05 µs	0.08 µs	No (per server only)	Local cache, config, feature flags

🔴 THE RULE: Use APCu for data that is server-specific and changes rarely. Use Redis for data that must be shared across servers (sessions, queues, shared cache). Never use file cache in production.

🔄 Hybrid Approach: APCu + Redis

LAYERED CACHING STRATEGY ═══════════════════════════════════════════════════════════════════ Request │ ▼ ┌─────────────────────────────────────────────────────────────────┐ │ L1: APCu Cache (Local, 0.05µs) │ │ ┌─────────────────────────────────────────────────────────┐ │ │ │ • Feature flags │ │ │ │ • Application config │ │ │ │ • Server-local counters │ │ │ │ • Expensive computed values (per server) │ │ │ └─────────────────────────────────────────────────────────┘ │ │ │ │ │ │ MISS │ │ ▼ │ │ L2: Redis Cache (Shared, 10µs) │ │ ┌─────────────────────────────────────────────────────────┐ │ │ │ • User sessions │ │ │ │ • Database query results │ │ │ │ • API response cache │ │ │ │ • Rate limiting counters (shared) │ │ │ └─────────────────────────────────────────────────────────┘ │ │ │ │ │ │ MISS │ │ ▼ │ │ L3: Database (Shared, 1,000-10,000µs) │ └─────────────────────────────────────────────────────────────────┘

IMPLEMENTATION

class LayeredCache
{
    public function remember(string $key, int $ttl, callable $callback)
    {
        // Try APCu first (fastest)
        $value = apcu_fetch($key);
        if ($value !== false) {
            return $value;
        }
        
        // Try Redis second (shared)
        $value = Cache::get($key);
        if ($value !== null) {
            // Store in APCu for next time
            apcu_store($key, $value, $ttl);
            return $value;
        }
        
        // Finally, compute the value
        $value = $callback();
        
        // Store in both caches
        Cache::put($key, $value, $ttl);
        apcu_store($key, $value, $ttl);
        
        return $value;
    }
    
    public function forget(string $key): void
    {
        apcu_delete($key);
        Cache::forget($key);
    }
}

📊 Monitoring APCu

# APCu status via CLI
php -r "print_r(apcu_cache_info());"

# Sample output:
Array
(
    [num_slots] => 16384
    [ttl] => 7200
    [num_hits] => 125000    # Cache hits
    [num_misses] => 5000    # Cache misses
    [mem_size] => 5242880   # Memory used (bytes)
    [num_entries] => 342    # Number of cached items
    [start_time] => 1704067200
    [expunges] => 12
)

# Hit rate = hits / (hits + misses)
# Aim for > 95% hit rate

APCu LIMITATIONS

Data is lost when PHP-FPM restarts (unlike Redis)
Not shared across multiple servers (use Redis for that)
Limited to available PHP memory
No persistence — cache is purely in-memory

📝 Topic 20 Summary: APCu vs Redis

Feature APCu Redis Speed (read) 0.05 µs 10-500 µs Network overhead? No (local memory) Yes (TCP/IP) Shared across servers? No Yes Persistence? No (lost on restart) Yes (Redis persistence) Max size php.ini limit (apc.shm_size) Server RAM Best for Config, flags, local counters Sessions, queues, shared cache

📌 THE RULE: Use APCu for server-local, high-frequency data (config, feature flags, local counters). Use Redis for data that must be shared across servers (sessions, queues, shared cache). For maximum performance, use both in a layered cache strategy.

NEXT TOPIC PREVIEW

Topic 21: Laravel Octane — The nuclear option. Keep Laravel alive in memory with Swoole or RoadRunner. Eliminate bootstrap overhead entirely. But beware of memory leaks.