887 строки
30 KiB
Java
887 строки
30 KiB
Java
/*
|
|
* Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
|
|
* University Research and Technology
|
|
* Corporation. All rights reserved.
|
|
* Copyright (c) 2004-2005 The University of Tennessee and The University
|
|
* of Tennessee Research Foundation. All rights
|
|
* reserved.
|
|
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
|
|
* University of Stuttgart. All rights reserved.
|
|
* Copyright (c) 2004-2005 The Regents of the University of California.
|
|
* All rights reserved.
|
|
* Copyright (c) 2015 Los Alamos National Security, LLC. All rights
|
|
* reserved.
|
|
* Copyright (c) 2018 FUJITSU LIMITED. All rights reserved.
|
|
* $COPYRIGHT$
|
|
*
|
|
* Additional copyrights may follow
|
|
*
|
|
* $HEADER$
|
|
*
|
|
*
|
|
* This file is almost a complete re-write for Open MPI compared to the
|
|
* original mpiJava package. Its license and copyright are listed below.
|
|
* See <path to ompi/mpi/java/README> for more information.
|
|
*
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*
|
|
* File : Intracommm.java
|
|
* Author : Sang Lim, Xinying Li, Bryan Carpenter
|
|
* Created : Thu Apr 9 12:22:15 1998
|
|
* Revision : $Revision: 1.14 $
|
|
* Updated : $Date: 2002/12/16 15:25:13 $
|
|
* Copyright: Northeast Parallel Architectures Center
|
|
* at Syracuse University 1998
|
|
*
|
|
*
|
|
*
|
|
* IMPLEMENTATION DETAILS
|
|
*
|
|
* All methods with buffers that can be direct or non direct have
|
|
* a companion argument 'db' which is true if the buffer is direct.
|
|
* For example, if the buffer argument is recvBuf, the companion
|
|
* argument will be 'rdb', meaning if the receive buffer is direct.
|
|
*
|
|
* Checking if a buffer is direct is faster in Java than C.
|
|
*/
|
|
package mpi;
|
|
|
|
import java.nio.*;
|
|
import static mpi.MPI.assertDirectBuffer;
|
|
|
|
/**
|
|
* This class represents intracommunicator.
|
|
*/
|
|
public class Intracomm extends Comm
|
|
{
|
|
protected Intracomm()
|
|
{
|
|
}
|
|
|
|
protected Intracomm(long handle)
|
|
{
|
|
super(handle);
|
|
}
|
|
|
|
protected Intracomm(long[] commRequest)
|
|
{
|
|
super(commRequest);
|
|
}
|
|
|
|
/**
|
|
* Duplicates this communicator.
|
|
* <p>Java binding of {@code MPI_COMM_DUP}.
|
|
* <p>It is recommended to use {@link #dup} instead of {@link #clone}
|
|
* because the last can't throw an {@link mpi.MPIException}.
|
|
* @return copy of this communicator
|
|
*/
|
|
@Override public Intracomm clone()
|
|
{
|
|
try
|
|
{
|
|
return dup();
|
|
}
|
|
catch(MPIException e)
|
|
{
|
|
throw new RuntimeException(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Duplicates this communicator.
|
|
* <p>Java binding of {@code MPI_COMM_DUP}.
|
|
* @return copy of this communicator
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
@Override public Intracomm dup() throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new Intracomm(dup(handle));
|
|
}
|
|
|
|
/**
|
|
* Duplicates this communicator.
|
|
* <p>Java binding of {@code MPI_COMM_IDUP}.
|
|
* <p>The new communicator can't be used before the operation completes.
|
|
* The request object must be obtained calling {@link #getRequest}.
|
|
* @return copy of this communicator
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
@Override public Intracomm iDup() throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new Intracomm(iDup(handle));
|
|
}
|
|
|
|
/**
|
|
* Duplicates this communicator with the info object used in the call.
|
|
* <p>Java binding of {@code MPI_COMM_DUP_WITH_INFO}.
|
|
* @param info info object to associate with the new communicator
|
|
* @return copy of this communicator
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
@Override public Intracomm dupWithInfo(Info info) throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new Intracomm(dupWithInfo(handle, info.handle));
|
|
}
|
|
|
|
/**
|
|
* Partition the group associated with this communicator and create
|
|
* a new communicator within each subgroup.
|
|
* <p>Java binding of the MPI operation {@code MPI_COMM_SPLIT}.
|
|
* @param colour control of subset assignment
|
|
* @param key control of rank assignment
|
|
* @return new communicator
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Intracomm split(int colour, int key) throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new Intracomm(split(handle, colour, key));
|
|
}
|
|
|
|
private native long split(long comm, int colour, int key) throws MPIException;
|
|
|
|
/**
|
|
* Partition the group associated with this communicator and create
|
|
* a new communicator within each subgroup.
|
|
* <p>Java binding of the MPI operation {@code MPI_COMM_SPLIT_TYPE}.
|
|
* @param splitType type of processes to be grouped together
|
|
* @param key control of rank assignment
|
|
* @param info info argument
|
|
* @return new communicator
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Intracomm splitType(int splitType, int key, Info info) throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new Intracomm(splitType(handle, splitType, key, info.handle));
|
|
}
|
|
|
|
private native long splitType(long comm, int colour, int key, long info) throws MPIException;
|
|
|
|
/**
|
|
* Create a new communicator.
|
|
* <p>Java binding of the MPI operation {@code MPI_COMM_CREATE}.
|
|
* @param group group which is a subset of the group of this communicator
|
|
* @return new communicator
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Intracomm create(Group group) throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new Intracomm(create(handle, group.handle));
|
|
}
|
|
|
|
private native long create(long comm, long group);
|
|
|
|
/**
|
|
* Create a new intracommunicator for the given group.
|
|
* <p>Java binding of the MPI operation {@code MPI_COMM_CREATE_GROUP}.
|
|
* @param group group which is a subset of the group of this communicator
|
|
* @param tag an integer tag
|
|
* @return new communicator
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Intracomm createGroup(Group group, int tag) throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new Intracomm(createGroup(handle, group.handle, tag));
|
|
}
|
|
|
|
private native long createGroup(long comm, long group, int tag);
|
|
|
|
// Topology Constructors
|
|
|
|
/**
|
|
* Creates a communicator to which the Cartesian topology
|
|
* information is attached.
|
|
* Create a cartesian topology communicator whose group is a subset
|
|
* of the group of this communicator.
|
|
* <p>Java binding of the MPI operation {@code MPI_CART_CREATE}.
|
|
* <p>The number of dimensions of the Cartesian grid is taken to be the
|
|
* size of the {@code dims} argument. The array {@code periods} must
|
|
* be the same size.
|
|
* @param dims the number of processes in each dimension
|
|
* @param periods {@code true} if grid is periodic,
|
|
* {@code false} if not, in each dimension
|
|
* @param reorder {@code true} if ranking may be reordered,
|
|
* {@code false} if not
|
|
* @return new cartesian topology communicator
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final CartComm createCart(int[] dims, boolean[] periods, boolean reorder)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new CartComm(createCart(handle, dims, periods, reorder));
|
|
}
|
|
|
|
private native long createCart(
|
|
long comm, int[] dims, boolean[] periods, boolean reorder)
|
|
throws MPIException;
|
|
|
|
/**
|
|
* Creates a communicator to which the graph topology information is attached.
|
|
* <p>Java binding of the MPI operation {@code MPI_GRAPH_CREATE}.
|
|
* <p>The number of nodes in the graph, <em>nnodes</em>, is taken
|
|
* to be size of the {@code index} argument.
|
|
* @param index node degrees
|
|
* @param edges graph edges
|
|
* @param reorder {@code true} if ranking may be reordered,
|
|
* {@code false} if not
|
|
* @return new graph topology communicator
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final GraphComm createGraph(int[] index, int[] edges, boolean reorder)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new GraphComm(createGraph(handle, index, edges, reorder));
|
|
}
|
|
|
|
private native long createGraph(
|
|
long comm, int[] index, int[] edges, boolean reorder)
|
|
throws MPIException;
|
|
|
|
/**
|
|
* Creates a communicator to which the distributed graph topology
|
|
* information is attached.
|
|
* <p>Java binding of the MPI operation {@code MPI_DIST_GRAPH_CREATE}.
|
|
* <p>The number of source nodes is the size of the {@code sources} argument.
|
|
* @param sources source nodes for which this process specifies edges
|
|
* @param degrees number of destinations for each source node
|
|
* @param destinations destination nodes for the source nodes
|
|
* @param weights weights for source to destination edges
|
|
* @param info hints on optimization and interpretation of weights
|
|
* @param reorder the process may be reordered (true) or not (false)
|
|
* @return communicator with distributed graph topology
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final GraphComm createDistGraph(
|
|
int[] sources, int[] degrees, int[] destinations,
|
|
int[] weights, Info info, boolean reorder)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
|
|
return new GraphComm(createDistGraph(
|
|
handle, sources, degrees, destinations,
|
|
weights, info.handle, reorder, true));
|
|
}
|
|
|
|
/**
|
|
* Creates a communicator to which the distributed graph topology
|
|
* information is attached.
|
|
* <p>Java binding of the MPI operation {@code MPI_DIST_GRAPH_CREATE}
|
|
* using {@code MPI_UNWEIGHTED}.
|
|
* <p>The number of source nodes is the size of the {@code sources} argument.
|
|
* @param sources source nodes for which this process specifies edges
|
|
* @param degrees number of destinations for each source node
|
|
* @param destinations destination nodes for the source nodes
|
|
* @param info hints on optimization and interpretation of weights
|
|
* @param reorder the process may be reordered (true) or not (false)
|
|
* @return communicator with distributed graph topology
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final GraphComm createDistGraph(
|
|
int[] sources, int[] degrees, int[] destinations,
|
|
Info info, boolean reorder)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
|
|
return new GraphComm(createDistGraph(
|
|
handle, sources, degrees, destinations,
|
|
null, info.handle, reorder, false));
|
|
}
|
|
|
|
private native long createDistGraph(
|
|
long comm, int[] sources, int[] degrees, int[] destinations,
|
|
int[] weights, long info, boolean reorder, boolean weighted)
|
|
throws MPIException;
|
|
|
|
|
|
/**
|
|
* Creates a communicator to which the distributed graph topology
|
|
* information is attached.
|
|
* <p>Java binding of the MPI operation {@code MPI_DIST_GRAPH_CREATE_ADJACENT}.
|
|
* <p>The number of source/destination nodes is the size of the
|
|
* {@code sources}/{@code destinations} argument.
|
|
* @param sources ranks of processes for which the calling process
|
|
* is a destination
|
|
* @param sourceWeights weights of the edges into the calling process
|
|
* @param destinations ranks of processes for which the calling process
|
|
* is a source
|
|
* @param destWeights weights of the edges out of the calling process
|
|
* @param info hints on optimization and interpretation of weights
|
|
* @param reorder the process may be reordered (true) or not (false)
|
|
* @return communicator with distributed graph topology
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final GraphComm createDistGraphAdjacent(
|
|
int[] sources, int[] sourceWeights,
|
|
int[] destinations, int[] destWeights, Info info, boolean reorder)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
|
|
return new GraphComm(createDistGraphAdjacent(
|
|
handle, sources, sourceWeights, destinations,
|
|
destWeights, info.handle, reorder, true));
|
|
}
|
|
|
|
/**
|
|
* Creates a communicator to which the distributed graph topology
|
|
* information is attached.
|
|
* <p>Java binding of the MPI operation {@code MPI_DIST_GRAPH_CREATE_ADJACENT}
|
|
* using {@code MPI_UNWEIGHTED}.
|
|
* <p>The number of source/destination nodes is the size of the
|
|
* {@code sources}/{@code destinations} argument.
|
|
* @param sources ranks of processes for which the calling process
|
|
* is a destination
|
|
* @param destinations ranks of processes for which the calling process
|
|
* is a source
|
|
* @param info hints on optimization and interpretation of weights
|
|
* @param reorder the process may be reordered (true) or not (false)
|
|
* @return communicator with distributed graph topology
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final GraphComm createDistGraphAdjacent(
|
|
int[] sources, int[] destinations, Info info, boolean reorder)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
|
|
return new GraphComm(createDistGraphAdjacent(
|
|
handle, sources, null, destinations, null,
|
|
info.handle, reorder, false));
|
|
}
|
|
|
|
private native long createDistGraphAdjacent(
|
|
long comm, int[] sources, int []sourceweights, int[] destinations,
|
|
int[] distweights, long info, boolean reorder, boolean weighted)
|
|
throws MPIException;
|
|
|
|
|
|
/**
|
|
* Perform a prefix reduction on data distributed across the group.
|
|
* <p>Java binding of the MPI operation {@code MPI_SCAN}.
|
|
* @param sendbuf send buffer array
|
|
* @param recvbuf receive buffer array
|
|
* @param count number of items in input buffer
|
|
* @param type data type of each item in input buffer
|
|
* @param op reduce operation
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final void scan(Object sendbuf, Object recvbuf,
|
|
int count, Datatype type, Op op)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
|
|
int sendoff = 0,
|
|
recvoff = 0;
|
|
|
|
boolean sdb = false,
|
|
rdb = false;
|
|
|
|
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
|
|
{
|
|
sendoff = type.getOffset(sendbuf);
|
|
sendbuf = ((Buffer)sendbuf).array();
|
|
}
|
|
|
|
if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
|
|
{
|
|
recvoff = type.getOffset(recvbuf);
|
|
recvbuf = ((Buffer)recvbuf).array();
|
|
}
|
|
|
|
op.setDatatype(type);
|
|
|
|
scan(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
|
|
count, type.handle, type.baseType, op, op.handle);
|
|
}
|
|
|
|
/**
|
|
* Perform a prefix reduction on data distributed across the group.
|
|
* <p>Java binding of the MPI operation {@code MPI_SCAN}
|
|
* using {@code MPI_IN_PLACE} instead of the send buffer.
|
|
* @param recvbuf receive buffer array
|
|
* @param count number of items in input buffer
|
|
* @param type data type of each item in input buffer
|
|
* @param op reduce operation
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final void scan(Object recvbuf, int count, Datatype type, Op op)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
int recvoff = 0;
|
|
boolean rdb = false;
|
|
|
|
if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
|
|
{
|
|
recvoff = type.getOffset(recvbuf);
|
|
recvbuf = ((Buffer)recvbuf).array();
|
|
}
|
|
|
|
op.setDatatype(type);
|
|
|
|
scan(handle, null, false, 0, recvbuf, rdb, recvoff,
|
|
count, type.handle, type.baseType, op, op.handle);
|
|
}
|
|
|
|
private native void scan(
|
|
long comm, Object sendbuf, boolean sdb, int sendoff,
|
|
Object recvbuf, boolean rdb, int recvoff, int count,
|
|
long type, int baseType, Op jOp, long hOp) throws MPIException;
|
|
|
|
/**
|
|
* Perform a prefix reduction on data distributed across the group.
|
|
* <p>Java binding of the MPI operation {@code MPI_ISCAN}.
|
|
* @param sendbuf send buffer array
|
|
* @param recvbuf receive buffer array
|
|
* @param count number of items in input buffer
|
|
* @param type data type of each item in input buffer
|
|
* @param op reduce operation
|
|
* @return communication request
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Request iScan(Buffer sendbuf, Buffer recvbuf,
|
|
int count, Datatype type, Op op)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
op.setDatatype(type);
|
|
assertDirectBuffer(sendbuf, recvbuf);
|
|
Request req = new Request(iScan(handle, sendbuf, recvbuf, count,
|
|
type.handle, type.baseType, op, op.handle));
|
|
req.addSendBufRef(sendbuf);
|
|
req.addRecvBufRef(recvbuf);
|
|
return req;
|
|
}
|
|
|
|
/**
|
|
* Perform a prefix reduction on data distributed across the group.
|
|
* <p>Java binding of the MPI operation {@code MPI_ISCAN}
|
|
* using {@code MPI_IN_PLACE} instead of the send buffer.
|
|
* @param buf send/receive buffer array
|
|
* @param count number of items in buffer
|
|
* @param type data type of each item in buffer
|
|
* @param op reduce operation
|
|
* @return communication request
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Request iScan(Buffer buf, int count, Datatype type, Op op)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
op.setDatatype(type);
|
|
assertDirectBuffer(buf);
|
|
Request req = new Request(iScan(
|
|
handle, null, buf, count,
|
|
type.handle, type.baseType, op, op.handle));
|
|
req.addSendBufRef(buf);
|
|
return req;
|
|
}
|
|
|
|
private native long iScan(
|
|
long comm, Buffer sendbuf, Buffer recvbuf, int count,
|
|
long type, int baseType, Op jOp, long hOp) throws MPIException;
|
|
|
|
/**
|
|
* Perform a prefix reduction on data distributed across the group.
|
|
* <p>Java binding of the MPI operation {@code MPI_EXSCAN}.
|
|
* @param sendbuf send buffer array
|
|
* @param recvbuf receive buffer array
|
|
* @param count number of items in input buffer
|
|
* @param type data type of each item in input buffer
|
|
* @param op reduce operation
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final void exScan(Object sendbuf, Object recvbuf,
|
|
int count, Datatype type, Op op)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
|
|
int sendoff = 0,
|
|
recvoff = 0;
|
|
|
|
boolean sdb = false,
|
|
rdb = false;
|
|
|
|
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
|
|
{
|
|
sendoff = type.getOffset(sendbuf);
|
|
sendbuf = ((Buffer)sendbuf).array();
|
|
}
|
|
|
|
if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
|
|
{
|
|
recvoff = type.getOffset(recvbuf);
|
|
recvbuf = ((Buffer)recvbuf).array();
|
|
}
|
|
|
|
op.setDatatype(type);
|
|
|
|
exScan(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
|
|
count, type.handle, type.baseType, op, op.handle);
|
|
}
|
|
|
|
/**
|
|
* Perform a prefix reduction on data distributed across the group.
|
|
* <p>Java binding of the MPI operation {@code MPI_EXSCAN}
|
|
* using {@code MPI_IN_PLACE} instead of the send buffer.
|
|
* @param buf receive buffer array
|
|
* @param count number of items in input buffer
|
|
* @param type data type of each item in input buffer
|
|
* @param op reduce operation
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final void exScan(Object buf, int count, Datatype type, Op op)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
int off = 0;
|
|
boolean db = false;
|
|
|
|
if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
|
|
{
|
|
off = type.getOffset(buf);
|
|
buf = ((Buffer)buf).array();
|
|
}
|
|
|
|
op.setDatatype(type);
|
|
|
|
exScan(handle, null, false, 0, buf, db, off, count,
|
|
type.handle, type.baseType, op, op.handle);
|
|
}
|
|
|
|
private native void exScan(
|
|
long comm, Object sendbuf, boolean sdb, int sendoff,
|
|
Object recvbuf, boolean rdb, int recvoff, int count,
|
|
long type, int baseType, Op jOp, long hOp) throws MPIException;
|
|
|
|
/**
|
|
* Perform a prefix reduction on data distributed across the group.
|
|
* <p>Java binding of the MPI operation {@code MPI_IEXSCAN}.
|
|
* @param sendbuf send buffer array
|
|
* @param recvbuf receive buffer array
|
|
* @param count number of items in input buffer
|
|
* @param type data type of each item in input buffer
|
|
* @param op reduce operation
|
|
* @return communication request
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Request iExScan(Buffer sendbuf, Buffer recvbuf,
|
|
int count, Datatype type, Op op)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
op.setDatatype(type);
|
|
assertDirectBuffer(sendbuf, recvbuf);
|
|
Request req = new Request(iExScan(handle, sendbuf, recvbuf, count,
|
|
type.handle, type.baseType, op, op.handle));
|
|
req.addSendBufRef(sendbuf);
|
|
req.addRecvBufRef(recvbuf);
|
|
return req;
|
|
}
|
|
|
|
/**
|
|
* Perform a prefix reduction on data distributed across the group.
|
|
* <p>Java binding of the MPI operation {@code MPI_IEXSCAN}
|
|
* using {@code MPI_IN_PLACE} instead of the send buffer.
|
|
* @param buf receive buffer array
|
|
* @param count number of items in input buffer
|
|
* @param type data type of each item in input buffer
|
|
* @param op reduce operation
|
|
* @return communication request
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Request iExScan(Buffer buf, int count, Datatype type, Op op)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
op.setDatatype(type);
|
|
assertDirectBuffer(buf);
|
|
Request req = new Request(iExScan(
|
|
handle, null, buf, count,
|
|
type.handle, type.baseType, op, op.handle));
|
|
req.addRecvBufRef(buf);
|
|
return req;
|
|
}
|
|
|
|
private native long iExScan(
|
|
long comm, Buffer sendbuf, Buffer recvbuf, int count,
|
|
long type, int baseType, Op jOp, long hOp) throws MPIException;
|
|
|
|
/**
|
|
* Java binding of {@code MPI_OPEN_PORT} using {@code MPI_INFO_NULL}.
|
|
* @return port name
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public static String openPort() throws MPIException
|
|
{
|
|
MPI.check();
|
|
return openPort(Info.NULL);
|
|
}
|
|
|
|
/**
|
|
* Java binding of {@code MPI_OPEN_PORT}.
|
|
* @param info implementation-specific information
|
|
* @return port name
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public static String openPort(Info info) throws MPIException
|
|
{
|
|
MPI.check();
|
|
return openPort(info.handle);
|
|
}
|
|
|
|
private native static String openPort(long info) throws MPIException;
|
|
|
|
/**
|
|
* Java binding of {@code MPI_CLOSE_PORT}.
|
|
* @param name port name
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public static void closePort(String name) throws MPIException
|
|
{
|
|
MPI.check();
|
|
closePort_jni(name);
|
|
}
|
|
|
|
private native static void closePort_jni(String name) throws MPIException;
|
|
|
|
/**
|
|
* Java binding of {@code MPI_COMM_ACCEPT} using {@code MPI_INFO_NULL}.
|
|
* @param port port name
|
|
* @param root rank in comm of root node
|
|
* @return intercommunicator with client as remote group
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Intercomm accept(String port, int root) throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new Intercomm(accept(handle, port, Info.NULL, root));
|
|
}
|
|
|
|
/**
|
|
* Java binding of {@code MPI_COMM_ACCEPT}.
|
|
* @param port port name
|
|
* @param info implementation-specific information
|
|
* @param root rank in comm of root node
|
|
* @return intercommunicator with client as remote group
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Intercomm accept(String port, Info info, int root)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new Intercomm(accept(handle, port, info.handle, root));
|
|
}
|
|
|
|
private native long accept(long comm, String port, long info, int root)
|
|
throws MPIException;
|
|
|
|
/**
|
|
* Java binding of {@code MPI_COMM_CONNECT} using {@code MPI_INFO_NULL}.
|
|
* @param port port name
|
|
* @param root rank in comm of root node
|
|
* @return intercommunicator with server as remote group
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Intercomm connect(String port, int root) throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new Intercomm(connect(handle, port, Info.NULL, root));
|
|
}
|
|
|
|
/**
|
|
* Java binding of {@code MPI_COMM_CONNECT}.
|
|
* @param port port name
|
|
* @param info implementation-specific information
|
|
* @param root rank in comm of root node
|
|
* @return intercommunicator with server as remote group
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Intercomm connect(String port, Info info, int root)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
return new Intercomm(connect(handle, port, info.handle, root));
|
|
}
|
|
|
|
private native long connect(long comm, String port, long info, int root)
|
|
throws MPIException;
|
|
|
|
/**
|
|
* Java binding of {@code MPI_PUBLISH_NAME} using {@code MPI_INFO_NULL}.
|
|
* @param service service name
|
|
* @param port port name
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public static void publishName(String service, String port)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
publishName(service, Info.NULL, port);
|
|
}
|
|
|
|
/**
|
|
* Java binding of {@code MPI_PUBLISH_NAME}.
|
|
* @param service service name
|
|
* @param info implementation-specific information
|
|
* @param port port name
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public static void publishName(String service, Info info, String port)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
publishName(service, info.handle, port);
|
|
}
|
|
|
|
private native static void publishName(String service, long info, String port)
|
|
throws MPIException;
|
|
|
|
/**
|
|
* Java binding of {@code MPI_UNPUBLISH_NAME} using {@code MPI_INFO_NULL}.
|
|
* @param service service name
|
|
* @param port port name
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public static void unpublishName(String service, String port)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
unpublishName(service, Info.NULL, port);
|
|
}
|
|
|
|
/**
|
|
* Java binding of {@code MPI_UNPUBLISH_NAME}.
|
|
* @param service service name
|
|
* @param info implementation-specific information
|
|
* @param port port name
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public static void unpublishName(String service, Info info, String port)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
unpublishName(service, info.handle, port);
|
|
}
|
|
|
|
private native static void unpublishName(String service, long info, String port)
|
|
throws MPIException;
|
|
|
|
/**
|
|
* Java binding of {@code MPI_LOOKUP_NAME} using {@code MPI_INFO_NULL}.
|
|
* @param service service name
|
|
* @return port name
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public static String lookupName(String service) throws MPIException
|
|
{
|
|
MPI.check();
|
|
return lookupName(service, Info.NULL);
|
|
}
|
|
|
|
/**
|
|
* Java binding of {@code MPI_LOOKUP_NAME}.
|
|
* @param service service name
|
|
* @param info implementation-specific information
|
|
* @return port name
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public static String lookupName(String service, Info info) throws MPIException
|
|
{
|
|
MPI.check();
|
|
return lookupName(service, info.handle);
|
|
}
|
|
|
|
private native static String lookupName(String service, long info)
|
|
throws MPIException;
|
|
|
|
/**
|
|
* Java binding of {@code MPI_COMM_SPAWN}.
|
|
* This intracommunicator will contain the group of spawned processes.
|
|
* @param command name of program to be spawned
|
|
* @param argv arguments to command; if this parameter is null,
|
|
* {@code MPI_ARGV_NULL} will be used.
|
|
* @param maxprocs maximum number of processes to start
|
|
* @param info info object telling the runtime where
|
|
* and how to start the processes
|
|
* @param root rank of process in which previous arguments are examined
|
|
* @param errcodes one code per process; if this parameter is null,
|
|
* {@code MPI_ERRCODES_IGNORE} will be used.
|
|
* @return intercommunicator between original group and the newly spawned group
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Intercomm spawn(String command, String[] argv, int maxprocs,
|
|
Info info, int root, int[] errcodes)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
|
|
return new Intercomm(spawn(handle, command, argv, maxprocs,
|
|
info.handle, root, errcodes));
|
|
}
|
|
|
|
private native long spawn(long comm, String command, String[] argv,
|
|
int maxprocs, long info, int root, int[] errcodes)
|
|
throws MPIException;
|
|
|
|
/**
|
|
* Java binding of {@code MPI_COMM_SPAWN_MULTIPLE}.
|
|
* This intracommunicator will contain the group of spawned processes.
|
|
* @param commands programs to be executed
|
|
* @param argv arguments for commands; if this parameter is null,
|
|
* {@code MPI_ARGVS_NULL} will be used.
|
|
* @param maxprocs maximum number of processes to start for each command
|
|
* @param info info objects telling the runtime where
|
|
* and how to start the processes
|
|
* @param root rank of process in which previous arguments are examined
|
|
* @param errcodes one code per process; if this parameter is null,
|
|
* {@code MPI_ERRCODES_IGNORE} will be used.
|
|
* @return intercommunicator between original group and the newly spawned group
|
|
* @throws MPIException Signals that an MPI exception of some sort has occurred.
|
|
*/
|
|
public final Intercomm spawnMultiple(
|
|
String[] commands, String[][] argv, int[] maxprocs,
|
|
Info[] info, int root, int[] errcodes)
|
|
throws MPIException
|
|
{
|
|
MPI.check();
|
|
|
|
long hInfo[] = new long[info.length];
|
|
|
|
for(int i = 0; i < info.length; i++)
|
|
hInfo[i] = info[i].handle;
|
|
|
|
return new Intercomm(spawnMultiple(handle, commands, argv, maxprocs,
|
|
hInfo, root, errcodes));
|
|
}
|
|
|
|
private native long spawnMultiple(
|
|
long comm, String[] commands, String[][] argv, int[] maxprocs,
|
|
long[] info, int root, int[] errcodes) throws MPIException;
|
|
|
|
} // Intracomm
|