RUSTFS GPUCACHE · G3.5 En développement
Un cache KV partagé au niveau G3.5.
GPUCache est le niveau chaud G3.5 de KV partagé. Le chemin implémenté utilise la mémoire hôte et TCP. RustFS constitue le niveau objet G4, plus froid, hors du chemin des requêtes chaudes.
Rust · Apache 2.0 · Sources CPU/TCP disponibles
Problème
Quand le contexte est évincé, le GPU doit recalculer.
Un long contexte, un dialogue à plusieurs tours et les agents font grossir le KV Cache jusqu'à ce que la mémoire GPU ne puisse plus le contenir. Quand un KV évincé sert de nouveau, il faut refaire le préremplissage : le GPU dépense des cycles sur un travail déjà fait, et le premier token attend plus longtemps.
Chaque couche existante a une limite. La mémoire hôte est finie. Un SSD local au nœud ne sert qu'une machine et se partage mal entre nœuds. Le stockage partagé est fait pour la durabilité et la capacité, et il n'est pas sur le chemin chaud d'inférence.
Approche
Réutiliser les blocs compatibles, recalculer sur un miss.
BlueField-3, GDS et RDMA réel sont des objectifs en développement : NOT_RUN_HARDWARE. Le chemin actuel copie des données sur l’hôte et ne revendique ni zéro copie ni contournement du CPU.
- 01
Le chemin exécutable aujourd’hui
CPU/TCP et les backends mémoire et fichiers sont disponibles en source. Aucun GPU ni DPU requis.
- 02
Un nœud ou plusieurs shards
Routes, connexions et fencing des epochs bornés permettent des shards gérés par l’opérateur.
- 03
Une perte entraîne un recalcul
G3.5 n’ajoute ni codage d’effacement ni réplica de durabilité. Un transfert dont la fin est inconnue reste en quarantaine jusqu’à un drain explicite ou une clôture plus récente autorisant sa réutilisation. RustFS assure la durabilité des données froides. C’est un contrat de cache, pas une reprise après sinistre ou une qualification à l’échelle d’une flotte.
Ce qui ne convient pas
- Des données qui doivent rester. G3.5 est un cache. Les données durables vont sur RustFS en G4.
- Le stockage des checkpoints d'entraînement. C'est le travail de G4.
- Le déploiement en production n’est pas encore qualifié.
Architecture
CPU/TCP aujourd’hui. Le matériel reste à qualifier.
GPUCache est le niveau chaud G3.5 de KV partagé. Le chemin implémenté utilise la mémoire hôte et TCP. RustFS constitue le niveau objet G4, plus froid, hors du chemin des requêtes chaudes.
- Client hôte
- TCP
- Shard G3.5Rust
- CPU
- Mémoire hôte / fichiers
Contrat CPU disponible
- 01
Le chemin exécutable aujourd’hui
CPU/TCP et les backends mémoire et fichiers sont disponibles en source. Aucun GPU ni DPU requis.
- 02
Vérifier l’identité avant de réutiliser
Seuls les blocs validés avec l’identité complète attendue produisent un hit. Un miss entraîne un recalcul.
- 03
Un nœud ou plusieurs shards
Routes, connexions et fencing des epochs bornés permettent des shards gérés par l’opérateur.
- 04
Le stockage froid reste séparé
RustFS est le niveau G4 hors du chemin chaud. Les contrats mock sont testés ; RustFS réel reste NOT_RUN_HARDWARE.
- 05
L’objectif DPU
DPU/GDS/RDMA restent NOT_RUN_HARDWARE. engine-spike utilise des blocs factices ; aarch64 ne prouve que le fonctionnement CPU.
BlueField-3, GDS et RDMA réel sont des objectifs en développement : NOT_RUN_HARDWARE. Le chemin actuel copie des données sur l’hôte et ne revendique ni zéro copie ni contournement du CPU. Le chemin exécutable aujourd’hui
Feuille de route
Où en est le travail.
L’état distingue le code disponible et les contrats CPU reproductibles de la qualification matérielle. Aucune date de sortie ni capacité de flotte mesurée n’est promise.
| État | Fonctionnalité | Limite |
|---|---|---|
| CPU/TCP disponible | Identité, cycle de vie, MemoryStore/FileStore, ACL TCP et admission des lectures | Tests synthétiques ; réseau de confiance requis, sans mTLS. |
| CPU/TCP disponible | Clients de shards bornés, mise à jour des membres et fencing des epochs | Routage géré par l’opérateur ; ni consensus distribué ni certification de taille. |
| Contrat mock disponible | Manifeste G4 v3, file bornée, recharge et rétention | RustFS réel : NOT_RUN_HARDWARE. La collecte d’objets orphelins n’est pas automatique. |
| Simulation CPU disponible | Messages DPU, injection de pannes et comparaison fonctionnelle TCP | Aucune preuve d’offload matériel, de zéro copie, de débit ou de TCO. |
| Essai sur blocs factices | EngineBlockContract et engine-spike | Export/import vLLM réel : NOT_RUN_HARDWARE ; exécution GPU/modèle : NOT_RUN_BUDGET. |
| En développement | RDMA réel, GDS, BlueField-3 / DOCA et SPDK | NOT_RUN_HARDWARE. Les fonctionnalités optionnelles restent non liées et refusent l’ouverture. |
GPUCache est construit par l'équipe RustFS. Les deux ont un partage clair dans la hiérarchie de stockage. GPUCache est la couche chaude G3.5, proche du GPU et faite pour la réutilisation. RustFS est la couche de capacité G4, un stockage objet distribué compatible S3 écrit en Rust, chargé de garder modèles, jeux de données, historique de session et produits d'inférence.
Une couche chaude perdue peut être recalculée. Les données de la couche de capacité ne doivent pas se perdre. Séparer les deux tâches rend chacune plus simple.
Démarrage En développement
Compiler, tester et examiner le contrat CPU.
La branche main contient du code Rust exécutable pour le cache KV partagé G3.5 sur CPU/TCP. Commencez par les tests de contrat logiciel ; aucun GPU ni DPU n’est nécessaire.
Le code source est disponible. Il n’existe pas encore de version installable ni de qualification pour la production.
- Installer Rust stable avec Cargo, Git et Python 3.
- Cloner les sources et lancer les tests du workspace.
- Suivre le guide complet pour les démos et la régression CPU.
git clone https://github.com/rustfs/GPUCache.git
cd GPUCache
cargo test --workspace --all-targets
cargo run -p gpucache-transport --bin share-demoLe guide complet inclut la régression CPU et les limites matérielles explicites. Compiler et tester depuis les sources
Documentation
Lire l’implémentation et ses limites.
Architecture, hiérarchie, état, commandes source et montée en charge distinguent les contrats CPU des objectifs matériels non qualifiés.
Participer
Construire la couche G3.5 ensemble.
GPUCache accueille les personnes qui connaissent la programmation système en Rust, RDMA/RoCEv2, NVIDIA DOCA et BlueField, la compilation croisée ARM64, et les mécanismes de KV Cache de vLLM et TensorRT-LLM.