<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
<link rel="Start" href="index.html">
<link rel="Up" href="index.html">
<link title="Index of types" rel=Appendix href="index_types.html">
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
<link title="Index of values" rel=Appendix href="index_values.html">
<link title="Index of modules" rel=Appendix href="index_modules.html">
<link title="Mpi" rel="Chapter" href="Mpi.html"><link title="Error reporting" rel="Section" href="#2_Errorreporting">
<link title="Basic operations on communicators" rel="Section" href="#2_Basicoperationsoncommunicators">
<link title="Point-to-point communication" rel="Section" href="#2_Pointtopointcommunication">
<link title="Group communication" rel="Section" href="#2_Groupcommunication">
<link title="Broadcast" rel="Section" href="#2_Broadcast">
<link title="Scatter" rel="Section" href="#2_Scatter">
<link title="Gather" rel="Section" href="#2_Gather">
<link title="Gather to all" rel="Section" href="#2_Gathertoall">
<link title="Reduce" rel="Section" href="#2_Reduce">
<link title="Reduce to all" rel="Section" href="#2_Reducetoall">
<link title="Scan" rel="Section" href="#2_Scan">
<link title="Advanced operations on communicators" rel="Section" href="#2_Advancedoperationsoncommunicators">
<link title="Cartesian topologies" rel="Section" href="#2_Cartesiantopologies">
<link title="Process group management" rel="Section" href="#2_Processgroupmanagement">
<link title="Miscellaneous" rel="Section" href="#2_Miscellaneous">
<title>Mpi</title>
</head>
<body>
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
</div>
<h1>Module <a href="type_Mpi.html">Mpi</a></h1>
<pre><span class="keyword">module</span> Mpi: <code class="code">sig</code> <a href="Mpi.html">..</a> <code class="code">end</code></pre><div class="info module top">
Caml bindings for the Message Passing Interface (MPI) library<br>
</div>
<hr width="100%">
<br>
<h2 id="2_Errorreporting">Error reporting</h2><br>
<pre><span id="EXCEPTIONError"><span class="keyword">exception</span> Error</span> <span class="keyword">of</span> <code class="type">string</code></pre>
<div class="info ">
Raised when an operation of the <code class="code">Mpi</code> module encounters an error.
The string argument describes the error.<br>
</div>
<br>
<h2 id="2_Basicoperationsoncommunicators">Basic operations on communicators</h2><br>
<pre><span id="TYPEcommunicator"><span class="keyword">type</span> <code class="type"></code>communicator</span> </pre>
<div class="info ">
The type of communicators. Communicators are groups of
nodes (processing elements) that can exchange data.<br>
</div>
<pre><span id="TYPErank"><span class="keyword">type</span> <code class="type"></code>rank</span> = <code class="type">int</code> </pre>
<div class="info ">
The type of ranks of nodes. Nodes in a given communicator
are assigned integer ranks 0, 1, \ldots, $N-1$ where $N$
is the size of the communicator.<br>
</div>
<pre><span id="VALcomm_world"><span class="keyword">val</span> comm_world</span> : <code class="type"><a href="Mpi.html#TYPEcommunicator">communicator</a></code></pre><div class="info ">
The global communicator.<br>
</div>
<pre><span id="VALcomm_size"><span class="keyword">val</span> comm_size</span> : <code class="type"><a href="Mpi.html#TYPEcommunicator">communicator</a> -> int</code></pre><div class="info ">
Return the size (number of nodes) in the given communicator.<br>
</div>
<pre><span id="VALcomm_rank"><span class="keyword">val</span> comm_rank</span> : <code class="type"><a href="Mpi.html#TYPEcommunicator">communicator</a> -> <a href="Mpi.html#TYPErank">rank</a></code></pre><div class="info ">
Return the rank of the calling node in the given communicator.
The rank <code class="code">Mpi.comm_rank c</code> is between 0 (inclusive) and
<code class="code">Mpi.comm_size c</code> (exclusive).<br>
</div>
<br>
<h2 id="2_Pointtopointcommunication">Point-to-point communication</h2><br>
<pre><span id="TYPEtag"><span class="keyword">type</span> <code class="type"></code>tag</span> = <code class="type">int</code> </pre>
<div class="info ">
The type of tags associated with messages in point-to-point
communications. Tags are positive integers in the range
<code class="code">0 .. 32767</code>.<br>
</div>
<pre><span id="VALsend"><span class="keyword">val</span> send</span> : <code class="type">'a -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre><div class="info ">
<code class="code">Mpi.send d dst tag comm</code> sends a message containing data <code class="code">d</code>
to the node that has rank <code class="code">dst</code> in communicator <code class="code">comm</code>.
The message is sent with tag <code class="code">tag</code>. Depending on the
underlying MPI implementation, message sending can be
synchronous or asynchronous; that is, <code class="code">Mpi.send</code> can block
until the target node receives the message, or <code class="code">Mpi.send</code>
can return before the target node has received the message.<br>
</div>
<pre><span id="VALreceive"><span class="keyword">val</span> receive</span> : <code class="type"><a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> 'a</code></pre><div class="info ">
<code class="code">Mpi.receive src tag comm</code> blocks until a message is available,
and returns the data contained in that message.
The <code class="code">src</code> argument selects the desired source for the message:
if <code class="code">src</code> is <code class="code">Mpi.any_source</code>, messages from any node in communicator
<code class="code">comm</code> are accepted; otherwise, only messages sent by the node
having rank <code class="code">src</code> in <code class="code">comm</code> are accepted.
Similarly, the <code class="code">tag</code> argument selects messages by their tag:
if <code class="code">tag</code> is <code class="code">Mpi.any_tag</code>, messages are accepted regardless of
their tags; otherwise, only messages with tag equal to <code class="code">tag</code>
are accepted.
<p>
Warning: just like the <code class="code">Marshal.from_*</code> functions,
<code class="code">Mpi.receive</code> is not type-safe. The Caml value returned by
<code class="code">Mpi.receive</code> does not possess type <code class="code">'a</code>
for all <code class="code">'a</code>; it has one, unique type which cannot be determined
at compile-type. The programmer should be careful about using
the returned value with the right type.<br>
</div>
<pre><span id="VALreceive_status"><span class="keyword">val</span> receive_status</span> : <code class="type"><a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> 'a * <a href="Mpi.html#TYPErank">rank</a> * <a href="Mpi.html#TYPEtag">tag</a></code></pre><div class="info ">
Same as <code class="code">Mpi.receive</code>, but returns a triple <code class="code">(d, src, tag)</code>
where <code class="code">d</code> is the data associated with the message,
<code class="code">src</code> the rank of the node that sent the message,
and <code class="code">tag</code> the actual tag attached to the message.<br>
</div>
<pre><span id="VALprobe"><span class="keyword">val</span> probe</span> : <code class="type"><a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> <a href="Mpi.html#TYPErank">rank</a> * <a href="Mpi.html#TYPEtag">tag</a></code></pre><div class="info ">
<code class="code">Mpi.probe src tag comm</code> blocks until a message is available
on communicator <code class="code">comm</code>, with source and tag matching the
<code class="code">src</code> and <code class="code">tag</code> arguments as described in <code class="code">Mpi.receive</code>.
It then returns the rank of the node that sent the message
and the actual tag attached to the message. The message itself
is not read, and can be retrieved later with <code class="code">Mpi.receive</code>
or <code class="code">Mpi.receive_status</code>.<br>
</div>
<pre><span id="VALany_tag"><span class="keyword">val</span> any_tag</span> : <code class="type"><a href="Mpi.html#TYPEtag">tag</a></code></pre>
<pre><span id="VALany_source"><span class="keyword">val</span> any_source</span> : <code class="type"><a href="Mpi.html#TYPErank">rank</a></code></pre><div class="info ">
The special values of the <code class="code">tag</code> and <code class="code">src</code> arguments of
<code class="code">Mpi.receive</code>, <code class="code">Mpi.receive_status</code> and <code class="code">Mpi.probe</code>,
indicating that any message tag is acceptable (for <code class="code">Mpi.any_tag</code>)
or any message source is acceptable (for <code class="code">Mpi.any_source</code>).<br>
</div>
<pre><span id="VALsend_int"><span class="keyword">val</span> send_int</span> : <code class="type">int -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALreceive_int"><span class="keyword">val</span> receive_int</span> : <code class="type"><a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> int</code></pre>
<pre><span id="VALsend_float"><span class="keyword">val</span> send_float</span> : <code class="type">float -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALreceive_float"><span class="keyword">val</span> receive_float</span> : <code class="type"><a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> float</code></pre>
<pre><span id="VALsend_int_array"><span class="keyword">val</span> send_int_array</span> : <code class="type">int array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALreceive_int_array"><span class="keyword">val</span> receive_int_array</span> : <code class="type">int array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALsend_float_array"><span class="keyword">val</span> send_float_array</span> : <code class="type">float array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALreceive_float_array"><span class="keyword">val</span> receive_float_array</span> : <code class="type">float array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEtag">tag</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre><div class="info ">
Specialized versions of <code class="code">Mpi.send</code> and <code class="code">Mpi.receive</code>
for communicating integers, floating-point numbers,
arrays of integers, and arrays of floating-point numbers.
These specialized versions are more efficient than
<code class="code">Mpi.send</code> and <code class="code">Mpi.receive</code> since less copying is involved.
The arguments to the <code class="code">Mpi.send_*</code> functions have the same
meaning as for <code class="code">Mpi.send</code>.
The arguments to <code class="code">Mpi.receive_int</code> and <code class="code">Mpi.receive_float</code>
have the same meaning as for <code class="code">Mpi.receive</code>.
<code class="code">Mpi.receive_int_array</code> and <code class="code">Mpi.receive_float_array</code>
have one extra argument, which is the array in which the data
of the received message is stored. The caller is responsible
for pre-allocating an array large enough to hold the incoming data.
<p>
It is an error to send a message using one of the specialized
<code class="code">Mpi.send_*</code> functions and receive it with the generic
<code class="code">Mpi.receive</code> function, and conversely.<br>
</div>
<br>
<h2 id="2_Groupcommunication">Group communication</h2><br>
<pre><span id="VALbarrier"><span class="keyword">val</span> barrier</span> : <code class="type"><a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre><div class="info ">
<code class="code">Mpi.barrier comm</code> suspends the calling process until all
nodes in communicator <code class="code">comm</code> are executing <code class="code">Mpi.barrier comm</code>.
Then all nodes return from <code class="code">Mpi.barrier</code> and continue executing.<br>
</div>
<br>
<h2 id="2_Broadcast">Broadcast</h2><br>
<pre><span id="VALbroadcast"><span class="keyword">val</span> broadcast</span> : <code class="type">'a -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> 'a</code></pre><div class="info ">
<code class="code">Mpi.broadcast d root comm</code> broadcasts data <code class="code">d</code> from node
with rank <code class="code">root</code> in <code class="code">comm</code> to all other nodes in <code class="code">comm</code>.
All nodes in <code class="code">comm</code> must call <code class="code">Mpi.broadcast</code> with the same
<code class="code">root</code> and <code class="code">comm</code> arguments. The <code class="code">d</code> argument is significant
only at node <code class="code">root</code>; it is ignored at other nodes.
<code class="code">Mpi.broadcast</code> returns the broadcast data.<br>
</div>
<pre><span id="VALbroadcast_opt"><span class="keyword">val</span> broadcast_opt</span> : <code class="type">'a option -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> 'a</code></pre><div class="info ">
Same as <code class="code">Mpi.broadcast</code>, except that the data (first argument)
is provided as an option type. The root node must provide a
first argument of the form <code class="code">Some d</code> where <code class="code">d</code> is the data to
broadcast. The other node provide <code class="code">None</code> as their first
argument.<br>
</div>
<pre><span id="VALbroadcast_int"><span class="keyword">val</span> broadcast_int</span> : <code class="type">int -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> int</code></pre>
<pre><span id="VALbroadcast_float"><span class="keyword">val</span> broadcast_float</span> : <code class="type">float -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> float</code></pre>
<pre><span id="VALbroadcast_int_array"><span class="keyword">val</span> broadcast_int_array</span> : <code class="type">int array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALbroadcast_float_array"><span class="keyword">val</span> broadcast_float_array</span> : <code class="type">float array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre><div class="info ">
Specialized versions of <code class="code">Mpi.broadcast</code> for integers, floats,
arrays of integers and arrays of floats. For
<code class="code">Mpi.broadcast_int</code> and <code class="code">Mpi.broadcast_float</code>, the broadcast
value is returned as result, and the first argument is significant
only at the root node.
For <code class="code">Mpi.broadcast_int_array</code> and <code class="code">Mpi.broadcast_float_array</code>,
the broadcast value is stored in the array passed as first argument;
thus, the first argument is significant at all nodes.<br>
</div>
<br>
<h2 id="2_Scatter">Scatter</h2><br>
<pre><span id="VALscatter"><span class="keyword">val</span> scatter</span> : <code class="type">'a array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> 'a</code></pre><div class="info ">
<code class="code">Mpi.scatter a root comm</code> scatters the elements of array <code class="code">a</code>
from node <code class="code">root</code> to all nodes in <code class="code">comm</code>. The node with rank <code class="code">i</code>
in <code class="code">comm</code> receives the element <code class="code">a.(i)</code> and returns it as result
of <code class="code">Mpi.scatter</code>. The <code class="code">a</code> argument is significant only at node
<code class="code">root</code>; an empty array <code class="code">[||]</code> can be given as first argument
at other nodes.<br>
</div>
<pre><span id="VALscatter_int"><span class="keyword">val</span> scatter_int</span> : <code class="type">int array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> int</code></pre>
<pre><span id="VALscatter_float"><span class="keyword">val</span> scatter_float</span> : <code class="type">float array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> float</code></pre><div class="info ">
Specialized versions of <code class="code">Mpi.scatter</code> for integers and floats.<br>
</div>
<pre><span id="VALscatter_int_array"><span class="keyword">val</span> scatter_int_array</span> : <code class="type">int array -> int array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALscatter_float_array"><span class="keyword">val</span> scatter_float_array</span> : <code class="type">float array -> float array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre><div class="info ">
Specialized versions of <code class="code">Mpi.scatter</code> for arrays of integers and
arrays of floats. <code class="code">Mpi.scatter_int_array src dst root comm</code>
splits the array <code class="code">src</code> at node <code class="code">root</code> into <code class="code">Mpi.comm_size comm</code>
chunks of size <code class="code">Array.length dst</code>, and sends the chunks to
each node, storing them into array <code class="code">dst</code> at each node.
The <code class="code">src</code> argument is significant only at node <code class="code">root</code>.
<code class="code">Mpi.scatter_int_array</code> is similar.<br>
</div>
<br>
<h2 id="2_Gather">Gather</h2><br>
<pre><span id="VALgather"><span class="keyword">val</span> gather</span> : <code class="type">'a -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> 'a array</code></pre><div class="info ">
<code class="code">Mpi.gather d root comm</code> gathers the values of the <code class="code">d</code> argument
at all nodes onto node <code class="code">root</code>, and returns those values as an
array. At node <code class="code">root</code>, <code class="code">Mpi.gather</code> returns an array of
size <code class="code">Mpi.comm_size comm</code>; element number <code class="code">i</code> is the value
provided for argument <code class="code">d</code> by node <code class="code">i</code>. At other nodes,
the empty array <code class="code">[||]</code> is returned.<br>
</div>
<pre><span id="VALgather_int"><span class="keyword">val</span> gather_int</span> : <code class="type">int -> int array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALgather_float"><span class="keyword">val</span> gather_float</span> : <code class="type">float -> float array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre><div class="info ">
Specialized versions of <code class="code">Mpi.gather</code> for integers and floats.<br>
</div>
<pre><span id="VALgather_int_array"><span class="keyword">val</span> gather_int_array</span> : <code class="type">int array -> int array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALgather_float_array"><span class="keyword">val</span> gather_float_array</span> : <code class="type">float array -> float array -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre><div class="info ">
Specialized versions of <code class="code">Mpi.gather</code> for arrays of integers and
arrays of floats. <code class="code">Mpi.gather_int_array src dst root comm</code>
sends the arrays <code class="code">src</code> at each node to the node <code class="code">root</code>.
At node <code class="code">root</code>, the arrays are concatenated and stored in the
argument <code class="code">dst</code>. <code class="code">dst</code> is significant only at node <code class="code">root</code>.
<code class="code">Mpi.gather_int_array</code> is similar.<br>
</div>
<br>
<h2 id="2_Gathertoall">Gather to all</h2><br>
<pre><span id="VALallgather"><span class="keyword">val</span> allgather</span> : <code class="type">'a -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> 'a array</code></pre>
<pre><span id="VALallgather_int"><span class="keyword">val</span> allgather_int</span> : <code class="type">int -> int array -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALallgather_float"><span class="keyword">val</span> allgather_float</span> : <code class="type">float -> float array -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALallgather_int_array"><span class="keyword">val</span> allgather_int_array</span> : <code class="type">int array -> int array -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALallgather_float_array"><span class="keyword">val</span> allgather_float_array</span> : <code class="type">float array -> float array -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre><div class="info ">
The <code class="code">Mpi.allgather*</code> functions behave like the corresponding
<code class="code">Mpi.gather*</code> functions, except that the result of the gather
operation is available at all nodes, not only at the root node.
In other terms, <code class="code">Mpi.allgather</code> is equivalent to <code class="code">Mpi.gather</code>
at root <code class="code">r</code> followed by a broadcast of the result from node <code class="code">r</code>.<br>
</div>
<br>
<h2 id="2_Reduce">Reduce</h2><br>
<pre><code><span id="TYPEintop"><span class="keyword">type</span> <code class="type"></code>intop</span> = </code></pre><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTintop.Int_max"><span class="constructor">Int_max</span></span></code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTintop.Int_min"><span class="constructor">Int_min</span></span></code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTintop.Int_sum"><span class="constructor">Int_sum</span></span></code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTintop.Int_prod"><span class="constructor">Int_prod</span></span></code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTintop.Int_land"><span class="constructor">Int_land</span></span></code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTintop.Int_lor"><span class="constructor">Int_lor</span></span></code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTintop.Int_xor"><span class="constructor">Int_xor</span></span></code></td>
</tr></table>
<pre><code><span id="TYPEfloatop"><span class="keyword">type</span> <code class="type"></code>floatop</span> = </code></pre><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTfloatop.Float_max"><span class="constructor">Float_max</span></span></code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTfloatop.Float_min"><span class="constructor">Float_min</span></span></code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTfloatop.Float_sum"><span class="constructor">Float_sum</span></span></code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTfloatop.Float_prod"><span class="constructor">Float_prod</span></span></code></td>
</tr></table>
<br>
The operations that can be performed by a reduce or scan,
on integers and floats respectively. <code class="code">max</code> and <code class="code">min</code>
are maximum and minimum; <code class="code">sum</code> and <code class="code">prod</code>
are summation (<code class="code">+</code>) and product (<code class="code">*</code>).
<code class="code">land</code>. <code class="code">lor</code> and <code class="code">lxor</code> are logical (bit-per-bit) and,
or and exclusive-or.<br>
<pre><span id="VALreduce_int"><span class="keyword">val</span> reduce_int</span> : <code class="type">int -> <a href="Mpi.html#TYPEintop">intop</a> -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> int</code></pre>
<pre><span id="VALreduce_float"><span class="keyword">val</span> reduce_float</span> : <code class="type">float -> <a href="Mpi.html#TYPEfloatop">floatop</a> -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> float</code></pre><div class="info ">
<code class="code">Mpi.reduce_int d op root comm</code> computes the value of
<code class="code">d0 op d1 op ... op dN</code>, where <code class="code">d0 ... dN</code> are the values of
the <code class="code">d</code> argument at every node in <code class="code">comm</code>. The result value
is returned at node with rank <code class="code">root</code>. A meaningless integer
is returned at other nodes. <code class="code">Mpi.reduce_float</code> is similar
except for the use of floating-point operations instead of
integer operations.<br>
</div>
<pre><span id="VALreduce_int_array"><span class="keyword">val</span> reduce_int_array</span> : <code class="type">int array -> int array -> <a href="Mpi.html#TYPEintop">intop</a> -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALreduce_float_array"><span class="keyword">val</span> reduce_float_array</span> : <code class="type">float array -><br> float array -> <a href="Mpi.html#TYPEfloatop">floatop</a> -> <a href="Mpi.html#TYPErank">rank</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre><div class="info ">
<code class="code">Mpi.reduce_int_array d res op root comm</code> computes
<code class="code">Array.length d</code> reductions by operation <code class="code">op</code> simultaneously.
For every <code class="code">i</code>, the values of <code class="code">d.(i)</code> at every node
are combined using <code class="code">op</code> and the result is stored into <code class="code">dst.(i)</code>
at node <code class="code">root</code>.<br>
</div>
<br>
<h2 id="2_Reducetoall">Reduce to all</h2><br>
<pre><span id="VALallreduce_int"><span class="keyword">val</span> allreduce_int</span> : <code class="type">int -> <a href="Mpi.html#TYPEintop">intop</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> int</code></pre>
<pre><span id="VALallreduce_float"><span class="keyword">val</span> allreduce_float</span> : <code class="type">float -> <a href="Mpi.html#TYPEfloatop">floatop</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> float</code></pre>
<pre><span id="VALallreduce_int_array"><span class="keyword">val</span> allreduce_int_array</span> : <code class="type">int array -> int array -> <a href="Mpi.html#TYPEintop">intop</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALallreduce_float_array"><span class="keyword">val</span> allreduce_float_array</span> : <code class="type">float array -> float array -> <a href="Mpi.html#TYPEfloatop">floatop</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre><div class="info ">
The <code class="code">Mpi.allreduce_*</code> operations are similar to the
corresponding <code class="code">Mpi.reduce_*</code> operations, except that the result
of the reduction is made available at all nodes.<br>
</div>
<br>
<h2 id="2_Scan">Scan</h2><br>
<pre><span id="VALscan_int"><span class="keyword">val</span> scan_int</span> : <code class="type">int -> <a href="Mpi.html#TYPEintop">intop</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> int</code></pre>
<pre><span id="VALscan_float"><span class="keyword">val</span> scan_float</span> : <code class="type">float -> <a href="Mpi.html#TYPEfloatop">floatop</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> float</code></pre><div class="info ">
<code class="code">Mpi.scan_int d res op comm</code> performs a scan operation over
the integers <code class="code">d</code> at every node. Let <code class="code">d0 ... dN</code> be the
values of the <code class="code">d</code> at every node in <code class="code">comm</code>. At node with rank <code class="code">R</code>,
<code class="code">Mpi.scan_int d res op comm</code> returns <code class="code">d0 op ... op dR</code>.
<code class="code">Mpi.scan_float</code> is similar.<br>
</div>
<pre><span id="VALscan_int_array"><span class="keyword">val</span> scan_int_array</span> : <code class="type">int array -> int array -> <a href="Mpi.html#TYPEintop">intop</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre>
<pre><span id="VALscan_float_array"><span class="keyword">val</span> scan_float_array</span> : <code class="type">float array -> float array -> <a href="Mpi.html#TYPEfloatop">floatop</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> unit</code></pre><div class="info ">
Same as <code class="code">Mpi.scan_int</code> and <code class="code">Mpi.scan_float</code>, but perform several
scanning operations on the elements of the input array (first
argument). The result is stored in the array passed as second
argument at the root node.<br>
</div>
<br>
<h2 id="2_Advancedoperationsoncommunicators">Advanced operations on communicators</h2><br>
<pre><span id="VALcomm_compare"><span class="keyword">val</span> comm_compare</span> : <code class="type"><a href="Mpi.html#TYPEcommunicator">communicator</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a> -> bool</code></pre><div class="info ">
Compare two communicators and return <code class="code">true</code> if they are the same,
<code class="code">false</code> otherwise.<br>
</div>
<pre><span id="TYPEcolor"><span class="keyword">type</span> <code class="type"></code>color</span> = <code class="type">int</code> </pre>
<pre><span id="VALcomm_split"><span class="keyword">val</span> comm_split</span> : <code class="type"><a href="Mpi.html#TYPEcommunicator">communicator</a> -> <a href="Mpi.html#TYPEcolor">color</a> -> int -> <a href="Mpi.html#TYPEcommunicator">communicator</a></code></pre><div class="info ">
<code class="code">Mpi.comm_split comm col key</code> splits the communicator into
several communicators based on the values of <code class="code">col</code> and
<code class="code">key</code> at every node. For each distinct value of the <code class="code">col</code>
argument, a new communicator is created. It contains all
nodes of <code class="code">comm</code> that have presented that particular value of
<code class="code">key</code> to <code class="code">Mpi.comm_split</code>. The ordering of nodes in the
new communicator is determined by the <code class="code">key</code> argument:
nodes are ordered by increasing values of <code class="code">key</code>, and in case
of ties, by their original order in <code class="code">comm</code>. Thus, to preserve
the same ordering as in <code class="code">comm</code>, it suffices that all nodes
present <code class="code">0</code> as the <code class="code">key</code> argument. In each node, the communicator
returned is the one that corresponds to the <code class="code">color</code> argument
of that node.<br>
</div>
<pre><span id="VALcolor_none"><span class="keyword">val</span> color_none</span> : <code class="type"><a href="Mpi.html#TYPEcolor">color</a></code></pre><div class="info ">
In <code class="code">Mpi.comm_split</code>, a node can pass <code class="code">Mpi.color_none</code> as the
<code class="code">col</code> argument to indicate that it does not want to be part
of any of the new communicators. <code class="code">Mpi.comm_split</code> then
returns a null communicator (allowing no communications) in
that node.<br>
</div>
<br>
<h2 id="2_Cartesiantopologies">Cartesian topologies</h2><br>
<pre><span id="VALcart_create"><span class="keyword">val</span> cart_create</span> : <code class="type"><a href="Mpi.html#TYPEcommunicator">communicator</a> -> int array -> bool array -> bool -> <a href="Mpi.html#TYPEcommunicator">communicator</a></code></pre><div class="info ">
<code class="code">Mpi.cart_create comm dims periodic reorder</code> embeds a cartesian
topology (multi-dimensional grid) on the nodes of
communicator <code class="code">comm</code>, and return a
new communicator with that information attached.
The length of <code class="code">dims</code> determines the number of dimensions of
the topology. For each dimension <code class="code">d</code>, <code class="code">dims.(d)</code> specifies
the number of nodes in that dimension, and <code class="code">periodic.(d)</code>
says whether that dimension is periodic (wraps around) or not.
<code class="code">reorder</code> determines whether the ranks of nodes in the new
communicator can be reordered for better efficiency (<code class="code">true</code>)
or must remain the same as in <code class="code">comm</code> (<code class="code">false</code>).
The initial communicator <code class="code">comm</code> must contain at least as many
nodes as specified by <code class="code">dims</code>.<br>
</div>
<pre><span id="VALdims_create"><span class="keyword">val</span> dims_create</span> : <code class="type">int -> int array -> int array</code></pre><div class="info ">
<code class="code">Mpi.dims_create numnodes hints</code> helps determining a
suitable <code class="code">dims</code> argument to <code class="code">Mpi.cart_create</code>
given a number of nodes <code class="code">numnodes</code>, the number of
dimensions required, and optional constraints.
The length of the <code class="code">hints</code> array determines the number of
dimensions. For each dimension <code class="code">d</code>, <code class="code">hints.(d)</code>, if not null,
is the number of nodes required along this dimension. If null,
<code class="code">Mpi.dims_create</code> figures out a suitable number.
<p>
For instance, <code class="code">Mpi.dims_create 24 [|0;0|]</code> returns reasonable
dimensions for a two-dimensional grid containing 24 nodes.<br>
</div>
<pre><span id="VALcart_rank"><span class="keyword">val</span> cart_rank</span> : <code class="type"><a href="Mpi.html#TYPEcommunicator">communicator</a> -> int array -> <a href="Mpi.html#TYPErank">rank</a></code></pre><div class="info ">
<code class="code">Mpi.cart_rank comm coords</code> return the rank of the node in
the cartesian topology <code class="code">comm</code> that is at coordinates <code class="code">coords</code>.
The <code class="code">coords</code> array must have one element per dimension of the
cartesian topology. Individual coordinates range between <code class="code">0</code>
(inclusive) and the corresponding dimension (exclusive).<br>
</div>
<pre><span id="VALcart_coords"><span class="keyword">val</span> cart_coords</span> : <code class="type"><a href="Mpi.html#TYPEcommunicator">communicator</a> -> <a href="Mpi.html#TYPErank">rank</a> -> int array</code></pre><div class="info ">
The inverse operation of <code class="code">Mpi.cart_rank</code>.
<code class="code">Mpi.cart_coords comm r</code> returns the cartesian coordinates
of the node having rank <code class="code">r</code> in <code class="code">comm</code>.<br>
</div>
<br>
<h2 id="2_Processgroupmanagement">Process group management</h2><br>
<pre><span id="TYPEgroup"><span class="keyword">type</span> <code class="type"></code>group</span> </pre>
<div class="info ">
The type of groups. Groups represent sets of nodes
(processing elements). Unlike communicators, they cannot
be used directly for communication. Instead, one constructs
a group representing the desired set of nodes, then build
a communicator for this group.<br>
</div>
<pre><span id="VALcomm_create"><span class="keyword">val</span> comm_create</span> : <code class="type"><a href="Mpi.html#TYPEcommunicator">communicator</a> -> <a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPEcommunicator">communicator</a></code></pre><div class="info ">
<code class="code">Mpi.comm_create comm group</code> creates a communicator
whose nodes are those described in <code class="code">group</code>. <code class="code">comm</code> is
the initial communicator; the nodes in <code class="code">group</code> must be
a subset of those in <code class="code">comm</code>. The null communicator is
returned to the nodes that are not part of <code class="code">group</code>.<br>
</div>
<pre><span id="VALgroup_size"><span class="keyword">val</span> group_size</span> : <code class="type"><a href="Mpi.html#TYPEgroup">group</a> -> int</code></pre><div class="info ">
Return the size (number of nodes) in the given group.<br>
</div>
<pre><span id="VALgroup_rank"><span class="keyword">val</span> group_rank</span> : <code class="type"><a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPErank">rank</a></code></pre><div class="info ">
Return the rank of the calling node in the given group.<br>
</div>
<pre><span id="VALgroup_translate_ranks"><span class="keyword">val</span> group_translate_ranks</span> : <code class="type"><a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPErank">rank</a> array -> <a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPErank">rank</a> array</code></pre><div class="info ">
<code class="code">Mpi.group_translate_ranks g1 ranks g2</code> translates the ranks
of a number of nodes from one group to another. <code class="code">rank</code>
is an array of node ranks relative to group <code class="code">g1</code>. The
returned array contains the ranks for the same nodes, relative
to group <code class="code">g2</code>.<br>
</div>
<pre><span id="VALcomm_group"><span class="keyword">val</span> comm_group</span> : <code class="type"><a href="Mpi.html#TYPEcommunicator">communicator</a> -> <a href="Mpi.html#TYPEgroup">group</a></code></pre><div class="info ">
<code class="code">Mpi.comm_group comm</code> returns the group of all nodes belonging
to the communicator <code class="code">comm</code>, with the same ranks as in <code class="code">comm</code>.<br>
</div>
<pre><span id="VALgroup_union"><span class="keyword">val</span> group_union</span> : <code class="type"><a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPEgroup">group</a></code></pre>
<pre><span id="VALgroup_intersection"><span class="keyword">val</span> group_intersection</span> : <code class="type"><a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPEgroup">group</a></code></pre>
<pre><span id="VALgroup_difference"><span class="keyword">val</span> group_difference</span> : <code class="type"><a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPEgroup">group</a></code></pre><div class="info ">
Union, intersection and set difference over groups.<br>
</div>
<pre><span id="VALgroup_incl"><span class="keyword">val</span> group_incl</span> : <code class="type"><a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPErank">rank</a> array -> <a href="Mpi.html#TYPEgroup">group</a></code></pre><div class="info ">
<code class="code">Mpi.group_incl group ranks</code> returns the subset of <code class="code">group</code>
containing the nodes whose ranks are given in the array <code class="code">ranks</code>.<br>
</div>
<pre><span id="VALgroup_excl"><span class="keyword">val</span> group_excl</span> : <code class="type"><a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPErank">rank</a> array -> <a href="Mpi.html#TYPEgroup">group</a></code></pre><div class="info ">
<code class="code">Mpi.group_excl group ranks</code> returns the subset of <code class="code">group</code>
containing the nodes whose ranks are not given in the array
<code class="code">ranks</code>.<br>
</div>
<pre><code><span id="TYPEgroup_range"><span class="keyword">type</span> <code class="type"></code>group_range</span> = {</code></pre><table class="typetable">
<tr>
<td align="left" valign="top" >
<code> </code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTgroup_range.range_first">range_first</span> : <code class="type">int</code>;</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code> </code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTgroup_range.range_last">range_last</span> : <code class="type">int</code>;</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code> </code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTgroup_range.range_stride">range_stride</span> : <code class="type">int</code>;</code></td>
</tr></table>
}
<div class="info ">
A group range represents the set of nodes whose ranks are
(<code class="code">range_first</code>; <code class="code">range_first + range_stride</code>; ...; <code class="code">range_last</code>).<br>
</div>
<pre><span id="VALgroup_range_incl"><span class="keyword">val</span> group_range_incl</span> : <code class="type"><a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPEgroup_range">group_range</a> array -> <a href="Mpi.html#TYPEgroup">group</a></code></pre><div class="info ">
<code class="code">Mpi.group_range_incl group ranges</code> returns the subset of <code class="code">group</code>
containing the nodes whose ranks belong to the ranges
listed in <code class="code">ranges</code>.<br>
</div>
<pre><span id="VALgroup_range_excl"><span class="keyword">val</span> group_range_excl</span> : <code class="type"><a href="Mpi.html#TYPEgroup">group</a> -> <a href="Mpi.html#TYPEgroup_range">group_range</a> array -> <a href="Mpi.html#TYPEgroup">group</a></code></pre><div class="info ">
<code class="code">Mpi.group_range_excl group ranges</code> returns the subset of <code class="code">group</code>
containing the nodes whose ranks do not belong to the ranges
listed in <code class="code">ranges</code>.<br>
</div>
<br>
<h2 id="2_Miscellaneous">Miscellaneous</h2><br>
<pre><span id="VALwtime"><span class="keyword">val</span> wtime</span> : <code class="type">unit -> float</code></pre><div class="info ">
Return the wall-clock time elapsed at the calling node
since the beginning of the program execution.<br>
</div>
</body></html>
distrib
>
Mageia
>
5
>
x86_64
>
media
>
core-release
>
by-pkgid
>
181b8f128780007d64fd4e8e405cc4d2
>
files
>
7
