Langages de programmation - Agenium Campus

La page est créée Patricia Jean
 
CONTINUER À LIRE
Langages de programmation - Agenium Campus
Langages de programmation
Langages de programmation - Agenium Campus
• L’offre AGENIUM CAMPUS

Sommaire   • Cycle C++
           • Autres langages

                                      2
Langages de programmation - Agenium Campus
L’offre AGENIUM Campus
      PRESENTATION

                         3
Langages de programmation - Agenium Campus
Informations Agenium Campus
Agenium Campus est un organisme de formation Certifié             Taux de satisfaction des formations
DataDock depuis 2012 et Certifié QUALIOPI depuis le 08
mars 2021.                                                                      Très satisfait                Satisfait                Insatisfait   Très insatisfait
QUALIOPI a pour objectif d’attester la qualité du processus            2018          129,5                        46,5                        0             0
mis en œuvre par les prestataires de formation (ou action                              70                         20                          0             0
concourant au développement des compétences), à l’aide                 2019
d’une grille d’analyse individuelle des pratiques qui permet           2020            69                         18                          2             0
de répondre aux caractéristiques des critères de qualité :
faisabilité, acceptabilité, fréquence, potentiel d’amélioration
mesurabilité.                                                             Taux de satisfaction - Formations Agenium Campus

Nos salles de formations                                                      Très insatisfait
                                                                                    0%
Nos locaux sont situés principalement à Saint-Germain-en-                          Insatisfait
                                                                                                       Non répondu
                                                                                                           19%
Laye (78100), mais nous avons également des salles de                                 1%
formations disponibles sur le Plateau de Saclay à Gif-sur-
Yvette (91190) et également à Toulouse (31400)                                                    Satisfait
                                                                                                                             Très satisfait
                                                                                                    19%
                                                                                                                                 61%

Accès PMR
Nos locaux sont situés dans un bâtiment classé ERP 5,
facilitant l’accès des personnes en situation de mobilité
réduite (accès aux locaux, déplacement dans les locaux, …)                                       Très satisfait        Satisfait      Insatisfait

                                                                                                                                                                        4
Langages de programmation - Agenium Campus
Déroulement des formations
Agenium Campus propose des formations sur 3                             Organisation des formations : toutes nos
niveaux : niveau 1 - Intermédiaire, niveau 2 -                          formations sont proposées en présentiel ou en
Avancé, et niveau 3 - Expert.                                           distanciel.

Le niveau 1 – Intermédiaire, permet de reprendre                        Présentiel : les formations en présentiel peuvent se
les bases d’un langage de programmation.                                dérouler dans nos locaux ou bien sur site client.

Le niveau 2 – Avancé, permet de voir les fonctions                      Distanciel : les formations en distanciel se déroule
plus avancé d’un langage de programmation.                              sous forme de visio-conférence via l’application
                                                                        TEAMS pour la partie théorique et via notre
Le niveau 3 – Expert, met en avant les fonctions                        plateforme LEARN pour la partie pratique
plus avancé du langage de programmation.                                (exécution de code et résultat en direct).

Type de formation : sur catalogue ou sur-mesure.                        Langue : nos formations sont dispensées en français
                                                                        mais peuvent être également dispensées en anglais
                                                                        (sur demande).

   Ce catalogue comprend une liste non exhaustive de nos formations. Nous créons également des formations sur mesure en fonction des
                           besoins spécifiques de vos équipes, pour cela contacter notre service commercial.
                                                                                                                                       5
Langages de programmation - Agenium Campus
C++

-   Les bases du C++
-   Intel oneAPI – DPC++
-   Bonnes pratiques & performance en C++
-   Design patterns & performance en C++
-   Bonnes pratiques & Design patterns en C++
-   Transition vers C++ 14/17
-   Métaprogrammation

                                                6
Langages de programmation - Agenium Campus
Les bases du C++
         Objectif
         Cette formation vise à maîtriser le langage C++, les différents paradigmes
         de programmation : programmation impérative, objet, métaprogrammation
         et la bibliothèque standard STL.

                                                                                            Niveau 1
                      Public
                      Cette formation C++ s’adresse aux développeurs,
                      techniciens et scientifiques désirant s’initier au langage
                      C++ et sa bibliothèque standard.
                                                                                      INTERMÉDIAIRE

         Pré requis
         Une expérience de programmation dans un autre langage que C++ est
         nécessaire.
                                                                                      Niveau de satisfaction : 4,8 / 5

                                                                                                                         7
Fiche programme – réf. : CPP-LB
   Introduction                     Bibliothèque standard (STL)
   •   Introduction                 •   Bibliothèque standard STL
   Bases                            •   Conteneurs
   •   Bases                        •   Itérateurs
   •   « Hello world »              •   Algorithmes
   •   Variables et constantes      •   Entrée / Sorties
   •   Structures conditionnelles   •   Smart pointers
   •   Fonctions                    •   Pairs / Tuples
   •   Structures et classes        Héritages / Polymorphisme
   Généricité                       •   Héritage / Polymorphisme
   •   Généricité                   •   Héritage simple
   •   Fonctions génériques         •   Héritage multiple
   •   Classes génériques           •   Classe abstraite
   •   Templates variadiques        •   Interface
                                    •   Polymorphisme

                                                                    8
Intel oneAPI – DPC++

         Objectif
         Cette formation permet de se familiariser avec les produits/outils d’Intel
         oneAPI comprenant notamment le nouveau langage de programmation
         Data Parallel C++ (DPC++) offrant la possibilité d’offloader les données et
         l’exécution vers des accélérateurs cibles tels que les CPU, GPU et FPGA.
                                                                                               Niveau 1

                      Public                                                            INTERMÉDIAIRE
                      Cette formation C++ s’adresse aux développeurs, techniciens
                      et scientifiques désirant connaître les outils/produits d’Intel
                      oneAPI et principalement le développement de code Data
                      Parallel C++ (DPC++).

         Pré requis
                                                                                        Niveau de satisfaction : 4,5 / 5
         Pour suivre cette formation, les participants doivent disposer d’une
         première expérience du langage C++ et une expérience en CUDA est un
         plus.

                                                                                                                           9
Fiche programme – réf. : INT-DPC
Introduction à oneAPI et DPC++         ▪   Classes SYCL                        Data parallel C++ : nouvelles
                                               •   Device                      fonctionnalités
▪   oneAPI                                     •   Device selector             ▪   Unifed Shared Memory
▪   Intel oneAPI – Data Parallel C++           •   Queue
                                                                                      •   Qu’est-ce que c’est ?
                                               •   Kernel
▪   DPC++ / C++ Compiler                                                              •   Initialisation
                                       ▪   Kernels parallèle                          •   Types d’Unified Shared Memory
▪   Intel DPC++ Compatibility Tool
                                               •   Comparatif CUDA                    •   Transfert de données explicite
▪   Intel VTune Profiler                       •   Basic Parallel Kernel              •   Tranfert de données implicite

▪   Intel Advisor                              •   ND-Range Kernel                    •   Dépendance des données
                                               •   Hierarchical Kernel                          ₋   Wait
▪   Intel oneAPI Toolkits                                                                       ₋   Depends_on
                                       ▪   Buffers et Accesseurs
                                                                                                ₋   In_order
                                               •   Modèle buffers/accesseurs
Data parallel C++ : structure du                                                      •   Bonnes pratiques
programme                                      •   Anatomie du code
                                                                               ▪   Sub groups
                                       ▪   Synchronisation des données                •   Qu’est-ce que c’est ?
▪   Présentation de SYCL                       •   Execution asynchrone               •   Comment s’adaptent-ils au
        •    Description de SYCL               •   Host Accessors                         hardware ?
        •    Fonctions Lambda                                                         •   Classe sub_group
                                       ▪   Bonnes pratiques
        •    Historique SYCL                                                          •   Synchronization
        •    C++ Moderne                                                              •   Opération shuffle
                                                                                      •   Fonctions collectives

                                                                                                                           10
Bonnes pratiques & performance en
C++
        Objectif
        Cette formation vise à comprendre le cycle de vie des objets en C++.
        Connaître les bonnes pratiques pour écrire un code maintenable et
        performant. Gagner en performance en écrivant un code parallèle.              Niveau 2

                     Public                                                            AVANCÉ
                     Cette formation C++ s’adresse aux développeurs,
                     ayant une bonne connaissance de base du C++.

        Pré requis
        Pour suivre cette formations, les participants doivent disposer d’une   Niveau de satisfaction : 4,8 / 5
        expérience de programmation en C++.

                                                                                                                   11
Fiche programme – réf. : CPP-BPP
Module 1 : Cycle de vie des objets            Règle du zéro                                   Référence invalide                             Module 3 : Pour aller plus vite / loin
Valeurs, références et pointeurs                      ▪   Historique                                  ▪   Exemple
                                                                                                                                             Optimisation du compilateur
        ▪ Valeur                                      ▪   Règles de 3, 5, 0                           ▪   Extension de la durée de vie des
                                                                                                                                                     ▪   Coder simple pour aller vite
                •     Types fondamentaux,                                                                 variables temporaires
                      classes et structures
                                              Comportement indéfinis                                                                                 ▪   Rappel des comportements
                •     Portée                                                                          ▪   Itérateurs et modification de
                                                                                                                                                         indéfinis
                                                      ▪   Définition & explication                        conteneur
                •     Cycle de vie
       ▪    Référence : définition                    ▪   Exemples                                                                           Les outils pour mieux développer
                                                                                              Fuites mémoire
       ▪    Pointeur : définition                                                                                                                    ▪   Valgrind
                                                                                                      ▪   Définition / exemples
       ▪    Mémoire                                                                                                                                  ▪   GDB
                                              Module 2 : Bonnes pratiques                             ▪   Comment les éviter ?
                •     La pile / le tas                                                                                                               ▪   Perf
                •     Implications sur la                                                             ▪   Présentation de Valgrind
                      performance             Commentaires dans le code                                                                              ▪   Godbolt
                                                      ▪   Intention vs. description du code   Accès mémoire non protégés
RAII                                                                                                                                         Calculs parallèles
                                                                                                      ▪   Explications/intérêts
       ▪    Définition, exemple avec          Principe of Least Astonishment                                                                         ▪   Niveaux de parallélisme
            std::vector                                                                               ▪   Responsabilité de la ressource
                                              Namespacing                                                                                                    •    Machines
       ▪    Avantages                                                                                 ▪   Alternatives (std::vector)
                                                      ▪   Utilité par l’exemple                                                                              •    Processus
       ▪    Notes sur la performance                                                                  ▪   Application aux conteneurs
                                                                                                                                                             •    Cœurs
                                                      ▪   Utilisation
Optimisation et élision des copies                                                            Std::shared_ptr vs. Std::unique_ptr                            •    Instructions machine
                                                      ▪   ADL (survol)
       ▪ Explication par l’exemple                                                                                                                   ▪   Designs de parallélisme
                                                                                              ▪   Std::shared_ptr : définition et
       ▪    Condition                         Conversions implicites / explicites                 présentation                                               •    Threads
       ▪    Utilité                                   ▪   Implicites                                                                                         •    Tâches
                                                                                              ▪   Std::unique_ptr : définition et
                                                              •   Explications / exemple          présentation                                       ▪   Survol des outils de la STL
Transfert
                                                              •   Dangers
       ▪    Explication par l’exemple                                                         ▪   Conseils
       ▪    Comment faire?                            ▪   Explicite
       ▪    Exemple de réalisation                            •   Const/static/reinter
       ▪    Interaction avec l’élision &                          pret_cast/C cast
            Contre-exemple

                                                                                                                                                                               12
Design Patterns & performance
en C++
        Objectif
        Cette formation vise à comprendre le cycle de vie des objets en C++.
        Connaître les Design Patterns pour écrire un code maintenable et
        performant. Gagner en performance en écrivant un code parallèle.             Niveau 2

                     Public                                                           AVANCÉ
                     Cette formation C++ s’adresse aux développeurs,
                     ayant une bonne connaissance de base du C++.

        Pré requis
        Pour suivre cette formation, les participants doivent disposer d’une   Niveau de satisfaction : 4,8 / 5
        expérience de programmation en C++.

                                                                                                                  13
Fiche programme – réf. : CPP-DPP
Module 1 : Cycle de vie des objets       Module 2 : Design patterns                    Module 3 : Performance et parallélisme

▪   Valeur, référence et pointeurs       ▪   Présentation                              ▪   Optimisation du compilateur
                                                •   Présentation des Design Patterns           •   Exemples
▪   Transfert
                                                •   Critique des Design Patterns               •   Coder simple pour aller vite
        •   Exemple
        •   En pratique                  ▪   Notation UML simplifiée                           •   Rappels sur les comportements
                                                                                               •   Indéfinis
        •   Exemple de réalisation       ▪   Méthodologie SOLID
        •   Contre-exemples                     •   Single Responsability Principe     ▪   Architecture moderne des processeurs
                                                •   Open/closed Principe
▪   Optimisation et élision des copies                                                 ▪   Array of structure vs Structure of arrays
                                                •   Liskov Substitution Principe
        •   Exemple
                                                •   Interface Segregation Principe     ▪   Calculs parallèles
        •   Conditions
                                                •   Dependency Inversion Principe
        •   Utilité                                                                    ▪   Design parallèle en C++
                                         ▪   Design patterns du C++                            •   Accès concurrents
▪   Règle du zéro                               •   RAII                                       •   Passage de valeurs
▪   Comportements indéfinis                     •   CRTP
        •   Définition                   ▪   Design patterns généraux
        •   Exemples                            •   Itérateurs
                                                •   Observateur
▪   Programmation générique
                                                •   Singleton
                                                •   Stratégie
                                                •   Décorateur
                                                •   Visiteur
                                                •   Fabrique
                                                •   Fabrique abstraite

                                                                                                                                       14
Bonnes pratiques & design patterns
en C++
         Objectif
         Cette formation vise à comprendre le cycle de vie des objets en C++,
         acquérir des bonnes pratiques pour produire un code maintenable,
         consolider son code en reconnaissant des structures et des modèles
         rencontrés fréquemment pour résoudre certains problèmes.
                                                                                       Niveau 2
                      Public
                      Cette formation C++ s’adresse aux développeurs,                   AVANCÉ
                      ayant une connaissance de base du C++.

         Pré requis
         Pour suivre cette formations, les participants doivent disposer d’une
         expérience de programmation en C++.                                     Niveau de satisfaction : 4,8 / 5

                                                                                                                    15
Fiche programme – réf. : CPP-BPDP
Module 1 : Cycle de vie des objets            Règle du zéro                                   Référence invalide                          Notation UML simplifiée
                                                                                                     ▪ Exemple
Valeurs, références et pointeurs                      ▪   Historique                                                                      Méthodologie SOLID
                                                                                                     ▪ Extension de la durée de vie des
        ▪ Valeur                                      ▪                                                  variables temporaires
                                                          Règles de 3, 5, 0                                                                      ▪   Single Responsibility Principe
                •     Types fondamentaux,                                                            ▪ Itérateurs et modification de
                      classes et structures
                                              Comportement indéfinis                                     conteneur                               ▪   Open/Closed Principe
                •     Portée                                                                                                                     ▪   Liskov Subsitution Principe
                •     Cycle de vie                    ▪   Définition & explication            Fuites mémoire
                                                      ▪   Exemples                                    ▪ Définition / exemples                    ▪   Interface Segregation Principe
       ▪    Référence : définition
       ▪    Pointeur : définition                                                                     ▪ Comment les éviter ?                     ▪   Dependency Inversion Principe
       ▪    Mémoire                                                                                   ▪ Présentation de Valgrind
                                              Module 2 : Bonnes pratiques                                                                 Design Patterns du C++
                •     La pile / le tas                                                        Accès mémoire non protégés                         ▪   RAII
                •     Implications sur la     Commentaires dans le code                              ▪ Explications/intérêts
                      performance                                                                                                                ▪   CRTP
                                                      ▪   Intention vs. description du code          ▪ Responsabilité de la ressource
RAII                                                                                                 ▪ Alternatives (std::vector)         Design Patterns généraux
       ▪    Définition, exemple avec          Principe of Least Astonishment                         ▪ Application aux conteneurs
            std::vector                                                                                                                          ▪   Itérateur
       ▪    Avantages                         Namespacing                                     Std::shared_ptr vs. Std::unique_ptr                ▪   Observateur
       ▪    Notes sur la performance                  ▪   Utilité par l’exemple               ▪   Std::shared_ptr : définition et                ▪   Singleton
                                                      ▪   Utilisation                             présentation
Optimisation et élision des copies                                                                                                               ▪   Stratégie
                                                      ▪   ADL (survol)                        ▪   Std::unique_ptr : définition et                ▪   Décorateur
       ▪ Explication par l’exemple                                                                présentation
       ▪    Condition                         Conversions implicites / explicites                                                                ▪   Visiteur
                                                                                              ▪   Conseils
       ▪    Utilité                                   ▪   Implicites                                                                             ▪   Fabrique
                                                                                              Module 3 : Performance et parallélisme
                                                              •   Explications / exemple                                                         ▪   Fabrique abstraite
Transfert                                                                                     Présentation
                                                              •   Dangers
       ▪    Explication par l’exemple                                                                ▪ Exemples
       ▪    Comment faire?                            ▪   Explicite
                                                                                                     ▪ Coder simple pour aller vite
       ▪    Exemple de réalisation                            •   Const/static/reinter               ▪ Rappels sur les comportements
       ▪    Interaction avec l’élision &                          pret_cast/C cast
                                                                                                     ▪ Indéfinis
            Contre-exemple

                                                                                                                                                                          16
Transition vers C++ 14/17

         Objectif
         Cette formation permet d’approcher les éléments spécifiques des normes
         C++14 et C++17 à partir d’une base de code C, C++98 ou C++11.

                                                                                            Niveau 2
                      Public
                      Cette formation C++ s’adresse aux développeurs, techniciens,
                      et scientifiques désirant s’initier au langage C++ et sa
                      bibliothèque standard.                                                 AVANCÉ

         Pré requis
         Pour suivre cette formations, les participants doivent disposer d’une
         expérience de programmation en C++.
                                                                                     Niveau de satisfaction : 4,9 / 5

                                                                                                                        17
Fiche programme – réf. : CPP-14/17
   Introduction                                                    La bibliothèque standard
   •   Historique du langage et positionnement dans l’écosystème   •   Séquences et algorithmes standards
       logiciel actuel
                                                                   •   Fonctions anonymes
   •   C++ comme un langage multi-paradigmes
                                                                   •   Gestion du temps
   •   Axe de changement en C++14/17
                                                                   •   Outils pour le calcul numérique
   Un langage plus simple
                                                                   •   Threads et calculs asynchrones
   •   Inférence de type
                                                                   Programmation templates
   •   Boucles généralisées
                                                                   •   Inférence du type de retour
   •   Types énumérés
                                                                   •   Template variadique
   •   Liste d’initialisation
                                                                   •   Perfect Forwarding et références universelles
   •   Paires et tuples
                                                                   •   Alias de type
   •   Construction par délégation
                                                                   •   Introspection via les traits
   •   Gestion du polymorphisme : final, override
                                                                   •   Calcul à la compilation
   Gestion des ressources
   •   Ivalue et rvalue
   •   Sémantique de transfert
   •   Principe de RAII
   •   Pointeurs à sémantique riche
   •   Règle du Zéro

                                                                                                                       18
Métaprogrammation

       Objectif
       Cette formation permet de découvrir et de mettre en œuvre les idiomes
       fondamentaux de la métaprogrammation en C++14 et en C++ 17.

                                                                                          Niveau 2
                    Public
                    Cette formation C++ s’adresse aux développeurs, techniciens,
                    et scientifiques désirant s’initier au langage C++ et sa
                    bibliothèque standard.                                                 AVANCÉ

       Pré requis
       Pour suivre cette formations, les participants doivent disposer d’une
       bonne maitrise du langage C++.
                                                                                   Niveau de satisfaction : 4,8 / 5

                                                                                                                      19
Fiche programme – réf. : CPP-META
   Introduction                                              Manipulation de code
   •   Impact de la métaprogrammation C++ comme un langage   •   Duplication de code
       méta-programmable
                                                             •   Génération conditionnelle : Sfinae
   Technique de base
                                                             •   Génération conditionnelle : Tag
   •   Template de fonction et de base
                                                             •   Dispatching
   •   Spécialisation et spécialisation partielle
                                                             •   Génération : if constexpr
   •   Inférence du type de retour
                                                             Applications
   •   Template variadique
                                                             •   Fonctions génériques contraintes
   •   Perfect Forwarding et références universelles
                                                             •   Détections de plateformes
   •   Alias de type
                                                             •   Programmation générative
   Manipulation de type
   •   Notion de traits
   •   Introspection
   •   Génération de type
   •   Détection d’interface
   •   Erreur de compilation via static_assert
   •   Séquence de types et algorithmes associés

                                                                                                      20
Autres langages

-   PYTHON : Premier pas vers Python
-   CUDA : Programmation avec NVIDIA CUDA
-   Calculs performants avec FORTRAN

                                            21
Premier pas vers Python

         Objectif
         Cette formation permet d’aborder les bases du langage Python en utilisant
         la dernière version du langage.

                                                                                              Niveau 1
                      Public
                      Cette formation s’adresse aux développeurs,
                      techniciens et scientifiques désirant se familiariser avec les
                                                                                       INTERMÉDIAIRE
                      idiomes Python et développer une application en Python.

         Pré requis
         Pour suivre cette formations, les participants doivent disposer d’une
         expérience d’un de programmation.                                             Niveau de satisfaction : 4,5 / 5

                                                                                                                          22
Fiche programme – réf. : PYT-PP
   Introduction                                  Bibliothèque standard
          ▪   Objet du langage                          ▪   Utiliser les fichiers
          ▪   Pourquoi un langage interprété ?          ▪   Les arguments en ligne de commande
                                                        ▪   La date et l’heure
   Programmer en Python                                 ▪   Génération de nombres aléatoires
          ▪   Prise en main de l’interpréteur           ▪   Lecture et écriture de fichiers JSON et CSV
          ▪   Structures de contrôle
          ▪   Gestion des erreurs de syntaxe     Structurer son programme Python
                                                        ▪   Script vs module
   Aspect impératif                                     ▪   Notion de packages
          ▪   Principes généraux des fonctions          ▪   Les Doc string
          ▪   Arguments de fonctions                    ▪   Le style PEP8
                                                        ▪   Test unitaire et benchmark

   Structures de données
          ▪   Chaine de caractères               Aspect orienté objet
          ▪   Liste, Tuple, Dictionnaire                ▪   Notion de classe
          ▪   Autres collections                        ▪   Données et fonctions membres
                                                        ▪   Notion de visibilité
                                                        ▪   Interface et héritage

                                                                                                          23
Programmation avec NVIDIA CUDA

        Objectif
        Cette formation permet de se familiariser avec les outils et stratégies de
        programmation parallèle sur cartes graphiques programmables via le
        langage CUDA.
                                                                                           Niveau 2
                     Public
                     Cette formation C++ s’adresse aux développeurs,
                                                                                            AVANCÉ
                     techniciens et scientifiques désirant connaître les principes
                     généraux des GPGPUs.

        Pré requis
        Une première expérience du langage C++ est nécessaire.                       Niveau de satisfaction : 5 / 5

                                                                                                                      24
Fiche programme – réf. : CUDA-PROG
   Introduction                                                     Stratégie d’optimisation
          ▪   Historique, évolution                                        ▪   Adaptation de la configuration du kernel à
          ▪   Intérêts du GPU et de CUDA                                       l’architecture
          ▪   Ecosystème matériel et logiciel                              ▪   Communication et synchronisation entre threads,
                                                                               mémoire « shared »
                                                                           ▪   Recouvrement des calculs et communications
   Architecture                                                            ▪   Exemples de stratégies d’optimisation
          ▪   Architecture d’une carte graphique : GPU et mémoire
          ▪   Architecture d’un GPU : organisation des cœurs,
              mémoires (registres, shared, caches)

   Le langage CUDA
          ▪   Code « host » et « device » (kernel)
          ▪   Gestion de la mémoire du GPU, communication entre
              « host » et « device »
          ▪   Configuration et lancement d’un kernel
          ▪   Récupération des erreurs
          ▪   Mesure du temps des opérations sur la carte
              graphique
          ▪   Portage d’un code CPU vers GPU

                                                                                                                                 25
Calculs performants avec FORTRAN

        Objectif
        Cette formation vise à acquérir les bases de Fortran et une compréhension
        des architectures matérielles pour pouvoir écrire du code performant.
        Connaître les réflexes pour écrire un code performant. Gagner en                   Niveau 2
        performance en connaissant son matériel et les contraintes qu’il impose
        au code.

                     Public                                                                 AVANCÉ
                     Cette formation Fortran s’adresse aux développeurs,
                     ayant une connaissance de base du Fortran et/ou en
                     algorithme.

        Pré requis                                                                  Niveau de satisfaction : 4,8 / 5
        Pour suivre cette formations, les participants doivent disposer d’une
        expérience de programmation en Fortran.

                                                                                                                       26
Fiche programme – réf. : FOR-CP
Partie 1 : Les bases de Fortran               Partie 2 : Architectures des ordinateurs          Partie 3 : Outils d’optimisation                 Partie 4 : Bibliothèque de calcul
Types                                         Architectures générale d’un processeur            Flags intéressants pour la compilation           BLAS
        ▪   Types de base                            ▪   Notion de SIMD                         VTUNE                                                   ▪   BLAS 1, 2, 3
        ▪   Types dérivés                            ▪   Opérations sur les nombres                                                                     ▪   MKL
                                                                                                GNU Perf
                                                             •     Représentation IEEE
Modules                                                                                                 ▪   Utilisation                          FFTW
                                                             •     Nombres dénormaux
Orienté objet                                                •     Types natifs à la puce               ▪   Les flamegraphs                      Interfaçage avec d’autres langages
        ▪   Méthodes                                                                            Réflexes d’optimisation                                 ▪   iso_c_binding
                                              Accès aux caches
        ▪   Surchage de fonctions                                                                       ▪   Roofline model                              ▪   Présentation des intrinsics
                                                     ▪   Parcours de données                                                                                utilisables en C
Mémoire                                              ▪   Row major / column major                               •   Utilité
        ▪   La pile / le tas                                                                                    •   utilisation
                                                     ▪   Tuilage
        ▪   Implications sur la performance                                                             ▪   Boucles et branchements
                                              Pipeline du processeur                                            •   Fusion de boucles
Allocations dynamiques                               ▪   Répercussion sur les boucles                           •   Fission de boucles
        ▪   Allocate                                         •     Utilisation de if dans les                   •   Extraction des
        ▪   Allocated                                              boucles                                          branchements
        ▪   Deallocate                        Structures de données                                             •   Extraction des cas limites
                                                                                                                    (bords d’une image par
        ▪   Move_alloc                               ▪   Array of structures                                        exemple)
Pointeurs                                            ▪   Structure of Arrays                            ▪   Approximations numériques
                                                                                                                •   Algorithmes adaptés
                                                                                                                •   Précision variable
                                                                                                        ▪   Organisation des données
                                                                                                                •   Tableau vs. Table de
                                                                                                                    hachage

                                                                                                                                                                                 27
Agenium, un membre de :

                              10 rue des Gaudines
                 78100 Saint-Germain-en-Laye – France

                          formation@agenium.com
                          www.agenium-campus.fr

                         Virginie PIGEAT
                     Responsable formation
                          07 87 10 03 92
                 virginie.pigeat@agenium.com

La certification qualité a été délivrée au titre de la catégorie d’action suivante :
ACTIONS DE FORMATION                                                                         Enregistrée sous le numéro 117 884 289 78, cet enregistrement ne vaut pas agrément de l’Etat   28
Vous pouvez aussi lire