XenForo 2.3.13 — PHP 8.2 → 8.6 Web Stack Benchmark

rdn

Well-known member
Licensed customer

XenForo 2.3.13 — PHP 8.2 → 8.6 Web Stack Benchmark​


Part 1 of 2 — setup and per-host results

TL;DR​


QuestionAnswer
Biggest performance winAngie fastcgi_cache guest-page cache: 88×–180× more guest requests/s
Fastest stack overallStack 3 — Valkey + Angie page cache (guest-heavy forum)
Fastest stack for logged-in usersStack 1 — plain Angie + PHP + MariaDB (no Valkey, no page cache)
Does Valkey data caching help a single server?No. It costs 2–14 % versus plain; Credis and phpredis measured the same
Cost of Anubis−90…−94 % on cached guest pages, −17…−19 % on dynamic/member pages
PHP 8.6 vs 8.2+0…+3 % at low concurrency; ≤1.5 % at saturation — no meaningful gain
PHP version ranking8.6 RC5 > 8.5 > 8.4 ≈ 8.2 > 8.3 (differences are small)
PHP 8.6 without php-redisWorks with SV/RedisCache + bundled Credis; all add-ons active, all tiers HTTP 200

Test environment​


Hardware​


SpecHost A (remote)Host B (local)
CPUAMD EPYC 4245P, 6 cores / 12 threads, 5.49 GHz maxAMD Ryzen 7 8745HS, 8 cores / 16 threads, 4.97 GHz max
RAM30 GiB27 GiB
Disk2× 894 GB Samsung NVMe931 GB Crucial NVMe
Virtualisationnone detected (systemd-detect-virt)none detected
OSUbuntu 26.04.1 LTSUbuntu 26.04.1 LTS
Kernel7.0.0-43-generic7.0.0-43-generic

Software​


ComponentVersion
Angie1.12.4
PHP8.2.35, 8.3.36, 8.4.27, 8.5.12, 8.6.0RC5 (Sury packages, side by side)
MariaDB11.8.6
Valkey9.0.4
Anubis1.28.2 (opt-in, stack 4 only)
XenForo2.3.13
Add-onsSV/StandardLib 1.24.11, SV/RedisCache 2.18.12, SV/RedisFloodCheck 2.3.1, SV/RedisViewCounter 2.6.2, Hampel/Seeder 1.0.0b11
Load generatorwrk 4.1.0 (loopback, HTTPS)

Redis client: php-redis is not installed on any PHP version. SV/RedisCache uses its bundled pure-PHP Credis client on 8.2–8.6. A separate control showed phpredis and Credis within 1–2 % of each other on this workload, so the PHP-version comparison is like for like.

PHP profile: pm = static, 12 workers (Host A) / 16 workers (Host B), memory_limit=512M, OPcache 512 MB, interned strings 64 MB, JIT tracing, 64 MB, hot thresholds 64/127/16/64. JIT was confirmed active on every version.

Rate limiting: all Angie limit_req directives were disabled for the tests.

Dataset​


Seeded with the Hampel Seeder add-on:

ContentCount
Users20,001
Threads10,000
Posts100,400
Forum nodes47 (categories, forums, sub-forums)
Timespan2 years

Member account used for logged-in tests: meta.johns (valid, normal registered user).

Method​


  • Loopback HTTPS against xf.test.local, self-signed certificate.
  • wrk -t4 -c100 -d10s, 2 s warm-up, per tier.
  • Guest cached: GET / with no cookies.
  • Guest bypass: GET / with Cookie: xf_session=bench-bypass (bypasses the guest cache without logging in).
  • Member home: GET / with a valid XenForo session cookie.
  • Member thread: a seeded 100k-post thread with the same session cookie.
  • The FastCGI cache was cleared before each PHP version; Valkey DB 1 was flushed when the data cache was toggled.
  • The active PHP version was verified with a PHP_VERSION probe on every run (the first attempt exposed a stale Anubis connection pool serving the previous PHP version; the final runs force a restart on version changes).
  • Low-concurrency efficiency: wrk -t2 -c8 -d15s, 3 runs averaged, plain stack.

The four stack passes ran sequentially. Small differences between Stack 1 and Stack 2 (a few percent) are within run-order/thermal drift; the page-cache and Anubis effects are far larger than that drift.

Results​


Host A — AMD EPYC 4245P (6C/12T, 30 GiB)​


Stack 1 — Plain: Angie + PHP + MariaDB​


PHPGuest cachedGuest bypassMember homeMember thread
8.2789787691548
8.3775772686548
8.4787785692553
8.5791787695551
8.6788781698552

Stack 2 — Valkey data cache, no page cache​


PHPGuest cachedGuest bypassMember homeMember thread
8.2767765628500
8.3760758621494
8.4774779631496
8.5772774630498
8.6769767631496

Stack 3 — Valkey + Angie FastCGI page cache​


PHPGuest cachedGuest bypassMember homeMember thread
8.2138,697762624500
8.3138,034767629496
8.4138,598771633494
8.5137,999773636495
8.6136,483773630498

Stack 4 — Valkey + Angie page cache + Anubis​


PHPGuest cachedGuest bypassMember homeMember thread
8.27,903609523441
8.37,871614520439
8.47,890620526444
8.57,933627525443
8.67,892629529447

Host B — AMD Ryzen 7 8745HS (8C/16T, 27 GiB)​


Stack 1 — Plain: Angie + PHP + MariaDB​


PHPGuest cachedGuest bypassMember homeMember thread
8.2728723635506
8.3709699616495
8.4710700624499
8.5701696611489
8.6702695613490

Stack 2 — Valkey data cache, no page cache​


PHPGuest cachedGuest bypassMember homeMember thread
8.2685665538440
8.3657651530430
8.4658654534432
8.5663659537434
8.6650651536432

Stack 3 — Valkey + Angie FastCGI page cache​


PHPGuest cachedGuest bypassMember homeMember thread
8.258,896652528432
8.358,631650533434
8.459,549650538431
8.556,574656537432
8.657,760660536434

Stack 4 — Valkey + Angie page cache + Anubis​


PHPGuest cachedGuest bypassMember homeMember thread
8.26,194531442388
8.36,025532438384
8.45,996530444386
8.55,792519438383
8.65,831529444383

Continued in Part 2 — rankings, PHP comparison and conclusions.
 
Part 2 of 2 — rankings, PHP comparison and conclusions

Stack ranking​


Averages across PHP 8.2–8.6.

Rank (public/guest)StackGuest cached A / BGuest bypass A / BMember home A / B
1Stack 3 — Valkey + Angie page cache137,962 / 58,282769 / 654630 / 534
2Stack 4 — + Anubis7,898 / 5,968620 / 528525 / 441
3Stack 1 — Plain786 / 710782 / 703692 / 620
4Stack 2 — Valkey only768 / 663769 / 656628 / 535

By authenticated/member throughput the order is different:
Stack 1 (692/620) > Stack 3 (630/534) ≈ Stack 2 (628/535) > Stack 4 (525/441).


All 20 combinations, ranked by cached guest throughput (Host A)​


#StackPHPGuest cached A / BMember home A / B
138.2138,697 / 58,896624 / 528
238.4138,598 / 59,549633 / 538
338.3138,034 / 58,631629 / 533
438.5137,999 / 56,574636 / 537
538.6136,483 / 57,760630 / 536
648.57,933 / 5,792525 / 438
748.27,903 / 6,194523 / 442
848.67,892 / 5,831529 / 444
948.47,890 / 5,996526 / 444
1048.37,871 / 6,025520 / 438
1118.5791 / 701695 / 611
1218.2789 / 728691 / 635
1318.6788 / 702698 / 613
1418.4787 / 710692 / 624
1518.3775 / 709686 / 616
1628.4774 / 658631 / 534
1728.5772 / 663630 / 537
1828.6769 / 650631 / 536
1928.2767 / 685628 / 538
2028.3760 / 657621 / 530

The Stack 3 order is cache-hit bound and effectively noise; its member column is the PHP-sensitive number. The Stack 1/2 order changes slightly on Host B (8.2 leads there).

What the numbers mean​


  • Page cache is the whole game. Stack 3 serves guest pages 88× (Host B) to 180× (Host A) faster than Valkey-only. It is also 175× / 82× faster than the plain stack.
  • Valkey alone does not help XenForo on a single host. Removing the page cache and adding Valkey costs 2–7 % on guest requests and 9–14 % on member pages. On a separate host it may help; locally MariaDB is already fast and the cache adds serialization + network hops.
  • Anubis is a bot-filter tax, not a performance feature. It keeps 8–10× the plain stack's guest throughput because the page cache is still behind it, but it removes ~90–94 % of the cached-page ceiling and ~17–19 % of dynamic throughput.
  • Logged-in requests always bypass the FastCGI guest cache. XenForo's guest-cache map is cookie-gated, so the two member rows are the same with page cache on or off; they measure the cache-bypass path.
  • phpredis vs Credis made no material difference on PHP 8.5: 698/614 req/s with phpredis vs 697/616 with Credis.

PHP version ranking​


Low-concurrency (8 clients, 3 runs averaged) isolates PHP/application cost without worker queueing.

RankPHPGuest bypass A / BMember home A / Bc=100 dynamic A / B
18.6.0RC5589 / 418531 / 374619 / 534
28.5.12587 / 418530 / 373620 / 533
38.4.27576 / 416522 / 373619 / 535
48.2.35583 / 418523 / 370615 / 540
58.3.36574 / 410515 / 366612 / 533

Interpretation​


  • PHP 8.6 RC5 is fastest per request, but only by 1–3 %. Versus 8.3 it is +2.7 % guest / +3.1 % member on Host A and +1.9 % / +2.2 % on Host B.
  • PHP 8.3 is consistently the slowest in the low-concurrency test (~1.5–2.5 % behind).
  • At saturation (100 clients) all versions are within ~1.5 %, which is inside the run-to-run/thermal variance. Host A's c=100 average favours 8.5; Host B's favours 8.2.
  • XenForo 2.3.13 does not gain a major step from PHP 8.4/8.5/8.6. If you upgrade, do it for support/security, not for a large throughput jump.
  • PHP 8.6 works without php-redis with the SV add-ons and Credis; all guest/member/admin paths returned HTTP 200 on 8.6 RC5.

Final recommendation​


Use caseRecommended stack
Guest-heavy community (typical forum)Stack 3 — Angie page cache + Valkey + PHP 8.5 (8.6 when stable)
Mostly logged-in / low guest cacheabilityStack 1 — plain Angie + PHP 8.5/8.6 + MariaDB
Bot filtering requiredStack 4 — accept ~90 % cached-page cost and ~18 % dynamic cost
AvoidStack 2 (Valkey without page cache): more moving parts, lower throughput

Fastest and most performant overall: Stack 3 with PHP 8.6 RC5 / 8.5 for public forum traffic. Fastest for authenticated traffic: Stack 1 with PHP 8.5/8.6. The page cache is the only change that produces an order-of-magnitude improvement; PHP major versions are effectively flat for this application.

Caveats​


  • XenForo 2.3.13, single-server loopback tests, self-signed TLS, wrk synthetic load.
  • PHP 8.6.0RC5, not a final release.
  • All versions used the pure-PHP Credis client; phpredis is available for 8.2–8.5 and measured equal in the control, but a different Redis workload could differ.
  • Anubis requests used User-Agent: setup-bench/1.0 (allowed by policy). A browser first visit would solve one challenge before reaching the cached pages.
  • Stack passes were sequential; small Stack 1 vs Stack 2 deltas are within thermal/run-order drift. The page-cache and Anubis deltas are far outside that range.
 

AlmaLinux 10 + CentMinMod vs Ubuntu 26.04 + Angie — XenForo 2.3.13​


Same 12-thread EPYC host, same XenForo dataset, PHP 8.2–8.5. CentMinMod left completely default config.

TL;DR​


Metric (PHP 8.2–8.5 average)CentMinModUbuntu + AngieDelta
Guest cached page157,957138,332+14.2 %
Guest cache bypass596783−23.9 %
Member home530691−23.3 %
Member thread705550+28.2 %
Anubis cached page59,9587,899+659 %
Dynamic average605616−1.8 %

CentMinMod wins cached guest throughput and is dramatically leaner with Anubis. Ubuntu wins guest-bypass and member-home. Member-thread flips to CentMinMod. Overall, for a guest-heavy forum, CentMinMod Stack 3 is the fastest result in this comparison.

Environment​


SpecAlmaLinux 10.2 + CentMinModUbuntu 26.04 + Angie
CPU / RAMAMD EPYC 4245P, 6C/12T, 30 GiBSame host
Disk / OS2× 894 GB NVMe, AlmaLinux 10.2, kernel 6.12Ubuntu 26.04.1, kernel 7.0
Web serverNginx 1.31.8, 6 workers, 300k connectionsAngie 1.12.4, 12 workers, 32k connections
PHP8.2.35, 8.3.36, 8.4.27, 8.5.128.2.35–8.5.12 (plus 8.6 RC5)
PHP-FPMondemand, 30 children, TCP 127.0.0.1:9000static, 12 workers, Unix socket
OPcacheOn, JIT disabled512 MB, JIT tracing 64 MB
DatabaseMariaDB 10.11.19, 8 GB pool, 600 connsMariaDB 11.8.6, 1.7 GB pool, 200 conns
CacheRedis 8.6.8 + phpredisValkey 9.0.4 + Credis
XenForo2.3.13 + 5 add-ons2.3.13 + 5 add-ons

CentMinMod’s generated Nginx, PHP-FPM, MariaDB, and Redis configurations were default. Only the minimal fastcgi_cache layer and Anubis were added. PHP 8.6 is omitted because CentMinMod’s EL10 branch supports PHP 8.0–8.5 only.

Dataset and method​


  • 20,001 users, 10,000 threads, 101,134 posts (Ubuntu run: 100,400 posts), 51 forum nodes; Hampel Seeder.
  • wrk -t4 -c100 -d10s, 2 s warm-up, loopback HTTPS.
  • Guest cached: GET / no cookies. Guest bypass: xf_session=bench-bypass. Member home/thread: fresh login cookie per stack.
  • Page cache cleared per PHP version; Redis DB 1 flushed when toggled; Angie/Nginx rate limits disabled.
  • Stack 1 disables the three SV Redis add-ons; stacks 2–4 enable all five.

CentMinMod results​


Stack 1 — Plain: Nginx + PHP + MariaDB​


PHPGuest cachedGuest bypassMember homeMember thread
8.2598594532710
8.3604598532705
8.4597598530707
8.5598593526699

Stack 2 — Redis data cache, no page cache​


PHPGuest cachedGuest bypassMember homeMember thread
8.2598600544700
8.3604597538699
8.4602593545694
8.5595591540694

Stack 3 — Redis + Nginx FastCGI page cache​


PHPGuest cachedGuest bypassMember homeMember thread
8.2146,058602540698
8.3170,437595547696
8.4148,069592540691
8.5167,264589539691

Stack 4 — Redis + Nginx page cache + Anubis​


PHPGuest cachedGuest bypassMember homeMember thread
8.260,223582526668
8.360,416581528669
8.459,821571525664
8.559,371573521664

CentMinMod vs Ubuntu​


StackGuest cached CM / UbuntuMember home CM / UbuntuMember thread CM / Ubuntu
1 — Plain599 / 786530 / 691705 / 550
2 — Redis only600 / 768542 / 628697 / 497
3 — Redis + page cache157,957 / 138,332542 / 630694 / 496
4 — + Anubis59,958 / 7,899525 / 524666 / 442

Cached guest ranking​


RankPlatformStackGuest cached
1CentMinModStack 3157,957
2UbuntuStack 3138,332
3CentMinModStack 459,958
4UbuntuStack 47,899
5UbuntuStack 1786
6UbuntuStack 2768
7CentMinModStack 2600
8CentMinModStack 1599

Authenticated ranking (mean of member home + thread)​


RankPlatformStackMean
1UbuntuStack 1620.5
2CentMinModStack 2619.5
3CentMinModStack 3618.0
4CentMinModStack 1617.5
5CentMinModStack 4595.5
6UbuntuStack 3563.0
7UbuntuStack 2562.5
8UbuntuStack 4483.0

The top four are within 0.5 %; Ubuntu wins member-home, CentMinMod wins member-thread. There is no single authenticated winner.

PHP version comparison​


PHPCentMinMod dynamic avgUbuntu dynamic avgCM member home / thread
8.2608.0614.8530 / 705
8.3607.1612.0532 / 705
8.4604.2618.7530 / 707
8.5601.7619.5526 / 699

On CentMinMod, 8.2 is marginally fastest; on Ubuntu, 8.5. All four versions are within ~1 % on CentMinMod and ~1.2 % on Ubuntu. There is no meaningful PHP-version speed upgrade here; choose for support, not throughput.

Conclusion​


  • Fastest cached guest stack: CentMinMod Stack 3, 157,957 req/s, +14.2 % over Ubuntu Stack 3.
  • Best Anubis result: CentMinMod Stack 4, 59,958 req/s vs Ubuntu’s 7,899. The CentMinMod Anubis integration is a minimal Nginx terminator; the Ubuntu one used Angie with branding sub_filter and a static shadow, so this is not a like-for-like Anubis comparison.
  • Best plain dynamic/guest-bypass: Ubuntu Stack 1, 783/691 vs CentMinMod 596/530. Ubuntu’s tuned PHP-FPM/JIT/MariaDB profile is doing real work here.
  • Member thread: CentMinMod is ~28 % faster, likely because its stock ondemand pool allows 30 workers versus Ubuntu’s 12 static workers.
  • Valkey/Redis alone: no gain on either platform; page cache is the only order-of-magnitude win.

Overall: CentMinMod is the better cached guest and Anubis stack on this host. Ubuntu is better for guest-bypass and member-home. For a guest-heavy forum, CentMinMod Stack 3 wins; for logged-in home traffic, Ubuntu Stack 1 wins. CentMinMod’s stock configuration is not a drop-in performance upgrade over a tuned Ubuntu/Angie stack.

Caveats​


  • CentMinMod was deliberately untuned: ondemand/30 PHP-FPM, 6 Nginx workers, JIT off. Ubuntu was tuned by setup.sh: static workers, JIT on, larger MariaDB pool.
  • PHP 8.6 RC5 was not tested on CentMinMod; EL10 officially supports up to 8.5.
  • CentMinMod used Redis 8.6.8 + phpredis; Ubuntu used Valkey 9.0.4 + Credis. A PHP 8.5 phpredis-vs-Credis control on Ubuntu measured within 1–2 %.
  • Anubis implementations differ (minimal Nginx terminator vs Angie terminator with sub_filter/static shadow); the Anubis delta is indicative, not an apples-to-apples proxy benchmark.
  • Single 10 s run per cell; cache-hit variance on CentMinMod Stack 3 was 146k–170k across PHP versions.
 
Last edited:

Ubuntu 26.04 + Angie beats CentMinMod on the same EPYC host — XenForo 2.3.13, PHP 8.2–8.5​


Same AMD EPYC 4245P (6C/12T, 30 GiB, 2×894 GB NVMe), same XenForo dataset, same wrk 4.1.0 method as the AlmaLinux 10 + CentMinMod run.

TL;DR​


Stack (PHP 8.2–8.5 avg)MetricCentMinModUbuntu + AngieDelta
3 — Redis + page cacheGuest cached157,957390,232+147.1 %
4 — + AnubisGuest cached59,95868,725+14.6 %
1 — PlainGuest bypass596775+30.1 %
3 — Redis + page cacheMember home542747+37.9 %
3 — Redis + page cacheMember thread694838+20.7 %

Every comparable cell is above CentMinMod. The largest single difference is a TLS setting: ssl_buffer_size 1400 split each cached page into ~11 TLS records, 16k sends it as one. On the same page and TLS stack that alone moved the cached guest tier from 151,438 to 442,765 req/s.

Environment​


SpecAlmaLinux 10 + CentMinModUbuntu 26.04 + Angie
CPU / RAMAMD EPYC 4245P, 6C/12T, 30 GiBSame host (30,663 MiB)
Disk / OS2× 894 GB Samsung NVMe, AlmaLinux 10.2, kernel 6.122× 894 GB Samsung NVMe, Ubuntu 26.04.1, kernel 7.0.0-43
Web serverNginx 1.31.8, 6 workers, 300k connectionsAngie 1.12.4, 8 workers, 32k connections
PHP8.2.35, 8.3.36, 8.4.27, 8.5.12 (compiled, -O3 -march=native)8.2.35, 8.3.36, 8.4.27, 8.5.12 (Sury)
PHP-FPMondemand, 30 children, TCP 127.0.0.1:9000static, 12 children, Unix socket
OPcache384 MB, JIT disabled512 MB, JIT tracing 64 MB, huge pages
DatabaseMariaDB 10.11.19, 8 GB pool, 600 connsMariaDB 11.8.6, 1.9 GB pool, 200 conns
CacheRedis 8.6.8 + phpredisValkey 9.0.4 + phpredis
Anubis1.28.2 (minimal Nginx terminator)1.28.2 (Angie terminator, Unix sockets, static shadow)
XenForo2.3.13 + 5 add-ons2.3.13 + 5 add-ons

Dataset and method​


  • 20,001 users, 10,000 threads, 100,400 posts, 47 nodes (CentMinMod run: 101,134 posts, 51 nodes) — Hampel Seeder 1.0.0b11, 2-year span.
  • wrk -t4 -c100 -d10s, 2 s warm-up, loopback HTTPS against xf.test.local (self-signed).
  • Guest cached: GET / no cookies, Accept-Encoding: gzip (the gzip cache entry; the identity page is ~106 KB and is bandwidth-bound on both platforms).
  • Guest bypass: Cookie: xf_session=bench-bypass. Member: fresh XenForo session cookie, GET /.
  • Member thread: the median 9-post thread (129 KB); the first 18-post thread (191 KB) is listed separately in the caveats.
  • Page cache cleared per stack; Valkey DB 1 flushed when the Redis cache was toggled; rate limits disabled for the run.
  • Stack 4 cached is measured with ab -k -c100 because wrk 4.1.0 under-reads body bytes from the Go proxy on this host (it reported 4 KB per 15.6 KB response); ab and oha agree with curl. Stack 4 dynamic tiers use oha for the same reason.

Results — averages across PHP 8.2–8.5​


StackPlatformGuest cachedGuest bypassMember homeMember thread
1 — PlainCentMinMod599596530705
1 — PlainUbuntu688 (+14.7 %)775 (+30.1 %)663 (+25.1 %)767 (+8.7 %)
2 — RedisCentMinMod600595542697
2 — RedisUbuntu705 (+17.5 %)813 (+36.6 %)745 (+37.6 %)837 (+20.0 %)
3 — Redis + page cacheCentMinMod157,957595542694
3 — Redis + page cacheUbuntu390,232 (+147.1 %)819 (+37.8 %)747 (+37.9 %)838 (+20.7 %)
4 — + AnubisCentMinMod59,958577525666
4 — + AnubisUbuntu68,725 (+14.6 %)709 (+22.9 %)654 (+24.6 %)690 (+3.5 %)

Cached guest tier per PHP version​


PHPCentMinMod S3Ubuntu S3CentMinMod S4Ubuntu S4
8.2146,058389,51460,22370,946
8.3170,437392,05360,41669,209
8.4148,069390,67759,82166,145
8.5167,264388,68459,37168,600

Dynamic tiers at PHP 8.5​


StackBypassMember homeMember thread (9 posts)Member thread (18 posts)
CentMinMod 1593526699—
Ubuntu 1791667761613
CentMinMod 3589539691—
Ubuntu 3841770863678
CentMinMod 4573521664—
Ubuntu 4722668699566

What made the difference​


  • 16k TLS records. ssl_buffer_size 1400 fits one MTU but turns a 15.6 KB cached page into ~11 TLS records (and ~11 write syscalls). 16k sends it as one: 151,438 → 442,765 req/s on the same page and TLS stack. This is the whole Stack 3 gap and more.
  • 8 Angie workers on 12 CPUs. worker_processes auto (12) spent cores on TLS contention: 348–352k cached req/s. Two workers per three CPUs (8) gives 389–390k, with member/thread tiers unchanged (764–767 / 840–843 req/s).
  • Anubis with the Go collector out of the way. GOGC=off with GOMEMLIMIT=2GiB (the limit still bounds the heap; RSS < 2 GiB): 51,949 → 57,082 req/s through the filter. The static-asset shadow keeps CSS/JS/images off the proxy on top of that.
  • OPcache huge pages. vm.nr_hugepages sized from RAM plus opcache.huge_code_pages=1: +3.5 % on member/thread (808 → 835, 645 → 670 req/s).
  • The rest of the Ubuntu profile (already present): tracing JIT, pm=static one worker per CPU, gzip stored in the FastCGI cache, aio off + brotli off on cache hits, Unix sockets end to end, MariaDB pool-of-threads, XF data cache in Valkey.
  • Sweeps ruled out the usual suspects: 24/32 PHP workers were slower than 12 (536/534 vs 548 req/s), JIT 128 MB and altered hotness thresholds were noise, validate_timestamps=0 was noise, Anubis GOMAXPROCS 12/16 was within noise of 8.

Why CentMinMod was competitive​


  • PHP is compiled with -O3 -march=native (CentMinMod) vs generic Sury packages: roughly 5–10 % per-request advantage.
  • 30 ondemand PHP-FPM children over TCP hide database waits better than one static worker per CPU — that is why the 18-post thread page is still slightly behind, while member-home is 25–38 % ahead on Ubuntu.
  • Nginx 1.31.8 with newer OpenSSL and sendfile_max_chunk 2m, tcp_nodelay, open_file_cache.
  • Stock CentMinMod has no FastCGI page cache and no Anubis; those were added for the benchmark. Its 6 Nginx workers and JIT-disabled PHP leave performance unused.

Caveats​


  • CentMinMod’s page-cache config was a minimal addition, not its stock vhost; Ubuntu was tuned end to end. This measures the platforms, not identical configs.
  • Thread-page throughput is page-size sensitive. The CentMinMod dataset averages 10.1 posts/thread, so the 9-post page is the fair comparison; the 18-post page (191 KB) measures 613–678 req/s on Ubuntu Stacks 1–3 and 566 on Stack 4.
  • Single 10 s run per cell, except Stack 4 cached (2–4 runs, 66–74k, median reported). Cache-hit variance on this host is ±5 %.
  • Stack 4 cached uses ab and dynamic tiers use oha because wrk 4.1.0 misreads Go-proxy body lengths on this host; CentMinMod numbers are wrk. Cached tiers are server-bound and the tools agree within 1–2 % on Stacks 1–3.
  • PHP 8.6 RC5 is not in the matrix (CentMinMod EL10 supports up to 8.5); an earlier audit measured ~+6 % thread throughput on 8.6 RC5, offset by missing redis/imagick packages.

Configuration highlights​


Code:
# /tls/ssl_engine.conf  (the 3x cached-tier change)
ssl_buffer_size 16k;

# angie.conf  (2/3 of CPUs; 8 on a 12-thread host)
worker_processes 8;
worker_cpu_affinity auto;
worker_rlimit_nofile 131072;
worker_connections 32768;

# Anubis unit (>=16 GB hosts; GOMEMLIMIT still bounds the heap)
Environment=GOGC=off
Environment=GOMEMLIMIT=2048MiB
Environment=GOMAXPROCS=8

# kernel + OPcache
vm.nr_hugepages = 479
opcache.huge_code_pages = 1
opcache.jit = tracing
opcache.jit_buffer_size = 64M

# PHP-FPM (12 threads)
pm = static
pm.max_children = 12
listen = /run/php/php-fpm.sock

Conclusion​


On the same EPYC 4245P the Ubuntu 26.04 + Angie stack is now ahead on every measured tier: +147 % cached guest throughput (390,232 vs 157,957 req/s), +14.6 % with Anubis (68,725 vs 59,958), +38 % member home (747 vs 542) and +21 % member thread (838 vs 694). The decisive change was not a new service — it was one TLS directive, one worker-count rule, a Go runtime profile and PHP huge pages, all config-only.

Ubuntu 26.04.1 · Angie 1.12.4 · PHP 8.2–8.5 · MariaDB 11.8.6 · Valkey 9.0.4 · Anubis 1.28.2 · XenForo 2.3.13​
 
Last edited:
Back
Top Bottom