<html>
<head>
<title>
Running the MPI Tools within the Parallel Language Development Tools
</title>
	<link rel="stylesheet" type="text/css" href="help.css">
	<link rel="stylesheet" type="text/css" href="help.css">
	<script type="text/javascript" src="thumb.js"> </script>
	</head>
<body>
<h1 id="top"> Running the MPI Tools within the Parallel Language Development Tools</h1>
<p>To run the PTP PLDT MPI Tools, 
create a project (e.g a Managed Make C project), and
set the preferences and include paths as described in
<a href="setup.html">Setup for PTP MPI Tools</a>.

<p>The Parallel Language Development Tools should work on Standard Make C projects as well, and
on C++ projects (Standard Make and Managed Make).  The description here is for
a Managed Make C Project.

<p>Note: the terms "Managed Make" and "Standard Make" projects were more visibly used in CDT 3.1.
They are still there in CDT 4.0 but the names are usually hidden.  By default a project "New C project"
will create a makefile for you, and thus is a "Managed Make" project; if you create a "Makefile project"
then that is what was formerly called a "Standard Make" project.  Confused enough? Good.


<ol>
<li>Within the project, create a C file that includes MPI code. A sample is <a href="samples/testMPI.c">testMPI.c</a> 
If you used the PLDT new project wizard to create an MPI project, then you probably already have one.

<p>Note: A sample C++ file with MPI calls 
is <a href="samples/testMPIcpp.cpp">testMPIcpp.cpp</a>.
<br>A sample C++ file with MPI calls in ordinary C style 
is <a href="samples/helloMPI_c_style.cpp">helloMPI_c_style.cpp</a>.


</ul>
<p>&nbsp;


<li>Select the source file to analyse, to find the MPI artifacts.
Click on the source file in the Project Explorer on the left to highlight it.
<p>Click the "Show MPI Artifacts" menu item in the PLDT icon menu  in the tool bar.
<br> <img src="images/mpiMenu.png">
<br>(Note: if it complains that a source file is not selected the first time, select it again and retry.)
<p>The workbench with the selection and menu item is shown below:

<p><script> thumb("images/mpiButtons.gif",300)</script>
<li>The MPI Artifact View is opened, if it was not present.
It is populated with MPI artifacts found.
<p><script> thumb("images/mpiViewAnn.gif",300)</script>


<p>If no artifacts are found, check that:
<ol>
<li>The MPI preferences page lists the include file for the MPI installation
that your source code uses.  This list is how the analysis determines what is
an "MPI artifact."  
<li>Your project properties have the include path (the same one listed
in the MPI preferences page) listed.
Note that the MPI analysis may require this even if 
the build procedure - such as  a build command like 'mpicc' - 
implicitly does this include for you during build.
</ol>
<p>&nbsp;
<li>Double click on any line in the MPI Artifact View
to navigate the editor to that line in the source file.
<p>&nbsp;
<li>Hover over the MPI Artifact identified in the source file
(by blue squiggles) to see additional information about that
function call, for example. 
<br><img src="images/hover.gif" border=1>
<li>Rows in the MPI Artifact View can be sorted by any of the columns.
Click on the column heading to sort.
<li>Click the "Clear MPI Artifacts Markers" button (red X)
in the tool bar <i>of the MPI Artifact View</i> to remove all
the MPI artifacts.
<br><img src="images/clearMarkers.png" border=1> 
<li>You can run the analysis on another file and its markers
will be added to the view.
<li>You can run the analysis on more than one file (multiple selection)
or a container (folder or project), to analyse more than one file at a time.
Click on a project or a folder, then select the
"Show MPI Artifacts" action
 to run it on all C source files in that folder.
<br> <img src="images/mpiMenu.png">
<p>
<li><b>Content Assist</b><br>
Type an incomplete MPI function name e.g. "MPI_Ini"
and hit Ctrl-Space. The information that is shown
is populated with CDT completions including argument
types, but in addition, the PTP-MPI tools also provide
specific information about actual MPI constant values, etc.
where appropriate, and a yellow popup with additional 
textual descriptive information about the function.
Pick the one you want with the arrow keys or the mouse, to add the API to your source file.
<br><img src="images/contentAssist.gif" border=1>
<p>
<li><b>Context sensitive help</b><br>
Also, if F1 is pressed when the cursor is within
a function name, a help view appears which shows additional information.
(In Linux press Ctrl-F1; in Mac Use Help button or use menu Help > Dynamic Help)

<br><img src="images/helpContSensHitF1.gif" border=1>
<p>Help View appears:
<br><img src="images/helpContSens.gif" border=1>
<p>Click on the function name to see more information:
<br><img src="images/helpContSensHitF1click.gif" border=1>

</ol>
<p>&nbsp;
<p>See also the <a href="barrier.html">MPI Barrier Analysis</a> explanation.

<p>See also <a href="mpiTemplates.html">MPI Code Templates</a>.

<p>See also the <a href="setupOMP.html">OpenMP setup information</a>
or the <a href="runOMP.html">OpenMP run information</a>.
<p>&nbsp;<p>&nbsp;<p>&nbsp;
<p><a href="#top">Back to Top</a> | <a href="toc.html">Back to Table of Contents</a>

</body>
</html>