- Impostazioni di build che aiutano già: LTO, codegen-units, target-cpu, PGO
- Una ricetta che applicate da soli
- Per una parte lenta fino a 2k righe
- Pronto in pochi minuti
Il guadagno è misurato sulla nostra macchina, non indovinato.
Misuriamo il vostro programma sul vostro lavoro, lo rendiamo più veloce, verifichiamo che i risultati siano gli stessi e diciamo il numero prima che paghiate. Qui sotto: come si svolge, quanto costa, cosa garantiamo e cosa potete verificare da soli.
Preferite una versione più veloce già pronta di un programma che usate? Il catalogo è a un clic nel menu.
Quale programma, quanto è grande il compito, quanto spesso lo lanciate e quanto aspettate. Nessun file necessario.
Capiamo se possiamo accelerarlo, poi eseguiamo il vostro compito in entrambi i modi e confrontiamo tempo e risultati.
Se i risultati sono gli stessi e il tempo è sceso come concordato, ricevete la versione veloce. Altrimenti non dovete nulla. Prezzo e condizioni si concordano prima dell’inizio del lavoro.
Design partner: il 50% del primo ordine torna sul saldo come credito. 10 posti. Chiedete un controllo di velocità gratuito
Quale programma, quanto è grande il compito, quanto spesso lo lanciate e quanto aspettate. Niente file, niente installazione.
La maggior parte dei compiti che si ripetono con piccole modifiche si può accelerare. Se il vostro no, ve lo diciamo.
Nel modo consueto e nel nostro, dall’inizio alla fine, sulla stessa macchina, confrontando i risultati. Vedete i numeri prima di decidere.
Se il compito è diventato più veloce come concordato, ricevete la versione veloce: un file accanto al vostro programma, o un servizio che eseguiamo per voi.
Il prezzo dipende da quanto tempo risparmiate. Se il compito non è diventato più veloce, non dovete nulla.
Il prezzo dipende da quanto tempo risparmiate. Lo concordiamo prima dell’inizio del lavoro, e pagate solo dopo che la misura ha mostrato il guadagno.
Il guadagno è misurato sulla nostra macchina, non indovinato.
Il guadagno è misurato prima del pagamento. Nessun guadagno, niente da pagare.
Se il minimo garantito non viene raggiunto, il denaro torna sul vostro saldo secondo la tabella del contratto.
| Guadagno rispetto alla versione fatta da soli | fino a 1.000 righe | 1.000–3.000 righe | 3.000–10.000 righe | oltre 10.000 righe |
|---|---|---|---|---|
| 10–25% | $290 | $490 | $890 | su richiesta |
| 25–100% | $790 | $1.190 | $2.390 | su richiesta |
| 100–200% | $1.190 | $1.790 | $3.590 | su richiesta |
| oltre 200% | $1.990 | $2.990 | $5.990 | su richiesta |
L’accelerazione è quante volte la nuova versione è più veloce della versione gratuita con impostazioni di build, meno uno: 100% significa due volte più veloce, 200% tre volte. La tabella dei prezzi la conta in lavoro del processore (cicli): −20% al 25%, −50% al 100% e −67% al 200%. L’opzione gratuita con impostazioni di build copre il codice caldo fino a 2.000 righe; oltre, è inclusa nell’opzione automatica. Una piattaforma aggiuntiva: +30%. Le righe si contano con llvm-cov per Rust e gcov per C e C++: solo il codice eseguito dal benchmark concordato (dettagli nella domanda «Come si contano le righe?»).
Indichi quanto dura oggi un’esecuzione e quante volte la lancia. Prenda l’accelerazione dalla sua stima gratuita; 5,7× è il caso ta misurato.
Dopo = prima ÷ accelerazione. Il costo usa il numero di core e il prezzo per ora-core. Il risparmio monetario richiede una fatturazione a consumo o risorse che si possano liberare. Usate un fattore misurato per il vostro carico.
| Piano | Al mese, con fatturazione annuale | Cosa include |
|---|---|---|
| Crate | $149 | Codice caldo fino a 2.000 righe, fino a 4 release al mese, una piattaforma |
| Team | $399 | Fino a 10.000 righe, fino a 20 release al mese, due piattaforme |
| Enterprise | da $1.500 | Più progetti, un accordo sul livello di servizio, accettazione sul vostro 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 perché dia gli stessi risultati. Se non è stato possibile portare una release al livello concordato, 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.
Cosa firmiamo, come misuriamo e cosa potete verificare voi stessi: il registro delle misure, il nostro strumento di verifica gratuito, come il vostro codice resta isolato, e un confronto con le opzioni consuete.
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 del compilatore e degli strumenti, protocollo di misura. Il contratto fa riferimento solo a queste metriche.
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.
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.
runCicli, 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.
comparePrima 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.
showControlli 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 sul nostro esempio con gli indicatori ta (1 milione di barre): la build originale contro la build su misura. Il pacchetto delle letture contiene i dati della macchina, gli hash dei programmi, degli input e dell’output, e le metriche con la loro dispersione e un voto di qualità.
Codice sorgente e binario Linux pronto all’uso: github.com/abx-takt/takt-harness (MIT).
Le build automatiche girano in macchine virtuali usa e getta senza rete. Il lavoro su misura può usare in aggiunta uno spazio di progetto separato con diritti di accesso verificati e senza rete durante compilazione ed esecuzioni; le connessioni ai modelli di IA approvati sono gestite a parte.
Una chiave separata per ogni progetto. Dopo 30 giorni, o premendo il pulsante, la chiave viene distrutta insieme ai dati.
I vostri materiali non vengono mai usati in lavori per altri clienti. Se il lavoro su misura usa un modello di IA, Anthropic o OpenAI ricevono materiale solo a condizioni API commerciali e solo con il vostro permesso separato per il progetto, che potete ritirare. Le copie locali e quelle del fornitore hanno periodi di conservazione diversi, descritti nel DPA.
Un hash SHA-256 di ogni file, firmato con la nostra chiave pubblicata; l’elenco dei componenti; il rapporto di misura e la toolchain con cui è stata fatta la build.
La build non fa chiamate di rete, non avvia altri programmi e non scrive file. Uno script nel pacchetto lo mostra sui vostri input.
Potete inviare solo la parte lenta del programma, senza la vostra logica di business. La documentazione spiega come estrarla.
Consegniamo il programma accelerato come file pronto all’uso, con le prove di misurazione e verifica; 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.
| Un agente IA gestito in proprio | Servizi di benchmarking in CI | Un consulente | TAKT | |
|---|---|---|---|---|
| Accelera il codice | sì | no, intercetta le regressioni | sì | sì |
| Risultato noto prima del pagamento | no | — | no | sì, per l’opzione automatica |
| Garanzia nel contratto | no | no | di solito no | sì, sulla misura concordata |
| Protezione contro l’adattamento al benchmark | a suo carico | — | dipende dalla persona | input nascosti |
| Prova di correttezza per ogni modifica | no, solo i suoi test | — | raramente | sì, con revisione indipendente |
| Metodi di ottimizzazione propri | le conoscenze generali del modello | — | l’esperienza di una persona | una libreria di metodi dimostrati che cresce con ogni progetto |
| Un rifiuto onesto quando non c’è nulla da accelerare | un agente modifica sempre qualcosa | — | non sempre | sì, prima del pagamento |
| Hardware di riferimento | il suo | sì | il suo | sì |
| Modello di prezzo | token | per utente | a ore | a risultato |
Analizziamo il codice e applichiamo il principio di Pareto il più a fondo possibile: eliminiamo i calcoli superflui e usiamo altri metodi di calcolo, spostando una parte significativa del lavoro dal tempo di esecuzione alla compilazione.
Il modo in cui rendiamo i programmi più veloci è il nostro know-how, quindi ricevete un file pronto, mai codice sorgente: per un progetto Rust una libreria con header e collegamento in una riga; per C o C++ l’eseguibile. Lo verificate eseguendolo: i risultati devono coincidere con il vostro originale, e potete controllare firma e hash dei file.
La build consegnata è legata alla versione misurata. Se la parte lenta cambia, inviate la nuova versione per un’altra misura; seguire le vostre release è un abbonamento a parte. Per la continuità operativa si può richiedere prima del pagamento il deposito del sorgente secondo l’appendice di escrow.
Per la prima risposta no: basta una descrizione, e il nostro strumento gratuito produce letture senza codice sorgente. Per la build ci serve solo il codice che gira nel ciclo lento, di solito simulatore, indicatori e stato del portafoglio. È coperto da NDA, non è usato per altri clienti e viene cancellato insieme alla chiave.
Fate entrambe le cose. Le esecuzioni indipendenti si distribuiscono bene sui core, e la nostra build rende ogni esecuzione più veloce su ogni core. Più core non aiutano una singola simulazione che procede passo dopo passo, dove ogni passo dipende dal precedente, ed è proprio lì che aiutiamo.
Con l’opzione automatica pagate solo un risultato già misurato, quindi non può succedere. Nel lavoro su misura indichiamo un minimo garantito; se non viene raggiunto, il denaro torna sul vostro saldo secondo la tabella del contratto, e i fondi versati vengono restituiti su richiesta.
Compiliamo il vostro codice con la copertura attiva, nelle impostazioni concordate, eseguiamo il test concordato e contiamo le righe del vostro codice eseguite almeno una volta (llvm-cov per Rust, gcov per C e C++). Le librerie non contano.
I nostri esempi pubblici girano su Linux x86-64 con AVX2/FMA; i numeri di TA-Lib e vn.py sono stati presi su AMD Zen 3 e Zen 4. Per una build a pagamento, processore, sistema operativo e macchina di accettazione sono fissati nell’ordine. Intel, ARM e altri ambienti vengono valutati a parte.
Formati che hanno già librerie C molto ottimizzate (LZ4, zstd, deflate), codec video maturi con assembly scritto a mano (x264, x265), crittografia come SHA-256 e ChaCha20, e codice che attende soprattutto accessi casuali alla memoria. Ve lo diciamo prima che paghiate.
I tempi dipendono dal modello di processore, frequenza, turbo, memoria e input. I numeri contrattuali sono presi sulla nostra macchina secondo il protocollo concordato. Il nostro strumento legge gli stessi contatori, quindi con lo stesso modello di processore e le stesse impostazioni i vostri numeri dovrebbero essere vicini ai nostri.
Per impostazione predefinita i risultati coincidono bit per bit. L’unica eccezione è un caso ristretto con valori NaN, dove il linguaggio stesso ammette codifiche interne diverse; tutto il resto resta esatto salvo diverso accordo scritto.
Controllate i requisiti di processore di ogni pacchetto. I nostri esempi pubblici possono richiedere AVX2/FMA e non gireranno su un processore più vecchio. Per una build a pagamento, le funzioni del processore supportate e un eventuale fallback sono concordati nell’ordine.
Solo se il calcolo è il collo di bottiglia. Per un percorso dal vivo misuriamo l’intero percorso dall’evento di mercato all’ordine sul vostro server, non una singola funzione: spesso la maggior parte del tempo va in rete e borsa. Vi diciamo cosa abbiamo trovato.
Sì. I progetti C e C++ costruiti con CMake o make passano dalla dashboard come i progetti Rust, vengono misurati prima del pagamento e ricevete l’eseguibile. Per Python consegniamo una libreria sostitutiva con la stessa interfaccia, così i vostri programmi continuano a funzionare come prima.
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.
Prototipo per il deposito condizionato di segreti in una macchina virtuale con TPM. Il sorgente si verifica ricompilandolo prima del rilascio.
Un ambiente di avvio OpenWrt misurato che sblocca una root ZFS cifrata con Clevis e il TPM, poi avvia il sistema tramite ZFSBootMenu.
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.
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.
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.
Descrivete un compito: quale programma, quanto è grande, quanto spesso lo lanciate e quanto aspettate. In questo passo non servono file. Gli sviluppatori con un progetto Rust o C/C++ possono anche aprire la dashboard.
The documents are in English. Catalogue purchases use the seller's purchase terms and TAKT's Product Licence. Custom business services agreed directly with ABX use separate Terms; they are not part of the catalogue checkout.