OpenMP: diferència entre les revisions
Contingut suprimit Contingut afegit
Cap resum de modificació |
|||
| Línia 1: | Línia 1: | ||
{{Falta verificar admissibilitat|data=2020}} |
|||
{{Currículum}} |
|||
{{Infotaula programari}} |
{{Infotaula programari}} |
||
'''OpenMP''' (Open Multi-Processing) és una [[interfície de programació d'aplicacions]] (API) que |
'''OpenMP''' ('''Open Multi-Processing''') és una [[interfície de programació d'aplicacions]] (API) que admet programació [[Multiprocés|multiprocessament]] [[Memòria compartida|de memòria compartida]] multiplataforma en [[Llenguatge C|C]], [[C++]] i [[Fortran]],<ref name="OSConcepts2">{{Ref-llibre|cognom=Gagne|nom=Abraham Silberschatz, Peter Baer Galvin, Greg|títol=Operating system concepts|editorial=Wiley|lloc=Hoboken, N.J.|isbn=978-1-118-06333-0|pàgines=181–182|edició=9th|data=2012-12-17}}</ref> en moltes plataformes, [[Arquitectura del conjunt d'instruccions|arquitectures de conjunt d'instruccions]] i [[Sistema operatiu|sistemes operatius]], inclòs [[Solaris (sistema operatiu)|Solaris]], [[AIX]], [[FreeBSD]], [[HP-UX]], [[Linux]], [[macOS]] i [[Microsoft Windows|Windows]]. Consisteix en un conjunt de [[Compiler directive|directives del compilador]], [[Biblioteca informàtica|rutines de biblioteca]] i [[Variable d'entorn|variables d'entorn]] que influeixen en el comportament en temps d'execució.<ref>[http://openmp.org/wp/2008/10/openmp-tutorial-at-supercomputing-2008/ OpenMP Tutorial at Supercomputing 2008]</ref> <ref>[http://openmp.org/wp/2009/04/download-book-examples-and-discuss/ Using OpenMP – Portable Shared Memory Parallel Programming – Download Book Examples and Discuss]</ref> |
||
OpenMP està gestionat pel [[consorci]] tecnològic [[Organització sense ànim de lucre|sense ànim de lucre]] ''OpenMP Architecture Review Board'' (o ''OpenMP ARB''), definit conjuntament per una àmplia gamma de proveïdors de maquinari i programari informàtics líders, com [[ARM Holdings|Arm]], [[AMD]], [[IBM]], [[Intel]], [[Cray Inc.|Cray]], [[Hewlett-Packard|HP]], [[Fujitsu]], [[Nvidia]], [[NEC Corporation|NEC]], [[Red Hat]], [[Texas Instruments]] i [[Oracle Corporation]].<ref name="Board"><cite class="citation web cs1"><span class="cx-segment" data-segmentid="439">[https://web.archive.org/web/20130809153922/http://openmp.org/wp/about-openmp/ "About the OpenMP ARB and"]. </span><span class="cx-segment" data-segmentid="440">OpenMP.org. </span><span class="cx-segment" data-segmentid="441">2013-07-11. </span><span class="cx-segment" data-segmentid="442">Archived from [http://openmp.org/wp/about-openmp/ the original] on 2013-08-09<span class="reference-accessdate">. </span></span><span class="cx-segment" data-segmentid="443"><span class="reference-accessdate">Retrieved <span class="nowrap">2013-08-14</span></span>.</span></cite></ref> |
|||
Definit conjuntament per un grup dels principals fabricants de [[maquinari]] i [[programari]], OpenMP és un model portable i escalable que dona als programadors una interfície simple i flexible per a desenvolupar aplicacions paral·leles per a plataformes que van des de l'escriptori fins als [[supercomputador]]s. |
|||
OpenMP utilitza un model [[Portabilitat|portàtil]] i escalable que ofereix [[Programador|als programadors]] una interfície senzilla i flexible per desenvolupar aplicacions paral·leles per a plataformes que van des de l'[[Ordinador de taula|ordinador d'escriptori]] estàndard fins al [[Supercomputador|superordinador]]. |
|||
Una aplicació construïda amb el model híbrid de programació paral·lela pot executar-se en un raïm d'ordinadors fent servir OpenMP i [[Message Passing Interface]] (MPI). |
|||
Una aplicació construïda amb el model híbrid de [[Computació paral·lela|programació paral·lela]] es pot executar en un [[Clúster|clúster d'ordinadors]] utilitzant tant OpenMP com [[Message Passing Interface|la interfície de pas de missatges]] (MPI), de manera que OpenMP s'utilitza per al paral·lelisme ''dins'' d'un node (multi-nucli) mentre que MPI s'utilitza per al paral·lelisme ''entre'' nodes. També hi ha hagut esforços per executar OpenMP en sistemes [[Distributed shared memory|de memòria compartida distribuïda per programari]],<ref>{{Ref-publicació|cognom=Costa|nom=J.J.|display-authors=etal|data=May 2006|publicació=Journal of Parallel and Distributed Computing|volum=66|exemplar=5|pàgines=647–658|doi=10.1016/j.jpdc.2005.06.018}}</ref> per traduir OpenMP a MPI <ref>{{Ref-llibre|cognom=Basumallik|nom=Ayon|títol=2007 IEEE International Parallel and Distributed Processing Symposium|capítol=Programming Distributed Memory Systems Using OpenMP|pàgines=1–8|lloc=New York|editorial=IEEE Press|any=2007|doi=10.1109/IPDPS.2007.370397|isbn=978-1-4244-0909-9}}</ref> <ref>{{Ref-publicació|cognom=Wang|nom=Jue|cognom2=Hu|nom2=ChangJun|cognom3=Zhang|nom3=JiLin|cognom4=Li|nom4=JianJiang|data=May 2010|publicació=Science China Information Sciences|volum=53|exemplar=5|pàgines=932–944|doi=10.1007/s11432-010-0074-0|dataaccés=free}}</ref> i per estendre OpenMP per a sistemes de memòria no compartida.<ref>[https://software.intel.com/en-us/articles/cluster-openmp-for-intel-compilers Cluster OpenMP] (a product that used to be available for [[Intel C++ Compiler]] versions 9.1 to 11.1 but was dropped in 13.0)</ref> |
|||
== Introducció == |
|||
<!-- |
|||
[[Fitxer:Fork_join.svg|450px|miniatura|Una il·lustració de [[multithreading]] on el thread mestre es bifurca en un nombre de threads que executen blocs de codi en paral·lel]] |
|||
--> |
|||
OpenMP és una implementació de multithreading, un mètode de paral·lelització pel qual el "[[thread]]" (fil, en anglès) mestre (una sèrie d'instruccions executades consecutivament) es "bifurca" en un nombre determinat de "threads" esclaus i la tasca es divideix entre ells. Els threads llavors s'executen concurrentment, amb l'entorn d'execució ubicant els threads a diferents processadors. |
|||
La secció de codi que es vol que s'executi en paral·lel és marcada corresponentment, amb una directiva de preprocessador que farà que els threads es formin abans que la secció sigui executada. Cada thread té un "id" (identificador) associat que pot ser obtingut fent servir una funció (anomenada <code>omp_get_thread_num()</code> a C/C++ i <code>OMP_GET_THREAD_NUM()</code> a Fortran). L'id de thread és un enter, i el thread mestre té una id de "0". Després de l'execució del codi paral·lelitzat, els threads s'"uneixen" de nou al thread mestre, que continua endavant fins al final del programa. |
|||
Per defecte, cada thread executa la secció de codi paral·lelitzada independentment. Es poden fer servir "construccions de compartició de treball" per a dividir una tasca entre els threads de forma que cada thread executi la part de codi que té assignada. Fent servir OpenMP d'aquesta forma es pot aconseguir tant el [[paral·lelisme de tasques]] com el [[Paral·lelisme de Dades|paral·lelisme de dades.]] |
|||
L'entorn d'execució assigna els threads a processadors depenent de l'ús, la càrrega de la màquina i altres factors. El nombre de threads pot ser assignat per l'entorn d'execució basant-se en [[Variable d'entorn|variables d'entorn]] o en codi fent servir funcions. Les funcions OpenMP estan incloses en un fitxer de capçalera amb el nom "omp.h" a C/C++. |
|||
== Història == |
|||
{{Prosa}} |
|||
A l'Octubre de 1997, L'[https://www.openmp.org/ OpenMP] Architecture Review Board (ARB) va publicar el seu primer estàndard, OpenMP per a [[Fortran]] 1.0.<ref>{{Ref-web|url= https://www.openmp.org/wp-content/uploads/fspec10.pdf|títol=OpenMP Fortran Application Program |
|||
Interface| consulta=15 d'abril de 2019|llengua=Anglés| editor=OpenMP|data=11-2-1998}}</ref> A l'Octubre de l'any vinent van publicar l'estàndard per [[Llenguatge C|C]]/[[C++]].<ref>{{Ref-web|url= https://www.openmp.org/wp-content/uploads/cspec10.pdf|títol=OpenMP C and C++ Application |
|||
Program Interface| consulta=15-4-2019|llengua=Anglés| editor=OpenMP|data=30-10-1998}}</ref> A l'any 2000 va sortir la versió 2.0 de l'estàndard [[Fortran]],<ref>{{Ref-web|url= https://www.openmp.org/wp-content/uploads/fspec20.pdf|títol=OpenMP Fortran Application Program |
|||
Interface |
|||
Version 2.0, novembre 2000| consulta=15-4-2019|llengua=Anglés| editor=OpenMP|data=28-10-2000}}</ref> i dos anys més tard la mateixa versió per C/C++.<ref>{{Ref-web|url= https://www.openmp.org/wp-content/uploads/cspec20.pdf|títol=OpenMP C and C++ |
|||
Application Program |
|||
Interface |
|||
Version 2.0 març 2002| consulta=15-4-2019|llengua=Anglés| editor=OpenMP|data=1-3-2002}}</ref> La versió 2.5 és una combinació entre les especificacions de C/C++/Fortan, que va arribar al 2005.<ref>{{Ref-web|url= https://www.openmp.org/wp-content/uploads/spec25.pdf|títol=OpenMP Application |
|||
Program Interface |
|||
Version 2.5 maig 2005| editor=OpenMP|data=1-5-2005}}</ref> |
|||
Fins a la versió 2.0, OpenMP es va centrar principalment en formes de [[Computació paral·lela|paral·lelitzar]] bucles molt regulars, que es produeixen per exemple en la programació numèrica orientada a [[Matriu (matemàtiques)|matrius]], on es coneix el nombre d'iteracions del bucle al iniciar l'operació. Això es va reconèixer com una limitació del paral·lelisme i a partir d'aquest punt es van afegir diverses extensions de [[:en:Task parallelism|tasques paral·leles]] a les implementacions. El 2005, es va intentar estandarditzar el paral·lelisme de tasques, publicant una proposta al 2007, inspirada en les característiques del paral·lelisme de tasques de [[:en:Cilk|Cilk]], [[X10 (llenguatge de programació)|X10]] i [[:en:Chapel (programming language)|Chapel]]. |
|||
Així doncs, la versió 3.0 es va llançar al Maig de 2008,<ref>{{Ref-web|url= https://www.openmp.org/wp-content/uploads/spec30.pdf|títol=OpenMP Application |
|||
Program Interface |
|||
Version 3.0 maig 2008| editor=OpenMP|data=1-3-2008}}</ref> afegint noves directives per donar suport al paral·lelisme de tasques i la seva construcció, ampliant significativament l'abast d'OpenMP més enllà de les construccions de bucles paral·lels que formaven la majoria d'OpenMP 2.0. |
|||
Al Juliol de 2013 surt la versió 4.0.<ref>{{Ref-web|url= https://www.openmp.org/wp-content/uploads/OpenMP4.0.0.pdf|títol=OpenMP |
|||
Application Program |
|||
Interface |
|||
Version 4.0 - juliol 2013| editor=OpenMP|data=1-7-2013}}</ref> Aquesta afegeix o millora diversos aspectes de la versió anterior. Afegeix suport per [[:en:Hardware acceleration|acceleradors]], mecanismes per descriure regions de codi on còmput o memòria s'ha de moure cap algun altre dispositiu. Inclou suport per vectorització [[SIMD]]. Gestió d'errors (''[[:en:Exception handling|Error Handling]]'') per millorar la resistència i estabilitat de les aplicacions en relació amb errors a nivell de sistema, execució i definits per l'usuari. [[:en:Processor affinity|Thread affinity]], mecanismes per definir on executar els [[Fil d'execució|threads]] OpenMP. Extensions pel paral·lelisme de tasques, com el seu agrupament o avortament i major suport a la seva sincronització i [[:en:Data dependency|dependència de dades]]. Suport per Fortran 2003. [[:en:Reduce (parallel pattern)|Reduccions]] definides per l'usuari i [[:en:Linearizability|Operacions atòmiques]]. |
|||
Al Novembre de 2015, s'anuncia la versió 4.5.<ref>{{Ref-web|url= https://www.openmp.org/wp-content/uploads/openmp-4.5.pdf|títol=OpenMP |
|||
Application Programming |
|||
Interface |
|||
Version 4.5 novembre 2015| editor=OpenMP|data=1-11-2015}}</ref> Aquesta versió ofereix una millora del suport per a programació de dispositius acceleradors i [[Gpu|GPU]], la paral·lelització de bucles amb dependències ben estructurades i el suport per a [[:en:DOACROSS parallelism|bucles ''doacross'']], entre altres especificacions. |
|||
Al Novembre de 2018 surt la última versió d'OpenMP fins al moment 5.0.<ref>{{Ref-web|url= https://www.openmp.org/wp-content/uploads/OpenMP-API-Specification-5.0.pdf|títol=OpenMP |
|||
Application Programming |
|||
Interface |
|||
Version 5.0 novembre 2018| editor=OpenMP|data=1-11-2018}}</ref> Aquesta versió inclou finalment un suport complet per dispositius acceleradors, que encara s'estava desenvolupant a la versió 4.5. Millora de la [[Depuració de programes|depuració]] i l'anàlisi del rendiment. Suport per les últimes versions Fortran 2008, C11 i C++17. Suport per construccions de bucles “fully descriptive”, que dona al compilador més llibertat per triar una millor implementació. Sistemes de memòria multinivell, mecanismes d'assignació de memòria que col·loquen les dades en diferents tipus d'aquestes. I millora de la portabilitat. Aquesta versió és l'actual de les especificacions de l'API. |
|||
== Interfície d'usuari == |
|||
=== Directives de compilació === |
|||
A OpenMP es troben una sèrie de construccions de control i d'atributs de dades, que s'estenen al llenguatge base (F77, f90, C i C++). Els compiladors, per defecte, ometen aquestes directives OpenMP si no s'activen mitjançant un flag "-mp" o "-fopenmp". |
|||
=== Biblioteca i variables d'entorn === |
|||
OpenMP disposa d'un conjunt de funcions per controlar paràmetres incloses a la llibreria de C "omp.h". Un exemple seria la definició del número de threads mitjançant <code>call omp_set_num_threads(64)</code>. Per una altra banda, disposa de variables d'entorn que permeten controlar paràmetres de forma diferent, com per exemple <code>setenv OMP_NUM_THREADS(8).</code> |
|||
== Elements principals == |
|||
Els elements principals d'OpenMP són directives per a la creació de threads, distribució de treball, gestió de dades en l'entorn, sincronització de threads, rutines d'execució a nivell d'usuari i variables d'entorn. Aquestes directives a C/C++ s'anomenen #pragmas. |
|||
=== Directives vectorials === |
|||
En un primer nivell, podem diferenciar les directives [[SIMD]] o vectorial, destinades a paral·lelisme a nivell de dades. La directiva <code>#pragma omp simd</code>, indica al compilador que el bucle següent es vectoritzable. |
|||
Segons la versió del compilador apuesta directiva pot ser ignorada, que el processador trobi errades en dependències de dades que impedeixin la paral·lelització d'aquest o bé que utilitzi aquesta directiva com a pista per a utilitzar instruccions vectorials. La directiva <code>#pragma omp declare simd</code> indica al compilador que ha de generar una versió SIMD d'una funció que podrà ser cridada des d'un bucle vectoritzat. Per tant, la funció declarada amb aquesta directiva podrà també ser executada sense necessitat d'aplicar paral·lelisme de dades. |
|||
Tot i que no ho indiquem explícitament, el compilador analitza el codi i tracta de vectoritzar els bucles de forma automàtica (sempre que s'indiqui al compilador un nivell d'optimització adequat mitjançant clags com -O3 o Ofast). Per comprobar que realment el [[compilador]] ha vectoritzat un bucle, podem analitzar el [[codi màquina]] on descobrirem una "p" als mnemònics de les instruccions assembler, fet que confirma la utilització de paralel·lisme SIMD. |
|||
=== Creació de threads === |
|||
La directiva <code>#pragma omp parallel</code>, basada en un model d'execució FORK-JOIN que indica al compilador que el codi serà executat per diferents threads, creant així una regió paral·lela. El thread encarregat de crear la resta s'anomena master amb id 0. Un cop realitzat el [[Fork (Unix)|fork]], el compilador reparteix trossos d'iteracions del següent bucle als diferentes threads. Per defecte la variable d'iteració del bucle és privada per a cada thread però cal tenir en compte que si no s'especifica el contrari, la resta de variables del codi sera compartides per tots els threads. També és destacable que totes les variables creades a l'interior d'aquesta construcció seran creades per a cada thread. |
|||
=== Directives de compartició de treball === |
|||
Les directives de compartició de treball són utilitzades per a especificar com es reparteix el treball a un o tots els threads. |
|||
* <code>for</code>: Utilitzat per repartir iteracions de bucles entre diferents threads. |
|||
* <code>section</code>: Utilitzat per distribuir un bloc de codi a un únic thread. |
|||
* <code>single:</code> Especifica que un tros de codi serà executat per un únic thread, amb un barrier implícit al final. |
|||
* <code>master</code>: Especifica que un tros de codi serà executat per un únic thread, que serà el master. No conté un barrier al final. |
|||
=== Clàusules === |
|||
==== Clàusules de compartició de dades ==== |
|||
* <code>private(list)</code>: Especifica que cada subprocés ha de tenir la seva propia instància d'una variable. Una variable privada no és inicialitzada i tampoc es manté el seu valor fora de la regió paral·lela. Per definició, el comptador d'iteracions en OpenMP és privat. |
|||
* <code>firstprivate(list)</code>: Realitza la mateixa funció que la clàusula private, però inicialitza la variable privada amb el valor de la variable del thread master. |
|||
* <code>lastprivate(list)</code>: Les variables de la lista s'inicialitzen a 0 i la variable del thread master és actualitzada amb el valor de l'última iteració a realitzar. |
|||
* <code>shared(list)</code>: Especifica que les variables incloses a la llista són compartides per tots els threads. |
|||
* <code>default(shared | none)</code>: Es pot definir com a shared que significa que qualsevol variable de la regió paral·lela es tractarà com si estigués a l'interior d'una clàusula shared o no, on la variable serà tractada com a privada o compartida. Per defecte, el valor de la clàusula default serà shared. |
|||
* <code>reduction(reduction-identifier: list):</code> Especifica que les variables de la llista estan subjectes a un operador de reducció com sum, min/max o count. La reducció es pot implementar amb una crida a funció. |
|||
==== Clàusules de sincronització ==== |
|||
* <code>critical</code>: El bloc de codi s'executa per un únic thread en cada moment, fet que evita condicions de carrera. |
|||
* <code>atomic</code>: Les actualitzacions en memoria de la següents instrucció s'executen atòmicament, és a dir, microinstrucció a microinstrucció. El compilador utilitza instruccions hardware que proporcionen un millor rendiment que utilitzant <code>critical</code> |
|||
* <code>ordered</code>: El block s'executa en l'ordre en que les iteracions s'executarien en un bucle seqüencial. |
|||
* <code>barrier</code>: Cada thread espera que la resta acabi la seva execució. Les directives de compartició de treball contenen un barrier implícit. |
|||
* <code>nowait</code>: Especifica que els threads que acabin el treball assignat no han d'esperar a que la resta finalitzin la seva execució. En absència d'aquesta clàusula, els threads esperaran a l'execució de la resta. |
|||
==== Clàusules de planificació ==== |
|||
* <code>schedule(type, chunk)</code>: Utilitzat en directives de compartició de treball per definir el mètode utilitzat per repartir iteracions d'un bucle entre diferents threads. |
|||
** <code>static</code>: Les iteracions del bucle són assignades a cada thread abans de l'execució. Per defecte, les iteracions es reparteixen de forma equitativa entre tots els threads, però mitjançant el paràmetre ''chunk'' especifiquem el nombre chunk d'iteracions que assignarem a un thread. |
|||
** <code>dynamic</code>: S'assignen una sèrie d'iteracions als threads, que quan acaben l'execució, obté noves iteracions per a realitzar. El paràmetre ''chunk'' especifica quantes iteracions s'assignen a cada thread cada vegada. |
|||
** <code>guided</code>: S'assigna una gran quantitat d'iteracions a cada thread, que va disminuint a mesura que avança l'execució. D'aquesta manera, cada thread rep menys treball cada vegada que en demana més. El paràmetre ''chunk'' indica quin és el nombre mínim d'iteracions que pot arribar a rebre cada thread. |
|||
==== Control amb if ==== |
|||
* <code><nowiki>if([ parallel :] scalar-logical-expression)</nowiki></code>: Permet establir una expressió tenera, que segons si s'evalua com a 1 o un 0, executarà el codi de la regió paral·lela en paral·lel o de forma seqüencial, respectivament. |
|||
==== Còpia de dades ==== |
|||
* <code>copyin(list)</code>: Realitza la mateixa funció que la clàusula private, però inicialitza la variable privada amb el valor de la variable del thread master. És útil en variables definides mitjançant <code>threadprivate(list)</code> que permet definir variables privades associades a cada thread d'una regió paral·lela que mantindran el mateix valor cada cop que el thread associat sigui creat. |
|||
* <code>copyprivate</code>: Utilitzat amb <code>single</code> per copiar valors d'objectes privats d'un thread a objectes d'altres threads. |
|||
==== Distribució física de threads ==== |
|||
* <code>proc_bind(master | close | spread)</code>: Controla el thread affinity dels threads. La opció master obliga a tots els threads del team a ser assignats al mateix lloc del thread master. Amb l'opció close, els threads són assignats a llocs propers al del thread master. En cas que siguie spread, els threads s'assignen de forma dispersa. |
|||
==== Definició del número de threads ==== |
|||
* <code>num_treads(scalar-integer-expression)</code>: Permet definir el nombre de threads que executaran el codi de la regió paral·lela. |
|||
=== Variables d'entorn === |
|||
Les variables d'entorn són un mètode per alterar les característiques d'execució de les aplicacions que utilitzen OpenMP, com per exemple el número de threads que es crearan per defecte a les regions paral·leles mitjançant OMP_NUM_THREADS. |
|||
== Implementacions<ref>{{Ref-web|url= http://www.openmp.org/resources/openmp-compilers/|títol=OpenMP Compilers - OpenMP| consulta=2017-07-14|llengua=anglès}}</ref> == |
|||
Compiladors amb implementació d'OpenMP 3.0: |
|||
* [[Gcc|GCC 4.3.1]] |
|||
* Compilador Mercurium |
|||
* Compiladors Intel Fortran i C/C++, versions 11.0 i 11.1 i Intel C/C++ and Fortran Composer XE 2011 and Intel Parallel Studio. |
|||
* Compilador IBM XL C/C++ |
|||
* L'actualització 1 de Sun Studio 12 té una implementació completa d'OpenMP 3.0 |
|||
Nombrosos compiladors soporten OpenMP 3.1: |
|||
* GCC 4.7 |
|||
* Compiladors Intel Fortran i C/C++ 12.1 |
|||
* [[LLVM|LLVM/Clang 3.7]] |
|||
Diferents compiladors soporten OpenMP 4.0: |
|||
* GCC 4.9.0 per C/C++, GCC 4.9.1 per Fortran |
|||
* Compiladors Intel Fortran i C/C++ 15.0 |
|||
* LLVM/Clang 3.7 (partial) |
|||
Compiladors auto-paral·lelitzadors que generen codi font amb directives d'OpenMP: |
|||
* iPat/OMP |
|||
* Parallware |
|||
* PLUTO |
|||
* ROSE(Compiler framework) |
|||
* S2P by KPIT Cummins Infosystems Ltd. |
|||
Diversos profilers i debuggers també soporten OpenMP: |
|||
* Allinea Distributed Debugging Tool (DDT) |
|||
* Allinea MAP |
|||
* ompP |
|||
* VAMPIR |
|||
== Avantatges i inconvenients == |
|||
=== Avantatges === |
|||
* Codi multithreading portable. |
|||
* Simple, ja que no necessita [[pas de missatges]] com a [[Message Passing Interface|MPI]]. |
|||
* La descomposició de dades es gestionada per directives automàticament. |
|||
* Escalabilitat, si ho comparem amb MPI, en sistemes de memòria compartida. |
|||
* Pot treballar només en una part del programa, i no necessita que el codi original sigui modificat pel que es redueix la probabilitat d'introduir bugs. |
|||
* Codi unificat per aplicacions sèrie i paral·leles. Les directives d'OpenMP són tractades com a comentaris si no s'especifica el flag corresponent. |
|||
* Permet paral·lelisme amb granularitat fina o gruixuda, depenent de les necessitats i l'entorn de cada aplicació. |
|||
* Pot ser utilitzat en acceleradors com [[GPGPU]]. |
|||
=== Inconvenients === |
|||
* Risc d'introduir [[Error de programari|bugs]] en debugging i condicions de carrera. |
|||
* La seva execució només es eficient en [[multiprocessador]]s amb [[memòria compartida]]. |
|||
* Necessita un compilador que suporti OpenMP (gcc i icc en serien bons exemples). |
|||
* L'escalabilitat es superior a la de MPI però ve determinada per l'arquitectura de memoria. |
|||
* No té suport per a compare-and-swap. |
|||
* No té un bon tractament d'errors. |
|||
* És possible reduir el rendiment fàcilment amb un ús compartit fals (false sharing). |
|||
== Referències == |
== Referències == |
||
Revisió del 16:59, 16 nov 2024
  | |
| Tipus | estàndard tècnic i programari |
|---|---|
| Versió estable | 6.0 (14 novembre 2024)
|
| Característiques tècniques | |
| Sistema operatiu | multiplataforma |
| Escrit en | C++ i C |
| Més informació | |
| Lloc web | openmp.org (anglès) |
| Stack Exchange | Etiqueta |
|
| |
OpenMP (Open Multi-Processing) és una interfície de programació d'aplicacions (API) que admet programació multiprocessament de memòria compartida multiplataforma en C, C++ i Fortran,[1] en moltes plataformes, arquitectures de conjunt d'instruccions i sistemes operatius, inclòs Solaris, AIX, FreeBSD, HP-UX, Linux, macOS i Windows. Consisteix en un conjunt de directives del compilador, rutines de biblioteca i variables d'entorn que influeixen en el comportament en temps d'execució.[2] [3]
OpenMP està gestionat pel consorci tecnològic sense ànim de lucre OpenMP Architecture Review Board (o OpenMP ARB), definit conjuntament per una àmplia gamma de proveïdors de maquinari i programari informàtics líders, com Arm, AMD, IBM, Intel, Cray, HP, Fujitsu, Nvidia, NEC, Red Hat, Texas Instruments i Oracle Corporation.[4]
OpenMP utilitza un model portàtil i escalable que ofereix als programadors una interfície senzilla i flexible per desenvolupar aplicacions paral·leles per a plataformes que van des de l'ordinador d'escriptori estàndard fins al superordinador.
Una aplicació construïda amb el model híbrid de programació paral·lela es pot executar en un clúster d'ordinadors utilitzant tant OpenMP com la interfície de pas de missatges (MPI), de manera que OpenMP s'utilitza per al paral·lelisme dins d'un node (multi-nucli) mentre que MPI s'utilitza per al paral·lelisme entre nodes. També hi ha hagut esforços per executar OpenMP en sistemes de memòria compartida distribuïda per programari,[5] per traduir OpenMP a MPI [6] [7] i per estendre OpenMP per a sistemes de memòria no compartida.[8]
Referències
- ↑ Gagne, Abraham Silberschatz, Peter Baer Galvin, Greg. Operating system concepts. 9th. Hoboken, N.J.: Wiley, 2012-12-17, p. 181–182. ISBN 978-1-118-06333-0.
- ↑ OpenMP Tutorial at Supercomputing 2008
- ↑ Using OpenMP – Portable Shared Memory Parallel Programming – Download Book Examples and Discuss
- ↑ "About the OpenMP ARB and". OpenMP.org. 2013-07-11. Archived from the original on 2013-08-09. Retrieved 2013-08-14.
- ↑ Costa, J.J.; etal Journal of Parallel and Distributed Computing, 66, 5, 5-2006, pàg. 647–658. DOI: 10.1016/j.jpdc.2005.06.018.
- ↑ Basumallik, Ayon. «Programming Distributed Memory Systems Using OpenMP». A: 2007 IEEE International Parallel and Distributed Processing Symposium. New York: IEEE Press, 2007, p. 1–8. DOI 10.1109/IPDPS.2007.370397. ISBN 978-1-4244-0909-9.
- ↑ Wang, Jue; Hu, ChangJun; Zhang, JiLin; Li, JianJiang Science China Information Sciences, 53, 5, 5-2010, pàg. 932–944. DOI: 10.1007/s11432-010-0074-0 [Consulta: free].
- ↑ Cluster OpenMP (a product that used to be available for Intel C++ Compiler versions 9.1 to 11.1 but was dropped in 13.0)
Enllaços externs
- OpenMP - Lloc web oficial
- GNU GOMP (anglès) Projecte de suport d'OpenMP a C, C++ i Fortran per als compiladors de la GNU Compiler Collection, en funcionament des de la versió GCC 4.2
- OpenMP a Visual C++ (anglès)