CocoaHeads Rennes #1 : Grand Central DispatchCocoaHeadsRNS
Slides de la présentation "TA la découverte de Grand Central Dispatch" de la session des CocoaHeads Rennais du 21 avril 2011. Présentation assurée par Pierre Duchêne et Thomas Dupont, ingénieurs chez Niji
This course will introduce the core data structures of the Python programming language. We will move past the basics of procedural programming and explore how we can use the Python built-in data structures such as lists, dictionaries, and tuples to perform increasingly complex data analysis.
CocoaHeads Rennes #1 : Grand Central DispatchCocoaHeadsRNS
Slides de la présentation "TA la découverte de Grand Central Dispatch" de la session des CocoaHeads Rennais du 21 avril 2011. Présentation assurée par Pierre Duchêne et Thomas Dupont, ingénieurs chez Niji
This course will introduce the core data structures of the Python programming language. We will move past the basics of procedural programming and explore how we can use the Python built-in data structures such as lists, dictionaries, and tuples to perform increasingly complex data analysis.
Nouveautés JavaScript dans le monde Microsoftdavrous
Présentation delivrée le 19 mars 2015 lors du JavaScript Open Day: http://www.meetup.com/Javascript-Open-Day/events/220087351/
Au programme: les nouveautés du moteur du projet Spartan comme Web Audio ou ECMAScript 6
Introduction à la programmation lock-free en C++11 au moyen des atomics. Présentation données par Cyril Comparon lors des rencontres C++ de Montpellier (novembre 2014).
Objectif général : Acquérir les bases méthodologiques de la résolution d'un problème conduisant à la réalisation d'un programme informatique
Objectifs spécifiques :
Connaître les étapes de résolution d’un problème
Stocker et traiter des données simples
Permettre à un programme de communiquer avec l’extérieur
Contrôler le flux d’exécution des instructions
Traiter des données composites
Définir et utiliser des procédures et des fonctions
Objectif général : Prendre en main la bibliothèque JavaScript la plus utilisée
Objectifs spécifiques :
Inclure la bibliothèque
Sélectionner du contenu
Manipuler des éléments
Mettre en forme du contenu
Gérer des évènements
Utiliser des effets
Effectuer des requêtes AJAX
Ce cours est le premier en lien avec l'algorithmique présente les algorithmes et fonctions récursives ainsi que le type abstrait de données arbre. La première partie revient sur les notions de problème, algorithhme et spécification. La deuxième partie présente la récursion et de nombreux exemples. Enfin, la troisième partie présente le type abstrait de données arbre qui permet d'organiser des données de manière hiérarchique. Le cours se termine avec une introduction aux notions de backtracking et lookahead.
JavaScript est désormais omniprésent et rend possible l'écriture d'applications complexes et riches. Mais il est souvent mal connu des développeurs orientés objets classiques comme ceux pratiquant le C#, le Java ou le PHP. Cette session passera donc en revue les bases du langage JavaScript, ses spécificités comme les portées, les closures, le this différent de ce que vous pouvez connaître. Bref, vous verrez qu'il y a des pièges à éviter et qu'il ne faut pas négliger JavaScript. Il est très puissant mais potentiellement différent de ce vous connaissez déjà. Venez apprendre à le respecter avant de le maitriser!
Objectif général : Savoir créer des pages Web interactives sans trop solliciter le serveur et le réseau pour offrir une meilleure expérience utilisateur
Objectifs opérationnels :
Stocker des données à l’aide des variables
Traiter des données à l’aide des opérateurs.
Communiquer avec l’internaute à l’aide des E/S de base
Contrôler le flux d’exécution des instructions.
Réutiliser et organiser le code en créant des fonctions
Créer l’interactivité grâce à la gestion des évènements
Traiter plus facilement plusieurs données connexes grâce aux tableaux et aux objets
Traiter des chaînes de caractères avec l’objet String
Gérer les propriétés de la fenêtre avec l’objet Window
Manipuler le contenu de la page Web grâce à l’objet Document
Contrôler la saisie d’un formulaire avec l’objet Form
Initialisation dynamique en c++11 (n2660)Daniel Strul
Support de formation sur les évolutions en C++11 concernant:
- L'initialisation dynamique des variables statiques non-locales (le "static initialisation order fiasco")
- La thread-safety du singleton via les "magic statics"
- Le thread-safety du Double-Checked Locking Pattern via les atomiques
Cette présentation concerne le développement piloté par les tests (TDD, Test-Driven Development). Cette méthodologie se base sur des tests unitaires qui testent de manière indépendante des unités de code (module, procédure/fonction, classe...). En particulier, cette présentation utilise la librairie CUnit utilisée pour le langage C.
Les bases de javascript. Introduction au langage javascript. Les boucles, les fonctions, scope local et global. Accès et modification des éléments du Dom (Document object model)
C++11 introduit les fonctions lambda : qu'est-ce que c'est ? Comment (bien) les utiliser ? Voici le support d'une présentation donnée à l'occasion des rencontres C++ à Montpellier le 21 oct. 2014.
Ce cours introduit à la notion de type abstrait de données (TAD). On commence par y découvrir les principes de complexité temporelle et spatiale permettant d'analyser les performances d'une structure de données et d'algorithmes. Ensuite, le cours présente plusieurs TAD : la pile, la file, le deque et le vecteur. Enfin, il présente comment implémenter des TAD avec des structures chainées.
Ce cours présente la notion de qualité de code et comment il est possible de l'évaluer grâce à des métriques mesurables. Après avoir présenté plusieurs métriques standards, il se concentrer sur des aspects de qualité de code spécifique à l'orienté objet et présente les cinq concepts de l'orienté objet. La deuxième partie du cours présente plusieurs bonnes pratiques à avoir en programmation orientée objet, sur base d'exemples concrets.
The document discusses using Lombok and Guava annotations and utilities to simplify Java code by automatically generating boilerplate code like getters, setters, toString methods. It provides an example of how Lombok reduces a Dog class from 210 lines to just 12 lines by adding annotations, and shows how Guava provides cleaner implementations of common methods like toString and equals.
This document discusses how to foster continuous improvement through retrospectives. It begins with an agenda that covers why continuous improvement matters, what retrospectives are, and how to run them. It then discusses concepts like kaizen and gemba walks for improvement. Retrospectives are presented as an important tool for iterative development. Effective facilitation, structure, and participation are emphasized. Sample exercises and anti-patterns to avoid are provided. The document concludes by introducing a "retrospective cookbook" with additional techniques.
Nouveautés JavaScript dans le monde Microsoftdavrous
Présentation delivrée le 19 mars 2015 lors du JavaScript Open Day: http://www.meetup.com/Javascript-Open-Day/events/220087351/
Au programme: les nouveautés du moteur du projet Spartan comme Web Audio ou ECMAScript 6
Introduction à la programmation lock-free en C++11 au moyen des atomics. Présentation données par Cyril Comparon lors des rencontres C++ de Montpellier (novembre 2014).
Objectif général : Acquérir les bases méthodologiques de la résolution d'un problème conduisant à la réalisation d'un programme informatique
Objectifs spécifiques :
Connaître les étapes de résolution d’un problème
Stocker et traiter des données simples
Permettre à un programme de communiquer avec l’extérieur
Contrôler le flux d’exécution des instructions
Traiter des données composites
Définir et utiliser des procédures et des fonctions
Objectif général : Prendre en main la bibliothèque JavaScript la plus utilisée
Objectifs spécifiques :
Inclure la bibliothèque
Sélectionner du contenu
Manipuler des éléments
Mettre en forme du contenu
Gérer des évènements
Utiliser des effets
Effectuer des requêtes AJAX
Ce cours est le premier en lien avec l'algorithmique présente les algorithmes et fonctions récursives ainsi que le type abstrait de données arbre. La première partie revient sur les notions de problème, algorithhme et spécification. La deuxième partie présente la récursion et de nombreux exemples. Enfin, la troisième partie présente le type abstrait de données arbre qui permet d'organiser des données de manière hiérarchique. Le cours se termine avec une introduction aux notions de backtracking et lookahead.
JavaScript est désormais omniprésent et rend possible l'écriture d'applications complexes et riches. Mais il est souvent mal connu des développeurs orientés objets classiques comme ceux pratiquant le C#, le Java ou le PHP. Cette session passera donc en revue les bases du langage JavaScript, ses spécificités comme les portées, les closures, le this différent de ce que vous pouvez connaître. Bref, vous verrez qu'il y a des pièges à éviter et qu'il ne faut pas négliger JavaScript. Il est très puissant mais potentiellement différent de ce vous connaissez déjà. Venez apprendre à le respecter avant de le maitriser!
Objectif général : Savoir créer des pages Web interactives sans trop solliciter le serveur et le réseau pour offrir une meilleure expérience utilisateur
Objectifs opérationnels :
Stocker des données à l’aide des variables
Traiter des données à l’aide des opérateurs.
Communiquer avec l’internaute à l’aide des E/S de base
Contrôler le flux d’exécution des instructions.
Réutiliser et organiser le code en créant des fonctions
Créer l’interactivité grâce à la gestion des évènements
Traiter plus facilement plusieurs données connexes grâce aux tableaux et aux objets
Traiter des chaînes de caractères avec l’objet String
Gérer les propriétés de la fenêtre avec l’objet Window
Manipuler le contenu de la page Web grâce à l’objet Document
Contrôler la saisie d’un formulaire avec l’objet Form
Initialisation dynamique en c++11 (n2660)Daniel Strul
Support de formation sur les évolutions en C++11 concernant:
- L'initialisation dynamique des variables statiques non-locales (le "static initialisation order fiasco")
- La thread-safety du singleton via les "magic statics"
- Le thread-safety du Double-Checked Locking Pattern via les atomiques
Cette présentation concerne le développement piloté par les tests (TDD, Test-Driven Development). Cette méthodologie se base sur des tests unitaires qui testent de manière indépendante des unités de code (module, procédure/fonction, classe...). En particulier, cette présentation utilise la librairie CUnit utilisée pour le langage C.
Les bases de javascript. Introduction au langage javascript. Les boucles, les fonctions, scope local et global. Accès et modification des éléments du Dom (Document object model)
C++11 introduit les fonctions lambda : qu'est-ce que c'est ? Comment (bien) les utiliser ? Voici le support d'une présentation donnée à l'occasion des rencontres C++ à Montpellier le 21 oct. 2014.
Ce cours introduit à la notion de type abstrait de données (TAD). On commence par y découvrir les principes de complexité temporelle et spatiale permettant d'analyser les performances d'une structure de données et d'algorithmes. Ensuite, le cours présente plusieurs TAD : la pile, la file, le deque et le vecteur. Enfin, il présente comment implémenter des TAD avec des structures chainées.
Ce cours présente la notion de qualité de code et comment il est possible de l'évaluer grâce à des métriques mesurables. Après avoir présenté plusieurs métriques standards, il se concentrer sur des aspects de qualité de code spécifique à l'orienté objet et présente les cinq concepts de l'orienté objet. La deuxième partie du cours présente plusieurs bonnes pratiques à avoir en programmation orientée objet, sur base d'exemples concrets.
The document discusses using Lombok and Guava annotations and utilities to simplify Java code by automatically generating boilerplate code like getters, setters, toString methods. It provides an example of how Lombok reduces a Dog class from 210 lines to just 12 lines by adding annotations, and shows how Guava provides cleaner implementations of common methods like toString and equals.
This document discusses how to foster continuous improvement through retrospectives. It begins with an agenda that covers why continuous improvement matters, what retrospectives are, and how to run them. It then discusses concepts like kaizen and gemba walks for improvement. Retrospectives are presented as an important tool for iterative development. Effective facilitation, structure, and participation are emphasized. Sample exercises and anti-patterns to avoid are provided. The document concludes by introducing a "retrospective cookbook" with additional techniques.
The document introduces Tugdual Grall, a technical evangelist from Couchbase, and provides an agenda for his presentation on NoSQL and Couchbase Server 2.0. The agenda includes discussing why NoSQL is needed, the NoSQL landscape, document design, use cases, and an introduction to Couchbase Server 2.0. Trends like big data, cloud computing, and more data-driven mobile users are driving disruption of the database market and increased adoption of NoSQL technologies.
Fungi, bacteria, and viruses are the three main types of microbes. Fungi are usually the largest type of microbe and have hard cell walls. Bacteria are generally smaller than fungi and have soft cell walls. Viruses are the smallest type of microbe and instead of cells have a protein coat and their genetic material is a single strand instead of a nucleus. The document provides information on the key characteristics of fungi, bacteria, and viruses.
Este documento discute los aspectos éticos de la investigación. Brevemente describe los principios éticos fundamentales como el consentimiento informado, la evaluación de riesgos y beneficios, y la selección justa de participantes. También resume varios códigos y declaraciones éticas importantes como la Declaración de Helsinki y el Informe Belmont que establecen pautas para la investigación ética con seres humanos. El objetivo final es promover la dignidad y el bienestar de los participantes en la investigación.
Ce premier cours présente les notions d'objet et de classe, et le lien entre elles. Il présente aussi le premier concept clé de la programmation orientée objet, à savoir l'encapsulation des données. Les exemples sont fournis dans plusieurs langages (Python, C#, Java, C++ et PHP).
Decouvrez les particularités de JavaScript qui vous aideront à débogguer sans craindre ce langage aujourd'hui indispensable.
- la portée des variables et comment ne pas polluer l'espace global
- comprendre le mot clé this
- les particularités des fonctions
- introduction aux namespaces
Loin de la théorie vous aurez des explications pratiques et des démos de code ainsi que les bonnes pratiques.
Le développement d'applications lourdes à base de JavaScript est désormais possible. Cependant, cela requiert de bien connaître le langage en lui-même ainsi que les meilleurs patterns et pratiques établit ces 10 dernières années à travers des frameworks comme YUI ou jQuery par exemple. Vous verrez donc ici comment bien structurer votre code, comment utiliser des approches permettant de palier à certaines limitations de JS et comment également industrialiser le code grâce à la mise en place de tests unitaires.
JMS (Java Message Services) est une API qui permet aux applications Java de s'échanger des messages asynchrones par le biais d'un MOM (Message Orieneted Middleware). Cette session passera en revue l'API Java Message Services et présentera quelques retours d'expérience sur sa mise en œuvre.
Bonita Open Solution est la première solution Open Source complète de Business Process Management (BPM). Basée sur un moteur de workflow robuste, elle fournit tout l'outillage nécessaire pour créer efficacement des applications d’automatisation de processus métier, avec tous les bénéfices de l'approche BPM et une forte connectivité avec les systèmes d'informations existants.
Cette présentation introduira d'abord le concept du BPM et ses objectifs, puis une démonstration de Bonita Open Solution montrera comment elle peut être utilisée pour implémenter des applications métier. Ensuite, nous étudierons les choix et l'architecture techniques et nous verrons comment Bonita tire parti de technologies bien connues et efficaces (Eclipse RCP, Goolge Web Toolkit, Hibernate, Groovy...). Nous pourrons même donner quelques détails sur la manière dont l'équipe de Bonita utilise Scrum pour gérer le cycle de développement du produit.
Par Aurélien Pupier
GWT allows developers to create AJAX applications using Java instead of JavaScript. It provides a Java compiler that translates Java code into optimized JavaScript that can run across browsers. Key features include easy RPC, JSON handling, debugging, internationalization, and reuse of custom widgets. Some myths are that GWT is only for Java programmers or that it only works with Java backends, but it can integrate with any server technology and lower the barrier to AJAX development.
This document provides an overview and agenda for a presentation on Java EE 6 and GlassFish v3. Key points include:
- Java EE 6 and GlassFish v3 were final releases in December 2009.
- The presentation will provide an overview of the new Java EE 6 specifications and demos of JPA 2.0, Servlet 3.0, EJB 3.1, JSF 2.0, and more.
- The speakers are experts on Java EE and GlassFish with experience at Sun Microsystems and as authors and conference speakers.
- The agenda includes deep dives on the major Java EE 6 specifications and building a sample web application using many of the new features.
Comment concilier Agilité et projet au forfait ?Lorraine JUG
La gestion de projet Agile à capacité à devenir un mode privilégié de production de logiciel dans les prochaines années. Il donne une excellente visibilité sur la réalisation, et concentre les vecteurs de qualité sur le produit plutôt que sur les procédures.
Mais dans le cadre d’une sous-traitance du développement informatique, la gestion de projet agile se heurte naturellement à la notion de contrat forfaitaire. Au travers de 2 retours d’expériences de projets menés en Scrum je vous montre comment le forfait classique handicape l’agilité, mais aussi comment on peut réussir sur la base de nouveaux types de contrats.
Par Jean-François Jagodzinski
Montrer la mécanique de Scrum en l'appliquant à la session elle-même. Comme cette mécanique est mise en œuvre avec iceScrum, la session permet également de présenter un outil Open Source dédié à Scrum. Le backlog utilisé contient des sujets autour de Scrum et de l’agilité. C’est interactif : les participants sont invités à proposer des sujets pour compléter le backlog initial défini par les animateurs, à choisir ceux qui les intéressent le plus et à dire si un sujet (une "story") est terminé.
Par Claude Aubry (Aubry Conseil) & Vincent Barrier (iceScrum Technologies)
Le Comptoir OCTO - Qu’apporte l’analyse de cycle de vie lors d’un audit d’éco...OCTO Technology
Par Nicolas Bordier (Consultant numérique responsable @OCTO Technology) et Alaric Rougnon-Glasson (Sustainable Tech Consultant @OCTO Technology)
Sur un exemple très concret d’audit d’éco-conception de l’outil de bilan carbone C’Bilan développé par ICDC (Caisse des dépôts et consignations) nous allons expliquer en quoi l’ACV (analyse de cycle de vie) a été déterminante pour identifier les pistes d’actions pour réduire jusqu'à 82% de l’empreinte environnementale du service.
Vidéo Youtube : https://www.youtube.com/watch?v=7R8oL2P_DkU
Compte-rendu :
Le Comptoir OCTO - Équipes infra et prod, ne ratez pas l'embarquement pour l'...OCTO Technology
par Claude Camus (Coach agile d'organisation @OCTO Technology) et Gilles Masy (Organizational Coach @OCTO Technology)
Les équipes infrastructure, sécurité, production, ou cloud, doivent consacrer du temps à la modernisation de leurs outils (automatisation, cloud, etc) et de leurs pratiques (DevOps, SRE, etc). Dans le même temps, elles doivent répondre à une avalanche croissante de demandes, tout en maintenant un niveau de qualité de service optimal.
Habitué des environnements développeurs, les transformations agiles négligent les particularités des équipes OPS. Lors de ce comptoir, nous vous partagerons notre proposition de valeur de l'agilité@OPS, qui embarquera vos équipes OPS en Classe Business (Agility), et leur fera dire : "nous ne reviendrons pas en arrière".
Ouvrez la porte ou prenez un mur (Agile Tour Genève 2024)Laurent Speyser
(Conférence dessinée)
Vous êtes certainement à l’origine, ou impliqué, dans un changement au sein de votre organisation. Et peut être que cela ne se passe pas aussi bien qu’attendu…
Depuis plusieurs années, je fais régulièrement le constat de l’échec de l’adoption de l’Agilité, et plus globalement de grands changements, dans les organisations. Je vais tenter de vous expliquer pourquoi ils suscitent peu d'adhésion, peu d’engagement, et ils ne tiennent pas dans le temps.
Heureusement, il existe un autre chemin. Pour l'emprunter il s'agira de cultiver l'invitation, l'intelligence collective , la mécanique des jeux, les rites de passages, .... afin que l'agilité prenne racine.
Vous repartirez de cette conférence en ayant pris du recul sur le changement tel qu‘il est généralement opéré aujourd’hui, et en ayant découvert (ou redécouvert) le seul guide valable à suivre, à mon sens, pour un changement authentique, durable, et respectueux des individus! Et en bonus, 2 ou 3 trucs pratiques!
OCTO TALKS : 4 Tech Trends du Software Engineering.pdfOCTO Technology
En cette année 2024 qui s’annonce sous le signe de la complexité, avec :
- L’explosion de la Gen AI
-Un contexte socio-économique sous tensions
- De forts enjeux sur le Sustainable et la régulation IT
- Une archipélisation des lieux de travail post-Covid
Découvrez les Tech trends incontournables pour délivrer vos produits stratégiques.
L'IA connaît une croissance rapide et son intégration dans le domaine éducatif soulève de nombreuses questions. Aujourd'hui, nous explorerons comment les étudiants utilisent l'IA, les perceptions des enseignants à ce sujet, et les mesures possibles pour encadrer ces usages.
Constat Actuel
L'IA est de plus en plus présente dans notre quotidien, y compris dans l'éducation. Certaines universités, comme Science Po en janvier 2023, ont interdit l'utilisation de l'IA, tandis que d'autres, comme l'Université de Prague, la considèrent comme du plagiat. Cette diversité de positions souligne la nécessité urgente d'une réponse institutionnelle pour encadrer ces usages et prévenir les risques de triche et de plagiat.
Enquête Nationale
Pour mieux comprendre ces dynamiques, une enquête nationale intitulée "L'IA dans l'enseignement" a été réalisée. Les auteurs de cette enquête sont Le Sphynx (sondage) et Compilatio (fraude académique). Elle a été diffusée dans les universités de Lyon et d'Aix-Marseille entre le 21 juin et le 15 août 2023, touchant 1242 enseignants et 4443 étudiants. Les questionnaires, conçus pour étudier les usages de l'IA et les représentations de ces usages, abordaient des thèmes comme les craintes, les opportunités et l'acceptabilité.
Résultats de l'Enquête
Les résultats montrent que 55 % des étudiants utilisent l'IA de manière occasionnelle ou fréquente, contre 34 % des enseignants. Cependant, 88 % des enseignants pensent que leurs étudiants utilisent l'IA, ce qui pourrait indiquer une surestimation des usages. Les usages identifiés incluent la recherche d'informations et la rédaction de textes, bien que ces réponses ne puissent pas être cumulées dans les choix proposés.
Analyse Critique
Une analyse plus approfondie révèle que les enseignants peinent à percevoir les bénéfices de l'IA pour l'apprentissage, contrairement aux étudiants. La question de savoir si l'IA améliore les notes sans développer les compétences reste débattue. Est-ce un dopage académique ou une opportunité pour un apprentissage plus efficace ?
Acceptabilité et Éthique
L'enquête révèle que beaucoup d'étudiants jugent acceptable d'utiliser l'IA pour rédiger leurs devoirs, et même un quart des enseignants partagent cet avis. Cela pose des questions éthiques cruciales : copier-coller est-il tricher ? Utiliser l'IA sous supervision ou pour des traductions est-il acceptable ? La réponse n'est pas simple et nécessite un débat ouvert.
Propositions et Solutions
Pour encadrer ces usages, plusieurs solutions sont proposées. Plutôt que d'interdire l'IA, il est suggéré de fixer des règles pour une utilisation responsable. Des innovations pédagogiques peuvent également être explorées, comme la création de situations de concurrence professionnelle ou l'utilisation de détecteurs d'IA.
Conclusion
En conclusion, bien que l'étude présente des limites, elle souligne un besoin urgent de régulation. Une charte institutionnelle pourrait fournir un cadre pour une utilisation éthique.
9. 1) De quoi cette puissance est-elle faite ?
Architectures muticœurs
2) Conséquences sur la façon de coder ?
3) Quels sont les problèmes des applications
« parallèles » ?
Synchronisation
4) Comment s’y prendre pour
« synchroniser » les opérations
10. 5) De quels outils dispose-t-on ?
Java 6
Java 7
Java 8
6) Importance de l’algorithmique ?
19. Processeurs multicœurs
• Fin de la « soupe gratuite »
• La puissance de calcul augmente
par le nombre de cœurs, et non
plus par l’augmentation de la fréquence de
chaque cœur
• Apparition des GPGPU (2007)
20. Processeurs multicœurs
• Aujourd’hui
– Smartphone : 2 à 4 cœurs
– PC de bureau : 4 à 8 cœurs
– Serveur pro : 128 cœurs
• Demain
– Plateforme exascale : de 100k à 1M
nœuds
– Chaque nœud : de 1k à 10k cœurs
21. Java.util.concurrent
• API de concurrence avancée
– Dispo en Java 4 EDU.oswego
• Nouvelle approche du multithreading
– Nouvelle façon de lancer des threads
– Nouvelle façon de synchroniser les
opérations
37. Solutions aux « data races »
• Synchronisation de la modification des
variables
« garder les variables »
• Et si on ne modifie jamais nos variables ?
Systèmes immutables
39. Java Memory Model
• Objet : définir la valeur d’une variable à un
instant donné
• Règle : « toute lecture d’une variable
retourne la dernière valeur écrite dans cette
variable »
40. Java Memory Model
• Objet : définir la valeur d’une variable à un
instant donné
• Règle : « toute lecture d’une variable
retourne la dernière valeur écrite dans cette
variable »
• Monothread : contrainte sur le
fonctionnement des compilateurs &
de la JVM
41. Java Memory Model
• Objet : définir la valeur d’une variable à un
instant donné
• Règle : « toute lecture d’une variable
retourne la dernière valeur écrite dans cette
variable »
• Multithread multicœur : vrai problème !
« toute lecture … retourne
la dernière valeur écrite … »
42. Java Memory Model
• Multithread multicœur : vrai problème !
« toute lecture … retourne
la dernière valeur écrite … »
• Chronologie entre les threads / cœurs
43. Happens before
• Chronologie = créer des liens entre les
lectures et les écritures
x = 1
r1 = x
• Valeur de r1 ?
– Même thread ⇒ évident
– Threads différents : impossible de prévoir
44. Happens before
• Chronologie = créer des liens entre les
lectures et les écritures
x = 1
happens before
r1 = x
• Valeur de r1 ?
– Imposée par la JLS : r1 = 1
45. Happens before
• Règle :
Un lien « happens before » est établi
entre toute écriture synchronisée ou
volatile et toute lecture synchronisée ou
volatile qui suit
• Existence de ce lien ⇒
Javadoc (java.util.concurrent)
46. private int index ;
public void incrementonsGaiement() {
index++ ;
}
public void testonsJoyeusement() {
if (index > 10) {
System.out.println("Index est grand !") ;
}
}
47. Pas de lien
« happens before »
private int index ;
public void incrementonsGaiement() {
index++ ;
}
public void testonsJoyeusement() {
if (index > 10) {
System.out.println("Index est grand !") ;
}
}
48. private volatile int index ;
public void incrementonsGaiement() {
index++ ;
}
public void testonsJoyeusement() {
if (index > 10) {
System.out.println("Index est grand !") ;
}
}
49. Lien
« happens before »
private volatile int index ;
public void incrementonsGaiement() {
index++ ;
}
public void testonsJoyeusement() {
if (index > 10) {
System.out.println("Index est grand !") ;
}
}
50. Cas pathologique
private int x, y, r1, r2 ;
private Object lock = new Object() ;
void maMethode() { void maMethodeAussi() {
x = 1 ; synchronized(lock) {
synchronized(lock) { r1 = y ;
y = 1 ; }
} r2 = x ;
} }
51. 1) T1 prend le lock
private int x, y, r1, r2 ;
private Object lock = new Object() ;
void maMethode() { 1 void maMethodeAussi() {
x = 1 ; synchronized(lock) {
synchronized(lock) {
y = 1 ;
2 }
r1 = y ;
} r2 = x ;
} }
52. 1) T1 prend le lock
private int x, y, r1, r2 ;
private Object lock = new Object() ;
void maMethode() { 1 void maMethodeAussi() {
x = 1 ; synchronized(lock) {
synchronized(lock) {
y = 1 ;
2 }
r1 = y ;
} 3 r2 = x ;
} }
4
53. 1) T1 prend le lock
private int x, y, r1, r2 ;
private Object lock = new Object() ;
void maMethode() { 1 void maMethodeAussi() {
x = 1 ; synchronized(lock) {
synchronized(lock) {
y = 1 ;
2 }
r1 = y ;
} 3 r2 = x ;
} }
4
r2 = 1
54. 1) T2 prend le lock
private int x, y, r1, r2 ;
private Object lock = new Object() ;
void maMethode() { 1 void maMethodeAussi() {
x = 1 ; synchronized(lock) {
synchronized(lock) { r1 = y ;
y = 1 ; }
} r2 = x ;
} }
4
55. 1) T2 prend le lock
private int x, y, r1, r2 ;
private Object lock = new Object() ;
void maMethode() { 1 void maMethodeAussi() {
x = 1 ; synchronized(lock) {
synchronized(lock) { r1 = y ;
y = 1 ; ? ? }
} r2 = x ;
} }
4
56. 1) T2 prend le lock
private int x, y, r1, r2 ;
private Object lock = new Object() ;
void maMethode() { 1 void maMethodeAussi() {
x = 1 ; synchronized(lock) {
synchronized(lock) { r1 = y ;
y = 1 ; ? ? }
} r2 = x ;
} }
4
r2 = 0 ? r2 = 1 ?
57. Double
public class Singleton {
check locking
private static Singleton instance ;
Lecture non
public static Singleton synchronisée
getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton() ;
}
}
}
return instance ;
}
}
58. Variable volatile !
public class Singleton {
private volatile static Singleton instance ;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton() ;
}
}
}
return instance ;
}
}
72. Barrière de mémoire
• Une instruction assembleur
• Permet de « propager » une modification
d’un cœur à l’autre
• Invalide le cache L1, force sa relecture dans
L3 ou la mémoire
73.
74.
75.
76.
77. Optimisation 1
Concevoir des traitements tels que :
• Les données tiennent dans 32kO
• Le code tient dans 32kO
• Et pas de barrière de mémoire
⇒ Exécution à 1GHz
78.
79. Optimisation 2
• S’arranger pour placer ses données dans
des zones contigües de la mémoire
⇒ Divise pas 8 les temps de chargement
80. Cadeau empoisonné de L3
• Le cache invalide les données ligne par ligne
• Cas de deux threads :
– Le premier exécute une méthode, accède
àa
– Le second exécute une autre méthode,
accède à b
• Pas de concurrence d’accès sur a et b
81.
82.
83.
84.
85.
86.
87.
88.
89. Cadeau empoisonné de L3
• Catastrophique pour les perf !
• Solution : recours au « variable padding »
• Utilisé dans le disruptor (LMAX)
91. Conclusion
• Prendre en compte le processeur
– Permet de belles optimisations
– Délicat à utiliser !
• Tenir compte de l’ordre des variables en mémoire
92. Conclusion
• Prendre en compte le processeur
– Permet de belles optimisations
– Délicat à utiliser !
• Tenir compte de l’ordre des variables en mémoire
• Veut-on le faire ?
• Le langage est-il prêt ?
95. La manière du JDK 1.1
Runnable r = new Runnable() {
public void run() {
while (true) {
System.out.println("Vogue la galère !") ;
}
}
} ;
Thread t = new Thread(r) ;
t.start() ;
96. La manière du JDK 1.1
Runnable r = new Runnable() {
public void run() {
while (true) {
System.out.println("Vogue la galère !") ;
}
}
} ;
Thread t = new Thread(r) ;
t.start() ;
1) Pas de type de retour
2) Pas d’exception
3) Création / destruction
97. La manière du JDK 5
ExecutorService service =
new ScheduledThreadPoolExecutor(10) ;
Callable<Boolean> task = new Callable<Boolean>() {
public Boolean call() throws Exception {
int i = 0 ;
while (i++ < 1000) {
System.out.println("Vogue la galère !") ;
}
return true ;
} 1) Type de retour, exception
};
2) Cycle de vie géré par le pool
Future<Boolean> f = service.submit(task) ;
Boolean b = f.get(100, TimeUnit.MILLISECONDS) ;
104. Classe CountDownLatch
• Utilisable en initialisation (pas de reset)
private CountDownLatch latch = new CountDownLatch() ;
public void init() {
db.connect() ; // étape « lente »
latch.countDown() ; // ouverture du latch
} ;
public void process() {
latch.await() ; // attente de l’ouverture
} ;
105. Classe CyclicBarrier
• Synchronisation sur la fin du traitement de
plusieurs tâches
private CyclicBarrier barrier = new CyclicBarrier(4) ;
public void processOne() {
// traitements divers
barrier.await() ;
} ;
public void processTwo() {
// traitements divers
barrier.await() ;
} ;
106. Interface ReadWriteLock
• Gère des paires de Lock
– Un pour la lecture
– Un pour l’écriture
• Lecture : concurrence possible
• Écriture : exclusive
• Visibilité des modifications garantie
107. Interface ReadWriteLock
private ReadWriteLock rwLock = new ReentrantReadWriteLock() ;
• Pas de contrainte sur les lectures
private ReadWriteLock rwLock = new ReentrantReadWriteLock() ;
public void maMethodeQuiLit() {
Lock readLock = rwLock.readLock() ;
readLock.lock() ;
// traitements de lecture
readLock.unlock() ;
} ;
108. Interface ReadWriteLock
• Les écritures stoppent les lectures
• Une seule écriture à la fois
private ReadWriteLock rwLock = new ReentrantReadWriteLock() ;
public void maMethodeQuiEcrit() {
Lock writeLock = rwLock.writeLock() ;
writeLock.lock() ;
// traitements de lecture
writeLock.unlock() ;
} ;
110. Types atomiques
• AtomicLong, AtomicFloat, etc…
private AtomicInteger index = new AtomicInteger(0) ;
public void uneMethode() {
long newValue = index.incrementAndGet() ;
}
• Compile en une unique instruction
assembleur
111. Types atomiques
• Principe du CAS « compare and swap »
• Prend en entrée :
– Une adresse mémoire
– Deux valeurs « ancienne » & « nouvelle »
• Si la valeur lue à l’adresse correspond à
l’ancienne alors la nouvelle est recopiée
• Sinon, retourne false
• Pas de synchronisation !
112. Types atomiques
// classe AtomicLong
public final long incrementAndGet() {
for (;;) {
long current = get() ;
long next = current + 1 ;
if (compareAndSet(current, next))
return next ;
}
}
113. Files d’attente
• BlockingQueue
– File d’attente de taille fixe
– add(e), offer(e), put(e) avec timeout
– remove(e), poll(e), take(e)
– element(e), examine(e)
• Thread safe (locks internes)
– Utilisable pour le pattern producteur /
consommateur
114. Tableau immutable
• CopyOnWriteArrayList (et version LinkedList)
– Lecture synchronisée
– Écriture par duplication
• Le tableau lu n’est jamais modifié, donc on
peut le partager sans synchronisation
115.
116.
117.
118.
119.
120. Structures immutables
• Peut-on construire d’autres structures
immutables dans l’API Collection ?
– Tables de hachage
• Réponse : oui, et de façon efficace
– Ce qui n’est pas le cas des tableaux
123. Philisophie
• Base de données :
begin
update ... set ... where ...
commit
• Sur le commit :
– Succès : on continue
– Échec : on annule les modifications
– Règles de visibilité
• Idée de 1986, implémentations 1995
124. Même chose dans la JVM ?
• Plusieurs implémentations
• Akka 1.3.1
<dependency>
<groupId>se.scalablesolutions.akka</groupId>
<artifactId>akka-kernel</artifactId>
<version>1.3.1</version>
</dependency>
<repository>
<id>Akka</id>
<name>Akka Maven2 Repository</name>
<url>http://akka.io/repository/</url>
</repository>
125. Pattern STM Effectué dans
une transaction
final Ref<Integer> source = new Ref<Integer>(500) ;
final Atomic<Object> atom = new Atomic<Object>() {
@Override
public Object atomically() {
source.swap(source.get() + 1) ;
return null ;
}
} ;
atom.execute() ;
126. Pattern STM Exécuté dans le
thread courant
final Ref<Integer> source = new Ref<Integer>(500) ;
final Atomic<Object> atom = new Atomic<Object>() {
@Override
public Object atomically() {
source.swap(source.get() + 1) ;
return null ;
}
} ;
atom.execute() ;
127. Pattern STM
• Une transaction qui échoue est rejouée
(idem AtomicLong)
– Utilisation du processeur différente de la
synchronisation
• Cas applicatifs non accessibles aux Locks
Object o = queue1.remove() ;
queue2.add(o) ;
128. Pattern STM
• Bons cas applicatifs : faible concurrence
d’accès
• Forte concurrence : les cœurs passent leur
temps à rejouer le code
129. Implémentation des STM
• Peut utiliser les Locks
• Peut ne pas les utiliser
Dans ce cas : quid de la visibilité (pas de
barrière de mémoire)
Visibilité : comment l’intégrité des données
est-elle garantie ?
130. Implémentation des STM
• Consomme des ressources (mémoire)
– Fonction du nombre de transactions
– Peut être en O(n2) (très mauvais)
• Concurrence avec les Locks, qui n’en
consomment pas
131. Futur des STM
• Architecture Haswell d’Intel (2013)
– Support de TSX (Transactional
Synchronisation Extension)
– TSX permet de marquer des portions de
code
– La mémoire modifiée n’est visible que du
thread qui modifie cette mémoire
– Elle est publiée « instantanément » sur
commit
133. Modèle d’acteurs
1973
• Un acteur réalise un traitement
• Il reçoit un message immutable
• Effectue un traitement, et retourne
éventuellement un résultat
Non synchronisé car sans accès concurrent
134. Modèle d’acteurs
• Utilisé en Erlang
• Plusieurs API Java et sur la JVM (Scala,
Clojure)
Akka : écrit en Scala
135. Akka : fonctionnement
• Akka gère un pool de threads
• On crée des acteurs, on leur envoie des
messages
• Un message reçu est traité dans un thread
• Un acteur ne peut pas être exécuté dans
deux threads à la fois
• Pas de concurrence d’accès sur son éventuel
état
136. 4000! – Akka
public class PrimeFinderActor extends UntypedActor {
public void onReceive(Object o) throws Exception {
List<Integer> bounds = (List<Integer>)o ;
int debut = bounds.get(0) ;
int fin = bounds.get(1) ;
PrimeFactors pfs = new PrimeFactors() ;
for (int i = debut ; i < fin ; i++) {
PrimeFactors pfi = pfs.getPrimeFactors(i) ;
pfs.add(pfi) ;
} // return pfs ;
getContext().reply(pfs) ;
}
}
137. 4000! - ExecutorService
public class PrimeFactorCallable
implements Callable<PrimeFactors> {
private int debut, fin ;
public PrimeFactorCallable(int debut, int fin) {
this.debut = debut ; this.fin = fin ;
}
public PrimeFactors call() throws Exception {
PrimeFactors pfs = new PrimeFactors() ;
for (int i = debut ; i < fin ; i++) {
PrimeFactors pfi = pfs.getPrimeFactors(i) ;
pfs.add(pfi) ;
}
return pfs ;
}
}
138. public static void main(String[] args) {
Future [] futures = new Future [400] ;
for (int i = 0 ; i < futures.length ; i++) {
List<Integer> bound = Collections.unmodifiableList(
Arrays.asList(10*i, 10*(i + 1))) ;
ActorRef primeFactorFinder =
Actors.actorOf(PrimeFinderActor.class).start() ;
futures[i] =
primeFactorFinder.sendRequestReplyFuture(bound) ;
}
PrimeFactors pfs = new PrimeFactors() ;
for (int i = 0 ; i < futures.length ; i++) {
pfs.add((PrimeFactors)futures[i].get()) ;
}
Actors.registry().shutdownAll() ;
}
139. public static void main(String... args)
throws ExecutionException, InterruptedException {
ExecutorService es = new ScheduledThreadPoolExecutor(10) ;
Future [] futures = new Future [400] ;
for (int i = 0 ; i < futures.length ; i++) {
PrimeFactorCallable callable =
new PrimeFactorCallable(10*i, 10*(i + 1)) ;
futures[i] = es.submit(callable) ;
}
PrimeFactors pfs = new PrimeFactors() ;
for (int i = 0 ; i < futures.length ; i++) {
pfs.add((PrimeFactors)futures[i].get()) ;
}
es.shutdown() ;
}
141. Performances
• Les codes se ressemblent
• Utilisation CPU : idem
• Temps de calcul :
– Akka : 2,7s
– ExecutorService : 2,3s
• Différence non significative
142. Exécution transactionnelle
public class Balance {
public final int montant ;
public Balance(int montant) {
this.montant = montant ;
}
}
public class Retrait {
public final int montant ;
public Retrait(int montant) {
this.montant = montant ;
}
}
143. Exécution transactionnelle
public class Depot {
public final int montant ;
public Depot(int montant) {
this.montant = montant ;
}
}
public class GetBalance {
}
144. Exécuté dans
une transaction
public class CompteBancaire extends UntypedTransactor {
private final Ref<Integer> balance = new Ref<Integer>(0) ;
public void atomically(final Object message) {
if (message instanceof Depot) {
int montant = ((Depot)message).montant ;
if (montant > 0)
balance.swap(balance.get() + montant) ;
}
if (message instanceof Retrait) {
int montant = ((Retrait)message).montant ;
if (montant > 0) {
if (balance.get() < montant)
throw new IllegalStateException("...") ;
balance.swap(balance.get() - montant) ;
}
}
if (message instanceof GetBalance)
getContext().replySafe((new Balance(balance.get()))) ;
}
}
145. Fera échouer la
transaction
public class CompteBancaire extends UntypedTransactor {
private final Ref<Integer> balance = new Ref<Integer>(0) ;
public void atomically(final Object message) {
if (message instanceof Depot) {
int montant = ((Depot)message).montant ;
if (montant > 0)
balance.swap(balance.get() + montant) ;
}
if (message instanceof Retrait) {
int montant = ((Retrait)message).montant ;
if (montant > 0) {
if (balance.get() < montant)
throw new IllegalStateException("...") ;
balance.swap(balance.get() - montant) ;
}
}
if (message instanceof GetBalance)
getContext().replySafe((new Balance(balance.get()))) ;
}
}
146. public class Transfert {
public final ActorRef source ;
public final ActorRef destination ;
public final int montant ;
public Transfert(final ActorRef source,
final ActorRef destination,
final int montant) {
this.source = source ;
this.destination = destination ;
this.montant = montant ;
}
}
147. Ensemble d’appels
d’acteurs
public class ServiceBancaire extends UntypedTransactor {
public Set<SendTo> coordinate(final Object message) {
if (message instanceof Transfert) {
Set<SendTo> s = new HashSet<SendTo>() ;
Transfert t = (Transfert)message ;
if (t.montant > 0) { // validation
s.add(sendTo(t.destination, new Depot(t.montant))) ;
s.add(sendTo(t.source, new Retrait(t.montant))) ;
return Collections.unmodifiableSet(s) ;
}
}
return nobody() ;
}
}
148. Ensemble d’appels
d’acteurs
public class ServiceBancaire extends UntypedTransactor {
public Set<SendTo> coordinate(final Object message) {
if (message instanceof Transfert) {
Set<SendTo> s = new HashSet<SendTo>() ;
Transfert t = (Transfert)message ;
if (t.montant > 0) { // validation
s.add(sendTo(t.destination, new Depot(t.montant))) ;
s.add(sendTo(t.source, new Retrait(t.montant))) ;
return Collections.unmodifiableSet(s) ;
}
}
return nobody() ;
}
}
149. Appel dans une
transaction
public class ServiceBancaire extends UntypedTransactor {
public Set<SendTo> coordinate(final Object message) {
if (message instanceof Transfert) {
Set<SendTo> s = new HashSet<SendTo>() ;
Transfert t = (Transfert)message ;
if (t.montant > 0) { // validation
s.add(sendTo(t.destination, new Depot(t.montant))) ;
s.add(sendTo(t.source, new Retrait(t.montant))) ;
return Collections.unmodifiableSet(s) ;
}
}
return nobody() ;
}
}
150. Exécution transactionnelle
• Chaque acteur gère un compte
• Il possède un état, mais qui n’est jamais
partagé
• Les transferts sont gérés par un acteur sans
état
• Toutes les opérations sont transactionnelles
151. Bilan STM & acteurs
• STM & acteurs : deux approches
alternatives à synchronized
• Offrent des fonctionnalités
supplémentaires
• Vont bénéficier du support de l’assembleur
• Pas de miracle au niveau performance
153. Nouveautés Java 7 & 8
• Pattern Fork / Join
• API non incluse en Java 7 : parallel arrays
• Méthode en Java 8 : parallel()
Objet :
• Automatiser la parallélisation sur les
tableaux et les collections
• Ne plus avoir à écrire de code de
parallélisation
155. Fork / Join
• Traite des calculs sur de grandes quantités
de données, numériques ou non
• Gère des tâches
– Si elle est trop grosse elle se divise : Fork
– Sinon elle s’exécute et retourne son
résultat
• Une tâche qui s’est divisée récupère les
résultats de ses sous-tâches : Join
156. Fork / Join
• Gère un pool de threads
• Chaque thread possède une file d’attente
qui stocke les tâches
• Quand sa file d’attente est vide, il va voler
du travail à son voisin
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171. Fork / Join
• Chaque tâche travaille sur ses propres
données
• Pas de bloc synchronisé
• Pas de variables partagées
• On doit donc « dupliquer » des informations
• Cas du traitement des tableaux de grande
taille ?
180. Parallel Arrays
• API non incluse dans le JDK
• Peut être utilisée en Java 6
• Fork / Join dans un package jsr166y.*
• Avantage : API auto-porteuse
187. Méthodes virtuelles d’ext.
• On ajoute des méthodes dans les interfaces,
avec leurs implémentation par défaut
public interface Collection<E> {
public boolean add(E e) ;
public boolean addAll(Collection<? extends E> c) ;
// la litanie des méthodes de Collection
// méthode virtuelle d'extension
public void sort(Comparator<? super E> comp)
default Collections.sort(comp) ;
}
188. Syntaxe
• Du light !
int maxAge =
persons.map(p -> p.getAge()).reduce(0, Integer::max) ;
Collection<Person> oldies =
persons.filter(p -> p.age > 40).into(new ArrayList()) ;
• Support du parallélisme
Collection<Person> oldies =
persons.parallel().filter(p -> p.age > 40)
.into(new ArrayList()) ;
189. Interface spliterable()
• Extension d’iterable()
• Type de retour de parallel()
• Le fork / join devient un framework système
• Les fonctionnalités des parallel arrays sont
intégrées via les lambdas
• On gagne java.util.parallel
191. Une anecdote
Le 24/2/2012 Heinz Kabutz
lance un défi :
• Déterminer les 10 premiers et
10 derniers octets du nombre
Fibonacci (1 milliard)
• Taille du nombre écrit dans
un fichier = ~180Mo
193. Une anecdote
• Record à battre : 5600s sur un CPU 8 cœurs
• 1ère amélioration : 3300s sur un CPU 4
cœurs
194. Une anecdote
• Record à battre : 5600s sur un CPU 8 cœurs
• 1ère amélioration : 3300s sur un CPU 4
cœurs
• 2ème amélioration : 51s sur un cœur
195. Une anecdote
Par quel miracle ?
• Utilisation de GNU Multiple Precision
Arithmetic Lib (GMP)
• Changement d’implémentation de
BigInteger
• Changement d’algorithme de calcul de
Fibonacci
• Suppression de l’utilisation de la récursivité
196. Par quel miracle ?
Quel rapport avec
• Utilisation de GNU Multiple Precision
Arithmetic Lib (GMP)
• Changement d’implémentation de
Fork / Join ou la
BigInteger
• Changement d’algorithme de calcul de
parallélisation ?
Fibonacci
• Suppression de l’utilisation de la récursivité
197. Algorithmique
L’optimisation des fonctions linéaires a gagné
un facteur 43M sur les temps de traitement
en 15 ans :
• 1k est dû à la vitesse des processeurs
• 43k est dû à l’amélioration des algorithmes
198. Moralité
• Utiliser les bons algorithmes de traitement
avant de penser à la parallélisation
199. Moralité
• Utiliser les bons algorithmes de traitement
avant de penser à la parallélisation
• S’assurer que les algorithmes sont bien
parallélisables !!
200. Moralité
• Utiliser les bons algorithmes de traitement
avant de penser à la parallélisation
• S’assurer que les algorithmes sont bien
parallélisables !!
Quick sort : se parallélise mal
• Merge sort consomme de la mémoire
201. Moralité
• Utiliser les bons algorithmes de traitement
avant de penser à la parallélisation
• S’assurer que les algorithmes sont bien
parallélisables !!
Recuit simulé : ne se parallélise pas, perd ses
propriétés de convergence
203. Conclusion
Une nouvelle période charnière se déroule en
ce moment
En 1995 : la mémoire est devenue une
ressource gérée par la JVM
En 2012 : le CPU est en train de devenir une
ressource gérée par la JVM (et le serveur
aussi !)
Les langages et les processeurs s’adaptent les
uns aux autres
204. Conclusion
Les applications vont utiliser des traitements
en parallèle de façon transparente
Mais les pièges se trouvent au niveau des
algorithmes, ils seront plus durs à éviter
Nouveaux challenges pour les développeurs,
et de nouvelles opportunités !