Symfony 8 sa PHP 8.4: FrankenPHP vs RoadRunner Benchmarked

Ang pag-release ng Symfony 7.4 LTS ay nagpapakita ng isang pivotal moment sa ecosystem ng PHP. Habang ang framework mismo ay nag-introduce robust na mga tampok tulad ng mas karaniwang uri ng seguridad at native PHP serialization para sa mga container, ang tunay na pag-revolusyon ay dumating sa kung paano gumagamit namin ang mga application na ito. Ang mga server ng application na napili sa Go ay matatagpuan, na nag-aalok ng mga kakayahan ng "Worker Mode" na mag-boot ang iyong kernel isang beses at mangyaring ito sa memorya, pag-cutting latency at skyrocketing throughput. NGINX + PHP-FPM Sa artikulong ito, nagtatampok kami ng dalawang heavyweights laban sa ibang tao: (Ang modernong challenger na binuo sa Caddy) at (ang battle-tested veteran mula sa Spiral Scout). Kami ay i-implementate ang parehong sa isang application ng Symfony 8 na gumagana sa PHP 8.4, i-compare ang kanilang mga architectures at i-analysate ang kanilang pagganap. FrankenPHP RoadRunner ang mga contesters ang napili ng Ipinanganak sa itaas ng Caddy web server, ito ay isang modernong application server na simulan ang stack. It compiles PHP direkta sa binary (o gumagamit ng isang espesyal na build) at gumagamit ng Caddy's automatic at ang ang support. FrankenPHP HTTPS HTTP/3 Ang NGINX, PHP-FPM at ang terminator ng SSL ay umabot sa isang binary. Key Advantage: Native suporta sa pamamagitan ng Runtime component na may Symfony 7.4+. Mga RoadRunner Na-develop ng Spiral Scout, RoadRunner ay isang high-performance PHP application server, load balancer at process manager. Ito ay gumagamit ng isang pool ng mga trabahador upang i-manage mga request. Pumili ng kategorya, gaya ng mga gasolinahan o grocery store, o maghanap ng partikular na uri ng lugar ( na ang na ang ) na nagtatrabaho sa simfoniya. Key Advantage: gRPC Queues KV storage Magandang integrasyon sa pamamagitan ng runtime/roadrunner-symfony-nyholm. Ang Benchmark Code (Symfony 8 at PHP 8.4) Upang gawin ang paghahatid ay totoo, i-create ang isang lightweight API endpoints na nag-interact sa isang database. Ito ay test na hindi lamang ang raw "Hello World" speed, ngunit ang overhead ng database connections at serialization sa isang persistent worker environment. Kami ay gumagamit ng PHP 8.4 Property Hooks (hindi magagamit sa iyong build) o standard tiped properties. Para sa karagdagang compatibility sa tutorial na ito, ginagamit namin ang standard 8.3+ promoted properties na may Attributes. The Entity: namespace App\Entity; use Doctrine\ORM\Mapping as ORM; use Symfony\Component\Serializer\Attribute\Groups; #[ORM\Entity] #[ORM\Table(name: 'products')] class Product { #[ORM\Id] #[ORM\GeneratedValue] #[ORM\Column] #[Groups(['product:read'])] private ?int $id = null; public function __construct( #[ORM\Column(length: 255)] #[Groups(['product:read'])] public string $name, #[ORM\Column] #[Groups(['product:read'])] public int $price, ) {} public function getId(): ?int { return $this->id; } } Kami ay gumagamit ng ang atributo na inilunsad sa mga nakaraang bersyon ng Symfony upang mapapunta ang input ng JSON automatically. The Controller: #[MapRequestPayload] namespace App\Controller; use App\DTO\ProductDto; use App\Entity\Product; use Doctrine\ORM\EntityManagerInterface; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\HttpKernel\Attribute\MapRequestPayload; use Symfony\Component\Routing\Attribute\Route; #[Route('/api/v1')] class BenchmarkController extends AbstractController { #[Route('/products', methods: ['POST'])] public function create( #[MapRequestPayload] ProductDto $dto, EntityManagerInterface $em ): JsonResponse { // Simple logic to test throughput $product = new Product($dto->name, $dto->price); $em->persist($product); $em->flush(); return $this->json($product, 201, [], ['groups' => 'product:read']); } #[Route('/ping', methods: ['GET'])] public function ping(): JsonResponse { $this->counter->increment(); // Increment on each call return new JsonResponse([ 'status' => 'pong', 'timestamp' => time() ]); } } The DTO: namespace App\DTO; use Symfony\Component\Validator\Constraints as Assert; class ProductDto { public function __construct( #[Assert\NotBlank] #[Assert\Length(min: 3)] public string $name, #[Assert\Positive] public int $price, ) {} } Mga Benchmark Ginagamit namin ang wrk (ang isang modernong HTTP benchmarking tool) na gumagana sa isang partikular na machine sa parehong lokal na network upang maiwasan ang CPU contention. Methodology: 8 Core CPU, 16GB ng RAM Machine: 30 segundo, 100 competing connections. Test: /api/v1/ping (Raw throughput) at /api/v1/products (database interaction) sa pamamagitan ng pag-aaral ng mga produkto. Target: Ang NGINX + PHP-FPM ay 8.4. Baseline: Scenario A: ang “Ping” (Raw Overhead) +---------------------+----------------+---------------+---------------------+ | Server | Req/Sec | Latency (Avg) | Memory Usage | +---------------------+----------------+---------------+---------------------+ | PHP-FPM | ~2,100 | 45ms | Low (per process) | | FrankenPHP (Worker) | ~8,500 | 4ms | Moderate | | RoadRunner | ~9,200 | 3ms | Low | +---------------------+----------------+---------------+---------------------+ Ang parehong application servers decimate PHP-FPM. RoadRunner ay may isang maliit na pandaigdig sa raw throughput para sa simple JSON responses dahil sa kanyang mataas na optimized Go-based RPC komunikasyon. Scenario B: Database Write (Real World) +-------------+---------------+----------------+------------+ | Server | Req/Sec | Latency (Avg) | Stability | +-------------+---------------+----------------+------------+ | PHP-FPM | ~850 | 110ms | Stable | | FrankenPHP | ~3,200 | 25ms | Excellent | | RoadRunner | ~3,400 | 22ms | Excellent | +-------------+---------------+----------------+------------+ Ngunit ang persistent application boot (Worker Mode) ay nangangahulugan na ang Symfony ay hindi re-initialize ang container, Doctrine metadata, o event listeners para sa bawat request. at ang Nag-aalok ng isang 3x-4x performance boost kaysa sa standard FPM. FrankenPHP RoadRunner Scenario C: ang “Number Cruncher” (CPU Bound) Ang pagsubok na ito ay nagtatampok ng mabilis na pag-execute at ang stability ng proseso ng worker kapag ang CPU ay pinupunta sa 100%. Kami ay magpatakbo ng isang matrix multiplication (N x N), isang klasikong O(n3) algorithm na nag-iisip na ang PHP engine upang magtrabaho nangangahulugan nang hindi gumagamit ng I/O wait times. The Code (Matrix Service): namespace App\Service; class MathService { public function multiplyMatrix(int $size): array { $matrixA = $this->generateMatrix($size); $matrixB = $this->generateMatrix($size); $result = array_fill(0, $size, array_fill(0, $size, 0)); for ($i = 0; $i < $size; $i++) { for ($j = 0; $j < $size; $j++) { for ($k = 0; $k < $size; $k++) { $result[$i][$j] += $matrixA[$i][$k] * $matrixB[$k][$j]; } } } return $result; } private function generateMatrix(int $size): array { $matrix = []; for ($i = 0; $i < $size; $i++) { for ($j = 0; $j < $size; $j++) { $matrix[$i][$j] = rand(1, 100); } } return $matrix; } } The Controller: namespace App\Controller; use App\Service\MathService; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\Routing\Attribute\Route; #[Route('/api/v1')] class MathController extends AbstractController { #[Route('/math/matrix/{size}', requirements: ['size' => '\d+'], methods: ['GET'])] public function matrix(int $size, MathService $service): JsonResponse { // $size = 100 creates 1,000,000 iterations. $start = microtime(true); $service->multiplyMatrix($size); $duration = microtime(true) - $start; return $this->json([ 'size' => $size, 'duration_ms' => $duration * 1000, 'memory_peak' => memory_get_peak_usage(true) ]); } } Results (Matrix Size: 150x150, 50 Concurrent Users): +--------------+---------------------+----------------+----------------------+ | Server | Avg Response Time | Std. Deviation | Throughput (Req/Sec) | +--------------+---------------------+----------------+----------------------+ | PHP-FPM | 210ms | 15ms | ~450 | +--------------+---------------------+----------------+----------------------+ | FrankenPHP | 205ms | 45ms | ~465 | +--------------+---------------------+----------------+----------------------+ | RoadRunner | 208ms | 8ms | ~460 | +--------------+---------------------+----------------+----------------------+ Lahat ng tatlong gumagana halos sama. Ito ay inaasahan dahil ang bottleneck dito ay ang Zend Engine (PHP mismo), hindi ang web server. Walang halaga ng Go wrapping ay maaaring gumawa ng PHP para sa loops mas mabilis. Ang RoadRunner ay nagpapakita ng mas mababang standard deviation (jitter). Ang kanyang proseso isolation (via separated worker binaries na naka-connected sa pamamagitan ng pipes) ay nagpapakita na magtatrabaho ng CPU contention isang maliit na mas predictably kaysa sa FrankenPHP's threaded model sa mababang load, kung saan Go routines at C threads ay nag-competite para sa parehong CPU time slices. Scenario D: Ang “Big Data Stream” (I/O at Memory Bound) Ito ay ang "Worker Killer." Sa isang long-running worker environment, pag-buffer ng isang malaking file sa memory ay katapusan. Kailangan naming i-test ang mga kakayahan ng streaming. Kami ay lumikha ng isang 100,000-row CSV report sa fly at i-streaming ito sa client. The Code (Streaming Response): namespace App\Controller; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\StreamedResponse; use Symfony\Component\Routing\Attribute\Route; #[Route('/api/v1')] class ReportController extends AbstractController { #[Route('/report/stream', methods: ['GET'])] public function streamBigReport(): StreamedResponse { $response = new StreamedResponse(function () { $handle = fopen('php://output', 'w+'); fputcsv($handle, ['ID', 'Name', 'Email', 'Status', 'Created_At']); // Simulate 100k rows for ($i = 0; $i < 100_000; $i++) { fputcsv($handle, [ $i, "User $i", "user$i@example.com", $i % 2 === 0 ? 'Active' : 'Inactive', date('Y-m-d H:i:s') ]); // Crucial: Flush buffer to prevent memory explosion if ($i % 1000 === 0) { flush(); } } fclose($handle); }); $response->headers->set('Content-Type', 'text/csv'); $response->headers->set('Content-Disposition', 'attachment; filename="big_report.csv"_report.csv"'); // RoadRunner/FrankenPHP specific header to disable internal buffering if needed $response->headers->set('X-Accel-Buffering', 'no'); return $response; } } Results (Downloading 50MB CSVs): +------------+---------------------------+---------------------------+--------------+ | Server | Time to First Byte (TTFB) | Max Memory Usage (Worker) | Success Rate | +------------+---------------------------+---------------------------+--------------+ | PHP-FPM | 30ms | 4MB | 100% | | FrankenPHP | 5ms | 6MB | 100% | | RoadRunner | 12ms | 4MB | 100% | +------------+---------------------------+---------------------------+--------------+ FrankenPHP: Pumunta sa TTFB (Time To First Byte). Dahil ang FrankenPHP ay bumubuo ng PHP direkta, ang output ng echo / fwrite ay halos instantaneously pumunta sa network socket na ginagamit ng Caddy. It's feel remarkably snappy. RoadRunner: Ang data ay naglalakbay mula sa PHP Worker -> Relay (Pipes/Socket) -> RoadRunner (Go) -> Client. Habang napaka-rapid, mayroong isang maliit na teorikal na overhead compared sa FrankenPHP's shared-memory approach. Memory: Ang parehong mga server ay may kamangha-kumpleto na natagpuan ang memory (~4–6MB) dahil ginagamit namin ang StreamedResponse. Kung kami ay buffered ang string na ito sa isang variable, ang parehong mga nagtrabaho ay nag-crash o paused para sa Garbage Collection, na hinihintay ng pag-aari. Scenario E: ang “Pixel Cruncher” (imaging processing) I-upload ang isang 4K na imahe (3840x2160), i-re-size ito sa 800x600, i-apply ang isang filter ng grayscale at i-return ang binary na data. Ito ay nangangailangan ng CPU upang magtrabaho nangangahulugan at ang memory upang i-spike kapag ang uncompressed bitmap ay i-load. Kailangan natin ang ang library, isang standard abstraction para sa sa PHP. imagine/imagine GD/Imagick The Code (Image Service): namespace App\Service; use Imagine\Gd\Imagine; use Imagine\Image\Box; class ImageProcessor { private Imagine $imagine; public function __construct() { // We use the GD driver as it is strictly CPU-bound and blocking $this->imagine = new Imagine(); } public function process(string $imagePath): string { $image = $this->imagine->open($imagePath); // Resize and apply effects (CPU Intensive) $image->resize(new Box(800, 600)); $image->effects()->grayscale(); // Return binary string (Memory Intensive) return $image->get('jpeg', ['quality' => 80]); } } The Controller: namespace App\Controller; use App\Service\ImageProcessor; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\File\UploadedFile; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpFoundation\Response; use Symfony\Component\Routing\Attribute\Route; #[Route('/api/v1')] class MediaController extends AbstractController { #[Route('/media/process', methods: ['POST'])] public function process(Request $request, ImageProcessor $processor): Response { /** @var UploadedFile $file */ $file = $request->files->get('image'); if (!$file) { return new Response('No image provided', 400); } $processedImage = $processor->process($file->getPathname()); return new Response($processedImage, 200, [ 'Content-Type' => 'image/jpeg', // Prevent caching for benchmark accuracy 'Cache-Control' => 'no-cache, no-store, must-revalidate', ]); } } Benchmark Configuration: Ang input: 5MB JPEG (High-Res 4K) Competition: 20 simultaneous users (simulating isang bump ng mga upload). Araw ng Kalayaan - 60 Ago Worker Pool Limit: Ang parehong mga server ay limitado sa 8 worker upang simulate resource constraint. +-------------+-------------------+-------------------------+----------------------+----------+ | Server | Avg Response Time | 99th Percentile Latency | Throughput (Req/Sec) | Failures | +-------------+-------------------+-------------------------+----------------------+----------+ | PHP-FPM | 450ms | 1.2s | ~42 | 0 | | FrankenPHP | 430ms | 950ms | ~48 | 0 | | RoadRunner | 435ms | 880ms | ~47 | 0 | +-------------+-------------------+-------------------------+----------------------+----------+ Kung ginagamit mo ang FPM, RoadRunner, o FrankenPHP, isang core ng CPU ay 100% na nakaupo para sa ~400ms per request. Ang "Magic" ng Go ay hindi maaaring i-fix ang single-threaded nature ng PHP dito. Concurrency Management (The Real Difference): PHP-FPM: Ang mga proseso ay bumaba hanggang sa nakalipas ng pm.max_children. Kung ang limitasyon ay nakalipas, ang NGINX buffer ay bumubuo, nangangahulugang humantong sa 502 mga error kung ang timeout ay nakalipas. RoadRunner: May isang fixed pool ng mga trabaho. Kung 8 requests ay pagproseso, ang 9th request ay naghintay sa RoadRunner's internal priority queue (written sa Go). Ang queue na ito ay napaka-efficient. Ito ay inihanda ng server mula sa crashing OOM (Out Of Memory) ngunit inilunsad ang "Wait Time" para sa user. FrankenPHP: Similar sa RoadRunner, ngunit gumagamit ang paghahatid ng koneksyon ng Caddy. Nagtatrabaho ito ng isang maliit na mas mabilis sa crude throughput, posibleng dahil sa mas mababang overhead sa paglipat ng file descriptor sa pagitan ng RoadRunner's RPC pipes. Scenario F: Ang "Heavy Framework" Boot Test (Serialization) Sa "Worker Mode" ang kernel boots isang beses. Gayunpaman, ang runtime ay nangangailangan upang i-manage demand-specific cleansings at heavy object serialization. Ang test na ito ay tinatanggap ng overhead ng serializing complex object graphs - isang karaniwang bottleneck sa Symfony apps na gumagamit ng API Platform o extensive Doctrine collections. Kami ay mag-serialize ng isang koleksyon ng 50 Order entities, ang bawat isa ay naglalaman ng at ang Ito ay nagkakahalaga sa serializer at ang memory manager. OrderItems Product The Code: namespace App\Entity; use App\Repository\OrderRepository; use Doctrine\Common\Collections\ArrayCollection; use Doctrine\Common\Collections\Collection; use Doctrine\ORM\Mapping as ORM; use Symfony\Component\Serializer\Attribute\Groups; #[ORM\Entity(repositoryClass: OrderRepository::class)] #[ORM\Table(name: 'orders')] class Order { #[ORM\Id, ORM\GeneratedValue, ORM\Column] #[Groups(['order:read'])] private ?int $id = null; #[ORM\OneToMany(targetEntity: OrderItem::class, mappedBy: 'orderRef', cascade: ['persist', 'remove'])] #[Groups(['order:read'])] public Collection $items; public function __construct() { $this->items = new ArrayCollection(); } public function getId(): ?int { return $this->id; } public function getItems(): Collection { return $this->items; } public function addItem(OrderItem $item): self { if (!$this->items->contains($item)) { $this->items[] = $item; $item->orderRef = $this; } return $this; } } The Controller: namespace App\Controller; use App\Repository\OrderRepository; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\Routing\Attribute\Route; #[Route('/api/v1')] class HeavyController extends AbstractController { #[Route('/heavy/orders', methods: ['GET'])] public function list(OrderRepository $repo): JsonResponse { // Assume database is seeded with 50 complex orders $orders = $repo->findAll(); return $this->json($orders, 200, [], ['groups' => 'order:read']); } } Results (100 Concurrent Users): +----------------------+--------------------+----------------------+----------------+ | Metric | NGINX + FPM | FrankenPHP (Worker) | RoadRunner | +----------------------+--------------------+----------------------+----------------+ | Throughput (req/sec) | ~180 | ~420 | ~405 | | Memory per Worker | Low (Reset/req) | High (Accumulates) | Stable | | GC Overhead | Negligible | Moderate | Low | +----------------------+--------------------+----------------------+----------------+ Nagpakita ng isang malakas na jump sa FPM (2.3x) dahil ang Doctrine Metadata at Serializer ClassMetadata ay na-memory. Ito na-edge RoadRunner isang maliit na dahil ang "CGO" (C-Go) overhead ay hindi pa rin; FrankenPHP pumapasok ang pointer direkta sa embedded PHP engine. FrankenPHP: : Extremely stable. Habang isang maliit na mas mababa kaysa sa FrankenPHP dito, ang kanyang memory footprint ay mas mababa. Ang breakdown ay nagpapakita na ang paglipat ng malaking JSON payloads sa pamamagitan ng mga pipes ng RPC (Standard Streams/TCP) ay may isang maliit na serialization penalty na FrankenPHP ay humihingi. RoadRunner Scenario G: Ang "Keep-Alive" at Memory Leak Stress Test Ang lang-running PHP scripts leak memory. Ito ay isang katotohanan ng buhay. Ang parehong mga server ay may mga mekanismo upang mawas at i-substitute ang mga trabaho (TTL / Max Requests). Kami ay test kung paano "graceful" ito recycling ay. The “Leaky” Code: namespace App\Controller; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\Routing\Attribute\Route; class LeakController { // Intentional static leak private static array $buffer = []; #[Route('/api/v1/leak', methods: ['GET'])] public function leak(): JsonResponse { // Leak 1MB per request self::$buffer[] = str_repeat('A', 1024 * 1024); return new JsonResponse(['memory' => memory_get_usage(true)]); } } Configuration (Restart every 50 requests): Pumili ng kategorya, gaya ng mga gasolinahan o grocery store, o maghanap ng partikular na uri ng lugar. FrankenPHP: FRANKENPHP_CONFIG=”worker ./public/index.php 16 50" Results (Sustained Load): +------------------------+-------------+--------------+ | Metric | RoadRunner | FrankenPHP | +------------------------+-------------+--------------+ | Restart Latency Spike | ~15ms | ~40ms | | Memory Reclamation | Instant | Instant | | Consistency | Smooth | Slight Jitter| +------------------------+-------------+--------------+ RoadRunner: Ang spiral/roadrunner process manager ay napaka-mature. Ito ay gumagawa ng “soft resets” — ito ay nag-spin up ng isang bagong worker bago sa pag-atake ng mga nakaraang (upload). Ito ay nagpapakita ng halos unnoticable latency spikes para sa user. FrankenPHP: Nagtatrabaho rin ang mga reboot na mahusay, ngunit natagpuan namin ang isang mas mataas na "jitter" (variance) kapag ang ilang mga thread ay nagsisimula upang reboot simultaneously. Konklusyon Ang battle sa pagitan ng FrankenPHP at RoadRunner sa ecosystem ng Symfony 8 ay hindi tungkol sa "fast vs. slow" - ang parehong ay ganap na mabilis. Mga pahinang tumuturo sa FrankenPHP Best Para sa: Modern na "Cloud-Native" apps, mga developer na gusto Simplicity at mga proyekto na kailangan HTTP/3 / Early Hints. Killer Feature: Ang Single Binary. Kung maaari mong magpadala ng isang Docker imahe na naglalaman ng Web Server (Caddy) at App Server (PHP) ay isang pag-implementasyon dream. Performance: Maging mas mataas na raw output sa maliit na payloads dahil sa embedded architecture. Ang "Modern Standard." Mahirap na maging ang default para sa Symfony Docker setup. Mga pahinang tumuturo sa RoadRunner Best Para sa: Enterprise Microservices, High-Traffic Systems na nangangailangan ng mga karaniwang SLA at malaki na pagproseso ng background. Killer Feature: The Ecosystem. Kung kailangan mo ng isang gRPC server, isang Kafka consumer, isang distributed Key-Value store at isang Metrics exporter ang lahat sa isang binary, RoadRunner ay walang katangian. Stability: Ang kanyang proseso manager ay battle-hardened. Ang "Industrial Grade" Piliin. Kung ikaw ay bumuo ng isang banking API o isang high-throughput na sistema, piliin ang RoadRunner. nagsisimula sa Ito ay humaba ang barya sa entry para sa high-performance PHP. Switch sa kung kailangan mo ng mga espesyal na mga advanced na mga tampok (RPC/Queues) o kung nakikita mo ang edge cases sa configuration ng Caddy. FrankenPHP RoadRunner Maaari mong makita ang buong implementation at patuloy ang proyekto sa GitHub: [ ] Source Code: https://github.com/mattleads/FrankenVSRoadRunner https://github.com/mattleads/FrankenVSRoadRunner Let’s Connect! Kung nakita mo ito na kasiyahan o may mga tanong tungkol sa pag-implementasyon, gusto kong malaman mula sa iyo. Magkakaroon ka ng kontak at patuloy ang pag-conversation sa pagitan ng mga platform na ito: Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Mga pahinang tumuturo: [https://x.com/MattLeads] Mga pahinang tumuturo sa [https://t.me/MattLeads] GitHub: [https://github.com/mattleads] https://www.linkedin.com/in/matthew-mochalkin/ https://x.com/MattLeads https://t.me/MattLeads https://github.com/mattleads