air - User contributions [en]

Extensions XBMC 2015

2015-03-25T09:04:57Z

RICM4-prj14-grp5: /* Enhancement */

= Introduction =

This project idea is to develop various plug-in for kodi (formerly xbmc).

More information on Project [[Extensions XBMC Sujet 2015]]

=Documents=
* [[Proj-2014-2015-Ext_XBMC/SRS|Software Requirements Specification (SRS)]]
* [[Proj-2014-2015-Ext_XBMC/UML| Diagrammes UML]]
* [http://www.mediafire.com/view/sxx0luo8th5o7m9/MPI_VALENTIN_BOBO_LEGROS.pdf Rapport]
* [ Slides of the Presentation]
* [http://www.mediafire.com/view/2xmcb18l9xqpig1/11080023_347584275444770_1002629747_n.jpg.png Flyer]

= Team =

* Tutors : Nicolas Palix

* Members : Clément Valentin, William Bobo, Jules Legros, Gabin Teulon

* Departement : [http://www.polytech-grenoble.fr/ricm.html RICM 5], [[Polytech Grenoble]]

= Project objectives =

= Progress of the project =

The project started January 26th, 2014.

== Week 1 (January 26th - January 30th) ==
* Project discovery
* Discovery of Kodi (formerly XBMC) and the add-on structure

== Sprint 1 (February 02nd - February 14th) ==
* Installation of a shared library in kodi between computers
** Use of mySQL database/server on the SalleAIR computer
** Synchronization of the movies lecture (can resume a movie on any computer, viewed list updating)
* Discovery of dev tool for the kinect : we chose to use C++ library (native library) instead of python one's, because on windows, it is not userfriendly at all, and in the aim of providing an addon that can be easily installed, it's not the good solution.
* Discovery of the source code of the remote control android application

== Holidays ==

== Sprint 2 (February 23rd - March 10th) ==
* Development of the kodi add-on
** Pop-up mechanism
** Port communication in order to communicate with the kinect program. We first wanted to use [http://en.wikipedia.org/wiki/D-Bus D-Bus] or [http://en.wikipedia.org/wiki/%C3%98MQ ØMQ] but once again, the fact that the installation is not easy on windows, is incompatible with the fact that we want an addon easily installable by anyone.
* Development of a kinect program to count the number of people in front of the TV
* Development of the NFC part, and including it in the remote control android application

== Sprint 3 (March 10th - March Xth) ==
* Developing a multi-platform solution for the kinect
* Creating scenarios in order to decide of interaction with the NFC tags and the kinect

= Choices for the remote =
*Choice of the app
We used the official remote because there was things already done last year
*Follow-me : NFC or Bluetooth
Bluetooth seem perfect for following someone without interaction but there is material differences which change signal's power and made it unreliable.
NFC add a user interaction but we are sure that the remote is here and we already known how to deal with NFC on Android
*Tag content
Our tag are very small. We can write around 144 byte. At first, it was not a problem because we just needed un id, but it work with only one remote. When we choose to make it work with all the remote, we needed to write all the data about un host. Where was not enough place and we had to choose most important information.
*Remote integration
We choose to do it with a minimum of change and before each commit, code was cleaned to reflect it so if we choose to push our modification to the original repository, our push will be clean.
*Communication with XBMC/Kodi
We choose not to communicate with XBMC through an addon with our own socket because we found JSON-RPC. JSON-RPC is already implemented in the remote and allow to control XBMC through JSON request.
*Centralisation on remote
The remote have access to everything through JSON-RPC and it avoid to deal with negotiation between add-on.
*XBMC/Kodi on Android
We thought of using Kodi on Android for the "follow me", it consist in moving the playing media from a TV to the smart-phone then to another TV. We choose not to do it because Kodi on Android is a native application and it would take too much time to retro-engineering this.

= Enhancement =
*Follow me on Kodi Android
*Deal with more user-case
*More options and user choice
*UPNP server for follow me on media not shared on the network

= To continue =
*About the remote
We did not found any documentation about the remote. So you have understand it yourself with your Android skills.
The main part which deal with NFC tag is "NFCIntentActivity.java". This is the core of the remote application. It read a tag, add the host if it dosn't exist then do the follow me thing.
"FollowMeActivity.java" was also added for writing on NFC and settings.

Extensions XBMC 2015

2015-03-25T08:27:24Z

RICM4-prj14-grp5: /* Choices for the remote */

= Introduction =

This project idea is to develop various plug-in for kodi (formerly xbmc).

More information on Project [[Extensions XBMC Sujet 2015]]

=Documents=
* [[Proj-2014-2015-Ext_XBMC/SRS|Software Requirements Specification (SRS)]]
* [[Proj-2014-2015-Ext_XBMC/UML| Diagrammes UML]]
* [ Rapport]
* [ Slides of the Presentation]
* [ Flyer]

= Team =

* Tutors : Nicolas Palix

* Members : Clément Valentin, William Bobo, Jules Legros, Gabin Teulon

* Departement : [http://www.polytech-grenoble.fr/ricm.html RICM 5], [[Polytech Grenoble]]

= Project objectives =

= Progress of the project =

The project started January 26th, 2014.

== Week 1 (January 26th - January 30th) ==
* Project discovery
* Discovery of Kodi (formerly XBMC) and the add-on structure

== Sprint 1 (February 02nd - February 14th) ==
* Installation of a shared library in kodi between computers
** Use of mySQL database/server on the SalleAIR computer
** Synchronization of the movies lecture (can resume a movie on any computer, viewed list updating)
* Discovery of dev tool for the kinect : we chose to use C++ library (native library) instead of python one's, because on windows, it is not userfriendly at all, and in the aim of providing an addon that can be easily installed, it's not the good solution.
* Discovery of the source code of the remote control android application

== Holidays ==

== Sprint 2 (February 23rd - March 10th) ==
* Development of the kodi add-on
** Pop-up mechanism
** Port communication in order to communicate with the kinect program. We first wanted to use [http://en.wikipedia.org/wiki/D-Bus D-Bus] or [http://en.wikipedia.org/wiki/%C3%98MQ ØMQ] but once again, the fact that the installation is not easy on windows, is incompatible with the fact that we want an addon easily installable by anyone.
* Development of a kinect program to count the number of people in front of the TV
* Development of the NFC part, and including it in the remote control android application

== Sprint 3 (March 10th - March Xth) ==
* Developing a multi-platform solution for the kinect
* Creating scenarios in order to decide of interaction with the NFC tags and the kinect

= Choices for the remote =
*Choice of the app
We used the official remote because there was things already done last year
*Follow-me : NFC or Bluetooth
Bluetooth seem perfect for following someone without interaction but there is material differences which change signal's power and made it unreliable.
NFC add a user interaction but we are sure that the remote is here and we already known how to deal with NFC on Android
*Tag content
Our tag are very small. We can write around 144 byte. At first, it was not a problem because we just needed un id, but it work with only one remote. When we choose to make it work with all the remote, we needed to write all the data about un host. Where was not enough place and we had to choose most important information.
*Remote integration
We choose to do it with a minimum of change and before each commit, code was cleaned to reflect it so if we choose to push our modification to the original repository, our push will be clean.
*Communication with XBMC/Kodi
We choose not to communicate with XBMC through an addon with our own socket because we found JSON-RPC. JSON-RPC is already implemented in the remote and allow to control XBMC through JSON request.
*Centralisation on remote
The remote have access to everything through JSON-RPC and it avoid to deal with negotiation between add-on.
*XBMC/Kodi on Android
We thought of using Kodi on Android for the "follow me", it consist in moving the playing media from a TV to the smart-phone then to another TV. We choose not to do it because Kodi on Android is a native application and it would take too much time to retro-engineering this.

= Enhancement =
*Follow me on Kodi Android
*Deal with more user-case
*More options and user choice

Extensions XBMC 2015

2015-03-25T08:20:28Z

RICM4-prj14-grp5: /* Choices for the remote */

= Introduction =

This project idea is to develop various plug-in for kodi (formerly xbmc).

More information on Project [[Extensions XBMC Sujet 2015]]

=Documents=
* [[Proj-2014-2015-Ext_XBMC/SRS|Software Requirements Specification (SRS)]]
* [[Proj-2014-2015-Ext_XBMC/UML| Diagrammes UML]]
* [ Rapport]
* [ Slides of the Presentation]
* [ Flyer]

= Team =

* Tutors : Nicolas Palix

* Members : Clément Valentin, William Bobo, Jules Legros, Gabin Teulon

* Departement : [http://www.polytech-grenoble.fr/ricm.html RICM 5], [[Polytech Grenoble]]

= Project objectives =

= Progress of the project =

The project started January 26th, 2014.

== Week 1 (January 26th - January 30th) ==
* Project discovery
* Discovery of Kodi (formerly XBMC) and the add-on structure

== Sprint 1 (February 02nd - February 14th) ==
* Installation of a shared library in kodi between computers
** Use of mySQL database/server on the SalleAIR computer
** Synchronization of the movies lecture (can resume a movie on any computer, viewed list updating)
* Discovery of dev tool for the kinect : we chose to use C++ library (native library) instead of python one's, because on windows, it is not userfriendly at all, and in the aim of providing an addon that can be easily installed, it's not the good solution.
* Discovery of the source code of the remote control android application

== Holidays ==

== Sprint 2 (February 23rd - March 10th) ==
* Development of the kodi add-on
** Pop-up mechanism
** Port communication in order to communicate with the kinect program. We first wanted to use [http://en.wikipedia.org/wiki/D-Bus D-Bus] or [http://en.wikipedia.org/wiki/%C3%98MQ ØMQ] but once again, the fact that the installation is not easy on windows, is incompatible with the fact that we want an addon easily installable by anyone.
* Development of a kinect program to count the number of people in front of the TV
* Development of the NFC part, and including it in the remote control android application

== Sprint 3 (March 10th - March Xth) ==
* Developing a multi-platform solution for the kinect
* Creating scenarios in order to decide of interaction with the NFC tags and the kinect

= Choices for the remote =
*Choice of the app
We used the official remote because there was things already done last year
*Follow-me : NFC or Bluetooth
Bluetooth seem perfect for following someone without interaction but there is material differences which change signal's power and made it unreliable.
NFC add a user interaction but we are sure that the remote is here and we already known how to deal with NFC on Android
*Tag content
Our tag are very small. We can write around 144 byte. At first, it was not a problem because we just needed un id, but it work with only one remote. When we choose to make it work with all the remote, we needed to write all the data about un host. Where was not enough place and we had to choose most important information.
*Remote integration
We choose to do it with a minimum of change and before each commit, code was cleaned to reflect it so if we choose to push our modification to the original repository, our push will be clean.
*Communication with XBMC/Kodi
We choose not to communicate with XBMC through an addon with our own socket because we found JSON-RPC. JSON-RPC is already implemented in the remote and allow to control XBMC through JSON request.
*Centralisation on remote
The remote have access to everything through JSON-RPC and it avoid to deal with negotiation between add-on.
*XBMC/Kodi on Android
We thought of using Kodi on Android for the "follow me", it consist in moving the playing media from a TV to the smart-phone then to another TV. We choose not to do it because Kodi on Android is a native application and it would take too much time to retro-engineering this.

Extensions XBMC 2015

2015-03-25T07:43:09Z

RICM4-prj14-grp5: /* Choices for the remote */

Extensions XBMC 2015

2015-03-25T07:00:17Z

RICM4-prj14-grp5:

Projets 2014-2015

2015-01-26T12:31:31Z

RICM4-prj14-grp5: /* Projet Semestre S10 */

<<[[Projets 2013-2014]] [[Projets|^Projets^]] [[Projets 2015-2016]]>>

=RICM=
==RICM3==

==RICM4==

* '''Evaluation à mi-parcours le lundi 2 mars''': Format: 10min (5min de présentation 3 slides au plus, 5min de discussion). Cette évaluation sera prise en compte dans la note finale.

'''Consignes générales:'''

* '''Vous devez être pro-actifs !!!''': Si des points sont pas ou mals spécifiés, vous le faîtes et vous justifiez vos choix. Pour les problèmes techniques éventuels vous pouvez: vous creusez la question, vous contactez l'auteur du code si il y a lieux, vous faites un rapport de bug ('''Attention:''' ca se prépare !), vous soumettez un patch, vous contactez l'enseignant ou la personne suivant le projet.

* '''Vous devez maintenir une fiche de suivi de projet''': elle doit être mise à jour chaque semaine, elle rassemble les élements essentiels du projet, elle
indique les évolutions du projet et présente sa feuille de route. '''Note:''' le nom de la fiche doit être composé du nom du projet et suffixé par ricm4_2014_2015.

* '''Vous devez utiliser un logiciel de gestion de version''' pour vos développements comme [http://en.wikipedia.org/wiki/Git_%28software%29 git ] et nous vous conseillons d'utiliser le site [https://github.com github] pour l'hébergement de votre dépôt public.

* Les document public (exemple sur github) doivent être rédigés en anglais (README, documentation, commentaires de code, nom de variables et de fonctions). Une bonnification sera accordée si le rapport et les transparents sont en anglais (la soutenance sera en francais).

{|class="wikitable alternance"
|+ Affectation des projets RICM4 2014-2015
|-
|
!scope="col"| Sujet
!scope="col"| Etudiants
!scope="col"| Enseignant(s)
!scope="col"| Fiche de suivi
!scope="col"| Dépot git
|-

!scope="row"| 1
| [[Projet de monoski intelligent]]
| Blondet, Torck
| Didier Donsez, Pascal Jay, David Eon
| [[Proj-2014-2015-MonoskiIntelligent| '''Fiche''']] [[Proj-2014-2015-MonoskiIntelligent/SRS| '''SRS''']] [[Proj-2014-2015-MonoskiIntelligent/UML| '''Diagrammes UML''']] [[Proj-2014-2015-MonoskiIntelligent/Scrum| '''Scrum''']]
| [https://github.com/ '''github''']
| [[Media:ProjetXYZ/Rapport|rapport]] - [[Media:ProjetXXX-transparents.pdf|transparents]] - [[Media:ProjetXXX-flyer.pdf|flyer]] - [[Media:ProjetXXX-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 2
| [[Smart Classroom]]
| Darrigol, Badamo, Damotte, Leonard
| Didier Donsez, Vivien Quema, Jérome Maisonnasse
| [[Proj-2014-2015-SmartClassroom| '''Fiche''']] [[Proj-2014-2015-SmartClassroom/SRS| '''SRS''']] [[Proj-2014-2015-SmartClassroom/UML| '''Diagrammes UML''']] [[Proj-2014-2015-SmartClassroom/Scrum| '''Scrum''']]
| [https://github.com/ '''github''']
| [[Media:Proj-2014-2015-SmartClassroom/Rapport|rapport]] - [[Media:Proj-2014-2015-SmartClassroom-transparents.pdf|transparents]] - [[Media:Proj-2014-2015-SmartClassroom-flyer.pdf|flyer]] [[Media:ProjetXXX-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 3
| [[RobAIR]] et [[STM32 Nucleo]]
| Hammerer, Michel, Klipffel, Vialler
| Didier Donsez
| [[Projet-2014-2015-RobAIR| '''Fiche''']] [[Projet-2014-2015-RobAIR/SRS| '''SRS''']] [[Projet-2014-2015-RobAIR/UML| '''Diagrammes UML''']] [[Projet-2014-2015-RobAIR/Scrum| '''Scrum''']]
| [https://github.com/ '''github''']
| [[Media:Projet-2014-2015-RobAIR/Rapport|rapport]] - [[Media:Projet-2014-2015-RobAIR-transparents.pdf|transparents]] - [[Media:ProjetXXX-flyer.pdf|flyer]] [[Media:Projet-2014-2015-RobAIR-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 4
| [[IDS|Interactive Digitale Signage]]
| Adam, Zhang
| Didier Donsez
| [[Proj-2014-2015-Interactive_Digitale_Signage| '''Fiche''']]
| [https://github.com/ '''github''']
| [[Media:Proj-2014-2015-Interactive_Digitale_Signage/Rapport|rapport]] - [[Media:Proj-2014-2015-Interactive_Digitale_Signage-transparents.pdf|transparents]] - [[Media:Proj-2014-2015-Interactive_Digitale_Signage-flyer.pdf|flyer]] [[Media:ProjetXXX-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 5
| [[Régie vidéo autonome et mobile multi-caméra]]
| Zominy, Bodard, Qian
| Didier Donsez, Thierry C.
| [[Proj-2014-2015-RegieVideoAutonomeEtMobileMulticamera| '''Fiche''']] [[Proj-2014-2015-Regie_Video_Autonome_Et_Mobile_Multicamera/SRS| '''SRS''']]
| [https://github.com/ '''github''']
| [[Media:Projet-2014-2015-RegieVideoAutonomeEtMobileMulticamera/Rapport|rapport]] - [[Media:ProjetXXX-transparents.pdf|transparents]] - [[Media:ProjetXXX-flyer.pdf|flyer]] - [[Media:ProjetXXX-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 6
| OpenHAB Extended GUI ([[IFTTT]] et à la [[Node-RED]] ou [[Flowhub]] pour [[OpenHAB]], Découverte [[UPnP]] des équipements)
| Toussaint, Saussac
| Didier Donsez
| [[Proj-2014-2015-OpenHAB-ExtendedGUI| '''Fiche''']]
| [https://github.com/ '''github''']
| [[Media:Proj-2014-2015-OpenHAB-ExtendedGUI/Rapport|rapport]] - [[Media:Proj-2014-2015-OpenHAB-ExtendedGUI-transparents.pdf|transparents]] - [[Media:PProj-2014-2015-OpenHAB-ExtendedGUI-flyer.pdf|flyer]] - [[Media:ProjetXXX-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 7
| [[Inventaire Forestier]]
| Rodrigues-Pereira-Anselmo, Le-Jean
| Emmanuel Promayon
| [[Proj-2014-2015-XYZ| '''Fiche''']]
| [https://github.com/ '''github''']
| [[Media:ProjetXYZ/Rapport|rapport]] - [[Media:ProjetXXX-transparents.pdf|transparents]] - [[Media:ProjetXXX-flyer.pdf|flyer]]- [[Media:ProjetXXX-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 8
| [[CannonBall de voitures autonomes|CannonBall de voitures autonomes, Edition 2015]]
| Pelloux-Prayer, Mammar
| Didier Donsez & Vivien Quema
| [[Project-2014-2015-CannonBall| '''Fiche''']][[Project 2014-2015-CannonBall/SRS| '''SRS''']]
| [https://github.com/ '''github''']
| [[Media:ProjetXYZ/Rapport|rapport]] - [[Media:ProjetXXX-transparents.pdf|transparents]] - [[Media:ProjetXXX-flyer.pdf|flyer]]- [[Media:ProjetXXX-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 9
| [[Navigation et Montre connectée]]
| Hamdani, Mesnier, Yao
| Jacques Lemordant
| [[Proj-2014-2015-Montreconnectée| '''Fiche''']] [[Proj-2014-2015-Montreconnectée/SRS| '''SRS''']] [[Proj-2014-2015-Montreconnectée/UML| '''Diagrammes UML''']] [[Proj-2014-2015-Montreconnectée/Scrum| '''Scrum''']]
| [https://github.com/ '''github''']
| [[Media:ProjetXYZ/Rapport|rapport]] - [[Media:ProjetXXX-transparents.pdf|transparents]] - [[Media:ProjetXXX-flyer.pdf|flyer]]- [[Media:ProjetXXX-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 10
| [[Python sur ESP8266]]
| Libralesso, Soldano
| Olivier Richard
| [[Project-2014-2015-ESP8266| '''Fiche''']] [[Proj-2014-2015-ESP8266/SRS| '''SRS''']]
| [https://github.com/librallu/RICM4Projet/ '''github''']
| [[Media:ProjetXYZ/Rapport|rapport]] - [[Media:ProjetXXX-transparents.pdf|transparents]] - [[Media:ProjetXXX-flyer.pdf|flyer]]- [[Media:ProjetXXX-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 11
| [[Serious Game: Handicap, parole et geste v2]]
| Aissanou, Codazzi, Guo
| Olivier Richard
| [[Proj-2014-2015-SeriousGamev2| '''Fiche''']][[Proj-2014-2015-SeriousGamev2/SRS| '''SRS''']][[Proj-2014-2015-SeriousGamev2/Scrum| '''Scrum''']]
| [https://github.com/ '''github''']
| [[Media:ProjetXYZ/Rapport|rapport]] - [[Media:ProjetXXX-transparents.pdf|transparents]] - [[Media:ProjetXXX-flyer.pdf|flyer]]- [[Media:ProjetXXX-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 12
| [[Plateforme d'expérimentation mini-datacentre]] Système
| Fotsing, Morisson
| Olivier Richard
| [[Proj-2014-2015-Mini_DataCenter_Systeme| '''Fiche''']]
| [https://github.com/ '''github''']
| [[Media:ProjetMini_DataCenter_Systeme/Rapport|rapport]] - [[Media:ProjetMini_DataCenter_Systeme-transparents.pdf|transparents]] - [[Media:ProjetMini_DataCenter_Systeme-flyer.pdf|flyer]]- [[Media:ProjetMini_DataCenter_Systeme-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 13
| [[Plateforme d'expérimentation mini-datacentre]] Portail
| Rossi, Eudes
| Olivier Richard
| [[Proj-2014-2015-Mini_datacenter_portail| '''Fiche''']]
| [https://github.com/EudesRobin/Mini_datacenter_webui '''github''']
| [[Media:Projet_Projet_Mini_datacenter_portail/Rapport|rapport]] - [[Media:Projet_Mini_datacenter_portail-transparents.pdf|transparents]] - [[Media:Projet_Mini_datacenter_portail-flyer.pdf|flyer]]- [[Media:ProjetXXX-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

|}

* [[Projet de monoski intelligent]] (RICM4 et 3I4 et Matériaux) pour le [http://www.defi-foly-laclusaz.com/ défi Foly 2015] : Didier Donsez, Pascal Jay, David Eon (2 élèves)
* [[Smart Classroom]] (avec ENSIMAG) Didier Donsez, Vivien Quema, Jérome Maisonnasse (4 élèves)
* Robot [[RobAIR]] à base de [[STM32 Nucleo]] (+ cartes additionnelles MEMS BLE4) et de téléphones [[Firefox OS]]. Didier Donsez (4 élèves)
* [[StartAIR]] (Fabrice Dubost) (2 élèves)
* [[IDS|Interactive Digitale Signage]] avec [[Reveal.js]], [[Kinect]], [[WebRTC]], [[Node.js]], [[Open Data]], [[NFC]], [[Miracast]] [http://blueimp.github.io/Bootstrap-Image-Gallery/ Bootstrap Gallery]... (Didier Donsez) (2 élèves)
* [[Régie vidéo autonome et mobile multi-caméra]] (Didier Donsez, Thierry C.) (2 élèves)
* Interface HTML5 à la [[IFTTT]] et à la [[Node-RED]] ou [[Flowhub]] pour [[OpenHAB]] (2 élèves)
* [[Intégration d'Espruino à RIOT OS]] sur [[STM32 Nucleo]]: Application à la robotique [[RobAIR]] (Didier Donsez) (2 élèves)
* [[Inventaire Forestier]] sous Android (3I4 ou 5, RICM4) Emmanuel Promayon (2 élèves)
* [[Navigation indoor basé iBeacons]], Jacques Lemordant (2 élèves)
* [[Navigation et Montre connectée]], Jacques Lemordant (2 élèves)
* [[Projets Sitra avec la région Rhône-Alpes]], Jacques Lemordant (2 élèves)
* [[CannonBall de voitures autonomes|CannonBall de voitures autonomes, Edition 2015]] Didier Donsez & Vivien Quema (piste [[Star War Drone Race]]) (2 élèves)
* [[Python sur ESP8266]] Olivier Richard (2 élèves)
* [[Serious Game: Handicap, parole et geste v2]], edition 2015, Olivier Richard (2 élèves)
* [[Plateforme d'expérimentation mini-datacentre]] édition 2015, Olivier Richard (2 élèves)

==RICM5==
===Projet Semestre S10===
Démarrage : Lundi 26/01 à 8H00-12H00, P257 (Rendez-vous devant la salle AIR)
* [[Extensions XBMC Sujet 2015]] Nicolas Palix
* [[Smart Classroom]] (avec ENSIMAG) Didier Donsez & Vivien Quema : tables tactiles en mode [[Tiled Display]], Murs interactifs, Robots de Téléprésence, ...
* Défi H 2015 : Rééducation de la main, Didier Donsez & Alessandro Semere & Nicolas Vuillerme
* Plateforme Ubilitics pour [[SmartCampus 2015]] (déploiement grande échelle de capteurs [[LoRa]]), Didier Donsez & Vivien Quema (voir [[OpenBAS]])
*

Remarque: il y aura 3 étudiants PEIPD de l'IUT 1 qui participeront aux projets.

{|class="wikitable alternance"
|+ Affectation des projets RICM5 2014-2015
|-
|
!scope="col"| Sujet
!scope="col"| Etudiants
!scope="col"| Enseignant(s)
!scope="col"| Fiche de suivi
!scope="col"| Dépot git
|-

!scope="row"| 1
| [[iRock]] :Plateforme Ubilitics pour la surveillance des risques naturelles (déploiement grande échelle de capteurs [[LoRa]] sur le terrain pour l'observation de glissement de terrain) .
| Peyre, Guo, Ginoux, Boey
| Didier Donsez & Denis Jongmans & Georges-Pierre Bonneau
| [[Proj-2014-2015-iRock| '''Fiche''']] [[Proj-2014-2015-iRock/SRS| '''SRS''']] [[Proj-2014-2015-iRock/UML| '''Diagrammes UML''']] [[Proj-2014-2015-iRock/Scrum| '''Scrum''']]
| [https://github.com/ '''github''']
| [[Media:Proj-2014-2015-iRock/Rapport|rapport]] - [[Media:Proj-2014-2015-iRock-transparents.pdf|transparents]] - [[Media:Proj-2014-2015-iRock-flyer.pdf|flyer]] - [[Media:Proj-2014-2015-iRock-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

!scope="row"| 2
| [[Extensions XBMC Sujet 2015]]
| Valentin, Bobo, Perruche
| Nicolas Palix
| [[Proj-2014-2015-Ext_XBMC| '''Fiche''']] [[Proj-2014-2015-Ext_XBMC/SRS| '''SRS''']] [[Proj-2014-2015-Ext_XBMC/UML| '''Diagrammes UML''']] [[Proj-2014-2015-Ext_XBMC/Scrum| '''Scrum''']]
| [https://github.com/ '''github''']
| [[Media:Proj-2014-2015-Ext_XBMC/Rapport|rapport]] - [[Media:Proj-2014-2015-Ext_XBMC-transparents.pdf|transparents]] - [[Media:Proj-2014-2015-Ext_XBMC-flyer.pdf|flyer]] - [[Media:Proj-2014-2015-Ext_XBMC-poster.pdf|poster]] - [http://youtube.com Video ou Screencast]
|-

|}

Rappel: les séances de MPI (Management de Projet Innovant) auront lieu les jours suivants (salles sur ADE) :
* Mardi 27/01 après-midi (Stéphanie Diligent)
* Lundi 2/02 matin (Emmanuelle Tréhoust)
* Lundi 9/02 matin (Emmanuelle Tréhoust)
* Lundi 23/02 matin (Stéphanie Diligent)
* Mardi 17/03 matin (Stéphanie Diligent+Emmanuelle Tréhoust)

===Projet Biométrie===
Démarrage : Lundi 26/01 à 8H00-9H45

Voir Laurent Besacier & François Portet

=3I=
==3I3==

==3I4==

==3I5==
* Carte d'extension Semtech [[LoRa]] pour [[Arduino]] et [[STM32 Nucleo]] (Didier Donsez)

=M2PGI=
* Extensions à [[SmartCampus]]

=Bachelor Summer Program=

=Année A définir=
* [[Smart campus augmenté et contributif]]
* [[Intégration OpenHAB / OpenTele]]
* [[Client MQTT pour OBD]] sur Android
* [[Sommeilomètre]] (Michael Perin, Didier Donsez)
* [[Open DynDNS]]
* [[IllumiRoom]]
* [[Emergency mobile app]] Nicolas Palix pour TIS, PRI et RICM
* [[OwnPOI]] ownCloud plugin and osmand plugin to share POI and favorite positions. Nicolas Palix.
* [[OwnList]] ownCloud plugin and Android app to share a TODO list. Nicolas Palix.
* [[floatingimage UPnP feed]] Nicolas Palix
* [[XBMC Reflexive Remote]] Dynamic remote control for XBMC. Nicolas Palix.
* [http://intgat.tigress.co.uk/rmy/uml/index.html Zerofree] Portage de zerofree pour d'autres systèmes de fichiers que ext2/3/4 (notamment Unix FS). Voir également la page [http://packages.qa.debian.org/z/zerofree.html QA de Debian]. Nicolas Palix.
* [[Bracelet électronique de monitoriing de l'alcoolémie]]
* [[Oxymètre DIY]]
* [[PinSound]]
* [[Extension du support STM32Fx-Discovery dans libopencm3]] : Olivier Richard
* [[Arduino et libopencm3]] : Olivier Richard
* [[Data Acquisition System et Stm32f4-Discovery]] : Olivier Richard
* [[Distributed Data Storage System]] : Olivier Richard
* [[Dashboard based on w2ui]]
* [[Environnement logiciel pour FabLab]] : Olivier Richard
* [[Environnement logiciel pour le Live Programming]] : Olivier Richard
* [[VirtualPinball]]
* Tondeuse dessinatrice
* [[ImmersiveDog]] Nicolas Glade, Didier Donsez
* Projet avec [[OpenROV]] ???? : Didier Donsez
* [[Sphero]] malin (Michael Périn) (2 etudiants)
* [[Drone paramoteur]] ???
* [[IRock : Surveillance Géotechnique LoRa|iRock]]: Plateforme Ubilitics pour la surveillance des risques naturelles (déploiement grande échelle de capteurs [[LoRa]] sur le terrain pour l'observation de glissement de terrain) en commun avec Geotech (à confirmer) : Didier Donsez & Denis Jongmans
* [[Optimisation de l'énergie pour cyclotouriste électrique]]
* [[SmartSelfService|Smart Self-Service 2015]] Didier Donsez & Vivien Quema
* [[Station Météo LoRa]] : contribution au projet [[LoRA-Fabian]] (Didier Donsez)

=Réserve (boite à idées)=

# [[Tag et Paint Ball en réalité augmentée]] (Michaël Périn)
# [[Passe moi ton fichier]] (Michaël Périn)
# [[Extensions à Fab Server]] (Jean-Michel Molenaar) sous reserve (CM ou SR)
# [[Table multijeux de café 2.0]]
# [[ GPIO_Qemu_RasPI| Emulation des GPIO dans QEMU pour le carte Raspberry Pi]] (Olivier Richard)
# [[ Qemu et STM32F0-Discovery ]] (Olivier Richard)
# [[Serrure à clé MIDI multifactorielle]] (Didier Donsez)
# [[Table interactive musicale]] (Didier Donsez)
# [[iMailbox]] (Didier Donsez)
# [[AmILight]] (eclairage d'ambience intelligent) (Didier Donsez)
# [[PDAmeetPDA]] (synchronisation d'agenda) (Michaël Périn)
# [[1 000 000 VMs]] (expérimentation d'application distribuée à très grande échelle) (Olivier Richard) (2-3 RICM4)
# [[Multiple Kinect]] (utilisation simultanée de plusieurs Kinect) (Olivier Richard) (RICM ou 3I)
# [[Kinect musicale]] (Didier Donsez) (RICM)
# [[Ktechlab Simavr Arduino | Ktechlab et integration de Simavr(Arduino)]] (Olivier Richard) (2-3 RICM4-SR)
# Ocaml on AVR (Arduino)
# Ocaml on Cortex-M3
# [[Arduino on STM32 Discovery]]
# [[Reverse Geocache Puzzle Box]]
# [[OSGi ME]] (Didier Donsez)
# [[Affichage Etudiant à Polytech]]
# Synthèse 3D + motion capture Kinect
# Logiciel d'[[apprentissage du calcul]] sur tablette Android (reconnaissance de chiffres manuscrits)
# Plancher de verre (saint gobain) à la [http://www.wat.tv/video/mickael-jackson-billie-jean-oewj_2ey2h_.html Mickael Jackson dans Billie Jean] ! woo
# [[Ktechlab Simavr Arduino | Ktechlab et integration de Simavr(Arduino)]] (Olivier Richard) (2-3 RICM4-SR)
# [[CNC]]
# [[Idées en Vrac]]
# Scheme Everywhere (Olivier Richard) (2-3 RICM4-SR)
# [[Projet Station Météo]]
# Ocaml on AVR (Arduino)
# [[Table interactive musicale]] (Didier Donsez)
# [[AmILight]] (eclairage d'amnbience intelligent) (Didier Donsez)
# [[Cube pointeur]] d'activité ingénieur
# [http://www.instructables.com/id/Puppeteer-Motion-Capture-Costume/ Puppeteer Motion-Capture Costume]
# [[Musical Staircase]] @ Polytech (Didier Donsez, 1 RICM4 + 1 3I4)
# [[Total Recall]] (Didier Donsez)
# [[SoundMachine]]
# [[IGN-OSM|Importation de données IGN publiques dans OSM]]
# [[Speed-limit-OSM|Analyse de traces GPX pour déterminer les limitations de vitesse]]
# [[Multi perceptual cameras]] (Didier Donsez)
# [[Photomaton 3D]] (Didier Donsez)
# [[ArduCopter]]
# [[Parking Intelligent]]

EA2014 GPGPU

2014-10-17T12:07:24Z

RICM4-prj14-grp5: /* Conclusion */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPGPU, GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPGPU, GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calculs graphiques permettant l'affichage sur un écran. Leur architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leur nombre de coeur, les GPU ont gagné en puissance brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent des calculs à hautes performances. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifiques tel que Matlab
* Tout ce qui calcul sur de grands ensembles de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratisent l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécutés sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grandes solutions.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode est celle présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances. CUDA reste tout d même le plus utilisé pour l'acceleration GPU.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

* [https://software.intel.com/en-us/intel-opencl https://software.intel.com/en-us/intel-opencl]

* [http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/ http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/]
Permet de comprendre le fonctionnement des ID dans OpenCl

*[http://gpgpu.org/ http://gpgpu.org/]

*[https://www.khronos.org/registry/cl/specs/opencl-1.2.pdf OpenCl specification]

*[https://www.khronos.org/ https://www.khronos.org/]

EA2014 GPGPU

2014-10-17T12:06:37Z

RICM4-prj14-grp5: /* OpenCl */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPGPU, GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPGPU, GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calculs graphiques permettant l'affichage sur un écran. Leur architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leur nombre de coeur, les GPU ont gagné en puissance brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent des calculs à hautes performances. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifiques tel que Matlab
* Tout ce qui calcul sur de grands ensembles de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratisent l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécutés sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grandes solutions.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode est celle présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

* [https://software.intel.com/en-us/intel-opencl https://software.intel.com/en-us/intel-opencl]

* [http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/ http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/]
Permet de comprendre le fonctionnement des ID dans OpenCl

*[http://gpgpu.org/ http://gpgpu.org/]

*[https://www.khronos.org/registry/cl/specs/opencl-1.2.pdf OpenCl specification]

*[https://www.khronos.org/ https://www.khronos.org/]

EA2014 GPGPU

2014-10-17T11:47:59Z

RICM4-prj14-grp5: /* Solutions */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPGPU, GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPGPU, GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calculs graphiques permettant l'affichage sur un écran. Leur architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leur nombre de coeur, les GPU ont gagné en puissance brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent des calculs à hautes performances. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifiques tel que Matlab
* Tout ce qui calcul sur de grands ensembles de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratisent l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécutés sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grandes solutions.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode est celle présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

* [https://software.intel.com/en-us/intel-opencl https://software.intel.com/en-us/intel-opencl]

* [http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/ http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/]
Permet de comprendre le fonctionnement des ID dans OpenCl

*[http://gpgpu.org/ http://gpgpu.org/]

*[https://www.khronos.org/registry/cl/specs/opencl-1.2.pdf OpenCl specification]

*[https://www.khronos.org/ https://www.khronos.org/]

EA2014 GPGPU

2014-10-17T11:46:16Z

RICM4-prj14-grp5: /* Pre-conditions */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPGPU, GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPGPU, GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calculs graphiques permettant l'affichage sur un écran. Leur architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leur nombre de coeur, les GPU ont gagné en puissance brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent des calculs à hautes performances. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifiques tel que Matlab
* Tout ce qui calcul sur de grands ensembles de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratisent l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécutés sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

* [https://software.intel.com/en-us/intel-opencl https://software.intel.com/en-us/intel-opencl]

* [http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/ http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/]
Permet de comprendre le fonctionnement des ID dans OpenCl

*[http://gpgpu.org/ http://gpgpu.org/]

*[https://www.khronos.org/registry/cl/specs/opencl-1.2.pdf OpenCl specification]

*[https://www.khronos.org/ https://www.khronos.org/]

EA2014 GPGPU

2014-10-17T11:45:24Z

RICM4-prj14-grp5: /* Motivations */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPGPU, GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPGPU, GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calculs graphiques permettant l'affichage sur un écran. Leur architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leur nombre de coeur, les GPU ont gagné en puissance brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent des calculs à hautes performances. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifiques tel que Matlab
* Tout ce qui calcul sur de grands ensembles de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratisent l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

* [https://software.intel.com/en-us/intel-opencl https://software.intel.com/en-us/intel-opencl]

* [http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/ http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/]
Permet de comprendre le fonctionnement des ID dans OpenCl

*[http://gpgpu.org/ http://gpgpu.org/]

*[https://www.khronos.org/registry/cl/specs/opencl-1.2.pdf OpenCl specification]

*[https://www.khronos.org/ https://www.khronos.org/]

EA2014 GPGPU

2014-10-17T11:42:34Z

RICM4-prj14-grp5: /* Introduction */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPGPU, GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPGPU, GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calculs graphiques permettant l'affichage sur un écran. Leur architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leur nombre de coeur, les GPU ont gagné en puissance brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

* [https://software.intel.com/en-us/intel-opencl https://software.intel.com/en-us/intel-opencl]

* [http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/ http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/]
Permet de comprendre le fonctionnement des ID dans OpenCl

*[http://gpgpu.org/ http://gpgpu.org/]

*[https://www.khronos.org/registry/cl/specs/opencl-1.2.pdf OpenCl specification]

*[https://www.khronos.org/ https://www.khronos.org/]

EA2014 GPGPU

2014-10-17T11:38:44Z

RICM4-prj14-grp5: /* Key Words */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPGPU, GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPGPU, GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

* [https://software.intel.com/en-us/intel-opencl https://software.intel.com/en-us/intel-opencl]

* [http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/ http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/]
Permet de comprendre le fonctionnement des ID dans OpenCl

*[http://gpgpu.org/ http://gpgpu.org/]

*[https://www.khronos.org/registry/cl/specs/opencl-1.2.pdf OpenCl specification]

*[https://www.khronos.org/ https://www.khronos.org/]

EA2014 GPGPU

2014-10-17T11:38:32Z

RICM4-prj14-grp5: /* Mots Clés */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPGPU, GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

* [https://software.intel.com/en-us/intel-opencl https://software.intel.com/en-us/intel-opencl]

* [http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/ http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/]
Permet de comprendre le fonctionnement des ID dans OpenCl

*[http://gpgpu.org/ http://gpgpu.org/]

*[https://www.khronos.org/registry/cl/specs/opencl-1.2.pdf OpenCl specification]

*[https://www.khronos.org/ https://www.khronos.org/]

EA2014 GPGPU

2014-10-17T11:37:29Z

RICM4-prj14-grp5: /* Notes et références */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

* [https://software.intel.com/en-us/intel-opencl https://software.intel.com/en-us/intel-opencl]

* [http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/ http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/]
Permet de comprendre le fonctionnement des ID dans OpenCl

*[http://gpgpu.org/ http://gpgpu.org/]

*[https://www.khronos.org/registry/cl/specs/opencl-1.2.pdf OpenCl specification]

*[https://www.khronos.org/ https://www.khronos.org/]

EA2014 GPGPU

2014-10-17T11:36:39Z

RICM4-prj14-grp5: /* Notes et références */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

* [https://software.intel.com/en-us/intel-opencl https://software.intel.com/en-us/intel-opencl]

* [http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/ http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/]
Permet de comprendre le fonctionnement des ID dans OpenCl

*[http://gpgpu.org/ http://gpgpu.org/]

*[https://www.khronos.org/registry/cl/specs/opencl-1.2.pdf OpenCl specification]

EA2014 GPGPU

2014-10-17T11:35:10Z

RICM4-prj14-grp5: /* Notes et références */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

* [https://software.intel.com/en-us/intel-opencl https://software.intel.com/en-us/intel-opencl]

* [http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/ http://jorudolph.wordpress.com/2012/02/03/opencl-work-item-ids-globalgrouplocal/]
Permet de comprendre le fonctionnement des ID dans OpenCl

EA2014 GPGPU

2014-10-17T11:32:59Z

RICM4-prj14-grp5: /* Notes et références */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
*Alexandre Chariot, Quelques Applications de la Programmation des Processeurs Graphiques à la Simulation Neuronale et à la Vision par Ordinateur, Thèse, [https://tel.archives-ouvertes.fr/file/index/docid/501212/filename/These_AChariot.pdf]

EA2014 GPGPU

2014-10-17T11:24:48Z

RICM4-prj14-grp5: /* OpenCl */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

==Conclusion==
L'un des principaux problème de accélération GPU et qu'ils étaient soit difficile à utiliser (au travers des shader) soit limité à certaines machine de par l’implémentation propre à chaque propriétaire. OpenCl résout ce problème partiellement en offrant un standard inter-constructeur. OpenCl est maintenant disponible dans plusieurs langages, permet à toutes les cartes compatibles d'utiliser GPGPU et d'effectuer des calculs hautes performances.

= Notes et références =
-

EA2014 GPGPU

2014-10-17T11:12:25Z

RICM4-prj14-grp5: /* OpenCl */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|right|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

= Notes et références =
-

EA2014 GPGPU

2014-10-17T11:11:45Z

RICM4-prj14-grp5: /* OpenCl */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.
[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|center|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

= Notes et références =
-

EA2014 GPGPU

2014-10-17T11:11:20Z

RICM4-prj14-grp5: /* OpenCl */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.
[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|center|Organisation des executions dans OpenCl]]

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|center|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

= Notes et références =
-

EA2014 GPGPU

2014-10-17T11:11:01Z

RICM4-prj14-grp5: /* OpenCl */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.
[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|center|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

= Notes et références =
-

EA2014 GPGPU

2014-10-17T11:10:07Z

RICM4-prj14-grp5: /* OpenCl */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter dans des fichiers ".cl" . L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|right|center|Diagramme de classe de l'API]]
L'API bien qu'initialement prevu en C est aussi decliné en C++. Le diagramme de classe associé permet de mieux comprendre la construction de l'API.
*Platform : Versions d'OpenCL exécutables sur cette machines
*Device : Les GPU ou CPU supportant la plateformes.
*Program : Un fichier .cl une fois compilé.
*Kernel : L'un des points d'entré du programme.
*Command Queue : La serie de command que devra executer un "device".

= Notes et références =
-

EA2014 GPGPU

2014-10-17T10:54:09Z

RICM4-prj14-grp5: /* Solutions */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté : OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter. L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|thumb|center|Diagramme de classe de l'API]]

= Notes et références =
-

EA2014 GPGPU

2014-10-17T10:53:52Z

RICM4-prj14-grp5: /* Solutions */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.

La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.

La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.

La dernière méthode et celle qui est présenté est OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter. L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|thumb|center|Diagramme de classe de l'API]]

= Notes et références =
-

File:EA2014 GPGPU OpenClClasse.jpg

2014-10-17T10:51:20Z

RICM4-prj14-grp5:

EA2014 GPGPU

2014-10-17T10:50:44Z

RICM4-prj14-grp5: /* OpenCl */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.
La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.
La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.
La dernière méthode et celle qui est présenté est OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter. L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.jpg|300px|thumb|center|Diagramme de classe de l'API]]

= Notes et références =
-

File:EA2014 GPGPU OpenClexecution.jpg

2014-10-17T10:49:27Z

RICM4-prj14-grp5:

EA2014 GPGPU

2014-10-17T10:48:57Z

RICM4-prj14-grp5: /* OpenCl */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.
La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.
La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.
La dernière méthode et celle qui est présenté est OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter. L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.jpg|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.png|300px|thumb|center|Diagramme de classe de l'API]]

= Notes et références =
-

File:EA2014 GPGPU OpenClSurcouche.png

2014-10-17T10:46:43Z

RICM4-prj14-grp5:

File:EA2014 GPGPU algorithme.png

2014-10-17T10:44:50Z

RICM4-prj14-grp5:

File:EA2014 GPGPU power.png

2014-10-17T10:42:35Z

RICM4-prj14-grp5:

File:EA2014 GPGPU graph.png

2014-10-17T10:40:44Z

RICM4-prj14-grp5:

EA2014 GPGPU

2014-10-17T09:54:17Z

RICM4-prj14-grp5: /* Principes */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.
La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.
La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.
La dernière méthode et celle qui est présenté est OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter. L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.png|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

[[Image:EA2014_GPGPU_OpenClClasse.png|300px|thumb|center|Diagramme de classe de l'API]]

= Notes et références =
-

EA2014 GPGPU

2014-10-17T09:53:20Z

RICM4-prj14-grp5: /* OpenCl */

[[Image:EA2014_GPGPU_thumb.png|right|thumb|300px|Logo d'OpenCL]]

= Présentation =

* Enseignants : Georges-Pierre Bonneau, Didier Donsez ([[EA2014]])
* Sujet : GPGPU
* Date : 17 octobre 2014
* Auteur : William Bobo <william.bobo@e.ujf-grenoble.fr>
* Lien vers les slides de la présentation : [[https://slides.com/willbobo/gpgpu Transparents]]

= Résumé =
GPGPU ou General-purpose Processing on Graphics Processing Units. C'est une méthode permettant l’exécution de calculs hautes performances sur des GPU.
Ces calculs peuvent ne pas être des calculs graphique pour lesquels ont été conçu les GPU à l'origine.
Nous prenons OpenCL comme exemple pour l’exécution de calcul sur le GPU.
== Mots Clés ==
GPU, calculs hautes performances, OpenCL

= Abstract =
GPGPU or General-purpose Processing on Graphics Processing Units. It's a methodology for high-performance computing that uses graphics processing.
Accelerated algorithms can be others than graphics algorithms that have enabled the development of GPU.
We will use OpenCL to run algorithms on a GPU.
== Key Words ==
GPU, HPC, OpenCL

= Synthèse =

==Introduction==

[[Image:EA2014_GPGPU_graph.png|300px|thumb|right|Puissances de calcul brutes comparées entre GPU NVidia et CPU Intel de 2003 à 2008.]]
Les GPU ont été à l'origine concu pour les calcul graphique permettant l'affichage sur un écran. Leurs architecture est différente des CPU, les GPU contiennent beaucoup plus de cœurs permettant la parallélisation d'une même tache. Les écrans se modernisant, les besoins en calcul ont aussi augmenté et avec leurs nombre coeur, les GPU ont gagné en puissant brut comparé aux CPU.
En 2002, une importante avancée dans la flexibilité de la programmation des GPU facilite les calculs autres que graphiques sur ces circuits.
C'est la naissance de la méthode GPGPU.
[[Image:EA2014_GPGPU_power.png|300px|thumb|center|Representation schematique des coeurs des CPU et GPU]]

==Motivations==
De nombreux domaines nécessitent de calcul à haute performance. Le fait d'utiliser GPGPU pour une application est appelé acceleration GPU.
Les principaux domaines sont :
* Le traitement de l'image
* Les simulations (Météorologique, simulation neuronal, simulation de fluide etc )
* Les outils scientifique tel que Matlab
* Tout ce qui calcul sur de grand ensemble de données (Moteur physique etc..)
Les calculs hautes performances peuvent aussi être fait sur des CPU à l'aide de cluster mais le coût est incomparable. Le rapport prix/puissance baisse régulièrement grâce aux jeux vidéos qui démocratise l'utilisation de GPU.

==Pre-conditions==
Les algorithmes exécuté sur les GPU ne sont pas les même que ceux sur les CPU. Les algorithmes doivent être re-écris pour une exécution parallèle.
[[Image:EA2014_GPGPU_algorithme.png|300px|thumb|center|Exécution en série et exécution parallèle]]
Ce type d’exécution rend très efficace le traitement de grands ensembles de données dans le cas où le traitement est identique pour chacun de ces éléments.

==Solutions==
Il y a trois grand type de solution.
La plus ancienne est celle des shaders qui semblera familière aux utilisateurs d'OpenGL.
La second méthode est conçu par les constructeurs de GPU. Nvidia a fait CUDA et AMD FireStream par exemple.
La dernière méthode et celle qui est présenté est OpenCL.

==OpenCl==

[[Image:EA2014_GPGPU_OpenClSurcouche.png|300px|thumb|right|OpenCl et certaines de ses surcouche]]
OpenCl ou Open Computing Langage est un standard proposé par le Khronos Group. C'est un consortium industriel dont font parti entre autres Nvidia, ATI, AMD, ARM et Intel.

OpenCL spécifie une API et un langage. Le langage est un dérivé du C et permet d’écrire les algorithme à exécuter. L'API permet de gérer les entré sorties de l'algorithme, la synchronisation et l’exécution.
OpenCL permet d'utiliser GPGPU mais va au delà. Ce standard est conçu pour qu'avec le même code, l’exécution puisse être faite sur un GPU ou un CPU.

===Principes===
Les programmes crées dans le langage OpenCl sont compilé à l’exécution à l'aide de l'API OpenCl. Cela rappel l'utilisation des shader dans OpenGl.
Il est possible de créer un pont entre OpenCl et OpenGl pour échanger des objets tel que des buffers.

[[Image:EA2014_GPGPU_OpenClexecution.png|300px|thumb|right|Organisation des executions dans OpenCl]]
Le CUDA se basait sur l'unité "Thread" pour exprimé l’exécution parallèle.
Pour OpenCl, l'unité est le work-item. Pour chaque work-item, une execution de l'algorithme est invoqué. Chaque work-item a une memoire privée.
Les work-item sont rassemblé dans es work-group. Chaque work-item d'un work-group partagent une mémoire local.
Le nombre total de work-item est specifié par la taille des données à traiter. Il y a une memoire constante et une memoire globale partagé par tout les work-item.

OpenCl utilise la notion de dimension. Les work-item et les work-group peuvent être déclaré avec des indices dimensionnel plutôt qu'un entier simple.

= Notes et références =
-

EA2014 GPGPU

2014-10-17T09:31:15Z

RICM4-prj14-grp5: /* OpenCl */

EA2014 GPGPU

2014-10-17T09:13:17Z

RICM4-prj14-grp5: /* OpenCL */

EA2014 GPGPU

2014-10-17T08:53:44Z

RICM4-prj14-grp5: /* Pre-conditions */

EA2014 GPGPU

2014-10-17T08:46:02Z

RICM4-prj14-grp5: /* Pre-conditions */

EA2014 GPGPU

2014-10-17T08:36:48Z

RICM4-prj14-grp5: /* Synthèse */

EA2014 GPGPU

2014-10-17T08:25:53Z

RICM4-prj14-grp5: /* Motivations */

EA2014 GPGPU

2014-10-17T08:18:29Z

RICM4-prj14-grp5: /* Motivations */

EA2014 GPGPU

2014-10-17T08:01:06Z

RICM4-prj14-grp5: /* Motivations */

EA2014 GPGPU

2014-10-17T07:52:23Z

RICM4-prj14-grp5: /* Motivations */

EA2014 GPGPU

2014-10-17T07:45:01Z

RICM4-prj14-grp5: /* Introduction */

EA2014 GPGPU

2014-10-17T07:44:44Z

RICM4-prj14-grp5: /* Introduction */

EA2014 GPGPU

2014-10-17T07:44:33Z

RICM4-prj14-grp5: /* Introduction */

EA2014 GPGPU

2014-10-17T07:44:11Z

RICM4-prj14-grp5: /* Introduction */

EA2014 GPGPU

2014-10-17T07:43:18Z

RICM4-prj14-grp5: /* Synthèse */