<html>
<head>
<title>
Setup for MPI Tools within the Parallel Language Development Tools
</title>
	<link rel="stylesheet" type="text/css" href="help.css">
	<script type="text/javascript" src="thumb.js"> </script>
<body>
<h1>Setup for MPI Tools within the Parallel Language Development Tools</h1>

<p>To use  the PTP Parallel Language Development
Tools feature for MPI development, you need to 
<ol>
<li><a href="#prefs">Specify the MPI include path in preferences</a>, and</li>
<li><a href="#project">Add the MPI include files etc.  to the build information for each  project.</a>
</ol>

<h2 id="prefs">Specifying the MPI Include path in Preferences</h2>
<p>To specify the MPI include path, use Window > Preferences. (For Mac, use Eclipse > Preferences)
Under PTP, Parallel Language Development Tools, MPI...
(Note: If you do not have core PTP installed, the "Parallel Language 
Development Tools" section in the preferences will be included without it.)

<p>Add the path to MPI include paths  - this tells PLDT what symbols to look
for in the MPI Artifact view.  You can also specify the default MPI build command.
These values will make the MPI New Project Wizard page make more
accurate predictions of settings for new projects.
<br><img src="images/pldt-prefs1.png">



<h2 id="project">Add MPI Include paths to each project</h2>
<p>The MPI include paths must also be added to each project.
There are two ways to do this.
<ol>
<li><a href="#wizard">Use the PLDT new project wizards</a>, or
</li>
<li><a href="#manual">Add the build information manually</a>.
</ol>
<h2 id="wizard">Use the PLDT new project wizards</h2>
<p>Create a new "C project"
<br>File->New->C project (if you are already in the C/C++ perspective this may be the simplest)
<br>is one way; there are several ways to get to this wizard
Enter a project name; under Project types, expand 'executable' and select, e.g. "MPI Hello World C project"
<br>
<img src="images/mpiWizard.gif">
<br>Select Next.
<br>On the next page, fill in any project template values, e.g. your name.
<br>Then select Next.
<br><img src="images/mpiWizard2.gif">
<p>On the next page, "MPI Project Settings" page,  make sure the "Add MPI project settings to this project"
is checked.  If you want to change any of the default values for this project, you can do so
here by unchecking the "Use default information" and altering the values.

<br><img src="images/mpiWizard3.gif">
<p>Select Finish.
<p>The project is created and should build automatically.
The Eclipse workbench is shown below after creating the new "MPI hello world" project.
The project explorer view on the left shows the project contents.
The source file is under the 'src' directory; expand this to see it.
Double-click on the source file name to edit the source file.  The outline view on the
right shows the outline of the file currently shown in the editor.
The Console view at the bottom shows the results of the project build.

<br><img src="images/mpiNewProjectWorkbench.gif">
<p>
<p><p>Now continue to set up to <a href="run.html">run the MPI tools</a>
<p>
<h2 id="manual">Add the Build Information Manually</h2>
<p>If the new project wizard isn't used as described 
above to set the MPI information for a project,
the MPI information can be added to the project manually as follows.
<ol>
<li>Create a CDT project (e.g. Managed Make C Project)

<li>Set up the include paths etc:
<br>Project Properties, C/C++ Build, Configuration Settings,
Tool Settings tab, Directories
<br>--> Add include path for mpi header files etc. - path to the 'include' dir
<br><img src="images/include.gif">
<p>
Project Properties, C/C++ Build, Configuration Settings,
Tool Settings tab, GCC C Linker, Libraries
<ol>
<li>Under "Libraries (-l)"  add the symbol "mpi"  
<li> Under "Library search path (-L)" add the path to the 'lib' dir in MPI dir.
<br><img src="images/lib.gif">
<li><b>MPI Build Command:</b> Note: If you have an MPI installed that requires a different
build command, such as 'mpicc' instead of 'gcc', specify it here as well.
Select the compiler tool on the left and modify the 'Command:' value.
You probably also need to do the same for the linker tool.
<br><img src="images/mpiBuildCommand.gif">
</ol>
<p>

</ol>

<p>Now continue to set up to <a href="run.html">run the MPI tools</a>

<p>&nbsp;
<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>