View source for OpenHMPP

{{Multiple issues|
{{third-party|date=August 2015}}
{{one source|date=June 2014}}
{{overly detailed|date=June 2014}}
}}

'''OpenHMPP''' (HMPP<ref>{{cite conference|url=http://www.caps-entreprise.com/wp-content/uploads/2012/08/caps-hmpp-gpgpu-Boston-Workshop-Oct-2007.pdf|title=HMPP: A Hybrid Multi-core Parallel Programming Environment|conference=Workshop on General Purpose Processing on Graphics Processing Units|conference-url=https://web.archive.org/web/20140116115330/http://www.ece.neu.edu/GPGPU/GPGPU-1/|last1=Dolbeau|first1=Romain|last2=Bihan|first2=Stéphane|last3=Bodin|first3=François|date=4 October 2007|access-date=14 January 2014|url-status=dead|archive-url=https://web.archive.org/web/20140116105646/http://www.caps-entreprise.com/wp-content/uploads/2012/08/caps-hmpp-gpgpu-Boston-Workshop-Oct-2007.pdf|archive-date=16 January 2014}}</ref> for Hybrid Multicore Parallel Programming) - programming standard for [[heterogeneous computing]]. Based on a set of compiler directives, standard is a programming model designed to handle [[hardware accelerator]]s without the complexity associated with [[GPGPU|GPU programming]]. This approach based on directives has been implemented because they enable a loose relationship between an application code and the use of a hardware accelerator (HWA).

== Introduction ==
The OpenHMPP directive-based programming model offers a syntax to offload computations on hardware accelerators and to optimize data movement to/from the hardware memory.

The model is based on works initialized by CAPS (Compiler and Architecture for Embedded and Superscalar Processors), a common project from [[National Institute for Research in Computer Science and Control|INRIA]], [[French National Centre for Scientific Research|CNRS]], the [[University of Rennes 1]] and the INSA of Rennes.

== OpenHMPP concept ==

OpenHMPP is based on the concept of codelets, functions that can be remotely executed on HWAs.

=== The OpenHMPP codelet concept ===

A codelet has the following properties:
# It is a [[pure function]].
#* It does not contain [[Static variable|static]] or [[Volatile variable|volatile]] variable declarations nor refer to any global variables except if these have been declared by a HMPP directive “resident”
#* It does not contain any function calls with an invisible body (that cannot be inlined). This includes the use of libraries and system functions such as malloc, printf, ...
#* Every function call must refer to a static pure function (no function pointers).
# It does not return any value (void function in [[C (programming language)|C]] or a subroutine in [[Fortran]]).
# The number of arguments should be fixed (i.e. it can not be a [[variadic function]] as in [[stdarg.h]] in C).
# It is not recursive.
# Its parameters are assumed to be non-aliased (see [[Aliasing (computing)]] and [[Pointer aliasing]]).
# It does not contain callsite directives (i.e. RPC to another codelet) or other HMPP directives.
These properties ensure that a codelet [[Remote procedure call|RPC]] can be remotely executed by a HWA. This RPC and its associated data transfers can be asynchronous.

=== Codelet RPCs ===
HMPP provides synchronous and asynchronous RPC. Implementation of asynchronous operation is hardware dependent.
[[File:HMPP RPC.png|center|thumb|upright=1.75|Synchronous versus asynchronous RPC]]

=== HMPP Memory Model ===
HMPP considers two address spaces: the host processor one and the HWA memory.

[[File:HMPP Memory Model.png|center|thumb|upright=1.7|HMPP memory Model]]

=== Directives concept ===
The OpenHMPP directives may be seen as “meta-information” added in the application source code. They are safe meta-information i.e. they do not change the original code behavior. They address the remote execution (RPC) of a function as well as the transfers of data to/from the HWA memory.

The table below introduces the OpenHMPP directives. OpenHMPP directives address different needs: some of them are dedicated to declarations and others are dedicated to the management of the execution.

{| class="wikitable"
|- 
| 
! style="background: #412682; color: #FFFFFF;" |Control flow instructions
! style="background: #412682; color: #FFFFFF;" | Directives for data management
|- 
! style="background: #412682; color: #FFFFFF;" | Declarations 
| codelet<br />group
| resident<br />map<br />mapbyname 
|-
! style="background: #412682; color: #FFFFFF;" | Operational Directives 
| callsite<br />synchronize<br />region
| allocate<br />release<br />advancedload<br />delegatedstore 
|}

=== Concept of set of directives ===
One of the fundamental points of the HMPP approach is the concept of directives and their associated labels which makes it possible to expose a coherent structure on a whole set of directives disseminated in an application.

There are two kinds of labels: 
* One associated to a codelet. In general, the directives carrying this kind of labels are limited to the management of only one codelet (called stand-alone codelet in the remainder of the document to distinguish it from the group of codelets).
* One associated to a group of codelets. These labels are noted as follow: “<LabelOfGroup>“, where “LabelOfGroup” is a name specified by the user. In general, the directives which have a label of this type relate to the whole group. The concept of group is reserved to a class of problems which requires a specific management of the data throughout the application to obtain performance.

=== OpenHMPP Directives Syntax ===
In order to simplify the notations, [[regular expression]]s will be used to describe the syntax of the HMPP directives.

The color convention below is used for the description of syntax directives: 
* Reserved HMPP keywords are in <span style="color:#339933;">'''green'''</span>;
* Elements of grammar which can be declined in HMPP keywords are in <span style="color:#990000;">'''red'''</span>;
* User's variables remain in black.

==== General syntax ====
The general syntax of OpenHMPP directives is: 
* For C language:
 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">></span> [codelet_label]? <span style="color:#990000;">directive_type</span> [<span style="color:#339933;">,</span><span style="color:#990000;">directive_parameters</span>]* [<span style="color:#339933;">&</span>]

* For FORTRAN language:
 <span style="color:#339933;">!$hmpp <</span>grp_label<span style="color:#339933;">></span> [codelet_label]? <span style="color:#990000;">directive_type</span> [<span style="color:#339933;">,</span><span style="color:#990000;">directive_parameters</span>]* [<span style="color:#339933;">&</span>]

Where:
*<code><grp_label></code>: is a unique identifier naming a group of codelets. In cases where no groups are defined in the application, this label can simply miss. Legal label name must follow this grammar: {{code|[a-zA-Z_][a-zA-Z0-9_]*}}. Note that the “< >” characters belong to the syntax and are mandatory for this kind of label.
*<code>codelet_label</code>: is a unique identifier naming a codelet. Legal label name must follow this grammar: {{code|[a-zA-Z_][a-zA-Z0-9_]*}}
*<code>directive</code>: is the name of the directive;
*<code>directive_parameters</code>: designates some parameters associated to the directive. These parameters may be of different kinds and specify either some arguments given to the directive either a mode of execution (asynchronous versus synchronous for example);
*<code>[&]</code>: is a character used to continue the directive on the next line (same for C and FORTRAN).

==== Directive parameters ====
The parameters associated to a directive may be of different types. 
Below are the directive parameters defined in OpenHMPP: 
* <code>version = major.minor[.micro]</code>: specifies the version of the HMPP directives to be considered by the preprocessor.
* <code>args[arg_items].size={dimsize[,dimsize]*}</code>: specifies the size of a non scalar parameter (an array).
* <code>args[arg_items].io=[in|out|inout]</code>: indicates that the specified function arguments are either input, output or both. By default, unqualified arguments are inputs.
* <code>cond = "expr"</code>: specifies an execution condition as a boolean C or Fortran expression that needs to be true in order to start the execution of the group or codelets.
* <code>target=target_name[:target_name]*</code>: specifies which targets to try to use in the given order.
* <code>asynchronous</code>: specifies that the codelet execution is not blocking (default is synchronous).
* <code>args[<arg_items>].advancedload=true</code>: indicates that the specified parameters are preloaded. Only in or inout parameters can be preloaded.
* <code>args[arg_items].noupdate=true</code>: this property specifies that the data is already available on the HWA and so that no transfer is needed. When this property is set, no transfer is done on the considered argument
* <code>args[<arg_items>].addr="<expr>"</code>: <code><expr></code> is an expression that gives the address of the data to upload.
* <code>args[<arg_items>].const=true</code>: indicates that the argument is to be uploaded only once.

== OpenHMPP directives ==

=== Directives for declaring and executing a codelet ===
A <code>codelet</code> directive declares a computation to be remotely executed on a hardware accelerator.
For the <code>codelet</code> directive: 
*The codelet label is mandatory and must be unique in the application
*The group label is not required if no group is defined.
*The codelet directive is inserted just before the function declaration.

The syntax of the directive is:

 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">></span> codelet_label <span style="color:#339933;">codelet</span> 
                             [<span style="color:#339933;">, version</span> = major.minor[.micro]?]?
                             [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].io=</span>[[<span style="color:#339933;">in</span>|<span style="color:#339933;">out</span>|<span style="color:#339933;">inout</span>]]*
                             [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].size={</span>dimsize[,dimsize]*<span style="color:#339933;">}</span>]*
                             [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].const=true</span>]*
                             [<span style="color:#339933;">, cond =</span> "expr"]
                             [<span style="color:#339933;">, target=</span><span style="color:#990000;">target_name</span>[:<span style="color:#990000;">target_name</span>]*]

More than one codelet directive can be added to a function in order to specify different uses or different execution contexts. However, there can be only one codelet directive for a given call site label.

The <code>callsite</code> directive specifies how the use a codelet at a given point in the program.

The syntax of the directive is:
 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">></span> codelet_label <span style="color:#339933;">callsite</span>
                      [<span style="color:#339933;">, asynchronous</span>]?
                      [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].size={</span>dimsize[,dimsize]*<span style="color:#339933;">}</span>]*
                      [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].advancedload=</span>[[<span style="color:#339933;">true</span>|<span style="color:#339933;">false</span>]]*
                      [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].addr="</span>expr<span style="color:#339933;">"</span>]*
                      [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].noupdate=true</span>]*

An example is shown here :
<syntaxhighlight lang="c">
 /* declaration of the codelet */
 #pragma hmpp simple1 codelet, args[outv].io=inout, target=CUDA
 static void matvec(int sn, int sm, float inv[sm], float inm[sn][sm], float *outv){
     int i, j;
     for (i = 0 ; i < sm ; i++) {
       float temp = outv[i];
       for (j = 0 ; j < sn ; j++) {
         temp += inv[j] * inm[i][ j];
     }
    outv[i] = temp;
  }
  
  int main(int argc, char **argv) {
    int n;
    ........
  
  /* codelet use */
  #pragma hmpp simple1 callsite, args[outv].size={n}
  matvec(n, m, myinc, inm, myoutv);
    ........
  }
</syntaxhighlight>
In some cases, a specific management of the data throughout the application is required (CPU/GPU data movements optimization, shared variables...).

The <code>group</code> directive allows the declaration of a group of codelets. The parameters defined in this directive are applied to all codelets belonging to the group. 
The syntax of the directive is:

 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">> group</span> 
                           [<span style="color:#339933;">, version =</span> <major>.<minor>[.<micro>]?]? 
                           [<span style="color:#339933;">, target =</span> <span style="color:#990000;">target_name</span>[:<span style="color:#990000;">target_name</span>]*]]? 
                           [<span style="color:#339933;">, cond  = “</span>expr<span style="color:#339933;">”</span>]?

=== Data transfers directives to optimize communication overhead ===
When using a HWA, the main bottleneck is often the data transfers between the HWA and the main processor.<br />
To limit the communication overhead, data transfers can be overlapped with successive executions of the same codelet by using the asynchronous property of the HWA.

* allocate directive
The <code>allocate</code> directive locks the HWA and allocates the needed amount of memory.
 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">> allocate</span> [<span style="color:#339933;">,args[</span>arg_items<span style="color:#339933;">].size={</span>dimsize[,dimsize]*<span style="color:#339933;">}</span>]*

* release directive
The <code>release</code> directive specifies when to release the HWA for a group or a stand-alone codelet.
 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">> release</span>

* advancedload directive
The <code>advancedload</code> directive prefetches data before the remote execution of the codelet.<br />
 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">></span> [codelet_label]? <span style="color:#339933;">advancedload</span>
                   <span style="color:#339933;">,args[</span>arg_items<span style="color:#339933;">]</span>
                   [<span style="color:#339933;">,args[</span>arg_items<span style="color:#339933;">].size={</span>dimsize[,dimsize]*<span style="color:#339933;">}</span>]*
                   [<span style="color:#339933;">,args[</span>arg_items<span style="color:#339933;">].addr="</span>expr<span style="color:#339933;">"</span>]*
                   [<span style="color:#339933;">,args[</span>arg_items<span style="color:#339933;">].section={</span>[<span style="color:#990000;">subscript_triplet</span><span style="color:#339933;">,</span>]+<span style="color:#339933;">}</span>]*
                   [<span style="color:#339933;">,asynchronous</span>]

* delegatedstore directive
The <code>delegatedstore</code> directive is a synchronization barrier to wait for an asynchronous codelet execution to complete and to then download the results.<br />
 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">></span> [codelet_label]? <span style="color:#339933;">delegatedstore</span> 
                 <span style="color:#339933;">,args[</span>arg_items<span style="color:#339933;">]</span>
                 [<span style="color:#339933;">,args[</span>arg_items<span style="color:#339933;">].addr="</span>expr<span style="color:#339933;">"</span>]*
                 [<span style="color:#339933;">,args[</span>arg_items<span style="color:#339933;">].section={</span>[<span style="color:#990000;">subscript_triplet</span><span style="color:#339933;">,</span>]+<span style="color:#339933;">}</span>]*

* Asynchronous Computations
The <code>synchronize</code> directive specifies to wait until the completion of an asynchronous callsite execution. 
For the synchronize directive, the codelet label is always mandatory and the group label is required if the codelet belongs to a group.
 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">></span> codelet_label <span style="color:#339933;">synchronize</span>

* Example
In the following example, the device initialization, memory allocation and upload of the input data are done only once outside the loop and not in each iteration of the loop.

The <code>synchronize</code> directive allows to wait for the asynchronous execution of the codelet to complete before launching another iteration. Finally the <code>delegatedstore</code> directive outside the loop uploads the sgemm result.
<syntaxhighlight lang="c">
 int main(int argc, char **argv) {
 
 #pragma hmpp sgemm allocate, args[vin1;vin2;vout].size={size,size}
 #pragma hmpp sgemm advancedload, args[vin1;vin2;vout], args[m,n,k,alpha,beta]
   
 for ( j = 0 ; j < 2 ; j ++) {
    #pragma hmpp sgemm callsite, asynchronous, args[vin1;vin2;vout].advancedload=true, args[m,n,k,alpha,beta].advancedload=true
    sgemm (size, size, size, alpha, vin1, vin2, beta, vout);
    #pragma hmpp sgemm  synchronize
 }
 
 #pragma hmpp sgemm delegatedstore, args[vout]
 #pragma hmpp sgemm release
</syntaxhighlight>

=== Sharing data between codelets ===
Those directives map together all the arguments sharing the given name for all the group.

The types and dimensions of all mapped arguments must be identical.

The <code>map</code> directive maps several arguments on the device. 
 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">>  map, args[</span>arg_items<span style="color:#339933;">]</span>

This directive is quite similar as the <code>map</code> directive except that the arguments to be mapped are directly specified by their name. The <code>mapbyname</code> directive is equivalent to multiple <code>map</code> directives. 
 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">> mapbyname</span> [<span style="color:#339933;">,</span>variableName]+

=== Global variable ===
The <code>resident</code> directive declares some variables as global within a group. Those variables can then be directly accessed from any codelet belonging to the group. 
This directive applies to the declaration statement just following it in the source code.

The syntax of this directive is:

 <span style="color:#339933;">#pragma hmpp <</span>grp_label<span style="color:#339933;">> resident</span> 
                [<span style="color:#339933;">, args[::</span>var_name<span style="color:#339933;">].io=</span>[[<span style="color:#339933;">in</span>|<span style="color:#339933;">out</span>|<span style="color:#339933;">inout</span>]]*
                [<span style="color:#339933;">, args[::</span>var_name<span style="color:#339933;">].size={</span>dimsize[,dimsize]*<span style="color:#339933;">}</span>]*
                [<span style="color:#339933;">, args[::</span>var_name<span style="color:#339933;">].addr="</span>expr<span style="color:#339933;">"</span>]*
                [<span style="color:#339933;">, args[::</span>var_name<span style="color:#339933;">].const=true</span>]*

The notation <code>::var_name</code>  with the prefix <code>::</code>, indicates an  application's variable declared as resident.

=== Acceleration of regions ===
A region is a merge of the codelet/callsite directives. The goal is to avoid code restructuration to build the codelet. Therefore, all the attributes available for <code>codelet</code> or <code>callsite</code> directives can be used on <code>regions</code> directives.

In C language:

 <span style="color:#339933;">#pragma hmpp [<</span>MyGroup<span style="color:#339933;">>] [</span>label<span style="color:#339933;">] region</span>         
                            [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].io=</span>[[<span style="color:#339933;">in</span>|<span style="color:#339933;">out</span>|<span style="color:#339933;">inout</span>]]*
                            [<span style="color:#339933;">, cond = "</span>expr<span style="color:#339933;">"]</span><
                            [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].const=true</span>]*
                            [<span style="color:#339933;">, target=</span><span style="color:#990000;">target_name</span>[<span style="color:#339933;">:</span><span style="color:#990000;">target_name</span>]*]
                            [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].size={</span>dimsize[<span style="color:#339933;">,</span>dimsize]*<span style="color:#339933;">}</span>]*
                            [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].advancedload=</span>[[<span style="color:#339933;">true</span>|<span style="color:#339933;">false</span>]]*
                            [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].addr="</span>expr<span style="color:#339933;">"</span>]*
                            [<span style="color:#339933;">, args[</span>arg_items<span style="color:#339933;">].noupdate=true</span>]*
                            [<span style="color:#339933;">, asynchronous</span>]?
                            [<span style="color:#339933;">, private=[</span>arg_items<span style="color:#339933;">]</span>]*
    {
 C BLOCK STATEMENTS
    }

== Implementations ==
The OpenHMPP Open Standard is based on HMPP Version 2.3 (May 2009, CAPS entreprise).

The OpenHMPP directive-based programming model is implemented in:
* CAPS Compilers, CAPS Entreprise compilers for hybrid computing
* PathScale ENZO Compiler Suite (support the NVIDIA GPUs)

OpenHMPP is used by [[High-performance computing|HPC]] actors{{who|date=August 2015}} in Oil & Gas,{{Citation needed|date=August 2015}} Energy,{{Citation needed|date=August 2015}} Manufacturing,{{Citation needed|date=August 2015}} Finance,{{Citation needed|date=August 2015}} Education & Research.{{Citation needed|date=August 2015}}

== See also ==
* [[GPGPU]]
* [[Parallel computing]]
* [[OpenACC]]
* [[OpenCL]]

== References ==
{{Reflist}}{{Parallel computing}}

[[Category:Application programming interfaces]]
[[Category:C programming language family]]
[[Category:Fortran]]
[[Category:Parallel computing]]