Abbiamo appena lanciato il servizio. Il sito e il servizio sono ancora in fase di rifinitura: ci scusiamo in anticipo per eventuali imprecisioni o imperfezioni. Ha notato un errore o qualcosa non funziona come previsto? Ci scriva e lo correggeremo subito.

IT
Accesso Stima gratuita
Backtest · addestramento di modelli · sweep di parametri

Calcoli ripetuti più veloci, lo stesso risultato

Invia il nucleo di calcolo di un backtest, simulatore o modello. I crate Rust usano il nostro pannello self-service; C, C++ e Python iniziano con una valutazione tecnica individuale. Puoi verificare le build pubblicate. Il miglioramento e i criteri di accettazione vengono concordati per il tuo carico e la tua piattaforma.

1 h → 11 minsweep di indicatori con il 5,7× misurato, livello 2 rispetto al livello 0 gratuito
1 h → 4 minsweep di addestramento di una rete a impulsi con il 14,2× misurato, livello 2 rispetto al livello 0 gratuito
0 bitdi differenza dal codice originale
Come funziona valutazione iniziale gratuita
  1. Invii il codice caldo

    Solo il nucleo computazionale, senza logica di business. Non è pronto a condividere il codice? Inizi con un pacchetto di letture dal nostro harness gratuito.

  2. Concorda la verifica

    Per Rust misuriamo le opzioni di compilazione e l’ottimizzazione automatica prima dell’acquisto. Il lavoro individuale di livello 2 prevede ambito, minimo misurabile e procedura di accettazione concordati.

  3. Scegli il lavoro a pagamento

    Il livello 1 non viene addebitato sotto il 10% di accelerazione misurata. Prezzo, eventuale anticipo e accettazione del livello 2 sono concordati in un ordine separato. L’equivalenza dell’output viene verificata sulla piattaforma concordata.

Subito sotto, casi misurati da scaricare ed eseguire ↓
Già misurati

Benchmark standard, output identico all’originale fino all’ultimo bit

Codice pubblico e dataset di uso comune: il corpus di compressione Silesia, le clip video Xiph, i set di previsione di serie temporali ETT, gli indicatori di analisi tecnica. Ogni misura è un’esecuzione sequenziale reale dell’intero set a confronto con l’originale non modificato, e tutti gli output vengono confrontati byte per byte. Le dimostrazioni di correttezza dei codec hanno superato una revisione indipendente.

Tutti e tre i livelli · binari pubblicati

Indicatori ADX, ATR e PSAR della libreria Python ta

Un port in Rust della libreria ta 0.11 che coincide con Python bit per bit. Una scansione di parametri su un milione di barre: ATR, ADX e ±DI per cinque finestre e Parabolic SAR in quattro configurazioni. Ogni livello è compilato, misurato sul banco e pubblicato; l’output di tutti i livelli è identico al byte, anche sugli input su cui il programma va in panic.

5,7×livello 2 rispetto al livello 0 gratuito, tempo dell’esecuzione completa
18×rispetto a Numba nel calcolo
< 48 hdi lavoro dell’ingegnere sul livello 2

Lo stesso algoritmo in Numba (anch’esso bit per bit): 335 ms di calcolo e 201 ms di pandas.read_csv. Livello 2: 18 ms di calcolo e 20 ms di parsing del CSV, 81 ms per l’intero programma. Python ta: 20,5 s per 100.000 barre.

Baseline, cicli per esecuzione (M1, mediana) 1.376,9 mln 503 ms
Livello 0LTO, codegen-units, target-cpu · gratuito 1.248,6 mln463 ms · riferimento
Livello 1ottimizzazione automatica con prova di correttezza 791,4 mln342 ms · 1,58× cicli · 1,35× tempo
Livello 2un ingegnere: un nuovo schema di calcolo 143,3 mln81 ms · 8,7× cicli · 5,7× tempo
Misurato sul banco: Zen 3, cicli vPMU, 9 round intercalati; il tempo è l’intero programma, inclusa la lettura dei dati. I livelli 1 e 2 sono confrontati con il livello 0 gratuito. Sono stati misurati esattamente i file pubblicati. In questo caso l’ottimizzazione automatica da sola dà 1,58× in cicli; il guadagno maggiore viene dal livello 2.
Download · MIT · Linux x86-64 pacchetto completo1 MB: programmi per ogni livello, sorgente della baseline, generatore di dati, misure baseline livello 0 livello 1 livello 2 come verificare SHA256SUMS
Tutti e tre i livelli · binari pubblicati

Sweep di addestramento di una rete neurale a impulsi (un modello BindsNET)

Un serbatoio di 128 neuroni leaky integrate-and-fire con connessioni ricorrenti; i pesi di ingresso sono addestrati online con STDP (PostPre di BindsNET). Lo sweep addestra 24 reti su soglia, costante di tempo di membrana e tasso di apprendimento su un flusso sintetico simile al mercato di 5.000 passi. Il programma Rust stampa esattamente ciò che stampa lo script BindsNET, bit per bit, sull’ingresso principale e su 54 insiemi generati.

15,8×livello 2 rispetto al livello 0 gratuito, cicli (14,2× in tempo)
395×rispetto allo stesso sweep in BindsNET, un core
0 bitdi differenza da BindsNET

BindsNET 0.3.3 su PyTorch (CPU, un thread, lo stesso core): 24,0 s per lo sweep, soprattutto overhead di Python e di dispatch a ogni passo. Livello 2: 60,9 ms su quel core. Qui la sola ottimizzazione della build è più lenta del 6% rispetto alla build normale; l’ottimizzazione automatica dà 3,89× sul livello 0 in cicli, e il livello 2 dà 15,8×.

Baseline, cicli per esecuzione (M1, mediana) 3.525,0 mln 805 ms
Livello 0LTO, codegen-units, target-cpu · gratuito 3.742,6 mln865 ms · riferimento
Livello 1ottimizzazione automatica con prova di correttezza 962,4 mln222 ms · 3,89× cicli · 3,90× tempo
Livello 2un ingegnere: un nuovo schema di calcolo 237,0 mln60,7 ms · 15,8× cicli · 14,2× tempo
Misurato sul banco: Zen 3, cicli vPMU in una VM isolata, 9 round intercalati; il CCX era riservato alla misura (2 delle sue 16 CPU logiche erano fuori dal nostro controllo). I livelli 1 e 2 sono confrontati con il livello 0 gratuito. Sono stati misurati esattamente i file pubblicati.
Download · MIT · Linux x86-64 pacchetto completo0,8 MB: programmi di tutti i livelli, sorgente della versione di base, script BindsNET, generatore di dati, misure baseline livello 0 livello 1 livello 2 come verificare SHA256SUMS
16–20×rispetto a un port nativo competente
≈12.000×rispetto all’ottimizzatore di vn.py
Ottimizzazione di strategie · vn.py · binari pubblicati

Ottimizzazione dei parametri in vn.py: la stessa top 10, un ordine di grandezza più veloce

L’ottimizzatore a forza bruta di vn.py su 600 insiemi di parametri della sua strategia a medie mobili inclusa. Il nostro programma stampa gli stessi dieci insiemi migliori con gli stessi indici di Sharpe, rendimenti, drawdown e numero di operazioni, bit per bit sulle macchine AVX2. È 16–20× più veloce di un port nativo competente che calcola ogni media mobile una sola volta, e circa 12.000× più veloce di vn.py stesso, soprattutto grazie all’uscita da Python. Misurato su AMD Zen 3 e Zen 4.

Download · MIT · Linux x86-64 pacchetto completo60 KB: il nostro programma, entrambi i port nativi, il driver vn.py, il generatore di dati, le misure su due piattaforme cosa è stato misurato
2,3–7,4×sette indicatori, C
2,0–6,0×da Python, invariato
Libreria C · sostituzione diretta · binari pubblicati

Indicatori tecnici TA-Lib: una libreria sostitutiva più veloce

Una sostituta della libreria C TA-Lib 0.8.1 con la stessa ABI: i programmi C e il wrapper Python di TA-Lib la usano senza modifiche, e ogni uscita coincide bit per bit con quella della libreria ufficiale (4,59 milioni di chiamate verificate). In uno sweep di parametri su un milione di barre, sette indicatori (CCI, SAR, DX, ADX, EMA, STOCH, RSI) sono 2,3–7,4× più veloci della più veloce tra la build ufficiale e quella -march=native, misurati su AMD Zen 3 e Zen 4. Attraverso il wrapper Python invariato, lo stesso sweep è 2,0–6,0× più veloce.

Download · BSD-3 · Linux x86-64 pacchetto completo3,2 MB: la libreria, i programmi di benchmark, lo strumento di verifica bit per bit, le misure su due piattaforme cosa è stato misurato
5,6–5,9×rispetto al Rust originale
2,3–3,6×rispetto a PyTorch + Inductor su tutti i core

Previsione di serie temporali in Rust

DLinear con i pesi addestrati ufficiali sui quattro set ETT, ogni finestra dello split di test, a confronto con l’implementazione Rust originale. Su tutti i core è 2,3–3,6× più veloce di PyTorch con il compilatore Inductor. PatchTST: 2,2–2,5×.

1,29–1,36×

rav1e 0.8: codifica AV1

Cinque clip Xiph scelte a caso prima della misura: Elephants Dream, Park Joy, Johnny, Bus, Stefan. Il ciclo di codifica completo con speed 6 e 10. Ogni clip è più veloce, e i bitstream coincidono byte per byte.

Download · BSD-2 · Linux x86-64 pacchetto completo baseline TAKT come verificare SHA256SUMS
3,4×rispetto al Rust originale
4,0×rispetto a libbz2 in C

Decompressione bzip2

Il crate bzip2-rs in puro Rust, tutti i 12 file del corpus Silesia, 212 MB. Ogni file è più veloce, da 2,8× a 4,2×. Su 400.000 stream di prova, di cui 360.000 corrotti, coincidono sia i dati sia i messaggi di errore.

Banco: AMD Threadripper PRO 5975WX (Zen 3, AVX2). Rapporto tra le mediane di esecuzioni reali sull’intero set: sette round per i codec, cinque ripetizioni per i modelli. Su un solo thread PyTorch resta più veloce su questi modelli: riordina le addizioni, mentre noi manteniamo l’output identico bit per bit al codice originale. Sono risultati su codice specifico, non una promessa per il suo: per il suo crate indichiamo i numeri dopo averlo misurato.

Prezzi

Si paga un’accelerazione già vista

Il prezzo del livello 1 dipende dalla dimensione del codice caldo e dall’accelerazione ottenuta. Il risultato si vede prima di pagare, quindi si paga solo ciò che si ottiene.

Livello 0
$0
  • Profili di build: LTO, codegen-units, target-cpu, PGO
  • Una ricetta di flag da applicare in autonomia
  • Codice caldo fino a 2.000 righe
  • Pronto in pochi minuti

Il numero è misurato sul banco, non stimato.

Livello 2 · ingegnere
su preventivo 30% in anticipo
  • Prima di tutto un cambio di paradigma computazionale, poi layout dei dati, SIMD e tutto il resto
  • Da un paio d’ore a un paio di giorni
  • Il saldo dopo il collaudo sulle metriche

Minimo garantito non raggiunto: l’importo torna sul suo saldo secondo la tabella del contratto.

Prezzi del Livello 1

Accelerazione rispetto al livello 0fino a 1.000 righe1.000–3.000 righe3.000–10.000 righeoltre 10.000 righe
10–25%$290$490$890su richiesta
25–100%$790$1.190$2.390su richiesta
100–200%$1.190$1.790$3.590su richiesta
oltre 200%$1.990$2.990$5.990su richiesta

L’accelerazione indica quante volte la nuova build è più veloce del livello 0, meno uno: 100% significa due volte più veloce, 200% tre volte; in cicli corrisponde a −20% al 25%, −50% al 100% e −67% al 200%. Il livello 0 gratuito copre il codice caldo fino a 2.000 righe; oltre questa soglia è incluso nel livello 1. Piattaforma aggiuntiva: +30%. Le righe si contano con llvm-cov: solo il codice eseguito dal benchmark del passaporto (dettagli nella domanda «Come si contano le righe?»).

Quanto le fa risparmiare

Indichi quanto dura oggi un’esecuzione e quante volte la lancia. Prenda l’accelerazione dalla sua stima gratuita; 5,7× è il caso ta misurato.

Attesa risparmiata al mese—
Calcolo risparmiato al mese—

Semplice aritmetica sui suoi dati: tempo risparmiato = esecuzioni × durata × (1 − 1/accelerazione). L’accelerazione per il suo codice viene misurata prima che paghi.

Abbonamento CI: l’accelerazione resiste alle nuove release

PianoAl mese, con fatturazione annualeCosa include
Crate$149Codice caldo fino a 2.000 righe, fino a 4 release al mese, una piattaforma
Team$399Fino a 10.000 righe, fino a 20 release al mese, due piattaforme
Enterpriseda $1.500Più crate, SLA, collaudo sul suo hardware

L’abbonamento dura un anno; il canone annuale ($1.788, $4.788 o da $18.000) viene addebitato sul saldo all’attivazione. Ogni nuova release viene ottimizzata di nuovo e verificata per l’equivalenza. Se non è stato possibile portare una release al livello del contratto, riceve la quota di mese corrispondente a tali release, a sua scelta: quella quota del canone mensile sul saldo oppure il prolungamento dell’abbonamento della stessa quota di mese. Se in un mese una release su quattro non è riuscita: un quarto del canone mensile o un quarto di mese.

Tutti i pagamenti passano dal saldo nell’area clienti. Il saldo si ricarica con carta tramite Stripe (carte, Apple Pay, Google Pay e metodi di pagamento locali), con bonifico bancario o con un codice promozionale; ogni servizio viene addebitato al momento dell’ordine. I fondi versati non utilizzati vengono rimborsati su richiesta; i fondi bonus da codici promozionali e bonus servono a pagare i servizi.

A chi si rivolge

Dove l’accelerazione è maggiore

Oggi lavoriamo su x86-64 (AMD Zen 3, AVX2). I guadagni maggiori vengono dai calcoli iterativi densi con retroazione, in cui ogni passo dipende dal precedente: indicatori ricorsivi, simulazione di strategie lungo uno storico, addestramento di reti a impulsi e di altri modelli ricorrenti, sweep su molti insiemi di parametri. Guadagna molto anche il codice che attende a lungo la memoria o analizza i dati bit per bit.

Backtesting e simulazione di strategie

Motori di trading, replay dei dati di mercato, ricerca ed evoluzione dei parametri. Un caso cliente riservato: 2,5–10,5× in automatico, fino a 33,7× con un ingegnere. Un caso pubblico: gli indicatori ta, 5,7× nel tempo dell’esecuzione completa rispetto al livello 0 gratuito.

Addestramento di modelli e ricerca di parametri

Modelli con forte retroazione, come le reti a impulsi (nello stile di BindsNET) e altri modelli ricorrenti, nell’addestramento e negli sweep su molti insiemi di parametri. Al livello 2 portiamo un modello Python in Rust bit per bit. Caso pubblico: uno sweep di addestramento STDP di un modello BindsNET, 15,8× rispetto al livello 0 gratuito e 395× rispetto a BindsNET stesso, con output identico.

Archivi e pipeline di dati

Decompressione di archivi, dump di Wikipedia e OpenStreetMap, dati scientifici e genomici, archiviazione dei log. bzip2: 3,4× rispetto al Rust originale e 4,0× rispetto al C.

Video e AV1

Piattaforme video e transcodifica cloud con rav1e. 1,29–1,36× sulla codifica completa: su un cluster significa circa un quarto di server in meno.

Inferenza ML su CPU

Modelli per serie temporali in Rust senza Python: previsione di carico, domanda ed energia. 5,6–5,9× rispetto al Rust originale, più veloci di PyTorch su tutti i core.

Classe di codiceAccelerazione misurataDove è stata misurata
Simulazioni con stato, ricerca di candidati lungo un’unica storia2,5–34×motore di trading
Reti a impulsi: addestramento STDP, sweep di parametri3,9–15,8×BindsNET: LIF + STDP
Indicatori di analisi tecnica, scansioni di parametri1,6–8,7×ta: ADX, ATR, PSAR
Ottimizzatori di strategie: ricerca a griglia dei parametri16–20×vn.py: DoubleMaStrategy
Librerie di indicatori in C, chiamate da C o Python2,0–7,4×TA-Lib 0.8.1
Decoder con consultazione di tabelle e parsing a livello di bit2,5–4×bzip2, Silesia
Inferenza di piccoli modelli su tutti i core2,2–5,9×DLinear, PatchTST, ETT
Encoder con ricerca della modalità di codifica1,3–1,4×rav1e, Xiph
Primitive crittografiche, codec con SIMD scritto a mano, formati con una libreria C molto ottimizzatanessunaSHA-256, ChaCha20, x264, LZ4

Per ta e la rete a impulsi: rispetto al livello 0 gratuito, in cicli. Altre righe: rispetto al programma originale o, dove il caso lo indica, alla libreria C di riferimento.

Come funziona

Dalla prima misura a una build firmata

Misuri in autonomia

L’harness gratuito registra cicli, istruzioni, cache miss e branch miss e il tempo reale. Può inviarci il pacchetto di letture senza codice sorgente: le indicheremo un intervallo preliminare.

Ci invii la parte calda

Per una misura reale, a differenza di una stima, serve il sorgente. La aiutiamo a estrarre solo il nucleo computazionale, senza logica di business, e ne rileviamo la baseline (misura di base) sul banco di riferimento.

Fissiamo il passaporto

Piattaforma, carico di lavoro, versioni degli strumenti e protocollo vengono registrati prima dell’inizio del lavoro. Il risultato si calcola a partire da questi numeri.

Vede tre numeri

Il livello 0 e il livello 1 vengono misurati in anticipo sul banco. Il livello 2 arriva come intervallo, con una tempistica e un minimo garantito.

Riceve la build

Dopo il pagamento: una libreria firmata, un header, l’SBOM, un report sulle misure e sulla verifica di equivalenza.

Per gli ingegneri

Le prove

Che cosa firmiamo, come misuriamo e che cosa può verificare da sé: il passaporto di misura, l’harness aperto, l’isolamento del suo codice e un confronto con le opzioni consuete.

Garanzia

Promettiamo numeri precisi su hardware preciso

Prima dell’inizio del lavoro fissiamo il passaporto di misura: modello e frequenza della CPU, carico di lavoro con gli hash dei dati di input, versioni di rustc e degli strumenti, protocollo di misura. Il contratto fa riferimento solo a queste metriche.

M1Cicli su una CPU realeIl contatore PMU sul banco di riferimento a frequenza fissa, con baseline e nuova versione alternate. Questa è la promessa.
M2Cicli e istruzioni deterministiciSimulazione su una versione fissata. Lo stesso numero per noi e per lei, per le verifiche incrociate e la CI.
M3Tempo p50 / p99Per i carichi sensibili alla latenza la promessa può essere espressa su p99.
M4Memoria di piccoVincolo: non peggiore della baseline oltre una percentuale concordata.
M5CorrettezzaTest differenziali e fuzzing, anche su input nascosti che l’ottimizzatore non ha mai visto.
Formulazione nel contratto

«Sulla piattaforma P, secondo il protocollo del passaporto di misura, la mediana di M1 diminuirà di almeno l’X% rispetto alla baseline, a condizione che M4 e M5 siano rispettate.»

Perché i cicli su una CPU reale. Un simulatore fornisce un numero ripetibile, ma non sempre quello giusto: non vede il calo di frequenza con istruzioni SIMD larghe, il prefetcher o il multithreading. Per questo il contratto si basa su hardware reale, e la simulazione serve per le verifiche incrociate.

Input nascosti. Una parte dei suoi dati resta riservata fino al collaudo, così l’accelerazione non può essere adattata al benchmark. Questi dati ci arrivano cifrati, e la chiave viene fornita quando il binario è pronto.

Harness

Misuri da sé

Uno strumento a riga di comando gratuito e open source (MIT) rileva lo stesso tipo di letture del nostro banco: cicli e istruzioni in modalità utente dai contatori hardware. Può inviarci le letture senza codice e collaudare il lavoro in autonomia.

run

Cicli, istruzioni, cache miss e branch miss, tempo reale e memoria. Mediana, dispersione, intervallo di confidenza al 95% e un giudizio di qualità.

:::

Più build in round alternati, così le variazioni di temperatura e di carico le colpiscono tutte allo stesso modo.

compare

Prima e dopo: il fattore di accelerazione con il suo intervallo, secondo la definizione dei nostri Termini, e la verifica che gli output coincidano. Il codice di uscita può bloccare un job di CI.

show

Controlli il pacchetto prima di inviarlo: niente codice, niente output, niente contenuto dei file, solo hash e dati della macchina. --redact sostituisce con hash anche percorsi e argomenti.

$ TAKT_INPUTS=data taskset -c 44 takt-harness run --input data \
    -- bin/ta-bench-base ::: bin/ta-bench-level2
machine   AMD Ryzen Threadripper PRO 5975WX 32-Cores · x86-64-v3
checks    pinned to CPU 44 · governor performance · SMT on
protocol  9 rounds after 1 warm-up · CI: percentile bootstrap

metric          baseline       new   factor   95% CI of factor
cycles:u         1.370 G   141.3 M   9.695×   9.582 – 9.927
instructions:u   3.156 G   391.7 M   8.057×   8.057 – 8.057
wall time      484.7 ms  66.90 ms   7.245×   6.983 – 7.346
stdout    match · sha256 ada682c61e5e… · 973 B
quality   good · 9 runs, typical deviation 0.06% / 0.73% (MAD)

verdict   outputs identical · cycles:u speed-up factor 9.695×
bundle    readings.json  # si può inviare senza codice sorgente

Output reale abbreviato sulla nostra vetrina ta-indicators (1 milione di barre): la build originale contro quella di livello 2. Il pacchetto di letture contiene i dati della macchina, gli hash dei programmi, degli input e dell’output, e le metriche con la loro dispersione e un giudizio di qualità.

Codice sorgente e binario Linux pronto all’uso: github.com/rdmitry0911/takt-harness (MIT).

Sicurezza

Il suo codice viene eseguito solo in un perimetro isolato, senza rete

Isolamento

Ogni build avviene in una microVM monouso senza accesso alla rete. Un nodo di benchmark serve un solo cliente alla volta.

Cifratura e cancellazione

Una chiave distinta per ogni progetto. Dopo 30 giorni, o premendo un pulsante, la chiave viene distrutta insieme ai dati.

Il suo codice resta suo

Codice e dati non vengono condivisi con terzi, non vengono usati nel lavoro per altri clienti e vengono cancellati alla scadenza prevista. I metodi matematici generali che scopriamo mentre acceleriamo il suo algoritmo ampliano la nostra libreria senza includere il suo codice, i suoi dati né i suoi nomi. Sono clausole del contratto e dell’NDA firmato prima del caricamento.

Pacchetto firmato

SHA-256 di ogni file, firmati con la nostra chiave pubblicata; lo SBOM dei componenti; il report di misura e la toolchain con cui è stata compilata la build.

Pulizia verificabile

La build non usa la rete, non avvia altri programmi e non scrive file. Uno script nel pacchetto lo dimostra sui suoi dati: esecuzione senza alcuna rete, più strace.

Solo il modulo caldo

Può inviare solo il nucleo computazionale, senza logica di business. La documentazione spiega come estrarlo.

Consegniamo un binario ottimizzato e prove di misurazione ed equivalenza; il metodo resta il nostro know-how. L’escrow del sorgente si richiede per iscritto prima del pagamento tramite una box specifica dell’ordine secondo il rider escrow. Piattaforma e procedura di preparazione e trasferimento devono essere qualificate e registrate nell’ordine. La modalità shadow richiede stato isolato riproducibile; sono ammessi controlli di sicurezza propri o tramite incaricati.

Come funziona la consegna e cosa può verificare da sé

Confronto

Le differenze rispetto alle opzioni consuete

Un agente IA gestito in proprioServizi di benchmarking in CIUn consulenteTAKT
Accelera il codicesìno, intercetta le regressionisìsì
Risultato noto prima del pagamentono—nosì, livelli 0–1
Garanzia nel contrattononodi solito nosì, su M1
Protezione contro l’adattamento al benchmarka suo carico—dipende dalla personainput nascosti
Prova di correttezza per ogni modificano, solo i suoi test—raramentesì, con revisione indipendente
Metodi di ottimizzazione proprile conoscenze generali del modello—l’esperienza di una personauna libreria di metodi dimostrati che cresce con ogni progetto
Un rifiuto onesto quando non c’è nulla da accelerareun agente modifica sempre qualcosa—non sempresì, prima del pagamento
Hardware di riferimentoil suosìil suosì
Modello di prezzotokenper utentea orea risultato
FAQ

Le domande più frequenti

Perché consegnate una build e non il sorgente?

Il metodo di ottimizzazione è il nostro know-how, quindi consegniamo una libreria statica o dinamica con un header C e un sottile wrapper Rust. Per collegarla basta una riga in Cargo.toml. La correttezza è confermata dai test di equivalenza, l’origine dalla firma e dalla provenienza.

Che cosa succede se modifico il mio codice?

Integrazione Rust e ritorno all’originale si concordano per la libreria. Un nucleo modificato richiede nuova versione e misurazione; CI richiede un ordine separato accettato. L’escrow si può richiedere prima del pagamento tramite una box qualificata secondo il rider.

Devo inviarvi la mia strategia?

Non per un intervallo preliminare: l’harness gratuito produce un pacchetto di letture senza codice sorgente. Per la build ci serve il codice che gira nel ciclo caldo, e solo quello: di solito il simulatore, gli indicatori e lo stato del portafoglio. È coperto dall’NDA, non viene usato nel lavoro per altri clienti e viene cancellato alla scadenza prevista. Una parte dei suoi dati può restare presso di lei fino al collaudo: gli input nascosti arrivano cifrati e la chiave viene fornita quando la build è pronta.

Perché non aggiungere semplicemente più core?

Faccia entrambe le cose. Le esecuzioni indipendenti di uno sweep si distribuiscono bene sui core, e la nostra build rende più veloce ciascuna di esse su ogni core aggiunto. Più core non aiutano una singola simulazione lungo uno storico, dove ogni passo dipende dal precedente, ed è proprio questo il codice che acceleriamo. Meno ore-core per lo stesso sweep significano anche una bolletta cloud più bassa.

E se l’accelerazione promessa non si concretizza?

Sul livello 1 si paga un risultato già misurato, quindi non può succedere. Sul livello 2 indichiamo un minimo garantito: se non viene raggiunto, l’importo torna sul suo saldo secondo la tabella del contratto, e i fondi versati sul saldo vengono rimborsati su richiesta.

Come si contano le righe?

Compiliamo il suo codice con -C instrument-coverage nello stesso profilo e per la stessa piattaforma indicati nel passaporto, ed eseguiamo il benchmark del passaporto sugli input aperti. Contiamo le righe Rust eseguite almeno una volta secondo llvm-cov. Non si contano: righe vuote e commenti, codice mai eseguito, test e codice di contorno del benchmark, dipendenze di terze parti fuori dall’ambito del lavoro e assembly; una funzione generica conta una volta sola. Questo numero entra nel passaporto prima del pagamento. I dati non contano, solo il suo codice. Come riferimento: la decompressione del corpus Silesia con bzip2-rs esegue 598 righe di codice del crate, e la codifica di cinque clip Xiph con rav1e esegue 12.809 righe su 55.419.

Quali piattaforme sono supportate?

Le demo pubbliche richiedono Linux x86-64 con AVX2/FMA. TA-Lib e vn.py sono stati misurati su AMD Zen 3 e Zen 4. Funzioni CPU, OS, ABI e hardware di accettazione si fissano per ordine; Intel, ARM e altri ambienti richiedono valutazione propria.

Quale codice si accelera poco?

I decoder di formati che hanno già librerie C ottimizzate da anni (LZ4, zstd, deflate): finora non le abbiamo superate. I codec maturi con SIMD e assembly scritti a mano (x264, x265), le primitive crittografiche come SHA-256 e ChaCha20, l’elaborazione di dati casuali incomprimibili e le chiamate molto brevi, in cui tutto il tempo se ne va in overhead. In questi casi la stima gratuita mostra onestamente un guadagno ridotto, e non c’è nulla da pagare.

I miei conteggi di cicli sono diversi dai vostri. Perché?

I cicli dipendono da modello di CPU, frequenza, turbo, memoria e dati di input. I numeri contrattuali si rilevano sul banco secondo il passaporto di misura. L’harness legge gli stessi contatori: con lo stesso modello di CPU e le stesse impostazioni i suoi numeri dovrebbero essere vicini ai nostri. Il numero di istruzioni dipende molto meno dalla macchina: lo confronti per primo.

E i numeri in virgola mobile?

Per impostazione predefinita gli output coincidono bit per bit, con un’eccezione limitata per i payload dei NaN prodotti dall’aritmetica in virgola mobile, dove Rust ammette payload diversi. Le codifiche di NaN preservate esplicitamente e gli altri output restano esatti, salvo diverso accordo nel passaporto. Il passaporto può anche richiedere payload dei NaN esatti. Qualsiasi altro scostamento concordato è definito nel passaporto e verificato dai test.

La build andrà in crash su un server datato?

Controlla i requisiti CPU di ogni pacchetto. I binari pubblici possono richiedere AVX2/FMA e non funzionare su CPU vecchie. Funzioni e possibile fallback di una build pagata si concordano nel passaporto; il fallback non è implicito in ogni binario.

Ridurrà la latenza del mio trading dal vivo?

Solo se la profilazione mostra che il calcolo è il collo di bottiglia. Per un percorso dal vivo misuriamo l’intero tragitto dall’evento di mercato all’ordine, ad esempio il suo p99 sul vostro server, non una singola funzione: spesso la maggior parte del tempo se ne va in rete e in borsa. I nostri risultati migliori riguardano i calcoli batch: backtest, addestramento e sweep di parametri.

Lavorate con C, C++ e Python?

Sì, come ordini individuali. Per C e C++ consegniamo una libreria sostitutiva con la stessa ABI, così i vostri programmi, e il codice Python che chiama la libreria, funzionano senza modifiche (vedi il caso TA-Lib). Per il codice Python consegniamo un programma o modulo nativo con la stessa uscita (vedi il caso vn.py). È lavoro di ingegneria di livello 2 con prezzo individuale; il self-service della dashboard accetta per ora crate Rust.

Oltre TAKT

I nostri altri progetti

Software di sistema dello stesso team: sblocco di una root ZFS cifrata all’avvio, riconfigurazione di RAIDZ sul posto, una console da browser per Proxmox VE e hotplug Thunderbolt in QEMU. Ogni scheda apre una breve descrizione; il codice è su GitHub. A questi si aggiunge il deposito condizionato di segreti in una macchina virtuale con TPM.

escrow-box

Prototipo per il deposito condizionato di segreti in una macchina virtuale con TPM. Il sorgente si verifica ricompilandolo prima del rilascio.

  • TPM 2.0
  • UKI
  • Clevis

zbm-openwrt-clevis

Un ambiente di avvio OpenWrt misurato che sblocca una root ZFS cifrata con Clevis e il TPM, poi avvia il sistema tramite ZFSBootMenu.

  • OpenWrt
  • ZFS
  • TPM 2.0
  • Clevis

zfs

Un fork di OpenZFS con un prototipo di riconfigurazione di RAIDZ sul posto: cambiare la parità tra raidz1, raidz2 e raidz3 senza esportare il pool.

  • OpenZFS
  • RAIDZ
  • C

qsm-rd

QSM Direct: una console grafica WebRTC per macchine virtuali e container LXC di Proxmox VE, con codifica hardware dove il nodo dispone di un encoder.

  • Proxmox VE
  • WebRTC
  • LXC

qemu-thunderbolt

Un livello di hotplug PCIe in stile Thunderbolt per QEMU: aggiungere e rimuovere dispositivi in guest come macOS che non ne supportano l’hotplug diretto.

  • QEMU
  • Thunderbolt
  • PCIe
  • macOS
Per iniziare

Valuta un carico

Un crate Rust? Apri subito il pannello. Per C, C++ o Python descrivi sotto un’esecuzione lenta: durata, frequenza e piattaforma. In questa fase non servono codice né installazione del harness.

In questa fase non serve alcun codice. Inviando la richiesta acconsente al trattamento dei suoi dati di contatto.