Performance - QR Code Generator v1.0.1

Discover the massive performance improvements and optimization techniques that make this QR code library

than the original implementation.

🚀 Performance Highlights

Benchmark Results

Real-world performance comparisons showing dramatic improvements:

Optimization Techniques

1. Intelligent Caching System

The biggest performance boost comes from our intelligent caching system:

 
use QR_Code\Types\QR_Text;
use QR_Code\Util\Tools;
 
// Enable caching for massive speed improvements
Tools::buildCache();
 
// First generation: ~0.5ms (builds cache)
$qr1 = new QR_Text('Hello World');
$result1 = $qr1->png();
 
// Subsequent identical generations: ~0.01ms (uses cache)
$qr2 = new QR_Text('Hello World');
$result2 = $qr2->png(); // Lightning fast!
 
// Clear cache when needed
Tools::clearCache();

2. Dual Image Engine Support

Automatic detection and optimization for both GD and ImageMagick:

 
use QR_Code\Enums\ImageEngine;
 
// Check available engines
$engines = ImageEngine::getAvailable();
// Returns: [ImageEngine::Imagick, ImageEngine::GD]
 
// Automatic best engine detection
$bestEngine = ImageEngine::detectBest();
 
// Performance comparison:
// ImageMagick: ~0.3ms per QR code
// GD Library:  ~0.5ms per QR code
// Pure PHP:    ~2.0ms per QR code (fallback)

3. Memory Optimization

Efficient memory management reduces overhead:

 
use QR_Code\Util\ArrayOptimizer;
 
// Matrix compression for large batches
$matrix = $qr->getMatrix();
$compressed = ArrayOptimizer::compressMatrix($matrix);
 
// Memory usage comparison:
// Original matrix: ~25KB per QR code
// Compressed:      ~5KB per QR code (5x reduction)
 
// Batch processing optimization
$urls = ['url1.com', 'url2.com', /* ... 1000 URLs */];
$processor = fn($url) => (new QR_Url($url))->png();
 
// Optimized batch processing
$results = ArrayOptimizer::batchProcess($urls, $processor);
// Uses ~80% less memory than individual processing

Performance Best Practices

Choosing the Right Settings

 
// Optimized configuration for speed
$qr = new QR_Text('Sample text');
$qr->setSize(4)                    // Good balance
   ->setErrorCorrectionLevel('L')   // Fastest
   ->setMargin(3);                  // Moderate margin
 
$fastQR = $qr->png(); // ~0.3ms generation time
 
// vs. slow configuration
$slowQr = new QR_Text('Sample text');
$slowQr->setSize(15)               // Large size = slower
       ->setErrorCorrectionLevel('H') // High correction = slower
       ->setMargin(10);               // Large margin = slower
 
$slowResult = $slowQr->png(); // ~2.5ms generation time

Batch Processing Optimization

 
// Efficient batch generation
$data = ['text1', 'text2', 'text3', /* ... hundreds more */];
$qrCodes = [];
 
// Pre-configure shared settings
$baseConfig = (new QR_Text(''))->setSize(4)->setErrorCorrectionLevel('M');
 
foreach ($data as $text) {
    $qr = clone $baseConfig; // Reuse configuration
    $qr->setText($text);     // Update only the text
    $qrCodes[] = $qr->png();
}
 
// With caching enabled, this processes 1000 QRs in ~500ms

Real-World Performance Test

Here's a live performance demonstration:

Memory Usage Optimization

 
// Monitor memory usage
$memStart = memory_get_usage();
 
// Generate QR codes efficiently
$qr = new QR_Text('Memory test');
$qr->setSize(4);
$result = $qr->png();
 
$memEnd = memory_get_usage();
$memUsed = ($memEnd - $memStart) / 1024; // KB
 
echo "Memory used: {$memUsed} KB per QR code";
// Typical usage: ~15-25KB per QR code (including PHP overhead)
 
// Memory cleanup (automatic, but can be explicit)
unset($qr, $result);
gc_collect_cycles(); // Force garbage collection if needed

Troubleshooting Performance Issues

 
// Performance diagnostics
use QR_Code\Enums\ImageEngine;
use QR_Code\Util\Benchmark;
 
// Check available engines
echo "Available engines: " . implode(', ', ImageEngine::getAvailable());
 
// Benchmark generation
Benchmark::mark('start');
$qr = new QR_Text('Benchmark test');
$result = $qr->png();
Benchmark::mark('end');
 
$results = Benchmark::getResults();
echo "Generation time: " . $results['total'] . "ms";

Production Optimization Checklist

• ✅ Enable caching with Tools::buildCache()
• ✅ Install ImageMagick for best performance
• ✅ Use appropriate sizes (3-6 for most use cases)
• ✅ Choose error correction wisely ('L' for speed, 'H' for durability)
• ✅ Implement client-side caching for repeated QR codes
• ✅ Monitor memory usage in high-volume applications
• ✅ Use batch processing for multiple QR codes
• ✅ Profile your specific use case with realistic data

Conclusion

The modernized QR Code library delivers exceptional performance through intelligent caching, dual engine support, and optimized algorithms. The

makes it suitable for high-volume production applications while maintaining perfect QR code quality and compatibility.

Whether you're generating a single QR code or thousands in batch, these optimizations ensure your application remains fast and responsive.