CS 6120 : cours en ligne autodirigé avancé sur les compilateurs (2020)

 (cs.cornell.edu)
2 points par GN⁺ 1 일 전 | 1 commentaires | Partager sur WhatsApp
  • Le cours de niveau doctorat CS 6120 de Cornell CS propose, pour celles et ceux qui veulent apprendre de façon structurée les compilateurs et l’implémentation des langages de programmation, un parcours continu allant des représentations intermédiaires au data flow, à l’optimisation, au parallélisme, au JIT et au garbage collection
  • La version autodirigée se suit comme dans une université fictive, en 4 crédits sans note, avec un planning linéaire combinant vidéos, notes de cours, lecture d’articles et travaux d’implémentation
  • La partie pratique utilise LLVM et Bril, un IR pédagogique, afin de relier les concepts abstraits des compilateurs à l’écriture de code réelle
  • Contrairement au vrai cours Cornell, il est possible d’ignorer les dates limites des devoirs, mais on ne peut pas participer aux discussions Zulip, et un devoir final propre à la version autodirigée remplace le projet de fin de semestre
  • Les supports du cours sont publiés en open source sur GitHub, ce qui permet de signaler des problèmes, et un formulaire de retour permet d’envoyer des suggestions d’amélioration après avoir terminé

Structure du cours et mode de suivi

  • CS 6120 est un cours sur l’implémentation des langages de programmation créé par Adrian Sampson de Cornell CS
  • Il couvre à la fois les thèmes fondamentaux des compilateurs généralistes et des sujets à caractère plus recherche
    • représentations intermédiaires
    • data flow
    • optimisations classiques
    • parallélisation
    • compilation JIT
    • garbage collection
  • L’apprentissage se prolonge par la lecture d’articles et des travaux pratiques sur de l’open source
    • utilisation de LLVM
    • utilisation de Bril, un IR pédagogique pour le cours
  • Le cursus autodirigé est construit comme un planning linéaire mêlant visionnage de vidéos et lecture d’articles
  • Certaines leçons incluent des travaux d’implémentation, avec de l’écriture de code en format ouvert pour assimiler des concepts abstraits
  • Il existe des différences entre le vrai CS 6120 et la version autodirigée
    • les dates limites des devoirs peuvent être ignorées
    • il n’est pas possible de participer aux fils de discussion Zulip
    • le vrai cours comporte un projet de fin de semestre
    • le devoir de fin de parcours de la version autodirigée consiste à « changer le monde grâce à la magie des compilateurs »
  • Le cours est publié en open source sur GitHub, ce qui permet de signaler des bugs en cas de problème
  • Il est possible de remplir un formulaire de retour après avoir terminé

Parcours des leçons et des lectures

À lire aussi

1 commentaires

 
GN⁺ 1 일 전
Commentaires Hacker News

  • La partie sur les compilateurs dynamiques porte presque entièrement sur la compilation par traces. En général, la compilation par traces a été une impasse et a été abandonnée à plusieurs reprises
    Les notions plus importantes ici me semblent être le retour de type, l’exécution spéculative et la désoptimisation, ainsi que les compilateurs rapides et la compilation hiérarchisée
    L’ensemble du cours a l’air très bien, et c’est formidable que tant de ressources aient été mises en ligne

    • Historiquement, il s’est avéré que le tracing n’était pas pratique comme principe d’organisation, mais je pense que c’est un concept utile à apprendre parce qu’il élargit la réflexion
      Comme tu l’as dit, j’aimerais simplement donner davantage de contexte sur ce qui fonctionne réellement dans l’industrie
    • Je travaille sur torch.compile de PyTorch, et c’est aussi un compilateur par tracing
      Cela dit, ce domaine est peut-être assez étroit, et il diffère aussi beaucoup des compilateurs traditionnels, donc certains aspects de ce que nous faisons pourraient vous mettre assez mal à l’aise
    • JAX est aussi un compilateur par tracing
      Bien sûr, je sais que l’espace de problèmes est radicalement différent de celui de TraceMonkey ou LuaJIT
    • L’article sur TraceMonkey figurait sur la liste de lecture pour mon examen de qualification de doctorat, et le calendrier de cet examen coïncidait justement avec le moment où TraceMonkey était retiré de SpiderMonkey
      J’ai parlé à l’un des développeurs de l’époque, probablement Jason Orendorff, et il disait que le tracing ne donnait pas vraiment de bons résultats, même s’il pensait que cela pouvait marcher dans des conditions limitées
      En revanche, j’ai complètement oublié quelles étaient ces conditions
    • La compilation par traces n’est pas une impasse
      LuaJIT fonctionne très bien, y compris sur de gros programmes et sur des centaines de millions de serveurs et d’appareils
      C’est vraiment regrettable que même les universitaires continuent à répéter ce lieu commun. Cela me rappelle que l’ignorance fait parfois le bonheur

  • Articles précédents liés :
    CS 6120: Advanced Compilers: The Self-Guided Online Course - https://news.ycombinator.com/item?id=39577878 - mars 2024, 102 commentaires
    Advanced Compilers: Self-Guided Online Course - https://news.ycombinator.com/item?id=35130975 - mars 2023, 82 commentaires
    Advanced Compilers: Self-Guided Online Course - https://news.ycombinator.com/item?id=25386756 - décembre 2020, 232 commentaires

  • Je suis un peu perplexe sur la raison pour laquelle ce cours est avancé. La plupart des sujets, comme l’élimination de code mort, le flot de données, l’analyse des dominateurs ou la forme SSA, ressemblent à des éléments qu’on verrait dans un premier cours sur les compilateurs

    • La numérotation des cours étant assez régulière, on peut chercher ce qu’est le cours « compilateurs débutants » : https://www.cs.cornell.edu/courses/cs4120/2026sp/?schedule
      En bref, les compilateurs sont en fait divisés en deux cours, et le premier traite du minimum nécessaire pour construire un compilateur : analyse lexicale, analyse syntaxique, génération de code et allocation de registres
      Le deuxième cours correspond à la manière de construire un compilateur optimisant
    • J’ai lu énormément de documentation connexe, mais ce genre de contenu n’était pas inclus dans la plupart des cas
      En pratique, qu’il s’agisse d’un compilateur ou d’un interpréteur, le backend est presque toujours laissé comme un « exercice au lecteur »
      Il est difficile d’imaginer tout ce qu’il reste à découvrir : comment construire des closures, suivre des environnements, faire du pattern matching, représenter la mémoire, etc.
      Tout ce qui est intéressant, il faut aller le chercher soi-même
      P.-S. : ceci ne représente qu’une seule année parmi d’autres : https://gist.githubusercontent.com/mamcx/e1743571b9a1ea163a7...
    • Je pense que les non-spécialistes commencent généralement par l’analyse syntaxique et n’abordent souvent jamais le backend
      J’ai lu deux livres sur les interpréteurs et les compilateurs, et ils ne couvraient pas beaucoup le backend
      C’est peut-être plus proche d’un cours d’introduction au backend
    • Je me demande alors ce qui est avancé. Si l’on traite correctement l’élimination de code mort, le flot de données, SSA, la sélection d’instructions et l’allocation de registres, on couvre pratiquement 98 % du backend

  • Existe-t-il d’autres cours universitaires d’informatique en ligne en autonomie de ce type ?

    • Il y en a des dizaines. Il suffit de chercher « mooc »
      Certains professeurs publient aussi leurs cours et leurs devoirs en dehors des frameworks « mooc »
      Il m’est même arrivé d’avoir une réponse d’un professeur après avoir posé une question en commentaire. Internet peut encore être assez génial parfois

  • Par rapport à Writing a C compiler de Nora Sandler, quel type de bénéfice le lecteur peut-il en tirer différemment ?

    • Ce livre est plus proche de ce qu’on obtient dans un cours de compilateurs de niveau licence, tandis que ce cours couvre un contenu plus avancé
      Pour un débutant ou quelqu’un qui explore le sujet par loisir, mieux vaut commencer par ce livre ou des ressources de niveau comparable, puis tenter ce cours en comblant les lacunes au fur et à mesure

  • Existe-t-il aussi un cours autodidacte sur les bases des compilateurs à suivre avant de passer à un niveau avancé ?

  • J’ai écouté un podcast sur le compilateur Rust, et il me semble qu’ils disaient qu’à un certain stade, un algorithme d’apprentissage automatique intervenait pour déterminer si un code pouvait faire planter le système

    • Je n’ai jamais entendu ça et je suis presque certain que c’est faux. Bien sûr, le terme « apprentissage automatique » peut être pris au sens large
      Tu aurais une source ?

  • Je me demande vraiment ce qu’alexia massalin fait ces jours-ci, en dehors de percevoir des royalties de brevet sur microunity