Performance Benchmarks

PivotPHP delivers exceptional performance through educational simplicity and maintained optimization. Our comprehensive benchmarks demonstrate real-world API performance across various scenarios, executed in standardized Docker containers for fair and reproducible testing. v1.2.0 “Simplicidade sobre Otimização Prematura” edition achieves 3.6M ops/sec Swagger UI generation, 2,122 req/sec HTTP peak performance, and 1,418 req/sec average HTTP throughput, establishing educational excellence without sacrificing technical capabilities.

Official Release Performance - PivotPHP v1.2.0 - July 21, 2025

PivotPHP v1.2.0 Official Release Performance Analysis

Framework: PivotPHP Core v1.2.0 (Simplicity Edition - “Simplicidade sobre Otimização Prematura”)
Release Date: July 21, 2025
Environment: Docker Container with PHP 8.4.8 (OPcache + JIT enabled)
Status: ✅ Official Release Validated

OpenAPI/Swagger Performance Breakthroughs (NEW v1.2.0) - Docker Validated

Average OpenAPI Performance: 1,783,236 ops/sec (Docker Environment)

Core Framework Performance (Docker Validated Comparison)

Average Performance Impact: -4.4% (Excellent trade-off for simplicity and educational value)

Real Docker Environment HTTP Performance (NEW)

Average HTTP Performance: 1,417.89 req/sec (Docker Environment)
Best Performance: 2,121.79 req/sec (Health endpoint)
Fastest Response: 0.36ms

Docker Environment Validation Summary

v1.1.4 Key Features Successfully Validated

1. Array Callable Support (NEW in v1.1.4)
   • PHP 8.4+ compatible syntax
   • Performance: 28,624 ops/sec
   • Usage: $app->get('/users', [UserController::class, 'index'])
2. Architectural Excellence
   • 100% PSR-12 compliance
   • Zero code violations
   • Clean, maintainable architecture
3. Object Pooling Revolution
   • 100% Request object reuse
   • 99.9% Response object reuse
   • Dramatic performance improvements
4. JSON Response Optimization
   • Efficient JSON processing
   • Automatic buffer pooling
   • Metadata inclusion

Performance Summary v1.1.4

• Average Performance: 30,623 ops/sec across all operations
• Peak Performance: 84,998 ops/sec (application creation)
• Memory Efficiency: Total ~16.5MB for all operations
• Response Time: 0.070ms average (excellent)
• Compatibility: Full backward compatibility maintained

v1.1.4 Performance Visualization

Cross-Framework HTTP Real Performance (Equivalent Environment)

Test Environment: Cross-framework equivalent setup (nginx + php-fpm + OPcache + JIT)
Test Date: July 15, 2025 - Phase 3 Ecosystem Validation
Methodology: HTTP requests via standardized container configuration
Stack Configuration: Docker containers with identical resource limits and server stack

PivotPHP All Configurations Cross-Framework Results

Cross-Framework Comparison (HTTP Real - Equivalent Setup)

Key Insights from Cross-Framework Equivalence Testing

• ✅ EQUIVALENT CONFIGURATION CONFIRMED: All PivotPHP configurations tested with identical stack (nginx + php-fpm + OPcache + JIT)
• 📊 Realistic HTTP Performance: 1,917-2,250 req/sec range for all PivotPHP configurations
• 🎯 Optimization Potential: 3x-5x improvement target with nginx/php-fpm tuning (6,000-10,000 req/sec)
• 🔧 Development Focus: Clear optimization path identified for production deployment
• 📈 Fair Comparison: Now directly comparable to other frameworks using same methodology
• ⚡ Strong Potential: ReactPHP configuration shows highest optimization potential (8,500 req/sec target)

Phase 3 Cross-Framework Analysis - v1.1.4 Ecosystem Validation

Phase 3 Analysis Date: July 15, 2025
Framework: PivotPHP v1.1.4 (Architectural Excellence & Performance Optimization Edition)
Analysis Type: Comprehensive cross-framework equivalent configuration validation

Strategic Market Position - Cross-Framework Equivalent

v1.1.4 Cross-Framework Competitive Analysis

1. HTTP Real Performance: 1,917-2,250 req/sec (all configurations) in equivalent testing
2. Configuration Equivalence: nginx + php-fpm + OPcache + JIT stack matching other frameworks
3. Optimization Roadmap: Clear path to 6K-10K req/sec with production tuning
4. Architectural Excellence: 100% PSR-12 compliance, zero code violations maintained
5. Development Experience: Express.js API with realistic performance expectations

Strategic Positioning & Next Steps

• Optimization Focus: Target nginx/php-fpm tuning to reach 6K+ req/sec for competitive position
• Configuration Strength: All 4 PivotPHP configurations now validated with equivalent methodology
• Development Clarity: Realistic performance expectations set with clear optimization targets
• Market Opportunity: Strong optimization potential positions PivotPHP for significant improvement
• Ecosystem Validation: Complete testing of Core, ReactPHP, ORM, and Full Ecosystem configurations

ReactPHP Performance Analysis - Continuous Runtime

🚀 Revolutionary Performance Metrics

📊 Performance Summary

• Average Performance: 25,619 req/sec (4x traditional PHP)
• Peak Performance: 35,472 req/sec (persistent state)
• Ultra-Low Latency: 0.0282ms minimum response time
• Memory Efficiency: Ultra-efficient continuous runtime

🎯 Use Case Recommendations

🚀 Choose ReactPHP for:

• WebSocket applications (29,560 req/sec)
• Real-time features (35,472 req/sec)
• Long-running processes (19,707 req/sec)
• High-concurrency scenarios (17,736 req/sec)

📱 Choose Core for:

• Traditional REST APIs (6,227 req/sec)
• Microservices (competitive performance)
• Serverless functions (stateless operations)
• Express.js-style development (familiar API)

Internal Benchmark Results - PivotPHP Core v1.2.0

PivotPHP Core v1.2.0 Performance Analysis

Framework: PivotPHP Core v1.2.0 Simplicity Edition
Test Date: July 11, 2025
Environment: Linux WSL2 with PHP 8.2+ (OPcache + JIT enabled)
Test Type: Simple Realistic Benchmark

JSON Operations Performance Excellence

Data Processing Performance

Memory Efficiency

Total Performance Summary

• JSON Operations: 837,411 ops/sec
• Data Processing: 485,286 ops/sec
• Combined Performance: 1,322,697 ops/sec
• Memory Footprint: Only 1.61MB

Cross-Framework Analysis

Comprehensive benchmarks comparing PivotPHP with established frameworks (Updated: 2025-07-11):

PivotPHP Ecosystem Specialization

PivotPHP Core v1.2.0 - Docker Benchmark Results

PivotPHP v1.2.0 JSON Performance (Docker)

Concurrency Performance

PivotPHP maintains excellent performance under various concurrent load levels:

Stress Test Results

API-Specific Performance

Real-world API operations benchmarked in Docker containers v1.2.0:

Latency Distribution

PivotPHP maintains consistent low latency across percentiles:

Framework Ecosystem Analysis

PivotPHP’s ecosystem approach provides specialized performance profiles:

Performance by Use Case (2025-07-21 Docker v1.2.0 Analysis)

Benchmark Methodology & Environment

• Test Date: July 11, 2025
• Environment: PHP 8.1+ with OPcache and JIT enabled in Docker containers
• Iterations: 1,000-5,000 per benchmark for statistical accuracy
• Categories: HTTP performance, REST API, JSON operations, status codes, content negotiation
• Containerization: Docker-based isolation for fair and reproducible comparison
• Version: PivotPHP Core v1.2.0 (Simplicity Edition)

When to Choose Each Framework

Choose PivotPHP Core v1.2.0 When:

• Building high-performance HTTP APIs
• Need excellent status code handling (692K ops/sec)
• Want superior content negotiation (548K ops/sec)
• Building Express.js-style applications in PHP
• Performance: 2.15M combined HTTP ops/sec with only 14MB memory

Choose PivotPHP for JSON APIs When:

• Processing small JSON datasets (161K ops/sec)
• Need efficient medium JSON handling (17K ops/sec)
• Building JSON-heavy APIs with pooling optimization
• Performance: Revolutionary JSON optimization with buffer pooling

Choose PivotPHP for HTTP Processing When:

• Need fast request parsing (317K ops/sec)
• Want efficient response creation (294K ops/sec)
• Building HTTP-focused microservices
• Performance: Excellent HTTP performance with low memory usage

Choose PivotPHP for Status-Heavy Apps When:

• Building APIs with frequent status code changes
• Need ultra-fast status code handling (692K ops/sec)
• Building monitoring or health-check endpoints
• Performance: Industry-leading status code performance

Concurrent Performance Testing

PivotPHP excels at handling concurrent requests with minimal performance degradation:

Concurrent Request Handling

Scaling Behavior

PivotPHP v1.2.0 demonstrates excellent scaling characteristics:

• HTTP Operations: Maintains 2.15M ops/sec across different operation types
• JSON Processing: Scales from 161K ops/sec (small) to 1.7K ops/sec (large)
• Memory Efficient: Only 14MB usage for HTTP operations, 0-1.6MB for JSON
• Docker Validated: All metrics validated in standardized Docker environment

Real-World Performance

API Response Times

// Ultra-fast status endpoint - 1.44μs average (692K ops/sec)
$app->get('/status', fn($req, $res) => $res->json(['ok' => true]));

// Fast users endpoint - 3.15μs average (317K ops/sec)
$app->get('/users', function($req, $res) {
    $users = User::paginate(10);
    return $res->json($users); // Small JSON: 161K ops/sec
});

// Medium JSON endpoint - 56.82μs average (17K ops/sec)
$app->post('/data', function($req, $res) {
    $data = DataService::process($req->body());
    return $res->json($data); // Medium JSON with pooling
});

Optimization Tips

1. Use Appropriate Endpoints

• Reserve heavy processing for dedicated endpoints
• Implement caching for computationally expensive operations
• Use lightweight responses for health checks

2. Leverage Middleware Efficiently

// Good: Conditional middleware
$app->group('/api', function($app) {
    $app->use(new RateLimitMiddleware());
    $app->use(new AuthMiddleware());
    // Routes here
});

// Avoid: Global heavy middleware
$app->use(new ExpensiveMiddleware()); // Applied to all routes

3. Optimize Database Queries

// Use eager loading
$users = User::with('posts', 'comments')->get();

// Use query builder for complex queries
$stats = DB::table('orders')
    ->select(DB::raw('DATE(created_at) as date'), DB::raw('SUM(total) as revenue'))
    ->groupBy('date')
    ->get();

Benchmark Methodology

All benchmarks were conducted with standardized Docker containers:

• Environment: Isolated Docker containers for fair testing
• Standardization: Identical PHP 8.1+ environment across all tests
• Configuration: Standard Docker compose setup
• Isolation: Each framework variant tested separately
• Reproducibility: All tests can be replicated with docker-compose up
• Metrics: Operations/second, requests/hour, memory usage
• Variants Tested: Core v1.2.0, ORM v1.0.1, ReactPHP v0.1.0

Running Your Own Benchmarks

Test PivotPHP performance in your environment with Docker:

# Clone the benchmark suite (private repository)
git clone https://github.com/pivotphp/pivotphp-benchmarks.git
cd pivotphp-benchmarks

# Run Docker-based benchmarks
docker-compose up

# Run specific variant benchmarks
php benchmark-core.php
php benchmark-orm.php
php benchmark-reactphp.php

# Generate reports
php generate-reports.php

Honest Performance Assessment

Based on comprehensive cross-framework analysis (July 2025):

🏆 Where PivotPHP v1.2.0 Excels

• Developer Experience: Express.js-style syntax with competitive performance
• Memory Efficiency: Ultra-efficient 1.61MB memory footprint
• Latency: Excellent 0.32ms average response time in Docker
• JSON Optimization: Revolutionary internal pooling system (505K ops/sec small JSON)
• Architecture: Modern PSR compliance with intuitive API

🥉 Docker Validation Performance (Realistic)

• Real HTTP Performance: 6,227 req/sec in standardized Docker environment
• Competitive Positioning: 3rd place, only 9.5% behind leader (Slim 4)
• Consistent Results: Reproducible performance in controlled conditions
• Framework Comparison: 96% faster than Flight, competitive with Lumen
• Express.js Alternative: Strong positioning for Express.js-style PHP development

📊 Benchmark Transparency

• Methodology: Standardized Docker containers, 1K-5K iterations
• Docker Environment: v1.2.0 tested in isolated containers
• Test Date: July 11, 2025
• Environment: PHP 8.1+ with OPcache and JIT enabled

🎯 Strategic Positioning

PivotPHP v1.2.0 offers documented, Docker-validated performance:

1. Status Code Excellence: Industry-leading 692K ops/sec performance
2. HTTP Operations: Strong 2.15M combined ops/sec across all operations
3. JSON Optimization: Revolutionary pooling with 161K ops/sec for small datasets
4. Memory Efficiency: Only 14MB for HTTP operations, minimal for JSON
5. Developer Experience: Express.js patterns with excellent performance

Choose PivotPHP v1.2.0 when you need competitive performance with educational simplicity, Express.js-style development experience, and comprehensive OpenAPI documentation generation with excellent memory efficiency.