documentation.cpp

来自「Boost provides free peer-reviewed portab」· C++ 代码 · 共 672 行 · 第 1/3 页

  "\n"
  "requests must be a RequestList instance.\n"
  "\n"
  "Returns a triple (value, status, index) consisting of received value\n"
  "(or None), the Status object for the completed request, and its index\n"
  "in the RequestList.\n";

const char* nonblocking_test_any_docstring =
  "Tests if any of the given requests have been completed, but does not wait\n"
  "for completion. It provides functionality equivalent to MPI_Testany.\n"
  "\n"
  "requests must be a RequestList instance.\n"
  "\n"
  "Returns a triple (value, status, index) like wait_any or None if no request\n"
  "is complete.\n";

const char* nonblocking_wait_all_docstring =
  "Waits until all of the given requests have been completed. It provides\n"
  "functionality equivalent to MPI_Waitall.\n"
  "\n"
  "requests must be a RequestList instance.\n"
  "\n"
  "If the second parameter `callable' is provided, it is called with each\n"
  "completed request's received value (or None) and it s Status object as\n"
  "its arguments. The calls occur in the order given by the `requests' list.\n";

const char* nonblocking_test_all_docstring =
  "Tests if all of the given requests have been completed. It provides\n"
  "functionality equivalent to MPI_Testall.\n"
  "\n"
  "Returns True if all requests have been completed.\n"
  "\n"
  "requests must be a RequestList instance.\n"
  "\n"
  "If the second parameter `callable' is provided, it is called with each\n"
  "completed request's received value (or None) and it s Status object as\n"
  "its arguments. The calls occur in the order given by the `requests' list.\n";

const char* nonblocking_wait_some_docstring =
  "Waits until at least one of the given requests has completed. It\n"
  "then completes all of the requests it can, partitioning the input\n"
  "sequence into pending requests followed by completed requests.\n"
  "\n"
  "This routine provides functionality equivalent to MPI_Waitsome.\n"
  "\n"
  "Returns the index of the first completed request."
  "\n"
  "requests must be a RequestList instance.\n"
  "\n"
  "If the second parameter `callable' is provided, it is called with each\n"
  "completed request's received value (or None) and it s Status object as\n"
  "its arguments. The calls occur in the order given by the `requests' list.\n";

const char* nonblocking_test_some_docstring =
  "Tests to see if any of the given requests has completed. It completes\n"
  "all of the requests it can, partitioning the input sequence into pending\n"
  "requests followed by completed requests. This routine is similar to\n"
  "wait_some, but does not wait until any requests have completed.\n"
  "\n"
  "This routine provides functionality equivalent to MPI_Testsome.\n"
  "\n"
  "Returns the index of the first completed request."
  "\n"
  "requests must be a RequestList instance.\n"
  "\n"
  "If the second parameter `callable' is provided, it is called with each\n"
  "completed request's received value (or None) and it s Status object as\n"
  "its arguments. The calls occur in the order given by the `requests' list.\n";

/***********************************************************
 * exception documentation                                 *
 ***********************************************************/
const char* exception_docstring = 
  "Instances of this class will be thrown when an MPI error\n"
  "occurs. MPI failures that trigger these exceptions may or may not\n"
  "be recoverable, depending on the underlying MPI implementation.\n"
  "Consult the documentation for your MPI implementation to determine\n"
  "the effect of MPI errors.\n";

const char* exception_what_docstring = 
  "A description of the error that occured. At present, this refers\n"
  "only to the name of the MPI routine that failed.\n";

const char* exception_routine_docstring = 
  "The name of the MPI routine that reported the error.\n";

const char* exception_result_code_docstring = 
  "The result code returned from the MPI routine that reported the\n"
  "error.\n";

/***********************************************************
 * collectives documentation                               *
 ***********************************************************/
const char* all_gather_docstring =
  "all_gather is a collective algorithm that collects the values\n"
  "stored at each process into a tuple of values indexed by the\n"
  "process number they came from. all_gather is (semantically) a\n" 
  "gather followed by a broadcast. The same tuple of values is\n"
  "returned to all processes.\n";

const char* all_reduce_docstring =
  "all_reduce is a collective algorithm that combines the values\n"
  "stored by each process into a single value. The values can be\n"
  "combined arbitrarily, specified via any function. The values\n"
  "a1, a2, .., ap provided by p processors will be combined by the\n"
  "binary function op into the result\n"
  "         op(a1, op(a2, ... op(ap-1,ap)))\n"
  "that will be returned to all processes. This function is the\n"
  "equivalent of calling all_gather() and then applying the built-in\n"
  "reduce() function to the returned sequence. op is assumed to be\n"
  "associative.\n";

const char* all_to_all_docstring =
  "all_to_all is a collective algorithm that transmits values from\n"
  "every process to every other process. On process i, the jth value\n"
  "of the values sequence is sent to process j and placed in the ith\n"
  "position of the tuple that will be returned from all_to_all.\n";

const char* broadcast_docstring =
  "broadcast is a collective algorithm that transfers a value from an\n"
  "arbitrary root process to every other process that is part of the\n"
  "given communicator (comm). The root parameter must be the same for\n"
  "every process. The value parameter need only be specified at the root\n"
  "root. broadcast() returns the same broadcasted value to every process.\n";

const char* gather_docstring =
  "gather is a collective algorithm that collects the values\n"
  "stored at each process into a tuple of values at the root\n"
  "process. This tuple is indexed by the process number that the\n"
  "value came from, and will be returned only by the root process.\n"
  "All other processes return None.\n";

const char* reduce_docstring =
  "reduce is a collective algorithm that combines the values\n"
  "stored by each process into a single value at the root. The\n"
  "values can be combined arbitrarily, specified via any function.\n"
  "The values a1, a2, .., ap provided by p processors will be\n"
  "combined by the binary function op into the result\n"
  "     op(a1, op(a2, ... op(ap-1,ap)))\n"
  "that will be returned on the root process. This function is the\n"
  "equivalent of calling gather() to the root and then applying the\n"
  "built-in reduce() function to the returned sequence. All non-root\n"
  "processes return None. op is assumed to be associative.\n";

const char* scan_docstring =
  "@c scan computes a prefix reduction of values from all processes.\n"
  "It is a collective algorithm that combines the values stored by\n"
  "each process with the values of all processes with a smaller rank.\n"
  "The values can be arbitrarily combined, specified via a binary\n"
  "function op. If each process i provides the value ai, then scan\n"
  "returns op(a1, op(a2, ... op(ai-1, ai))) to the ith process. op is\n"
  "assumed to be associative. This routine is the equivalent of an\n"
  "all_gather(), followed by a built-in reduce() on the first i+1\n"
  "values in the resulting sequence on processor i. op is assumed\n"
  "to be associative.\n";

const char* scatter_docstring =
  "scatter is a collective algorithm that scatters the values stored\n"
  "in the root process (as a container with comm.size elements) to\n"
  "all of the processes in the communicator. The values parameter \n"
  "(only significant at the root) is indexed by the process number to\n"
  "which the corresponding value will be sent. The value received by \n"
  "each process is returned from scatter.\n";

/***********************************************************
 * communicator documentation                              *
 ***********************************************************/
const char* communicator_docstring =
 "The Communicator class abstracts a set of communicating\n"
 "processes in MPI. All of the processes that belong to a certain\n"
 "communicator can determine the size of the communicator, their rank\n"
 "within the communicator, and communicate with any other processes\n"
 "in the communicator.\n";

const char* communicator_default_constructor_docstring =
  "Build a new Boost.MPI Communicator instance for MPI_COMM_WORLD.\n";

const char* communicator_rank_docstring =
  "Returns the rank of the process in the communicator, which will be a\n"
  "value in [0, size).\n";

const char* communicator_size_docstring =
  "Returns the number of processes in the communicator.\n";

const char* communicator_send_docstring =
  "This routine executes a potentially blocking send with the given\n"
  "tag to the process with rank dest. It can be received by the\n"
  "destination process with a matching recv call. The value will be\n"
  "transmitted in one of several ways:\n"
  "\n"
  "  - For C++ objects registered via register_serialized(), the value\n"
  "    will be serialized and transmitted.\n"
  "\n"
  "  - For SkeletonProxy objects, the skeleton of the object will be\n"
  "    serialized and transmitted.\n"
  "\n"
  "  - For Content objects, the content will be transmitted directly.\n"
  "    This content can be received by a matching recv/irecv call that\n"
  "    provides a suitable `buffer' argument.\n"
  "\n"
  "  - For all other Python objects, the value will be pickled and\n"
  "    transmitted.\n";

const char* communicator_recv_docstring =
  "This routine blocks until it receives a message from the process\n"
  "source with the given tag. If the source parameter is not specified,\n"
  "the message can be received from any process. Likewise, if the tag\n"
  "parameter is not specified, a message with any tag can be received.\n"
  "If return_status is True, returns a tuple containing the received\n"
  "object followed by a Status object describing the communication.\n"
  "Otherwise, recv() returns just the received object.\n"
  "\n"
  "When receiving the content of a data type that has been sent separately\n"
  "from its skeleton, user code must provide a value for the `buffer'\n"
  "argument. This value should be the Content object returned from\n"
  "get_content().\n";

const char* communicator_isend_docstring =
  "This routine executes a nonblocking send with the given\n"
  "tag to the process with rank dest. It can be received by the\n"
  "destination process with a matching recv call. The value will be\n"
  "transmitted in the same way as with send().\n"
  "This routine returns a Request object, which can be used to query\n"
  "when the transmission has completed, wait for its completion, or\n"