Les Webinaires CC-FR

Le centre de compétence CC-FR organise des webinaires techniques afin de vous accompagner à développer vos compétences sur les technologies de HPC, HPDA, IA et QUANTIQUE. Retrouvez la programmation 2025 de nos webinaires ainsi que les replay.

Participez à nos prochains webinaires !

  • 30-janv.-2025 – 10.AM : Gray Scott Thursdays : Presentation of the Gray Scott School 2025 This webinar will present news of this third edition, the schedule of 2025 and the Gray Scott Thrusdays, weekly webinars about technical topics of the school. By Pierre Aubert, LAPP/CNRS – Replay

  • 6-févr.-2025 – 10.AM : Gray Scott Thursdays : Unit tests, a philosophy and help on our applications – Developing a software over a long period, at many is one of the big challenge of moderne sciences. The unit test philosophy is one helper on this road. It helps keeping pleasure over the development en ensure having something working along the path. If it has been originally developed for engineering in industry, it also gives to the project the agility required to adapt when we take unknown explorative paths like in pure research or R&D. This course will give a feedback over the last 13 years by applying the unit test philosophy on my own researches as PhD. student, post-doc and research engineer. I will not only focus on the technical aspects, but probably more on what we humanly gain on that path. By Sébastien Valat, INRIA – Replay

  • 13-févr.-2025 – 10.AM : Gray Scott Thursdays : CPU Architecture – The internal organization of modern CPU is complex and partly kept secret. But performances of programs executions are directly linked to it. Thus, to optimize computing programs, knowing what is under the hood is quite interesting. By Hadrien Graslan, IJCLab – Online information & registration

  • 20-févr.-2025 – 10.AM : Gray Scott Thursdays : Computing precision – We compute, idealy fast with simple obects (we call them ‘primitive types’) : floating point numbers. Float or double, some languages call them Real. This webinar will highligth some surprising aspects of their behaviour. These numbers which can be represented as floating point and induced errors or the other. Moreover, defferent use cases will be presented to spot traps of floating point computing, and find the perfect balance between performance, precision and correction. An important point is the difference of performance which appears on several hardwares when exotic numbers appears in the computation such as denormals, NaN, inf. By Vincent Lafage & Hadrien Grasland, IJCLab – Online information & registration

  • 27-févr.-2025 – 10.AM : Gray Scott Thursdays : Memory allocation, why and how to profile applications – Sometimes memory has become a major problem in applications, with its bandwidth but also by the incresing size needed by more and more complex and dynamic applications. So, how to track these errors and point problematic patterns ? How to find where the memory is consumed when the application reaches the hardware limit ? After my PhD on memory management in HPC context (NUMA, parallel, etc) I had the opportunity to develop two profilers (malloc and numa) now open-sources for C/C++/Fortran and Rust. I will briefly present these tools with some examples and expected observations. By Sébastien Vlaat, Inria – Online information & registration

  • 6-mars-2025 – 10.AM : Gray Scott Thursdays : Modern C++ CPU computing with std::algorithm – Nowadays, hardware becomes more and more complex. Developing efficient programs on all these architectures becomes also more and more difficult. Several solutions are available. Using specialised libraries for one or an other achitecture, but which one to choose ? C++ 17 introduces high level algorithms to abstract the hardware, so classic implementations can be simplified to vectorize and parallelize computation. This deeply simplifies program which uses this method. Since these algorithms rely on the compiler, we will see in a future webinar how to use a specialised compiler (such as nvc++) to compile a C++17 program directly on GPU without any other modification. By Pierre Aubert, LAPP/CNRS – Online information & registration

  • 13-mars-2025 – 10.AM : Gray Scott Thursdays : The Rust language – The offer of programming languages for computing may be huge on a quick overview. But when we are a bit more demanding on it (generalist language in term of hardware and kind of applications, programs relativelly simple to optimise, which good scalability on big project…) we finaly found a place which is traditionnally the world of C++. Nowadays, Rust tries to change this established order. In this presentation, we will see how Rust innovates compare to its ancestor, and why this language could pretend to replace C++ on computing applications. By Hadrien Graslan, IJCLab – Online information & registration

  • 27-mars-2025 – 10.AM : Gray Scott Thursdays : GPU Architecture – Nowadays, computing uses more and more graphic processeurs, or GPU. This webinar will be a deep dive into their hardware architectures, their common points and differences with CPU (presented before) and behaviour of recent drivers, the impact of the expressed parallelism on performances and some methods to get both flexibility in development and performances. By Pierre Aubert, LAPP/CNRS – Online information & registration

  • 3-avr.-2025 – 10.AM : Gray Scott Thursdays : Sycl on CPU and GPU – Without too much technical details, we will see how SYCL evolves in the heterogeneous programming world of C++ : between first steps of C++ standard, CUDA performances and Kokkos library. We will start with SYCL’s promise and mooving code between several hardware architectures such as CPU, GPU and FPGA. Finaly, we will present the program of the summer school about SYCL. By David Chamont, IJCLab – Online information & registration

  • 10-avr.-2025 – 10.AM : Gray Scott Thursdays : Fortran on CPU and GPU – FORTRAN with the good pronounciation can rhyme with dinosaur was replaced in silence by Fortran (90), at the end of the previous century. Knocked out by languages of the internet bubble, its children are back at the front of the stage. We will have an overview of modern Fortran, how to exploite parallelism, vectorization and GPUs with this language dedicated to computing and its integration with development pipelines : build and unit tests. The grandeur and misery of self-parallelization. After an overview of modern capacities of post-90 Fortran, we will put to the test claims of compilers about vectorization, parallelization and GPU-ize all the concurency we can express with modern syntaxes. And eventually without the need of OpenMP or OpenACC instructions. The example came from a long time ago, three little photons, will be our test bench. By Vincent Lafage, IJCLab – Online information & registration

  • 17-avr.-2025 – 10.AM : Gray Scott Thursdays : Modern C++ GPU computing with std::algorithm and CUDA – In C++, GPU computing evoled drastically in 2020 when NVidia announced its compiler, nvc++, could compile C++ 17 computing directly on GPU without the need for the developer to use extra libraries such as SYCL, Kokkos, etc. Now, nvc++ can also deal with C++20 and Intel came in the race with dpc++. In this webinar, we will see how to compute on GPU with C++17 and C++20. Common ponits and differences with other approches, such as CUDA, and its compatibility with C++17 on CPU as we mentionned is a previous webinar. By Pierre Aubert, LAPP/CNRS – Online information & registration

  • 24-avr.-2025 – 10.AM : Gray Scott Thursdays : EVE : a C++ 20 computing library on CPU – SIMD instructions sets are a must have in all processors achitectures since the end of the 90s. Unfortunately, their manual usage or their use through autovectorizer are not always optimal. We will introduce EVE, a library which eases vectorization for C++ 20. It aims :
    • to play with modern idioms of C++20
    • to provide more than 200 pre-vectorized mathematical functions
    • to support Intel, ARM and PPC
    • to integrate in codes based on algorithms
    • We will mainly present the interface and attainable results with EVE on simple examples. By Joël Falcou, LISN/Code Reckons –Online information & registration

  • 15-mai-2025 – 10.AM : Gray Scott Thursdays : Python CPU computing (numpy, etc) – Python is a largely used in the scientific community for is simplicity of use. However, native Python is far from performances of compiled languages. Some computing libraries can be used to get clother to these performances. In this webinar we will present simple techniques to compute with numpy on CPU. We will also see other methods to use when numpy is not enough. In particular, just in time compiling libraries such as Numba, and multi-threading. By Alice Faure, LUPM, Nabil Garroum, LPNHE & Jean-Marc Colley, LPNHE – Online information a registration

  • 22-mai-2025 – 10.AM : Gray Scott Thursdays : Rust on CPU and GPU – In the Gray Scott webinar of march 13th we saw how Rust innovates on C++, and why it could be interesting to use this language for computing tasks. If these arguments convinced you, it is time to take action. In this webinar, we will see how to compute with Rust on CPU and GPU. Which will be the perfect excuse to talk about the maturity of softwares components in the Rust ecosystem. By Hadrien Graslan, IJCLab – Online information & registration

  • 5-juin-2025 – 10.AM : Gray Scott Thursdays : Python GPU computing (Cunumeric, Legate, Tensorflow) – How to use GPU to speed up computing with Python ? In this webinar we will study possibles senarios to guide you to the library which fit your needs. We will see basic principle of each of them, and the Gray Scott summer school will give a deeper vision of their use. We will present them by level of integration :
    • for high level : Nvidia CuNumeric, Intel DPNP, JAX, and PyTorch allow to keep practically the same code as the CPU version
    • for intermediate level : CuPy library provides access to advanced digital functionnalities, but needs specific code for the GPU
    • for low level : PyCUDA and Numba for GPU provide basic functionnalities on tables.
    • We will also present associated profiling tools. By Alice Faure, LUPM, Nabil Garroum, LPNHE & Jean-Marc Colley, LPNHE – Online information & registration

  • 12-juin-2025 – 10.AM : Gray Scott Thursdays : Feedback on the GTC 2025 – This webinar will present news from GTC 2025, in hardwares, softwares, compilers, computing libraries, etc By Pierre Aubert, LAPP/CNRS – Online information & registration

  • 19-juin-2025 – 10.AM : Gray Scott Thursdays : From CUDA to SYCL – Strategies and migration tools – Using SYCL opens the doors for maintenance and evolution of the computing programs on accelerators. Nevertheless, today, many code base still massively use proprietary tools such as CUDA. In this presentation, we will draw up a parallel between fundamentals elements of these two technologies and see whi this transision can be automatized, or at least well simplified with SYCLOMATIC. By Joël Falcou, LISN – CODE RECKONS – Online information & registration

  • 2025 : REX (Retour of Experience) HPC/AI DAY on climate, energy and Healcare : (registration coming soon)
    • Organized with NCC Spain and Montenegro, this webinar will present you :
      • a morning dedicated to Academic and Public Administration (presentation of use cases)
      • an afternoon dedicated to the industry (presentation of use cases)

  • 2025 – European Exascale HPC focus SkyCAB project, organized with NCC Germany, Altair and Kitware, University of Aachen (date and registration coming soon)

Et retrouvez ici les 37 webinaires que vous auriez manqué en 2024….

  • 16/12/2024 – Harnessing HPC and AI: Open Source Innovations and Real-World Applications, in english. This event will focus on using open-source tools, including Scikit-learn, in the HPC ecosystem and showcase practical AI and HPC applications through a series of compelling case studies presented by experts from multiple European National Competence Centres (NCCs) – NCC France, NCC Austria, NCC Netherlands and NCC Spain.
  • 04/12/2024 – Webinar on New Accelerated Architectures – Artificial Intelligence at the service of HPC, CERFACS
  • 07/11/2024 – Workshop on Guix in High-Performance Computing, Bordeaux, France
  • 16/10/2024 – HPC pour la simulation numérique et l’IA sur les supercalculateur régionaux, CRIANN
  • 15/10/2024 – Presentation NCC France at EuroCC 2 CASTIEL Workshop event on Ideas of engagement and interaction tracking, TERATEC
  • 08/10/2024 – Simulation based on HPC resources with visualization with open-source Software, in english (Replay) “Discover what happens when you drop your cell-phone: High-fidelity simulations with OpenRadioss & ParaView” Join us for this insightful webinar where we will introduce the OpenRadioss solver and delve into the fundamentals of explicit dynamics. Discover the wide range of applications for this cutting-edge technology, from automotive safety to healthcare and consumer goods. We’ll demonstrate how high-fidelity simulation results can be visualized using ParaView, including stunning photo-realistic rendering.
  • 4/10/2024 – Talk during a webinar “Jupyter Notebooks and HPC” organized by Humanum Research Infrastructure, CRIANN
  • 17/06/2024 – Café Techno Quantique, Infos

  • 13/06/2024 – 10h/11h : Retour sur la conférence de Nvidia GTC 2024 – Partie 2, présenté par Pierre Aubert, LAPP, Replay
    Dans cet exposé, Pierre présentera brièvement les nouveautés de la GTC 2024 (Nvidia’s GPU Technology Conference). Cette conférence a mis en lumière une grande varièté d’optimisations tant hardware que software qui rendent possible un nouveau passage à l’échelle en terme de calcul et de simulation. Cette conférence a mis en lumière une grande varièté d’optimisations tant hardware que software qui rendent possible un nouveau passage à l’échelle en terme de calcul et de simulation.
    Ce webinaire présentera les mises à jour des technologies et leurs implications en terme de développement, de consommation électrique, d’architecture et bien entendu de calcul (le webinaire courant).
    Ce webinaire est la suite directe de la première partie du 6/6/24. Les nouveautés Hardware et Software annoncées lors que la GTC 2024 y seront présentées. Différentes méthodes de calcul sur GPU seront comparées ainsi que les mises à jour pour les langages C++, Fortran, Python et Rust et leur utilisation dans l’écosysteme NVidia.

  • 12/06/2024 : CASTIEL First workshop “industry sector of the month” focused on Environment/climate/weather : Presentation of 2 NCC France success stories (RiskWeatherTech and Prolog Ingenierie)

  • 06/06/2024 – 10h/11h : Retour sur la conférence de Nvidia GTC 2024 – Partie 1, présenté par Pierre Aubert, LAPP, Replay
    Cette première partie présentera les hardwares et sorfwares NVidia depuis la GTC 2020 jusqu’à la GTC 2023 ainsi que leurs retours d’expériences discutées lors de la GTC 2024. Cette présentation est l’occasion de se remémorer les différentes technologies annoncées lors des dernières GTC afin de mieux apréhender les évolutions apportées par la GTC 2024.
  • 24/05/2024 – Conference attendance (online), “Deep-Learning pour la science” organized by CNRS (Idris and Fidle).
  • 23/05/2024 – 10h/11h : De CUDA à SYCL- Stratégies et Outils de Migration, présenté par Joël Falcou, LISN – CODE RECKONS, Replay
    L’utilisation de SYCL ouvre de nombreuses perspectives pour la maintenance et l’évolution de code numérique sur accélérateurs. Néanmoins, aujourd’hui, de nombreuses bases de code utilisent massivement des outils propriétaires comme CUDA. Dans cette présentation, nous allons  dresser un parallèle entre les éléments fondamentaux des deux technologies et voir comment cette transition peut être automatisée ou du moins grandement simplifié avec SYCLOMATIC.

  • 16/05/24 -10h/11h : Python sur GPU : cunumerics / Legate / Tensorflow, présenté par Alice Faure, LUPM et Jean-Marc Colley, CNRS, Replay
    Comment utiliser une carte GPU pour accélérer un calcul numérique avec Python? Lors de cette présentation nous allons examiner les possibilités offertes afin de vous guider vers la bibliothèque qui répond à vos besoins. Nous verrons les principes de base de chacune d’elles, et la future école Gray-Scott donnera une vision plus approfondie de leurs utilisations. Nous les présenterons par niveau d’intégration : pour le haut niveau, Nvidia CuNumeric, Intel DPNP, JAX, et PyTorch permettent de garder un code quasi identique à la version CPU. Pour le niveau intermédiaire, la bibliothèque CuPy permet un accès à des fonctionnalités numériques avancées, mais nécessite un code spécifique pour le GPU. Enfin, pour le bas niveau, les bibliothèques PyCUDA et Numba pour GPU fournissent les fonctionnalités de base sur les tableaux. Nous évoquerons également des outils de profilage associés.

  • 25/04/24 -10h/11h : Calculer sur CPU et GPU en Fortran avec NVfortran et OpenACC, présenté par Vincent Lafage, CNRS, Replay
    Calculer sur CPU et GPU en Fortran avec NVfortran et OpenACC « Grandeur et misère de l’autoparallélisation »
    Après avoir survolé les sémillantes capacités de ce langage moderne qu’est Fortran post-90, nous allons mettre à l’épreuve les prétentions affichés par les compilateurs : vectoriser, paralléliser et gpuifier toute la concurrence que nous aurons su exprimer à travers les syntaxes modernes. Et éventuellement sans recourir aux directives pointilleuses d’OpenMP/OpenACC. L’exemple tiré du fond des âges, les trois petits photons, nous servira de tapis de course initiatique.

  • 18/04/24 -10h/11h : Calculer avec Rust sur CPU et GPU, présenté Hadrien Grasland, IJClab, Replay
    Durant le webinaire Gray-Scott du 29 février, nous avons vu sur quels plans Rust innove par rapport à son ancêtre C++, et pourquoi il peut être intéressant d’utiliser ce langage pour des tâches calculatoires. Si cet argumentaire vous a convaincu, il est maintenant temps de passer à l’action. Dans ce webinaire, nous allons donc voir comment, concrètement, on effectue divers travaux de calcul courants avec Rust, sur CPU et GPU. Ce qui sera le prétexte parfait pour aborder dans un deuxième temps la question essentielle du niveau de maturité des briques logicielles de l’écosystème de calcul Rust.

  • 11/04/24 -10h/11h : Calculer avec Numpy en Python, présenté par Alice Faure, LUPM et Jean-Marc Colley, CNRS, Replay
    Python est un langage très largement utilisé dans la communauté scientifique pour sa simplicité d’utilisation. Cependant, le Python natif est loin des performances des langages compilés. Il existe toutefois des bibliothèques de calcul qui permettent de se rapprocher de ces performances. Dans ce webinaire, nous allons présenter les techniques de base pour calculer efficacement avec numpy sur CPU. Nous verrons également d’autres techniques à utiliser lorsque numpy ne suffit plus, notamment les bibliothèques de compilation à la volée comme Numba, et le multi-threading.

  • 04/04/24 -10h/11h : Bibliothèque de calcul Eve en C++ 20, présenté par Joël Falcou (LISN – CODE RECKONS), Replay
    Les jeux d’instructions SIMD sont un must have de toutes les architectures de processeurs depis la fin des années 90. Hélas, leur utilisation manuelle ou au travers d’un auto-vectorisateur laisse souvent à désirer. Nous allons ici présenter EVE, une bibliothèque d’aide à la vectorisation pour C++20 dont les objectifs sont de jouer le jeu des idiomes du C++ moderne, de fournir plus de 200 fonctions mathématiques pré-vectorisées, de supporter Intel, ARM et PPC, de s’intégrer dans des codes à bases d’algorithmes. Nous allons principalement présenter l’interface et les résultats atteignables avec EVE sur des exemples simples.

  • 28/03/24 -10h/11h : Calculer sur GPU en C++ 20 avec NVC++ et CUDA, présenté par Pierre Aubert, LAPP, Replay
    En C++, le calcul sur GPU a évolué drastiquement en 2020 lorsque NVidia a annoncé que son compilateur, nvc++, était capable de compiler un calcul en C++ 17 directement sur GPU sans que le développeur ne soit obligé de passer par des bibliothèques tierces (Sycl, Kokkos, etc). Depuis, nvc++ supporte également C++20 et Intel est entrée dans la course avec dpc++. Nous verrons dans ce webinaire comment calculer directement sur GPU en C++ 17 et C++ 20. Les points communs de cette méthode avec des approches plus classiques comme CUDA mais aussi leurs différences et la compatibilité avec l’approche C++ 17 standard pour CPU que nous avons vu dans un webinaire précédent.

  • 21/03/24 -10h/11h : Fortran (langage, OpenACC), présenté par Vincent Lafage, CNRS, Replay
    FORTRAN, qui avec la bonne prononciation rime avec dinosaure, a été remplacé dans le plus grand silence par Fortran (90), au tournant du siècle. Sorti du ring par les langages de la bulle internet, ses descendants sont de retour sur le devant de la scène.Nous survolerons les capacités du Fortran moderne, mais aussi comment exploiter le parallélisme, la vectorisation et les GPU avec ce langage dédié au calcul, et son intégration dans les chaînes de développement logiciel : build, test unitaire. 

  • 14/03/24 -10h/11h : Calculer avec Sycl en C++ 20 sur CPU et GPU, présenté par David Chamont, IJClab, Replay
    Nous verrons comment SYCL se positionne dans le paysage de la programmation hétérogène C++ : entre les premiers pas du standard C++, les performances de CUDA, et la bibliothèque Kokkos. Nous commencerons à examiner la promesse de SYCL de faciliter le portage de code entre les différentes architectures matérielles que sont les CPU, les GPU, et les FPGA. Enfin, nous présenterons le programme proposé à la Gray Scott School.

  • 08/03/24 -10h/11h : Profilage de compilation C++ avec crofiler, présenté par Hadrien Grasland, IJClab, Replay
    En C++, on peut faire un usage détourné des templates et de leurs spécialisations pour effectuer des calculs et transformations de code au moment de la compilation d’un programme. Certaines bibliothèques utilisent cette possibilité pour optimiser leurs performances d’exécution. Mais ce faisant, elles augmentent aussi la charge du travail du compilateur. Au point que la compilation d’une application peut devenir extrêmement lente, ou même consommer tellement de RAM qu’elle en devient impossible. Il faut alors optimiser les performances de compilation du code. Cette tâche est plus difficile qu’il n’y paraît au premier abord, et c’est ce qui a conduit au développement de crofiler, un outil d’analyse des performances de compilation basé sur le compilateur C++ clang.

  • 07/03/24 -10h/11h : Architecture GPU, présenté par Pierre Aubert, LAPP, Replay
    De nos jours, le calcul intensif utilise de plus en plus les processeurs graphiques, ou GPU. Nous verrons dans ce webinaire leur architecture matériel, leurs points communs et différences avec les CPU abordés précédemment ainsi que le comportement des pilotes récents, l’impact du parallélisme exprimé sur les performances obtenues et quelques méthodes qui permettent d’avoir de la flexibilité dans le développement en conservant les performances.

  • 29/02/24 -10h/11h : Le langage Rust, présenté par Hadrien Grasland, IJClab, Replay
    L’offre de langages de programmation pour le calcul numérique peut sembler pléthorique pour le non initié. Mais dès qu’on est un peu exigeant sur la marchandise (langage généraliste en termes de cibles matérielles et types d’applications, programmes relativement faciles à optimiser, passe bien à l’échelle sur les gros projets…), on se retrouve vite sur un terrain qui est traditionnellement la chasse gardée du C++. Aujourd’hui, Rust tente de bousculer cet ordre établi. Dans cette présentation, nous allons voir sur quels plans Rust innove par rapport à son ancêtre, et pourquoi ce langage est un solide prétendant au titre de remplaçant de C++ pour les applications calculatoires.

  • 27/02/24 -10h/11h : Quantum Computing : From Research to Industy, NCC France & Netherlands, Replay
    This webinar organized jointly by NCC France and NCC Netherlands aims to introduce the technologies of Quantum Computing and present the challenges and perspectives. After an introduction, this webinar will address quantum gate-based computing, annealers, analog computing, and quantum simulation.

  • 22/02/24 -10h/11h : Calcul en C++ 17/20/23, présenté par Pierre Aubert, LAPP, Replay
    De nos jours, le hardware devient de plus en plus complexe. Développer des programmes efficaces sur toutes ces architectures devient alors de plus en plus difficile. Plusieurs solutions sont alors possibles. Utiliser des bibliothèques spécialisées pour telle ou telle architecture, mais laquelle choisir ? Le C++17 introduit des algorithmes haut niveau qui permettent de s’affranchir des différents indices habituels qui doivent être passés lors de la compilation afin de vectoriser ou de paralléliser un calcul. Cela simplifie profondément les programmes qui utilisent cette méthode et permet de tirer pleinement parti des optimisations du compilateur. Comme les algorithmes à partir de C++17 se reposent sur le compilateur. Lors d’un prochain webinaire nous verront comment l’utilisation d’un compilateur spécialisé pour les GPU (comme NVC++) permettra au programme de s’exécuter également sur GPU sans aucune modification.

  • 15/02/24 -10h/11h : Profilage mémoire (MALT, NUMAPROF), présenté par Sébastien Valat, INRIA, Replay
    Allocations mémoires, pourquoi et comment profiler (MALT, NUMAPROF) : La mémoire est parfois devenue un problème majeur dans les applications, de par la question des performances d’accès mais aussi par les volumes géré au sein d’application souvent de plus en plus dynamiques et complexes. Se pose alors la question, comment se rendre compte de ses erreurs et de patterns problématiques facilement corrigeable. Comment trouver où elle est consommée lorsque l’on atteint les limites de sa machine ?

  • 08/02/2024 – Accelerating scientific breakthroughs with AI, WAICF trade fair, Cannes, Animation of a Workshop with HPE

  • 08/02/24 -10h/11h : Précision des calculs, présenté par Vincent Lafage, CNRS, Replay
    Nous calculons, vite de préférence, avec des objets qui devraient être simples (on les qualifie même de « types primitifs ») : les nombres à virgule flottante. Float ou double, certains langages les appellent même Real. Nous aborderons quelques aspects déstabilisants de leur comportement : les nombres effectivement représentables en flottant et les erreurs induites sur les autres. De plus, différents cas d’usage seront présentés pour naviguer entre les écueils du calcul à virgule flottante, et trouver l’équilibre dans le ménage à trois de la performance, de la précision et de la correction.

  • 01/02/24 -10h/11h : Architecture CPU, présenté par Hadrien Grasland, IJClab, Replay
    L’organisation interne des CPUs modernes est complexe et en partie secrète. Mais les performances d’exécution des programmes en découlent directement. Par conséquent, lorsqu’on veut optimiser les performances de programmes calculatoires, il est utile de s’intéresser un peu à ce qui se passe sous le capot.

  • 30/01/2024 – Explore and visualize large-scale data with ParaView, François Maen, Kitware, Replay

  • 25/01/2024 – Gray Scott School: Tests unitaires, une philosophie et une aide face à son logiciel, Sébastien Valat, INRIA, Replay
  • Le développement logiciel est au cœur d’un nombre croissant de domaines de recherches aujourd’hui. Une complexité qui parfois peut nous amener à être perdus devant notre propre code, ou plus difficile celui que l’on construit à plusieurs dans le temps long. Les tests unitaires sont un des moyens inventés par le génie logiciel pour atténuer ces problèmes.

  • 23/01/2024 – HPC Platform for Enhanced OpenFOAM Performance: A Comparative Analysis, Sam Zakrzewski, Rescale, Replay

  • 19/01/2024 – 10h11h : Gray Scott School Presentation, Replay
  • Ce webinaire, présenté par Pierre Aubert, présentera toutes les nouveautés de la seconde édition de l’école Gray Scott au LAPP, les modalités de participation, de partenariat, la programmation 2024 ainsi que les jeudis Gray Scott, des webinaires techniques cadencés tout au long de l’année 2024.

Inscrivez-vous à notre newsletter pour rester informé sur les actualités du Centre de compétence CC-FR : Inscription !

Vous souhaitez proposer un webinaire, un atelier, un workshop, une conférence sur les technologies de HPC, HPDA, IA, Simulation et Quantique, contactez-nous !