ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕਸ: ਸਹੀ ਨੌਕਰੀ ਲਈ ਸਹੀ ਟੂਲ ਦੀ ਚੋਣ ਕਰਨਾ

ਇਹ ਲੰਬੀ-ਰੂਪ ਡੂੰਘੀ-ਡੁਬਕੀ ਹੈ. ਇੱਕ ਤੇਜ਼, ਸਕੀਮ-ਪੜ੍ਹਨ ਯੋਗ ਸੰਸਕਰਣ ਲਈ, ਵੇਖੋ ਸਾਥੀ ਬਲੌਗ ਪੋਸਟ.

1. ਜਾਣ-ਪਛਾਣ: ਆਦਤ ਸਟੈਕ ਬਨਾਮ ਅਸਲ ਵਰਕਲੋਡ

ਪਰਿਪੱਕ ਸੰਸਥਾਵਾਂ ਵਿੱਚ ਟੈਕਨਾਲੋਜੀ ਵਿਕਲਪ ਘੱਟ ਹੀ ਅਸਫਲ ਹੁੰਦੇ ਹਨ ਕਿਉਂਕਿ ਕੋਈ ਵੀ ਬੈਂਚਮਾਰਕ ਬਲੌਗ ਪੋਸਟ ਨਹੀਂ ਪੜ੍ਹਦਾ। ਉਹ ਅਸਫਲ ਹੋ ਜਾਂਦੇ ਹਨ ਕਿਉਂਕਿ ਪ੍ਰਕਿਰਿਆ ਚੁਣਨ ਲਈ ਕਮਜ਼ੋਰ ਹੈ: ਇੱਕ ਉੱਚੀ ਸੀਨੀਅਰ ਇੰਜੀਨੀਅਰ ਦੀ ਤਰਜੀਹ, ਇੱਕ ਭਾਸ਼ਾ ਨਾਲ ਭਰੀ ਇੱਕ ਹਾਇਰਿੰਗ ਪਾਈਪਲਾਈਨ, ਜਾਂ ਇੱਕ ਕਾਨਫਰੰਸ ਵਿੱਚ ਇੱਕ ਸਿੰਗਲ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਡੈਮੋ। ਇਸ ਦੌਰਾਨ ਉਤਪਾਦ ਲੇਟੈਂਸੀ-ਸੰਵੇਦਨਸ਼ੀਲ APIs, ਬੈਚ ਮੇਲ-ਮਿਲਾਪ, NGINX ਵਿੱਚ ਕਿਨਾਰੇ ਪ੍ਰਮਾਣਿਕਤਾ, ਅੰਦਰੂਨੀ CLIs, ਅਤੇ ਕਦੇ-ਕਦਾਈਂ ਸਰਵਰ ਰਹਿਤ ਸਪਾਈਕ ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ। ਇੱਕ ਰਨਟਾਈਮ ਇਹਨਾਂ ਸਾਰੀਆਂ ਆਕਾਰਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ।

ਇਹ ਲੇਖ ਦੱਸਦਾ ਹੈ ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕਸ - ਇੱਕ ਲਾਈਵ ਤੁਲਨਾ ਡੈਸ਼ਬੋਰਡ ਅਤੇ ਓਪਨ ਵਰਕਫਲੋ-ਉਦਾਹਰਨਾਂ/ਬੈਂਚਮਾਰਕ ਇਸ ਦੇ ਪਿੱਛੇ ਹਾਰਨੇਸ — ਜਿਵੇਂ ਕਿ ਏ ਫੈਸਲੇ ਦਾ ਫਰੇਮਵਰਕ, ਇੱਕ ਪ੍ਰਸ਼ੰਸਕ ਲੀਡਰਬੋਰਡ ਨਹੀਂ। ਟੀਚਾ ਸਬੂਤ ਹੈ ਕਿ ਤੁਸੀਂ ਇੱਕ ਆਰਕੀਟੈਕਚਰ ਫੈਸਲੇ ਦੇ ਰਿਕਾਰਡ (ADR) ਨਾਲ ਨੱਥੀ ਕਰ ਸਕਦੇ ਹੋ: ਉਹੀ ਅੰਤ ਬਿੰਦੂ, ਉਹੀ ਲੋਡ ਜਨਰੇਟਰ, ਉਹੀ ਕੰਟੇਨਰ ਲੇਆਉਟ, ਕਈ ਭਾਸ਼ਾਵਾਂ।

ਮੈਂ ਵਾਰਤਕ ਵਿੱਚ ਥ੍ਰੋਪੁੱਟ ਨੰਬਰਾਂ ਦੀ ਖੋਜ ਨਹੀਂ ਕਰਾਂਗਾ। ਜਦੋਂ ਤੁਸੀਂ ਹਾਰਨੈੱਸ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਡੈਸ਼ਬੋਰਡ ਉਸ ਹਾਰਡਵੇਅਰ ਅਤੇ ਡੌਕਰ ਸੈੱਟਅੱਪ ਲਈ ਮਾਪੀਆਂ ਗਈਆਂ ਬੇਨਤੀਆਂ ਅਤੇ ਲੇਟੈਂਸੀ ਪ੍ਰਤੀਸ਼ਤ ਦਰਸਾਉਂਦਾ ਹੈ। ਇੱਥੇ ਕਿਸੇ ਵੀ ਸਥਿਰ ਦਰਜਾਬੰਦੀ ਨੂੰ ਹਾਰਨੇਸ ਦੇ ਟੈਸਟ ਪਰਿਵਾਰਾਂ ਅਤੇ ਡੈਸ਼ਬੋਰਡ ਦੀ ਬਿਲਟ-ਇਨ ਫੈਸਲੇ ਦੀ ਕਾਪੀ ਨਾਲ ਇਕਸਾਰ ਗੁਣਾਤਮਕ ਪੈਟਰਨਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਸਮਝੋ।

2. ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕਸ ਕੀ ਹੈ?

ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕਸ 'ਤੇ ਮੇਜ਼ਬਾਨੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ polyglot-benchmarks.fictionally.org (ਵਰਕਫਲੋ-ਉਦਾਹਰਨਾਂ ਈਕੋਸਿਸਟਮ ਵਿੱਚ ਕਾਲਪਨਿਕ-ਬ੍ਰਾਂਡਡ ਬੁਨਿਆਦੀ ਢਾਂਚਾ)। ਲੈਂਡਿੰਗ ਸਿਰਲੇਖ ਦੀ ਤੁਲਨਾ:

• NGINX njs — ਸਟਾਕ NGINX ਦੇ ਅੰਦਰ JavaScript ਮੋਡੀਊਲ
• OpenResty Lua — OpenResty 'ਤੇ ਕਿਨਾਰੇ 'ਤੇ Lua
• Python FastAPI - Uvicorn ASGI ਐਪ
• ਜਾਓ ਨੈੱਟ/http - ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਸਰਵਰ
• ਜੰਗਾਲ ਐਕਟਿਕਸ-ਵੈੱਬ - ਐਕਟਿਕਸ 'ਤੇ HTTP ਅਸਿੰਕ ਕਰੋ
• ਬਨ - ਮੂਲ HTTP ਸਰਵਰ ਨਾਲ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਰਨਟਾਈਮ
• Java (Javalin / Jetty) - Jetty 'ਤੇ ਹਲਕਾ JVM HTTP
• Kotlin (Ktor / Netty) - Netty 'ਤੇ ਕੋਰਟੀਨ-ਅਨੁਕੂਲ JVM HTTP

ਲਾਈਵ ਹੈੱਡਲਾਈਨ ਇੱਕ ਹੈ 8-ਭਾਸ਼ਾ ਤੁਲਨਾ: njs ਬਨਾਮ ਲੁਆ ਬਨਾਮ ਪਾਈਥਨ ਬਨਾਮ ਗੋ ਬਨਾਮ ਜੰਗਾਲ ਬਨਾਮ ਬਨ ਬਨਾਮ ਜਾਵਾ ਬਨਾਮ Kotlin. ਉਪਸਿਰਲੇਖ ਇਰਾਦੇ ਨੂੰ ਫਰੇਮ ਕਰਦਾ ਹੈ: ਪ੍ਰਦਰਸ਼ਨ ਲਈ ਲੰਬੀ ਪੋਲਿੰਗ / ਚੈਟ / ਕਤਾਰ / API ਵਰਕਲੋਡਸ — ਇੱਕ ਸਿੰਗਲ “ਹੈਲੋ ਵਰਲਡ” ਰੱਥ ਦੌੜ ਦੀ ਬਜਾਏ ਕੁਨੈਕਸ਼ਨ-ਭਾਰੀ, JSON-ਭਾਰੀ, ਅਤੇ ਰੂਟਿੰਗ-ਭਾਰੀ ਮਾਰਗ। JVM ਦੁਕਾਨਾਂ ਨੂੰ ਅੰਤ ਵਿੱਚ ਇੱਕ ਵੱਖਰੇ "ਐਂਟਰਪ੍ਰਾਈਜ਼" ਕਿੱਸੇ ਦੀ ਬਜਾਏ Go/Rust/Bun ਵਰਗੀ ਨਿਰਪੱਖ ਸਤਹ ਮਿਲਦੀ ਹੈ।

2.1 ਡੈਸ਼ਬੋਰਡ ਕੀ ਦਿਖਾਉਂਦਾ ਹੈ

ਜਦੋਂ ਇੱਕ ਦੌੜ ਅੱਗੇ ਵਧਦੀ ਹੈ, UI ਪੋਲ /data/results.json ਹਰ ਦੋ ਸਕਿੰਟ ਅਤੇ ਰੈਂਡਰ:

• ਬੇਨਤੀਆਂ/ਸਕਿੰਟ (ਥਰੂਪੁੱਟ) - ਤੋਂ ਇਕੱਤਰ ਕੀਤਾ ਗਿਆ wrk ਪ੍ਰਤੀ ਭਾਸ਼ਾ ਪ੍ਰਤੀ ਟੈਸਟ
• ਔਸਤ ਲੇਟੈਂਸੀ ਅਤੇ P99 ਟੇਲ ਲੇਟੈਂਸੀ — wrk ਦੇ ਲੇਟੈਂਸੀ ਮਾਡਲ ਤੋਂ ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ
• TTFB (ਪਹਿਲੇ ਬਾਈਟ ਲਈ ਸਮਾਂ) — wrk ਦੇ ਨਾਲ-ਨਾਲ ਕਰਲ ਟਾਈਮਿੰਗ JSON ਤੋਂ
• ਸੰਖੇਪ ਸਾਰਣੀ — ਸਰਵੋਤਮ ਸੈੱਲਾਂ 'ਤੇ ★ ਮਾਰਕਰਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ-ਟੈਸਟ ਜੇਤੂ
• ਵਿਸਤ੍ਰਿਤ ਟੈਸਟ ਕਾਰਡ - ਬਾਰ ਚਾਰਟ ਅਤੇ ਮੈਟ੍ਰਿਕ ਟੇਬਲ (P50, P90, P99.9, ਤਰੁੱਟੀਆਂ)
• ਲੇਟੈਂਸੀ ਪ੍ਰਤੀਸ਼ਤਤਾ ਵੰਡ - ਸਾਰੇ ਟੈਸਟਾਂ ਵਿੱਚ ਔਸਤ
• ਫੈਸਲਾ - ਤੁਹਾਡੇ ਵਰਤੋਂ ਦੇ ਕੇਸ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ - ਸਟੇਟਸ ਹੋਣ ਤੋਂ ਬਾਅਦ ਬਿਰਤਾਂਤ complete

ਉਹ ਢਾਂਚਾ ਜਾਣਬੁੱਝ ਕੇ ARB-ਅਨੁਕੂਲ ਹੈ: ਸਲਾਈਡਾਂ ਲਈ ਚਾਰਟ, ਸਪ੍ਰੈਡਸ਼ੀਟਾਂ ਲਈ ਟੇਬਲ, ADR ਦੇ ਜੋਖਮ ਭਾਗ ਲਈ ਬਿਰਤਾਂਤ।

3. ਵਰਕਫਲੋ-ਉਦਾਹਰਣ ਹਾਰਨੇਸ

ਪ੍ਰਜਨਨਯੋਗ ਹਰ ਚੀਜ਼ ਦੇ ਅਧੀਨ ਰਹਿੰਦੀ ਹੈ benchmarks/ ਵਿੱਚ ਵਰਕਫਲੋ-ਉਦਾਹਰਨਾਂ ਰਿਪੋਜ਼ਟਰੀ. ਸਿਖਰ-ਪੱਧਰ ਦਾ ਖਾਕਾ:

benchmarks/
  bench.sh              # orchestrates tests, writes results.json
  wrk_json.lua          # wrk done() → JSON summary (RPS, percentiles)
  docker-compose.yml    # eight app services + dashboard + bench runner
  njs/                  # NGINX + njs module
  lua/                  # OpenResty nginx.conf
  python/               # FastAPI + Dockerfile
  golang/               # net/http main.go
  rust/                 # Actix-web + Cargo
  bun/                  # Bun server.ts
  java/                 # Javalin on Jetty
  kotlin/               # Ktor on Netty
  dashboard/            # static index.html + nginx.conf

3.1 ਡੌਕਰ ਕੰਪੋਜ਼ ਟੋਪੋਲੋਜੀ

docker-compose.yml ਸਾਂਝੇ ਨੈੱਟਵਰਕ 'ਤੇ ਅਲੱਗ-ਥਲੱਗ ਸੇਵਾਵਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ:

• nginx-njs — ਪੋਰਟ 8081, ਇਸ ਤੋਂ ਸੰਰਚਨਾ ./njs
• openresty-lua - ਪੋਰਟ 8082
• python-fastapi — ਪੋਰਟ 8084, ਇਸ ਤੋਂ ਬਣਾਇਆ ਗਿਆ ./python
• go-server - ਪੋਰਟ 8085
• rust-actix - ਪੋਰਟ 8086
• bun-server - ਪੋਰਟ 8087
• java-server — ਪੋਰਟ 8088, Javalin / Jetty ਤੋਂ ./java
• kotlin-server — ਪੋਰਟ 8089, Ktor / Netty ਤੋਂ ./kotlin
• dashboard — ਪੋਰਟ 8083, HTML ਦੀ ਸੇਵਾ ਕਰਦਾ ਹੈ ਅਤੇ ਮਾਊਂਟ ਕਰਦਾ ਹੈ results 'ਤੇ ਵਾਲੀਅਮ /data
• bench - ਐਲਪਾਈਨ ਕੰਟੇਨਰ ਜੋ ਸਥਾਪਿਤ ਕਰਦਾ ਹੈ curl, wrk, jq, ਨਿਰਭਰਤਾ ਲਈ ਉਡੀਕ ਕਰਦਾ ਹੈ, ਚੱਲਦਾ ਹੈ bench.sh

ਬੈਂਚ ਦੌੜਾਕ ਸ਼ੇਅਰ ਕਰਦਾ ਹੈ results ਡੈਸ਼ਬੋਰਡ ਦੇ ਨਾਲ ਵਾਲੀਅਮ ਤਾਂ ਜੋ ਨਤੀਜੇ ਮੈਨੂਅਲ ਕਾਪੀ ਤੋਂ ਬਿਨਾਂ ਲਾਈਵ ਦਿਖਾਈ ਦੇਣ।

3.2 bench.sh ਵਿਧੀ

ਸ਼ੈੱਲ ਡਰਾਈਵਰ ਨਿਰਪੱਖਤਾ ਨਿਯਮਾਂ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਏਨਕੋਡ ਕਰਦਾ ਹੈ:

• ਮਿਆਦ: 10s ਪ੍ਰਤੀ ਅੰਤਮ ਬਿੰਦੂ ਪ੍ਰਤੀ ਭਾਸ਼ਾ
• ਥ੍ਰੈਡਸ: 4
• ਕਨੈਕਸ਼ਨ: 100 ਸਮਕਾਲੀ
• ਗਰਮ ਕਰਨਾ: 50 ਰਾਊਂਡ ਮਾਰੇ /hello ਸਮਾਂਬੱਧ ਟੈਸਟਾਂ ਤੋਂ ਪਹਿਲਾਂ ਹਰੇਕ ਸਰਵਰ 'ਤੇ
• ਪ੍ਰਤੀ ਸਰਵਰ: ਕਰਲ ਟਾਈਮਿੰਗ JSON (dns, connect, ttfb, ਕੁੱਲ) ਪਲੱਸ wrk ਨਾਲ wrk_json.lua

ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਸੱਤ ਟੈਸਟ ਪਾਈਪ-ਸੀਮਤ ਕੀਤੇ ਗਏ ਹਨ:

ਹਰੇਕ ਭਾਸ਼ਾ ਉਸੇ ਰੂਟ ਸਤਹ ਨੂੰ ਲਾਗੂ ਕਰਦੀ ਹੈ (ਵੇਖੋ golang/main.go, python/main.py, java/, kotlin/, NGINX ਸੰਰਚਨਾ, ਆਦਿ) ਇਸਲਈ ਅੰਤਰ ਰਨਟਾਈਮ ਅਤੇ ਫਰੇਮਵਰਕ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ, ਨਾ ਕਿ ਮੇਲ ਖਾਂਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ।

4. "ਪੌਲੀਗਲੋਟ" ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ (ਕੱਟੜਤਾ ਤੋਂ ਬਿਨਾਂ)

ਪੌਲੀਗਲੋਟ ਆਰਕੀਟੈਕਚਰ ਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਹਰ ਇੰਜੀਨੀਅਰ ਅੱਠ ਭਾਸ਼ਾਵਾਂ ਸਿੱਖਦਾ ਹੈ। ਇਸਦਾ ਅਰਥ ਹੈ ਸੀਮਾਬੱਧ ਪ੍ਰਸੰਗ ਇੱਕ ਰਨਟਾਈਮ ਪ੍ਰਾਪਤ ਕਰੋ ਜੋ ਫਿੱਟ ਹੋਵੇ:

• ਕਿਨਾਰੇ ਜਹਾਜ਼ — ਪ੍ਰਮਾਣਿਕਤਾ, ਦਰ ਸੀਮਾਵਾਂ, ਰੂਟਿੰਗ: NGINX ਦੇ ਅੰਦਰ Lua ਜਾਂ njs ਜੋ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਚਲਾਉਂਦੇ ਹੋ
• ਕੋਰ API ਜਹਾਜ਼ - SLOs ਨਾਲ ਵਪਾਰਕ ਤਰਕ: ਜਾਓ ਜਾਂ ਜੰਗਾਲ
• ਜੇਵੀਐਮ ਜਹਾਜ਼ — ਮੌਜੂਦਾ ਬਸੰਤ/ਜਕਾਰਤਾ ਅਸਟੇਟ, ਸਾਂਝੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ, ਹਾਇਰਿੰਗ ਡੂੰਘਾਈ: Java (Javalin) ਜਾਂ Kotlin (Ktor)
• ਡਾਟਾ ਪਲੇਨ — ETL, ਨੋਟਬੁੱਕ, ML ਗਲੂ: ਪਾਈਥਨ
• ਰੀਅਲ-ਟਾਈਮ ਜੇਐਸ ਜਹਾਜ਼ — WebSockets, ਫਰੰਟਐਂਡ ਨਾਲ ਸਾਂਝੀਆਂ ਕਿਸਮਾਂ: ਬਨ ਜਾਂ ਨੋਡ ਜਿੱਥੇ ਵੇਗ ਜਿੱਤਦਾ ਹੈ

ਯੂਨੀਫਾਰਮ ਸਟੈਕ ਐਚਆਰ ਅਤੇ ਖਰੀਦ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਂਦੇ ਹਨ। ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕ ਅਨੁਕੂਲ ਬਣਾਉਂਦੇ ਹਨ ਪ੍ਰਤੀ ਵਰਕਲੋਡ ਫਿੱਟ ਟੇਬਲ 'ਤੇ ਮਾਪਣਯੋਗ ਵਪਾਰ-ਬੰਦਾਂ ਦੇ ਨਾਲ।

5. ਮਾਪ ਜੋ ਮਹੱਤਵਪੂਰਨ ਹਨ

Raw req/s ਮੈਟ੍ਰਿਕ ਹੈ ਜੋ ਸਲੈਕ 'ਤੇ ਸਭ ਤੋਂ ਤੇਜ਼ ਯਾਤਰਾ ਕਰਦਾ ਹੈ। ਇਹ ਗਲਤ ਪੜ੍ਹਨਾ ਵੀ ਸਭ ਤੋਂ ਆਸਾਨ ਹੈ. ਇੱਕ ਬਹੁ-ਕਾਲਮ ਰੁਬਰਿਕ ਦੀ ਵਰਤੋਂ ਕਰੋ:

6. ਫੈਸਲਾ ਮੈਟ੍ਰਿਕਸ

ਹੇਠਾਂ ਦਿੱਤਾ ਚਿੱਤਰ ਉਹ ਗੁਣਾਤਮਕ ਨਕਸ਼ਾ ਹੈ ਜਿਸਦੀ ਵਰਤੋਂ ਅਸੀਂ ਸਮੀਖਿਆਵਾਂ ਵਿੱਚ ਕਰਦੇ ਹਾਂ — ਚਿੱਤਰਕਾਰੀ ਨੇਤਾ, ਤੁਹਾਡੀ ਕਿੱਟ 'ਤੇ ਹਾਰਨੈੱਸ ਚਲਾਉਣ ਦਾ ਬਦਲ ਨਹੀਂ।

ਇਸ ਨੂੰ ਕਤਾਰ-ਪਹਿਲਾਂ ਪੜ੍ਹੋ: ਆਪਣੇ ਕੰਮ ਦੇ ਬੋਝ ਦੀ ਸ਼ਕਲ ਚੁਣੋ, ਫਿਰ ਭਾਰ ਵਾਲੇ ਕਾਲਮ। ਜੇਕਰ ਦੋ ਮਾਪਦੰਡਾਂ ਦਾ ਟਕਰਾਅ ਹੁੰਦਾ ਹੈ (ਉਦਾਹਰਣ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਆਰਪੀਐਸ ਬਨਾਮ ਸਭ ਤੋਂ ਘੱਟ ਐਲਓਸੀ), ਤਾਂ ਇਹ ਤਣਾਅ ਹੋਣਾ ਏਡੀਆਰ ਚਰਚਾ ਹੈ।

7. ਕੇਸ ਪੈਟਰਨ (ਉਦਾਹਰਣ ਲੇਬਲਿੰਗ)

ਹੇਠਾਂ ਦਿੱਤੇ ਨਕਸ਼ੇ ਪਰਿਵਾਰਾਂ ਨੂੰ ਆਰਕੀਟੈਕਚਰਲ ਵਿਕਲਪਾਂ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਨ। ਤੁਹਾਡੀ ਮਸ਼ੀਨ 'ਤੇ ਲੀਡਰ ਦੌੜ ਤੋਂ ਬਾਅਦ ਡੈਸ਼ਬੋਰਡ 'ਤੇ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ - ਇਸ ਸੈਕਸ਼ਨ ਨੂੰ ਫਿਕਸਡ ਸਕੋਰ ਨਾ ਮੰਨੋ।

7.1 API ਲੇਟੈਂਸੀ-ਸੰਵੇਦਨਸ਼ੀਲ (ਟੈਸਟ 1–2, 5–7)

JSON APIs ਅਤੇ ਰੂਟਿੰਗ-ਹੈਵੀ ਹੈਂਡਲਰ ਟੈਸਟ 2, 5, ਅਤੇ 7 ਨੂੰ ਮਿਰਰ ਕਰਦੇ ਹਨ। ਸੰਕਲਿਤ ਅਸਿੰਕ ਰਨਟਾਈਮ (Rust Actix, Go) ਆਮ ਤੌਰ 'ਤੇ ਸਿੰਥੈਟਿਕ HTTP ਬੈਂਚਮਾਰਕਾਂ ਦੀ ਇਸ ਸ਼੍ਰੇਣੀ ਵਿੱਚ ਥ੍ਰੋਪੁੱਟ ਅਤੇ ਟੇਲ ਲੇਟੈਂਸੀ 'ਤੇ ਅਗਵਾਈ ਕਰਦੇ ਹਨ; ਬਨ ਅਕਸਰ JS ਐਰਗੋਨੋਮਿਕਸ ਦੇ ਨਾਲ JSON-ਭਾਰੀ ਮਾਰਗਾਂ 'ਤੇ ਨੇੜੇ ਬੈਠਦਾ ਹੈ। Java (Javalin) ਅਤੇ Kotlin (Ktor) JVM ਟੀਮਾਂ ਨੂੰ ਉਸੇ ਰੂਟਾਂ 'ਤੇ ਉਨ੍ਹਾਂ ਨੇਤਾਵਾਂ ਦੇ ਵਿਰੁੱਧ ਇੱਕ ਨਿਰਪੱਖ ਰੀਡ ਦਿਓ — ਲਾਭਦਾਇਕ ਜਦੋਂ ਸਵਾਲ "ਹਲਕੇ ਸਟੈਕ ਨਾਲ JVM 'ਤੇ ਬਣੇ ਰਹੋ" ਬਨਾਮ "ਗੋ/ਰਸਟ ਵਿੱਚ ਦੁਬਾਰਾ ਲਿਖਣਾ" ਹੋਵੇ। ਪਾਈਥਨ ਫਾਸਟਐਕਸਪੀਆਰ0ਐਕਸ ਵਿਕਾਸ ਦੀ ਗਤੀ ਲਈ ਕੱਚੇ ਆਰਪੀਐਸ ਦਾ ਵਪਾਰ ਕਰਦਾ ਹੈ - ਡੈਸ਼ਬੋਰਡ ਦਾ ਫੈਸਲਾ ਇਸ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਕਹਿੰਦਾ ਹੈ।

7.2 CPU-ਬਾਉਂਡ ਮਾਈਕ੍ਰੋ-ਵਰਕ (ਟੈਸਟ 3)

ਫਿਬੋਨਾਚੀ(30) I/O ਤੋਂ ਬਿਨਾਂ CPU ਨੂੰ ਅਲੱਗ ਕਰਦਾ ਹੈ। ਜੰਗਾਲ ਦੀ ਉਮੀਦ ਕਰੋ ਅਤੇ ਚਮਕਣ ਲਈ ਜਾਓ; ਵਿਆਖਿਆ ਕੀਤੇ ਸਟੈਕ ਓਵਰਹੈੱਡ ਦਾ ਭੁਗਤਾਨ ਕਰਦੇ ਹਨ; JVM JIT ਇੱਕ ਠੰਡੇ 10s ਵਿੰਡੋ ਨਾਲੋਂ ਗਰਮ ਹੋਣ ਤੋਂ ਬਾਅਦ ਮਜ਼ਬੂਤ ​​​​ਦਿਖ ਸਕਦਾ ਹੈ - ਜੇਕਰ ਇਹ ਤੁਹਾਡੀ ਅਸਲ ਪ੍ਰੋਫਾਈਲ ਹੈ ਤਾਂ ਮਿਆਦ ਵਧਾਓ। ਜੇਕਰ ਤੁਹਾਡੀ ਅਸਲ ਸੇਵਾ I/O ਬੱਧ ਹੈ, ਤਾਂ ਇਸ ਕਤਾਰ ਨੂੰ ਜ਼ਿਆਦਾ ਭਾਰ ਨਾ ਪਾਓ — ਇਹ ਕੰਪਿਊਟ-ਹੈਵੀ ਮਿਡਲਵੇਅਰ ਲਈ ਤਣਾਅ ਦਾ ਟੈਸਟ ਹੈ, ਨਾ ਕਿ ਆਮ CRUD।

7.3 ਐਜ ਟ੍ਰਾਂਸਫਾਰਮ (ਟੈਸਟ 6–7, NGINX ਰੂਪ)

ਸਬਰੇਕੁਸਟ ਅਤੇ ਰੂਟਿੰਗ ਟੈਸਟ ਕਿੱਥੇ ਹਨ OpenResty Lua ਅਤੇ NGINX njs ਸਬੰਧਤ: ਜ਼ੀਰੋ ਵਾਧੂ ਹੌਪ, ਸ਼ੇਅਰ ਵਰਕਰ ਮੈਮੋਰੀ, ਓਪਸ ਟੀਮਾਂ ਪਹਿਲਾਂ ਹੀ NGINX ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦੀਆਂ ਹਨ। ਹਾਰਨੇਸ ਦਾ ਫੈਸਲਾ ਕੋਰ ਚੈਟ/ਕਿਊ ਬੈਕਐਂਡ ਅਤੇ ਕਿਨਾਰੇ 'ਤੇ ਲੂਆ/ਐਨਜੇਐਸ ਲਈ Go/Rust ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕਰਦਾ ਹੈ - ਇੱਕ ਸਮਝਦਾਰ ਵੰਡ ਬਹੁਤ ਸਾਰੇ ਉਦਯੋਗ ਪਹਿਲਾਂ ਹੀ ਗੈਰ ਰਸਮੀ ਤੌਰ 'ਤੇ ਚੱਲਦੇ ਹਨ।

7.4 ਬੈਚ ETL ਅਤੇ ਡਾਟਾ ਪਾਈਪਲਾਈਨ

HTTP ਹਾਰਨੇਸ ਸਪਾਰਕ ਜਾਂ ਵੇਅਰਹਾਊਸ ਲੋਡਾਂ ਦੀ ਨਕਲ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਬੈਚ ਲਈ, ਟੀਮਾਂ ਆਮ ਤੌਰ 'ਤੇ ਥਰੂਪੁੱਟ ਲਈ ਪਾਈਥਨ ਈਕੋਸਿਸਟਮ ਅਤੇ ਆਰਕੈਸਟਰੇਸ਼ਨ (ਏਅਰਫਲੋ, ਡੈਗਸਟਰ) ਜਾਂ ਗੋ ਵਰਕਰਾਂ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੀਆਂ ਹਨ। ਲਈ ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕਸ ਦੀ ਵਰਤੋਂ ਕਰੋ API ਸਤਹ ਅਤੇ ਕੰਟਰੋਲ ਜਹਾਜ਼ ਉਹ ਨੌਕਰੀਆਂ ਬੇਨਕਾਬ ਕਰਦੀਆਂ ਹਨ, ਨਾ ਕਿ ਬੈਚ ਇੰਜਣ ਲਈ।

7.5 ਤੇਜ਼ ਅੰਦਰੂਨੀ ਟੂਲ

ਘੱਟ QPS ਅਤੇ ਉੱਚ ਪਰਿਵਰਤਨ ਦਰ ਦੇ ਨਾਲ ਅੰਦਰੂਨੀ ਪ੍ਰਬੰਧਕ APIs: ਪਾਇਥਨ ਜਾਂ ਬਨ/ਨੋਡ ਅਕਸਰ ਵੇਗ ਅਤੇ ਭਰਤੀ 'ਤੇ ਜਿੱਤਦੇ ਹਨ। ਓਵਰਹੈੱਡ ਸਵੀਕਾਰਯੋਗ ਹੈ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਟੈਸਟ 2 (JSON) ਅਤੇ ਟੈਸਟ 5 (ਨਿਰੀਖਣ) ਚਲਾਓ; ਜੇਕਰ p99 100 ਕੁਨੈਕਸ਼ਨਾਂ ਦੇ ਹੇਠਾਂ ਵਧਦਾ ਹੈ, ਤਾਂ ਗਾਹਕ-ਸਾਹਮਣਾ ਵਾਲੇ ਪੱਧਰਾਂ ਨੂੰ ਅੱਗੇ ਵਧਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਮੁੜ ਵਿਚਾਰ ਕਰੋ।

7.6 JVM ਅਸਟੇਟ (ਜਾਵਾ ਅਤੇ Kotlin)

ਬਹੁਤ ਸਾਰੇ ਉਦਯੋਗ ਪਹਿਲਾਂ ਹੀ ਸਾਂਝੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ, ਪਾਲਣਾ ਟੂਲਿੰਗ, ਅਤੇ ਹਾਇਰਿੰਗ ਡੂੰਘਾਈ ਲਈ Java ਜਾਂ Kotlin ਚਲਾਉਂਦੇ ਹਨ। ਹਾਰਨੇਸ ਦਾ java-server (Jetty 'ਤੇ Javalin, ਪੋਰਟ 8088) ਅਤੇ kotlin-server (Netty 'ਤੇ Ktor, ਪੋਰਟ 8089) Go ਅਤੇ Rust ਵਰਗੇ ਸੱਤ ਅੰਤਮ ਬਿੰਦੂਆਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਇਹ ਮਾਪ ਸਕੋ ਕਿ ਕੀ ਇੱਕ ਹਲਕਾ JVM HTTP ਸਟੈਕ ਮੁੜ-ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ ਦਿੱਤੇ ਗਏ SLO ਲਈ "ਕਾਫ਼ੀ ਚੰਗਾ" ਹੈ। Kotlin ਨੂੰ ਤਰਜੀਹ ਦਿਓ ਜਦੋਂ ਕੋਰਟੀਨ-ਸ਼ੈਲੀ ਦੀ ਸਹਿਮਤੀ ਅਤੇ Kotlin-ਪਹਿਲੀ ਟੀਮਾਂ ਮਾਇਨੇ ਰੱਖਦੀਆਂ ਹਨ; Java ਨੂੰ ਤਰਜੀਹ ਦਿਓ ਜਦੋਂ ਆਲੇ ਦੁਆਲੇ ਦੀ ਜਾਇਦਾਦ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀ ਗ੍ਰਾਫ ਪਹਿਲਾਂ ਹੀ Java-ਕੇਂਦ੍ਰਿਤ ਹਨ। ਲਾਈਵ ਡੈਸ਼ਬੋਰਡ ਕਤਾਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ — ਸਪਰਿੰਗ ਬੂਟ ਨੰਬਰਾਂ ਨੂੰ Javalin/Ktor ਨੰਬਰਾਂ ਦੇ ਬਰਾਬਰ ਨਾ ਮੰਨੋ।

8. ਵਰਕਫਲੋ ਡਾਇਗ੍ਰਾਮ

ਰੀਪ੍ਰੋਡਿਊਸੀਬਲ ਲੂਪ: ਵਰਕਲੋਡ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰੋ → ਕੰਪੋਜ਼ ਹਾਰਨੇਸ ਚਲਾਓ → ਨਤੀਜਿਆਂ ਨੂੰ ਫਿਕਸ਼ਨਲੀ ਡੈਸ਼ਬੋਰਡ (ਜਾਂ ਤੁਹਾਡੇ ਅੰਦਰੂਨੀ ਕਲੋਨ) 'ਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ → ਰਨਟਾਈਮ ਜਾਂ ਹਾਰਡਵੇਅਰ ਬਦਲਣ 'ਤੇ ਸੰਰਚਨਾ ਮੈਟਾਡੇਟਾ ਨਾਲ ਇੱਕ ADR ਰਿਕਾਰਡ ਕਰੋ → ਮੁੜ-ਚਾਲੂ ਕਰੋ।

9. ਆਪਣੀ ਤੁਲਨਾ ਕਿਵੇਂ ਚਲਾਉਣੀ ਹੈ

1. ਕਲੋਨ: git clone https://github.com/bwalia/workflow-examples.git && cd workflow-examples/benchmarks
2. ਸਟੈਕ ਸ਼ੁਰੂ ਕਰੋ: docker compose up --build - ਸਾਰੀਆਂ ਭਾਸ਼ਾ ਦੀਆਂ ਤਸਵੀਰਾਂ ਬਣਾਉਂਦਾ ਹੈ, ਪੋਰਟ 8083 'ਤੇ ਡੈਸ਼ਬੋਰਡ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਬੈਂਚ ਆਪਣੇ ਆਪ ਚਲਾਉਂਦਾ ਹੈ।
3. ਦੇਖੋ: ਖੁੱਲਾ http://localhost:8083 (ਜਾਂ ਜਨਤਕ ਸਾਈਟ ਜਦੋਂ ਇੱਕ ਹੋਸਟ ਕੀਤੀ ਰਨ ਕਿਰਿਆਸ਼ੀਲ ਹੁੰਦੀ ਹੈ)।
4. ਵਿਸਤਾਰ ਕਰੋ: ਇੱਕ ਫੋਲਡਰ ਸ਼ਾਮਲ ਕਰੋ myruntime/, ਮਿਰਰ ਐਂਡਪੁਆਇੰਟ ਪਾਥ, ਵਿੱਚ ਇੱਕ ਸੇਵਾ ਰਜਿਸਟਰ ਕਰੋ docker-compose.yml, ਸਰਵਰ ਨੂੰ ਜੋੜੋ SERVERS ਵਿੱਚ bench.sh.
5. ਲੋਡ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰੋ: ਸੰਪਾਦਿਤ ਕਰੋ DURATION, THREADS, CONNECTIONS ਦੇ ਸਿਖਰ 'ਤੇ bench.sh - ਤੁਹਾਡੇ ADR ਵਿੱਚ ਦਸਤਾਵੇਜ਼ ਤਬਦੀਲੀਆਂ।
6. ਉਤਪਾਦਨ ਦੇ ਆਕਾਰ ਦੇ ਟੈਸਟ ਸ਼ਾਮਲ ਕਰੋ: ਜਿਵੇਂ ਕਿ auth ਮਿਡਲਵੇਅਰ, ORM ਪੁੱਛਗਿੱਛ, 50KB ਪੇਲੋਡ — ਸਾਰੀਆਂ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਸਮਾਨਤਾ ਬਣਾਈ ਰੱਖੋ।

CI ਲਈ, ਰਾਤ ​​ਦੇ ਵਰਕਫਲੋ, ਆਰਕਾਈਵ ਵਿੱਚ ਕੰਪੋਜ਼ ਚਲਾਓ results.json ਇੱਕ ਆਰਟੀਫੈਕਟ ਦੇ ਤੌਰ 'ਤੇ, ਅਤੇ ਸਿਰਫ ਤੁਹਾਡੇ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਰਿਗਰੈਸ਼ਨ ਥ੍ਰੈਸ਼ਹੋਲਡ 'ਤੇ ਫੇਲ ਹੋ ਜਾਂਦਾ ਹੈ (ਜਿਵੇਂ ਕਿ p99 +20% ਹਫ਼ਤੇ ਤੋਂ ਵੱਧ ਟੈਸਟ 2)।

10. ਵਿਰੋਧੀ ਪੈਟਰਨ

• ਸਿਰਫ਼ ਟੈਸਟ 1 ਦੇ ਜੇਤੂ ਨੂੰ ਚੁਣਨਾ - ਸਾਦਾ ਟੈਕਸਟ ਘੱਟੋ-ਘੱਟ ਸਟੈਕ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ; ਇਹ JSON, CPU, ਅਤੇ ਰੂਟਿੰਗ ਦਰਦ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਦਾ ਹੈ।
• ਟੀਮ ਦੇ ਹੁਨਰ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ - ਬਿਨਾਂ ਸਲਾਹਕਾਰਾਂ ਦੇ ਉਤਪਾਦਨ ਵਿੱਚ ਜੰਗਾਲ ਘਟਨਾ ਦੇ ਸਮੇਂ ਵਿੱਚ ਮਹਿੰਗਾ ਹੁੰਦਾ ਹੈ।
• ਹੋਸਟਿੰਗ ਲਾਗਤ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ — 2× RPS ਬੇਕਾਰ ਹੈ ਜੇਕਰ ਮੈਮੋਰੀ ਪ੍ਰਤੀ ਪੌਡ ਤੁਹਾਡੇ ਬਿੱਲ ਨੂੰ ਦੁੱਗਣਾ ਕਰ ਦਿੰਦੀ ਹੈ।
• ਸੰਗਠਨ-ਵਿਆਪੀ ਇੱਕ ਭਾਸ਼ਾ ਨੂੰ ਲਾਜ਼ਮੀ ਕਰਨਾ - ਜਾਇਜ਼ ਕਿਨਾਰੇ ਬਨਾਮ ਕੋਰ ਸਪਲਿਟਸ ਨੂੰ ਨਸ਼ਟ ਕਰਦਾ ਹੈ।
• ਉਤਪਾਦਨ ਪ੍ਰੋਫਾਈਲਿੰਗ ਨੂੰ ਬਦਲਣਾ — ਸਿੰਥੈਟਿਕ HTTP ≠ ਤੁਹਾਡਾ ORM, ਕੈਸ਼, ਜਾਂ ਖੇਤਰੀ ਲੇਟੈਂਸੀ।
• ਹਾਰਡਵੇਅਰ ਦੇ ਉਲਟ ਤੁਲਨਾ — ਲੈਪਟਾਪ ਡੌਕਰ ≠ ਬੇਅਰ ਮੈਟਲ ≠ K8s ਸੀਮਾਵਾਂ; ADR ਵਿੱਚ ਕਲਾਸ ਨੂੰ ਨੋਟ ਕਰੋ।

11. ਇੰਜੀਨੀਅਰਿੰਗ ਲੀਡਰਸ਼ਿਪ ਲਈ ਲਾਭ

• ARB ਪੈਕ — ਡੈਸ਼ਬੋਰਡ ਸਕ੍ਰੀਨਸ਼ਾਟ ਐਕਸਪੋਰਟ ਕਰੋ + results.json + ਹੈਸ਼ ਲਿਖੋ।
• ਵਿਕਰੇਤਾ-ਨਿਰਪੱਖ ਸਬੂਤ - ਇੱਕ ਸਿੰਗਲ ਕਲਾਉਡ ਜਾਂ ਫਰੇਮਵਰਕ ਵਿਕਰੇਤਾ ਤੋਂ ਕੋਈ ਵਿਕਰੀ ਡੈੱਕ ਨਹੀਂ।
• ਆਨਬੋਰਡਿੰਗ ਸਪਸ਼ਟਤਾ - ਨਵੇਂ ਭਰਤੀ ਦੇਖਦੇ ਹਨ ਕਿ *ਕਿਉਂ* ਸੇਵਾ A ਗੋ ਹੈ ਅਤੇ ਸੇਵਾ B ਪਾਈਥਨ ਹੈ।
• ਜੋਖਮ ਘਟਾਉਣਾ - ਮੁੜ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ ਸ਼ੈਡੋ ਸੇਵਾ ਵਿੱਚ ਉਪ ਜੇਤੂ ਨੂੰ ਪਾਇਲਟ ਕਰੋ।
• FinOps ਗੱਲਬਾਤ - ਟੇਲ ਲੇਟੈਂਸੀ ਨੂੰ ਆਟੋਸਕੇਲਿੰਗ ਅਤੇ ਮੈਮੋਰੀ ਹੈੱਡਰੂਮ ਨਾਲ ਲਿੰਕ ਕਰੋ।
• ਪਲੇਟਫਾਰਮ ਰੋਡਮੈਪ — NGINX ਹੁਨਰ ਨਿਵੇਸ਼ ਬਨਾਮ ਕਿਸੇ ਹੋਰ K8s ਮਾਈਕ੍ਰੋਸਰਵਿਸ ਨੂੰ ਜਾਇਜ਼ ਠਹਿਰਾਓ।

12. ਸੀਮਾਵਾਂ

• ਸਿੰਥੈਟਿਕ ਵਰਕਲੋਡ — ਸੱਤ HTTP ਟੈਸਟ ਕਾਫਕਾ ਖਪਤਕਾਰਾਂ, GPU ਨੌਕਰੀਆਂ, ਜਾਂ ਗੁੰਝਲਦਾਰ ORM ਗ੍ਰਾਫਾਂ ਨੂੰ ਨਹੀਂ ਦਰਸਾਉਂਦੇ।
• ਡੌਕਰ ਨੈੱਟਵਰਕਿੰਗ - ਓਵਰਹੈੱਡ ਜੋੜਦਾ ਹੈ; ਪੂਰਨ ਸੰਖਿਆ ਬੇਅਰ ਮੈਟਲ ਤੋਂ ਵੱਖਰੀ ਹੁੰਦੀ ਹੈ।
• ਸਿੰਗਲ ਮਸ਼ੀਨ ਕਲਾਸ - ਹੋਸਟ ਕੀਤੇ ਨਤੀਜੇ ਜੋ ਵੀ ਹਾਰਡਵੇਅਰ ਕਾਲਪਨਿਕ ਤੌਰ 'ਤੇ ਵਰਤਦੇ ਹਨ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ; ਤੁਹਾਡੇ ਨੰਬਰ ਵੱਖਰੇ ਹੋਣਗੇ।
• ਕੋਈ ਸਥਿਰਤਾ ਪਰਤ ਨਹੀਂ — ਡਾਟਾਬੇਸ ਅਤੇ ਕੈਸ਼ ਪ੍ਰਭਾਵ ਡਿਜ਼ਾਈਨ ਦੁਆਰਾ ਗੈਰਹਾਜ਼ਰ ਹਨ।
• ਛੋਟੀ ਮਿਆਦ - 10s ਪ੍ਰਤੀ ਟੈਸਟ GC ਵਿਰਾਮ ਜਾਂ ਵਾਰਮਅੱਪ ਕਲਿਫਾਂ ਨੂੰ ਪ੍ਰਗਟ ਨਹੀਂ ਕਰ ਸਕਦਾ ਹੈ; ਤਣਾਅ ਮੁਹਿੰਮਾਂ ਲਈ ਵਧਾਓ.

ਉਤਪਾਦਨ ਲਈ ਸੱਚਾਈ ਦੇ ਸਰੋਤ ਵਜੋਂ ਨਿਰੰਤਰ ਪ੍ਰੋਫਾਈਲਿੰਗ (eBPF, APM, ਸਟੇਜਿੰਗ ਦੇ ਵਿਰੁੱਧ ਲੋਡ ਟੈਸਟ) ਰੱਖੋ। ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕਸ ਨੂੰ ਸੰਕੁਚਿਤ ਕਰਦੇ ਹਨ ਭਾਸ਼ਾ ਅਤੇ ਫਰੇਮਵਰਕ ਪੁਨਰ-ਉਤਪਾਦਨਯੋਗ ਬੇਸਲਾਈਨ ਨਾਲ ਬਹਿਸ।

13. ਸਿੱਟਾ

ਡਿਫੌਲਟ-ਸਟੈਕ ਪੱਖਪਾਤ ਆਰਾਮਦਾਇਕ ਹੈ; ਇਹ ਵੀ ਹੈ ਕਿ ਕਿਵੇਂ ਟੀਮਾਂ ਨੌਕਰੀ ਲਈ ਗਲਤ ਰਨਟਾਈਮ ਭੇਜਦੀਆਂ ਹਨ। ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕਸ ਅਤੇ ਵਰਕਫਲੋ-ਉਦਾਹਰਨਾਂ ਹਾਰਨੈੱਸ ਮੋੜ “ਕੌਣ ਭਾਸ਼ਾ ਜਿੱਤਦੀ ਹੈ?” ਵਿੱਚ "ਕਿਹੜੀ ਭਾਸ਼ਾ ਜਿੱਤਦੀ ਹੈ ਇਸ ਵਰਕਲੋਡ ਕਤਾਰ ਲਈ?" — ਚਾਰਟਾਂ ਦੇ ਨਾਲ ਤੁਹਾਡਾ ARB ਹਵਾਲਾ ਦੇ ਸਕਦਾ ਹੈ।

ਰੈਪੋ ਨੂੰ ਫੋਰਕ ਕਰੋ, ਅੰਤਮ ਬਿੰਦੂ ਜੋੜੋ ਜੋ ਤੁਹਾਡੇ ਗਰਮ ਮਾਰਗਾਂ ਵਰਗੇ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ, ਕੰਪੋਜ਼ ਚਲਾਓ, ਅਤੇ ਨਤੀਜਿਆਂ ਨੂੰ ਅਗਲੇ ਆਰਕੀਟੈਕਚਰ ਫੈਸਲੇ ਨਾਲ ਜੋੜੋ। ਸਾਥੀ ਬਲੌਗ ਪੋਸਟ ਸਾਂਝਾ ਕਰਨ ਲਈ ਪੰਜ-ਮਿੰਟ ਦਾ ਸੰਸਕਰਣ ਹੈ; ਇਹ ਲੇਖ ਹਵਾਲਾ ਹੈ।

ਦੁਆਰਾ ਪ੍ਰਕਾਸ਼ਿਤ Workstation (workstation.co.uk)। 'ਤੇ ਹੋਸਟ ਕੀਤਾ ਬੈਂਚਮਾਰਕ ਡੈਸ਼ਬੋਰਡ polyglot-benchmarks.fictionally.org ਕਾਲਪਨਿਕ ਉਦਾਹਰਣਾਂ ਈਕੋਸਿਸਟਮ ਵਿੱਚ।

ਇਸ ਲੇਖ ਲਈ ਐਸਈਓ ਸਨੈਪਸ਼ਾਟ

• ਐਸਈਓ ਸਿਰਲੇਖ: ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕ: ਨੌਕਰੀ ਲਈ ਸਹੀ ਟੂਲ
• ਮੈਟਾ ਵਰਣਨ: ਉਸੇ HTTP ਵਰਕਲੋਡਾਂ 'ਤੇ njs, Lua, Python, Go, Rust, Bun, Java, ਅਤੇ Kotlin ਦੀ ਤੁਲਨਾ ਕਰੋ। ਰੀਪ੍ਰੋਡਿਊਸੀਬਲ ਹਾਰਨੇਸ, ਲਾਈਵ ਡੈਸ਼ਬੋਰਡ, ਆਰਕੀਟੈਕਟਾਂ ਲਈ ਫੈਸਲਾ ਮੈਟ੍ਰਿਕਸ।
• ਪ੍ਰਾਇਮਰੀ ਕੀਵਰਡ: ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕ, ਭਾਸ਼ਾ ਦੀ ਤੁਲਨਾ, ਆਰਕੀਟੈਕਚਰ ਫੈਸਲੇ, ਵਰਕਫਲੋ ਉਦਾਹਰਨਾਂ, ਪ੍ਰਦਰਸ਼ਨ ਬੈਂਚਮਾਰਕ, ਰਸਟ ਬਨਾਮ ਗੋ, ਜਾਵਾ ਬਨਾਮ Kotlin, FastAPI, Javalin, Ktor
• Twitter / X (280 ਅੱਖਰਾਂ ਤੋਂ ਘੱਟ): ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕਸ: njs, Lua, Python, Go, Rust, Bun, Java, Kotlin ਵਿੱਚ ਇੱਕੋ ਜਿਹੇ 7 HTTP ਟੈਸਟ — ਲਾਈਵ ਡੈਸ਼ਬੋਰਡ + ਵਰਕਫਲੋ-ਉਦਾਹਰਨਾਂ ਦੀ ਵਰਤੋਂ। ਇੱਕ ਵੀ ਜੇਤੂ ਨਹੀਂ; ਇੱਕ ਫੈਸਲੇ ਦਾ ਫਰੇਮਵਰਕ. #Rust #GoLang #Java #Kotlin #Bunjs #polyglot
• ਲਿੰਕਡਇਨ ਪੋਸਟ: ਅਸੀਂ ਪੌਲੀਗਲੋਟ ਬੈਂਚਮਾਰਕਸ 'ਤੇ ਇੱਕ ਡੂੰਘੀ ਡੁਬਕੀ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੀ ਹੈ — ਆਦਤ ਤੋਂ ਇੱਕ ਸੰਗਠਨ-ਵਿਆਪਕ ਸਟੈਕ ਨੂੰ ਕਿਵੇਂ ਚੁਣਨਾ ਬੰਦ ਕਰਨਾ ਹੈ ਅਤੇ ਵਰਕਲੋਡਾਂ ਨਾਲ ਰਨਟਾਈਮ ਦਾ ਮੇਲ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ। ਅੱਠ ਭਾਸ਼ਾਵਾਂ (ਜਾਵਾ/Javalin ਅਤੇ Kotlin/Ktor ਸਮੇਤ), ਸੱਤ ਤੁਲਨਾਤਮਕ ਟੈਸਟ, ਡੌਕਰ ਕੰਪੋਜ਼ + wrk, polyglot-benchmarks.fictionally.org 'ਤੇ ਲਾਈਵ ਨਤੀਜੇ, github.com/bwalia/workflow-examples/tree/main/benchmarks 'ਤੇ ਸਰੋਤ। ਫੈਸਲੇ ਮੈਟ੍ਰਿਕਸ, ਐਂਟੀ-ਪੈਟਰਨ, ਅਤੇ ADR ਮਾਰਗਦਰਸ਼ਨ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ। Workstation ਇੰਜੀਨੀਅਰਿੰਗ ਤੋਂ। #Rust #GoLang #Java #Kotlin #Bunjs #Lua #Python #njs #FastAPI #Javalin #Ktor #OpenResty #polyglot #benchmarks