Numeri con le loro condizioni.
Build Release su un Intel i7-6700 (Skylake, AVX2, 4 core): Windows x64 con MSVC 19.51 e Linux x64 sotto WSL2 con GCC 15.2. Alcune baseline più vecchie sono state registrate con MSVC 19.44 e GCC 13.3, e il README di ogni modulo indica il suo compilatore. I valori sono mediane o il migliore di più esecuzioni, come indica ogni README. Dove compaiono due numeri, Windows viene per primo. Dove ne compare uno solo, la riga indica la piattaforma.
Throughput
Latenza
| Operazione | Modulo | Misurato |
|---|---|---|
| Emettere un segnale senza listener | event | 0.54 ns |
| Tick dello scheduler a vuoto, con il clock già letto | scheduler | 1.97 / 0.71 ns |
| Cercare un messaggio tradotto | i18n | da 1.4 a 2.6 ns |
| Proprietà Unicode di un code point | text | 2.2 / 2.6 ns |
| Lettura di configurazione tramite handle | config | 3.52 ns |
| Incrementare un contatore di telemetria | telemetry | da 4.88 a 4.98 ns |
| Cambio di fiber grezzo, Windows | coroutine | da 16 a 18 ns |
| Leggere l'orologio monotono | time | 18.75 / 22.00 ns |
| Armare un timer con un milione attivi | time | da 20 a 23 ns |
| Chiamata RPC unaria, trasporto nullo, Windows | rpc | da 617 a 714 ns |
| Aprire un key-value store da 1 GB dopo una chiusura pulita | storage | 1.49 / 0.92 ms |
Rispetto ai riferimenti
Regex contro std::regex. Da 10× a 351× più veloce di libstdc++ su sei pattern su sette (8× sul settimo), da 1.3× a 42× più veloce di quella di MSVC, in tempo lineare. std::regex gira su 512 KB dello stesso testo di 2 MB, con il risultato riscalato.
Formattazione di interi contro snprintf. 5.4× più veloce. A parte, il writer del terminale trasforma 100,000 scritture da un byte su /dev/null in 25 chiamate a write.
Ricerca vettoriale contro hnswlib 0.8. SIFT1M, un thread, Linux: recall@10 di 0.9633 contro 0.9634 con throughput comparabile (da 4,485 a 5,663 contro 4,624 query/s), indice costruito in 478 s contro 525 s.
Matematica AVX2 contro scalare. Normalizzazione a batch in structure-of-arrays, 512 punti in L1: 8.1× / 9.0× rispetto al percorso scalare, compilato senza autovettorizzazione. Ogni percorso restituisce gli stessi bit, senza contrazione FMA.
Confrontata con codice che non abbiamo scritto noi.
| Cosa | Confrontato con | Risultato |
|---|---|---|
| Ed25519 | OpenSSL, un riferimento Python a interi esatti e i vettori RFC 8032 | 11,848 · 0 divergenze |
| SHA-384/512, HMAC, HKDF, AES-GCM | Python cryptography 46 e hashlib su OpenSSL 3.5, più 47 vettori ufficiali | 127,502 · 0 divergenze |
| X25519, P-256, P-384, verifica RSA | gli stessi oracoli e RFC 7748 e 6979 | 59,001 · 0 divergenze |
| X.509 | openssl verify e Python cryptography, catene casuali | 23,643 |
| TLS 1.3 | Trace RFC 8448, openssl s_server e s_client, Python ssl | 31 casi · 0 errori |
| Compressione | liblz4, zlib e libxxhash, su Linux | 79,864 · 0 divergenze |
| Unicode 18 | i file di conformità Unicode ufficiali | 100% |
| Machine learning | scikit-learn, LightGBM, XGBoost, ONNX Runtime, hnswlib, scipy | entro 1e-4 o identici al bit, e il recall di hnswlib |
| Telemetria | Prometheus e OpenTelemetry Collector reali | accettata, nessun rifiuto |
| Build | Test |
|---|---|
| Windows x64, MSVC 19.51, Release | 282 su 282 |
| Linux x64, GCC 15.2, Release | 284 su 284 |
| Linux x64, Guard e ML attivi | 287 su 287 |
| Linux x64, ASan e UBSan | 274 · puliti, 17 ott |
| Linux x64, TSan | 274 su 274 · puliti, 17 ott |
Script di mutazione inseriscono il bug ed esigono che il test fallisca. Così sono stati scovati una chiave di offuscamento che si annullava da sola e un caso di falsificazione Ed25519, mentre tutti i test di round-trip passavano.
Un progetto separato viene compilato contro l'SDK pacchettizzato con find_package, nello stesso modo in cui lo usa un cliente. Ogni header pubblico compila da solo, su MSVC e GCC.
MSVC /W4 e GCC -Wall -Wextra, inclusi gli alberi dei sanitizer.
Dove gira, detto chiaramente.
24 obiettivi non ancora raggiunti. Per ora.
Ogni modulo ha la sua specifica con obiettivi di prestazioni. Questi sono quelli che le sue misure non hanno raggiunto, come riportato nella documentazione del modulo. Preferiamo che tu li legga qui piuttosto che scoprirli in produzione.
| Modulo | Misurato rispetto all'obiettivo |
|---|---|
| coroutine | Fiber contro thread: da 16x a 28x meno costosa. Obiettivo di 50x non raggiunto |
| coroutine | Creazione di un task: da 80 a 250 ns. Obiettivo di 100 ns non raggiunto con costanza |
| resilience | Catena di quattro policy: da 101 a 123 ns. Obiettivo di 50 ns non raggiunto |
| cache | Lettura con hit: 20.7 ns. Obiettivo di 20 ns non raggiunto |
| cache | Throughput di lettura da 1 a 8 thread: 2x. Obiettivo di 10x da 1 a 16 thread non raggiunto (4 core fisici) |
| compression | Blocco LZ4, testo: comprime a 365 e 380 MB/s, contro 391.2 MB/s del riferimento LZ4_compress_default sulla stessa macchina. Obiettivo di 600 MB/s non raggiunto. Decomprime a 3.24 GB/s su Windows e 2.48 GB/s su Linux (l'obiettivo di 3 GB/s è raggiunto solo su Windows) |
| compression | CRC32 (polinomio IEEE), tabella slice-by-8: 1.57 GB/s su Windows e 2.38 GB/s su Linux. Obiettivo di 20 GB/s non raggiunto: l'istruzione x86 CRC32 calcola solo CRC32C, che lo raggiunge |
| encoding | Validazione UTF-8, testo misto: 6.7 GB/s con AVX2. Obiettivo di 15 GB/s non raggiunto |
| config | Throughput del parser, file da 0.59 MB (MSVC 19.51, i7-6700): 133 MB/s. Obiettivo di 200 MB/s non raggiunto |
| storage | Lettura puntuale casuale su un database di 115 MB, più grande della cache della CPU: da 831 a 1578 ns e da 870 a 1176 ns. Obiettivo di 1 µs non raggiunto in modo stabile |
| regex | Contro std::regex, 7 pattern su 2 MB: da 10x a 351x rispetto a libstdc++ su sei dei sette, da 1.3x a 42x rispetto a MSVC. Obiettivo di 10x su tutti non raggiunto |
| regex | Compilazione di un pattern: da 1.0x a 2.2x la velocità di std::regex su GCC, da 0.2x a 0.7x su MSVC. Obiettivo di 10x più veloce non raggiunto |
| rpc | Allocazioni per chiamata: 1. Obiettivo di zero non raggiunto |
| bench | Ripetibilità su 10 esecuzioni: da 0.4% a 14.1% e da 1.3% a 14.1%. Obiettivo del 2% non raggiunto su questa macchina |
| math | Prodotto scalare e vettoriale su punti interleaved: 2.7x e da 1.9x a 2.2x, distanza interleaved 2.8x su MSVC. Obiettivo da 3x a 4x non raggiunto (le varianti structure-of-arrays arrivano da 4.1x a 4.8x) |
| ecs | Iterare 1 milione con 3 componenti: 4.19 ms, al limite della banda di memoria (14.3 GB/s). Obiettivo di 1 ms non raggiunto |
| Ml::Trees | Una predizione con 500 alberi: da 12 a 14 µs con AVX2. Obiettivo di 50 ns non raggiunto (il limite imposto dalla memoria è da 4 a 5 µs) |
| Ml::Trees | Verifica completa di un modello da 100 MB: circa 13 ms. Obiettivo di 5 ms non raggiunto |
| Ml::Trees | Predizione a batch: da 1.5x a 1.65x più veloce per riga rispetto a una alla volta. Obiettivo di 4x non raggiunto |
| Ml::Trees | Modalità compilata: 2.7x più lenta dell'interprete AVX2. Obiettivo di 2x più veloce non raggiunto |
| Ml::Features | Un evento con 50 feature: 0.45 µs con un'entità, 1.8 µs con 10,000. Obiettivo di 100 ns non raggiunto |
| Ml::Anomaly | Autoencoder: la feature che contribuisce di più è quella responsabile nel 94.3% dei casi. L'obiettivo del 95% fissato per gli altri rilevatori non è raggiunto |
| ModelGuard | Verifica e decifratura di 50 MB: da circa 330 a 380 ms. Obiettivo di 10 ms non raggiunto |
| VectorIndex | Obiettivo di 10,000 query/s con recall del 95% su 1M x 768 non raggiunto |
Misuralo sulla tua macchina.
L'infrastruttura di benchmark è inclusa nella libreria. Misura il tuo carico di lavoro durante la tua valutazione di 30 giorni.
