<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
          "http://www.w3.org/TR/html4/strict.dtd">
<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
<html>
<head>
  <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
  <title>OpenMP* : Support for the OpenMP language</title>
  <link type="text/css" rel="stylesheet" href="menu.css">
  <link type="text/css" rel="stylesheet" href="content.css">
</head>

<body>
<div id="menu">
  <div>
    <a href="http://llvm.org/">LLVM Home</a>
  </div>

  <div class="submenu">
    <label>OpenMP Info</label>
    <a href="/index.html">About</a>
  </div>

  <div class="submenu">
    <label>Quick Links</label>
    <a href="http://lists.cs.uiuc.edu/mailman/listinfo/openmp-dev">openmp-dev</a>
    <a href="http://lists.cs.uiuc.edu/mailman/listinfo/openmp-commits">openmp-commits</a>
    <a href="http://llvm.org/bugs/">Bug Reports</a>
    <a href="http://llvm.org/svn/llvm-project/openmp/trunk/">Browse SVN</a>
    <a href="http://llvm.org/viewvc/llvm-project/openmp/trunk/">Browse ViewVC</a>
  </div>
</div>

<div id="content">
  <!--*********************************************************************-->
  <h1>"OpenMP&reg;" Support for the OpenMP language</h1>
  <!--*********************************************************************-->

  <p>The OpenMP subproject of LLVM is intended to contain all of the
     components required to build an executing OpenMP program that are
     outside the compiler itself. Support for OpenMP 3.1 in Clang is in the
     process of being promoted into the Clang mainline, and can be
     found at <a href="http://clang-omp.github.io/">OpenMP/Clang</a>. 
  </p>

  <p>Here you can find the code for the runtime library against which
    code compiled by the OpenMP/Clang compiler must be linked before it
    can run. This code is also available
    at <a href="http://openmprtl.org/">openmprtl.org</a>; we intend to
    keep the different sites in sync.
  </p>

  <p>Support for the parts of the OpenMP 4.0 language that are not
  associated with the "target" constructs are contained in the
  "runtime" directory. Support for offloading computation via the
  "target" directive is in the separate "offload" directory. That
  builds a library that provides the interfaces for transferring code
  and data to an attached computational device. Initial support here
  is for the Intel&reg Xeon Phi&#0153 coprocessor, but work is
  beginning to support other attached computing devices, and the
  design is intended to be general. The README.txt in the "offload"
  directory describes how to build the offload library.
  </p>

  <p>All of the code here is <a
     href="http://llvm.org/docs/DeveloperPolicy.html#license">dual licensed</a>
     under the MIT license and the UIUC License (a BSD-like license).
     The LICENSE.txt file at the top of the OpenMP project contains
     the license text and associated patent grants.
  </p>

  <!--=====================================================================-->
  <h2 id="goals">Features and Goals</h2>
  <!--=====================================================================-->

    <ul>
        <li>Correctness as defined by the 
          <a href="http://www.openmp.org/mp-documents/OpenMP3.1.pdf">OpenMP
          3.1 standard (PDF)</a> now, and <a href="http://www.openmp.org/mp-documents/OpenMP4.0.0.pdf">OpenMP
          4.0 standard (PDF)</a> in the future.</li>
        <li>High performance.</li>
        <li>ABI compatibility with <a href="http://gcc.gnu.org">Gcc</a> and
        <a href="http://software.intel.com/en-us/intel-compilers">Intel's
        existing OpenMP compilers.</a> 
        However, we are not currently (May 2014) compatible with gcc 4.9, since
        it has introduced new entrypoints with which we have not yet
        caught up... 
        </li>
    </ul>

  <!--=====================================================================-->
  <h2 id="why">Why have the runtime code here?</h2>
  <!--=====================================================================-->

  <p>It makes sense to have the runtime sources in the same place
    (and with the same license) as the compiler.
  </p>

  <!--=====================================================================-->
  <h2 id="requirements">Platform Support</h2>
  <!--=====================================================================-->

  <p>The OpenMP runtime is known to work on 32 and 64 bit X86
    processors when compiled with either the Intel compiler or gcc, and also the Intel&reg;&nbsp;Xeon Phi&trade; product family, when compiled with
    the Intel compiler.
  </p>
  
  <p>A full OS compatibility matrix is in 
    <a href="README.txt">README.txt</a>
  </p>


  <!--=====================================================================-->
  <h2 id="dir-structure">Status</h2>
  <!--=====================================================================-->

   <p>The runtime can be built with gcc, icc or clang. However, note
   that a runtime built with clang cannot be guaranteed to work with
   OpenMP code compiled by the other compilers, since clang does not support
   a 128-bit float type, and cannot therefore generate the code used
   for reductions of that type (which may occur in user code compiled
   by the other compilers).
   </p>
 
   <p>The University of Houston has kindly contributed their test
   suite (in the "testsuite" directory). Integration and use of this
   for automatic testing remain to be done, but now the code is here
   work can begin.
   </p>

  <!--=====================================================================-->
  <h2>Get it and get involved!</h2>
  <!--=====================================================================-->

  <p>First please review our
     <a href="http://llvm.org/docs/DeveloperPolicy.html">Developer's Policy</a>.

  <p>To check out the code, use:</p>

  <ul>
  <li><code>svn co http://llvm.org/svn/llvm-project/openmp/trunk openmp</code></li>
  </ul>

  <p>
     Next:
  </p>
  
  <ul>
    <li><code>cd openmp/runtime</code></li>
    <li><code>make compiler=gcc</code></li>
  </ul>
  
  <p>Full details of how to build are in the
    <a href="README.txt">README.txt</a>
  </p>

  <!--=====================================================================-->
  <h3>Notes</h3>
  <!--=====================================================================-->

<p>

</p>

  <p>Send discussions to the
  (<a href="http://lists.cs.uiuc.edu/mailman/listinfo/openmp-dev">OpenMP mailing list</a>).</p>


  <!--=====================================================================-->
  <h2>Design Documents</h2>
  <!--=====================================================================-->

<ul>
<li><a href="Reference.pdf">Runtime design (PDF)</a></li>
</ul>

  <!--=====================================================================-->
  <h2>Copyright notices</h2>
  <!--=====================================================================-->
<ul>
<li>
  The OpenMP name and the OpenMP logo are registered trademarks of the
  OpenMP Architecture Review Board.
</li>
<li>
  Intel is a trademark of Intel Corporation in the U.S. and/or other
  countries.
</li>
</ul>
</div>
</body>
</html>
