Librairie CUDA haute performance exploitant la mémoire partagée cohérente. Routing automatique des jobs vers le mode GPU optimal. Jusqu'à 7.6x plus rapide que cudaMemcpy pour les buffers < 256 Ko.
UnifiedFlow v3.0 transforme un pipeline expérimental en une librairie de production capable de s'adapter automatiquement à chaque type de charge de travail.
Accès direct CPU↔GPU sans cudaMemcpy via la mémoire unifiée cohérente. Élimine totalement la latence de transfert pour les petits buffers.
Le PolicyEngine analyse chaque job (taille, intensité compute) et le route vers le mode GPU optimal. Seuils configurables, override possible.
Small (batch-pop), Large (1 CTA/job), Tiled (tile stealing coopératif). Chaque mode possède son kernel persistent et sa queue dédiée.
3 queues indépendantes évitent le head-of-line blocking. Les petits jobs ne sont plus bloqués par les gros. Watermarks et backpressure.
Les 3 kernels GPU restent actifs en permanence et consomment les jobs sans redémarrage. Zéro overhead de lancement, latence minimale.
Soumission asynchrone avec submit() retournant un JobFuture.
Wait, polling non-bloquant, ou fire-and-forget.
Un runtime léger qui classe, route et exécute chaque job avec la stratégie GPU optimale.
L'application soumet un job via pipeline.submit(data, size, op_kind).
Zéro configuration requise.
Analyse la taille (bytes_in) et l'intensité compute (FLOP/byte). Détermine automatiquement : MODE_SMALL, MODE_LARGE ou MODE_TILED.
Q_small, Q_large, Q_tiled — chacune avec ses watermarks, signaux stop/pause, et statistiques indépendantes.
64 buffers x 256 Ko en mémoire partagée cohérente. Accès zéro-copie via NVLink-C2C (900 Go/s).
kernel_small (256 threads, batch-pop), kernel_large (512 threads, streaming), kernel_tiled (256 threads, tile stealing). Exécution parallèle.
Chaque mode est optimisé pour un profil de charge différent. Le PolicyEngine choisit automatiquement le meilleur.
Idéal pour les petits buffers (< 64 Ko). Un CTA traite plusieurs jobs en séquence via batch-pop, réduisant la contention atomique.
Pour les gros buffers (≥ 512 Ko). Chaque CTA prend un job complet et le traite en streaming via grid-stride loop.
Pour les charges compute-heavy (matmul, convolution, attention). Plusieurs CTAs coopèrent via vol de tuiles atomique.
Benchmarks réels exécutés sur NVIDIA GB10 Grace-Blackwell. CUDA 13.0.88, 20 jobs par taille.
| Taille | Speedup | Gagnant |
|---|---|---|
| 4 Ko | 4.4x | UnifiedFlow |
| 16 Ko | 7.6x | UnifiedFlow |
| 64 Ko | 6.4x | UnifiedFlow |
| 256 Ko | 1.2x | UnifiedFlow |
| 1 Mo | 0.48x | cudaMemcpy |
| 4 Mo | 0.20x | cudaMemcpy |
Le mode hybride sélectionne automatiquement la meilleure stratégie selon votre profil applicatif.
Tokens LLM, embeddings, petits tenseurs. UnifiedFlow élimine la latence de transfert pour les buffers < 16 Ko.
Segments audio, spectrogrammes, features Whisper. Sweet spot de performance à 16-64 Ko.
Frames de caméra, prétraitement d'image, vision par ordinateur. Avantage significatif jusqu'à 256 Ko.
MatMul, convolution, attention. Le mode Tiled exploite le tile stealing pour saturer les SMs du GPU.
Gros fichiers, datasets, batch ML training. Le mode hybride bascule automatiquement sur cudaMemcpy (DMA).
Milliers de petits jobs/seconde, IoT, capteurs, télémétrie. Le kernel persistent évite tout overhead de lancement.
Soumettez des jobs en une seule ligne. La librairie gère le reste : classification, routing, exécution et récupération du résultat.
// Initialiser le pipeline PipelineV3 pipeline(cfg); pipeline.init(); // Soumettre un job (classification auto) JobFuture fut = pipeline.submit(data, size, OpKind::TRANSFORM); // Attendre le resultat if (fut.wait(1000)) { process(fut.data(), fut.bytes()); } pipeline.release(fut);
PipelineV3Config cfg; cfg.num_buffers = 64; cfg.bytes_per_buffer = 256 * 1024; // Seuils de classification cfg.policy.mode = PolicyMode::HYBRID; cfg.policy.big_threshold = 512 * 1024; cfg.policy.intensity_threshold = 8.0; cfg.policy.memcpy_threshold = 1024 * 1024; // Streams pour le mode hybride cfg.memcpy_streams = 4; PipelineV3 pipeline(cfg);
auto st = pipeline.get_stats(); printf("Total : %lu jobs\n", st.jobs_processed); printf(" Small : %lu\n", st.jobs_small); printf(" Large : %lu\n", st.jobs_large); printf(" Tiled : %lu\n", st.jobs_tiled); printf("Tiles : %lu\n", st.tiles_processed); printf("Bytes : %lu\n", st.total_bytes);
// Forcer un mode specifique auto fut = pipeline.submit_forced( data, size, ExecutionMode::MODE_TILED); // Pause / Resume pipeline.pause(); pipeline.resume(); // Drainer tous les jobs pipeline.drain(5000); // Arret propre pipeline.stop();
Deux formats disponibles pour intégrer UnifiedFlow v3.0.1 PRO dans vos projets. Compilé pour ARM64 (NVIDIA GB10 Grace Blackwell).
Chargement dynamique à l'exécution. Idéal pour les systèmes partageant la librairie entre plusieurs applications.
Intégrée directement dans l'exécutable. Idéal pour le déploiement autonome sans dépendances externes.
ⓘ Plateforme : ARM64 (aarch64-linux-gnu) — Requiert CUDA 12.0+ — C++17