Etat de ROMEO en un appel : partitions, noeuds libres par architecture, tes jobs en cours et ta part d'ordonnancement. A appeler avant de dimensionner un job.

Liste les modules Environment Modules, herites de l'ancien calculateur. Sur ROMEO 2025 la voie officielle est Spack : utilise romeo_software en premier lieu, et ne recours aux modules que si un logiciel n'existe pas dans le catalogue Spack.

Cherche un logiciel dans le catalogue Spack de ROMEO, plusieurs centaines de paquets qui constituent la voie officielle de chargement des logiciels. ATTENTION : le catalogue differe selon l'architecture. Des outils absents du PATH du noeud de login (conda via anaconda3, apptainer, plusieurs versions de cuda) s'y trouvent. Les paquets trouves se passent ensuite a submit_job ou build_on_node via spack_packages.

Quotas de stockage reels, par espace (home, scratch, projet), lus avec mmlsquota. Signale les depassements de quota souple et l'expiration du delai de grace, qui bloque l'ecriture. A consulter avant de produire des sorties volumineuses.

Recherche locale classee par pertinence dans la documentation ROMEO livree avec le MCP. Accepte mots-cles ou questions, sans distinction d'accents/casse. mode='phrase' cherche un motif exact. page_prefix restreint une branche (ex. ressources/romeo_2025/). max_chars borne le total des extraits. Chaque resultat donne source, titres, lignes et read_args pour lire la section complete. Suivre next_call pour parcourir les autres resultats sans perte par troncature.

Lit le texte original d'une page locale ROMEO. Utiliser les read_args de search_docs ou choisir start_line/end_line (inclusives, base 1). max_chars borne la reponse. Si truncated=true, rappeler avec next_call pour recuperer la suite exacte ; offset est relatif a la plage choisie. expected_sha256 detecte un changement de page entre deux lectures.

Confronte le modele de cluster encode dans ce serveur a la realite de SLURM : partitions et limites de temps, comptes de noeuds par architecture, capacites d'un noeud, plafonds du compte, outils declares absents. Rend les ecarts, sans rien corriger. A lancer quand un refus de dimensionnement parait injustifie, ou apres une maintenance du cluster.

Prepare et soumet un job SLURM. distributed='mpi' couvre le calcul parallele courant (prefixe srun, avec ou sans GPU) ; les familles ddp, accelerate, deepspeed et srun sont propres a PyTorch et ajoutent son point de rendez-vous. Options : container pour une image Apptainer, redirect_caches pour detourner les caches Python hors du home, stage_archive pour mettre un jeu de donnees en memoire vive. data_files choisit les entrees a empreinter au demarrage pour export_job_report (20 fichiers, 64 Mio). En simulation par defaut : rend le script sbatch genere, la partition et l'architecture deduites, et les avertissements de dimensionnement, SANS rien soumettre. Relance avec confirm=true pour soumettre reellement. La partition est deduite du temps demande et l'architecture du besoin en GPU : ne les force que si tu as une raison precise.

Etat d'un job : file d'attente puis historique si le job est termine. Inclut le demarrage estime pour un job en attente.

Sortie d'un job, tronquee par defaut. N'affiche JAMAIS un log entier : utilise lines pour la fin du fichier et grep pour cibler. Le mode stream='auto' montre la sortie d'erreur si elle n'est pas vide.

Efficacite reelle d'un job termine : CPU, memoire, GPU alloues, plus des recommandations de redimensionnement. Remplace seff, absent de ROMEO. A lire systematiquement apres un job pour calibrer le suivant.

Annule un job en file ou en cours.

Tes jobs : ceux en file cote SLURM, et ceux soumis via ce serveur (avec leur repertoire de travail et le chemin de leurs logs, meme apres une perte de contexte).

Attend qu'un job se termine, avec un plafond strict (600 s). Utilise-le seulement pour un job court : sinon reviens interroger job_status.

Soumet un balayage parametrique en tableau SLURM : une tache par jeu de parametres, avec un plafond de taches simultanees. Chaque tache recoit sa ligne de parametres dans la variable $PARAMS, que ta commande peut interpoler. Ideal pour une recherche d'hyperparametres ou une evaluation sur plusieurs jeux de donnees. Simulation par defaut, comme submit_job.

Soumet un calcul long sous forme de chaine de segments reprenables, pour depasser la limite de temps d'une partition rapide. Chaque segment recoit SIGUSR1 avant son expiration pour sauvegarder, et le suivant demarre apres lui via une dependance, en reprenant du dernier point de sauvegarde. Un marqueur de fin fait sauter les segments restants si le calcul se termine avant terme. Ton code doit savoir reprendre depuis checkpoint_dir et, idealement, traiter SIGUSR1.

Estime l'effet d'une charge envisagee sur la part d'usage du compte, donc sur la priorite des jobs suivants de l'equipe. Lit l'usage courant via sshare et le compare a la consommation projetee.

Recommande ou soumettre en confrontant la file d'attente a l'etat du parc : quelle partition et quelle architecture demarreraient le plus vite pour la taille de job envisagee.

Soumet un enchainement de jobs relies par des dependances SLURM : preparer, calculer, rassembler. Chaque etape decrit une intention (commande, temps, ressources) et les etapes dont elle depend ; le serveur ordonne, valide chacune comme submit_job le ferait, et pose les --dependency. L'architecture declaree pour l'enchainement est heritee par toutes les etapes, ce qui evite qu'une etape sans GPU parte sur x86_64 alors que les autres tournent en aarch64. SIMULATION PAR DEFAUT : rappelle avec confirm=true pour soumettre.

Contenu d'un repertoire distant (taille et date incluses).

Lit une tranche d'un fichier distant. Toujours borne : precise offset et limit plutot que de rapatrier un fichier entier.

Ecrit ou remplace un fichier texte distant (script, configuration).

Envoie un fichier ou un repertoire local vers ROMEO.

Rapatrie un fichier ou un repertoire depuis ROMEO vers la machine locale.

Repere ce qui occupe le stockage : plus gros repertoires, journaux de jobs anciens, points de reprise volumineux, environnements virtuels dupliques. Ne supprime rien ; propose les commandes de menage. A utiliser quand romeo_quota signale un depassement.

Telecharge un jeu de donnees depuis un noeud de calcul plutot que depuis le noeud de login, dont la bande passante est partagee. Accepte une URL directe, un depot Hugging Face ou un depot git.

Verifie un script de soumission AVANT de l'envoyer : fins de ligne Windows qui corrompent l'interpreteur, directives #SBATCH placees trop tard, --mem manquant que ROMEO exige, chemins inexistants, variables non definies, secrets ecrits en clair. Accepte le texte du script ou le chemin d'un script deja depose sur le cluster.

Repere les fichiers volumineux abandonnes sous le scratch : anciens, sans job actif associe, ou typiques de fichiers temporaires de calcul (.rwf, .scr, .tmp). Ne supprime rien. Utile quand romeo_quota signale un depassement.

Explique et prepare le stockage des variables sensibles (jetons, mots de passe) pour les jobs. Les valeurs ne transitent JAMAIS par ce serveur : tu les ecris toi-meme dans un fichier a droits restreints, que submit_job source au demarrage via secret_env_file. Elles n'apparaissent ainsi ni dans le script sbatch, ni dans le registre local, ni dans cette conversation.

Compile ou installe sur un noeud de calcul de l'architecture voulue, via srun. INDISPENSABLE pour cibler les noeuds GPU : ils sont en aarch64 alors que le noeud de login est en x86_64, donc tout artefact produit sur le login y est inutilisable. Synchrone, plafonne a 15 min.

Execute une commande COURTE et LEGERE sur le noeud de login (inspection, git, ls, grep). Les compilations, installations et calculs sont refuses par defaut : le noeud de login est partage par tout le laboratoire. allow_heavy=true leve ce refus pour les cas que la documentation ROMEO autorise explicitement, comme un pip install en environnement virtuel a destination du x86_64. Delai maximal 20 s.

Lance un service web sur un noeud de calcul (JupyterLab, TensorBoard, vLLM, MLflow) et rend la commande de pont SSH exacte a executer en local pour y acceder. Attend l'affectation du noeud pour pouvoir composer cette commande.

Reserve un noeud de calcul pour de la mise au point interactive (compilation, profilage, essais). Rend la commande a executer pour obtenir un shell dessus. Utile pour tester sur aarch64 sans passer par un aller-retour de job batch.

Compile un paquet Python en roue binaire sur un noeud de la bonne architecture et la depose dans un depot local. Evite de recompiler les extensions C++/CUDA (deepspeed, flash-attn, bitsandbytes) a chaque nouvel environnement. Les roues ainsi produites sont ensuite trouvees automatiquement par romeo_pip_install.

Installe des paquets Python dans un environnement virtuel, sur un noeud de la bonne architecture, en privilegiant les roues deja compilees par build_wheel. Evite de recompiler les extensions natives et n'utilise jamais le noeud de login, dont les roues seraient en x86_64.

Insere la mise en cache d'un jeu de donnees en memoire vive dans un script sbatch existant, que ce serveur n'a pas genere. Rend le script modifie sans rien ecrire : a toi de le relire puis de le deposer. Pour un job cree ici, prefere submit_job(stage_archive=...).

Ouvre un espace de travail interactif sur un noeud GPU et rend tout ce qu'il faut pour s'y connecter : commande de pont SSH a coller, et URL locale avec son jeton d'authentification. Contrairement a launch_interactive_service, le jeton est genere ici, donc l'URL est utilisable immediatement sans lire la sortie du job.

Autopsie d'un job en echec, en un seul appel : etat SLURM, fin des journaux, causes reconnues et remedes. Reconnait notamment le binaire x86 execute sur un noeud aarch64, la saturation de VRAM, le depassement de memoire, l'erreur de bus, les echecs NCCL et les quotas. En cas de depassement de temps, cherche aussi les points de reprise disponibles. A appeler des qu'un job echoue, avant toute autre investigation.

Telemetrie instantanee d'un job EN COURS, sans lire de journal ni attendre la fin : occupation et memoire des GPU, temperature, puissance, et processus les plus actifs. Detecte le cas ou le calcul dort sur des entrees-sorties pendant que les GPU sont reserves, et la montee vers la saturation de VRAM avant qu'elle ne provoque un echec.

Capture la pile d'appels des processus d'un job EN COURS, pour diagnostiquer un blocage : interblocage MPI, noyau CUDA fige, attente sur verrou. Utilise pstack, avec repli sur gdb puis eu-stack. Ne s'attache pas de maniere interactive : il preleve une trace et rend la main, ce qui n'interrompt pas le calcul.

Sante systeme d'un job EN COURS, GPU ou non : charge processeur face aux coeurs reserves, attente d'entrees-sorties, memoire utilisee face a la reservation. Detecte les trois gaspillages classiques : un code cense etre parallele qui tourne sur un seul coeur, un calcul qui passe son temps a attendre le systeme de fichiers, et une reservation memoire massivement surdimensionnee.

Profile un calcul GPU avec NVIDIA Nsight Systems et produit un rapport exploitable, au lieu de laisser deviner pourquoi un code est lent. La capture est fenetree pour ne pas produire une trace enorme. Lis ensuite le resume avec profile_report.

Resume le rapport de profilage d'un job traite par profile_job : repartition entre calcul et transferts memoire, et noyaux les plus couteux. Condense une sortie nsys de plusieurs centaines de lignes en quelques constats.

Verifie la sante des GPU sur un ou plusieurs noeuds : bridage thermique ou de puissance, erreurs memoire non corrigees, frequence anormalement basse. Un noeud degrade ne plante pas, il ralentit tout un job reparti sans erreur visible. Rend une clause --exclude prete a l'emploi pour les noeuds suspects.

Estime l'energie consommee et l'empreinte carbone d'un job. ATTENTION : ROMEO n'active aucun greffon de comptabilite energetique SLURM, le resultat est donc un MODELE et non une mesure. Sur un job en cours, la puissance GPU reelle est relevee, ce qui reduit fortement l'incertitude.

Consulte ou change le profil d'outils pour cette connexion : essential ou full. full reaffiche immediatement les outils avances. Aucun job ni fichier distant n'est modifie.

Exporte hors de Git une fiche JSON/Markdown d'un job soumis via ce MCP : script Slurm filtre, provenance, ressources mesurees et SHA-256 de fichiers distants explicitement choisis. Lecture seule sur ROMEO ; cree des fichiers locaux prives. live=false autorise l'export hors ligne.