Conversion cuTile Python → cuTile.jl (Julia)

Convertir les kernels Python @ct.kernel en kernels cuTile.jl Julia function ... end.

Sélection du flux de travail

Conversion standard → Flux complet : translations/workflow.md
Erreurs (MethodError, IRError, décalage numérique) → references/debugging.md
Référence rapide → references/api-mapping.md + references/critical-rules.md
Patterns de test → references/testing.md

Architecture

Les kernels Julia sont autonomes — pas de pont Python, pas d'intégration pytest. Le sous-projet Julia vit dans julia/ à la racine du dépôt avec son propre Project.toml pour la gestion des dépendances.

julia/                          # Sous-projet Julia auto-contenu
├── Project.toml                # Dépendances : CUDA.jl, cuTile.jl, NNlib.jl, Test
├── kernels/                    # Implémentations de kernels cuTile.jl
│   ├── add.jl                  # ← Source de vérité : 1D élément par élément avec scaling alpha (tensor+tensor, tensor+scalaire)
│   ├── matmul.jl               # ← Source de vérité : 2D tiled MMA, layout Julia standard (M,K)×(K,N)→(M,N)
│   └── softmax.jl              # ← Source de vérité : 3 stratégies (TMA, online, chunked) utilisant ct.load/ct.store
└── test/                       # Tests natifs Julia (utilisant stdlib Test)
    ├── runtests.jl             # Point d'entrée du test runner
    ├── test_add.jl
    ├── test_matmul.jl
    └── test_softmax.jl

Référence source de vérité : Consultez toujours julia/kernels/*.jl et julia/test/*.jl pour les patterns qui compilent et passent les tests. Ce sont les exemples canoniques de code cuTile.jl fonctionnant.

Instructions

Analyser le kernel Python : identifier les patterns, formes, dtypes, opérations
Écrire le kernel Julia — julia/kernels/<op>.jl avec kernel cuTile.jl + fonction(s) bridge
Convertir la signature du kernel (voir translations/workflow.md Phase 2)
Convertir le corps du kernel (appliquer references/api-mapping.md + references/critical-rules.md)
Écrire le test Julia — julia/test/test_<op>.jl utilisant stdlib Test + NNlib.jl pour la référence
Enregistrer le test — ajouter include(...) dans julia/test/runtests.jl
Valider — exécuter le validateur inclus : python <skill-dir>/scripts/validate_cutile_jl.py <file.jl>
Tester — exécuter julia --project=julia/ julia/test/runtests.jl

Liste complète de conversion avec vérification post-conversion → translations/workflow.md

⚠️ Pièges majeurs

Les erreurs de traduction les plus dangereuses. Règles complètes (17 au total) dans references/critical-rules.md.

#	Piège	Correctif en une ligne
1	`ct.full()` n'existe pas en Julia	Utiliser `fill(val, shape)`, `zeros(T, dims...)`, ou `ones(T, dims...)`
2	`max(a, b)` sur des tiles → `IRError`	Utiliser `max.(a, b)` (broadcast avec point)
3	`IRError` / `MethodError` mentionnant `IRStructurizer`	Bug du compilateur — signaler en amont avec reproducer minimal
4	Ordre des arguments `ct.launch` silencieusement erroné	Arguments positionnels — correspondre exactement à la signature du kernel
5	`ct.load` avec `order` — positions d'index incorrectes	`order` remappeille FOIS la forme ET l'index (Critical Rule 16)

Exemples travaillés

Conversions Python → Julia côte à côte correspondant aux kernels Julia publiés dans julia/kernels/. Chaque répertoire contient cutile_python.py (avant) et cutile_julia.jl (après).

#	Exemple	Patterns clés	Quand référencer
01	`add`	1D `ct.load`/`ct.store`, scaling alpha, broadcast scalaire, `fill`/`zeros`, load/store par mot-clé	Point de départ ; patterns TMA basiques + élément par élément
02	`matmul`	`muladd`, conversion TF32, boucle K avec `for`, swizzle 2D, layout Julia standard, `ct.@compiler_options`	Opérations MMA / tensor core
03	`softmax`	Planification persistante, boucles `for`, `gather`/`scatter`, `padding_mode`, multi-pass	Patterns de réduction large-tenseur

Ceux-ci correspondent aux kernels publiés dans julia/kernels/ (add.jl, matmul.jl, softmax.jl). Les exemples sont des versions d'enseignement simplifiées — consultez toujours julia/kernels/*.jl pour les implémentations canoniques testées.

Documents de référence

Catégorie	Document	Contenu
Flux	`translations/workflow.md`	Flux de travail complet avec liste todo, boucle de validation, checklist
Règles	`references/critical-rules.md`	17 Critical Rules pour conversion cuTile Python → Julia
API	`references/api-mapping.md`	Mappage API bidirectionnel Python↔Julia + patterns de kernel
Test	`references/testing.md`	Patterns de test natifs Julia, tolérances, diagnostic de défaillance
Débogage	`references/debugging.md`	Diagnostic d'erreur spécifique à Julia + commandes débogage IR
Scripts	`scripts/validate_cutile_jl.py`	Validation statique pour anti-patterns Julia (l'exécuter)
Source de vérité	`julia/kernels/.jl` + `julia/test/.jl`	Implémentations réellement fonctionnelles du codebase

Configuration de l'environnement

Prérequis — Julia : cette skill nécessite la version Julia déclarée dans julia/Project.toml sous [compat] julia. Si julia --version est absent ou plus ancien que cela, installer depuis le site officiel Julia à https://julialang.org/install/ en suivant les instructions du programme d'installation vérifié pour votre OS. Reprendre ci-dessous une fois julia --version compatible.

Ensuite, depuis la racine du dépôt :

# Installer les dépendances Julia déclarées dans julia/Project.toml
julia --project=julia/ -e 'using Pkg; Pkg.instantiate()'

# Exécuter les tests
julia --project=julia/ julia/test/runtests.jl

Prérequis :

Julia (version minimale déclarée dans julia/Project.toml sous [compat] julia)
Pilote CUDA 13.1+
GPU Blackwell (compute capability 10+)
Dépendances gérées via julia/Project.toml : CUDA.jl, cuTile.jl, NNlib.jl, Test

converting-cutile-to-julia