documentation.cpp

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

  "cancel the transmission.\n";

const char* communicator_irecv_docstring =
  "This routine initiates a non-blocking receive 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"
  "This routine returns a Request object, which can be used to query\n"
  "when the transmission has completed, wait for its completion, or\n"
  "cancel the transmission. The received value be accessible\n"
  "through the `value' attribute of the Request object once transmission\n"
  "has completed.\n"
  "\n"
  "As with the recv() routine, when receiving the content of a data type\n"
  "that has been sent separately from its skeleton, user code must provide\n"
  "a value for the `buffer' argument. This value should be the Content\n"
  "object returned from get_content().\n"; 

 const char* communicator_probe_docstring =
  "This operation waits until a message matching (source, tag)\n"
  "is available to be received. It then returns information about\n"
  "that message. If source is omitted, a message from any process\n"
  "will match. If tag is omitted, a message with any tag will match.\n"
  "The actual source and tag can be retrieved from the returned Status\n"
  "object. To check if a message is available without blocking, use\n"
  "iprobe.\n";

const char* communicator_iprobe_docstring =
  "This operation determines if a message matching (source, tag) is\n"
  "available to be received. If so, it returns information about that\n"
  "message; otherwise, it returns None. If source is omitted, a message\n"
  "from any process will match. If tag is omitted, a message with any\n"
  "tag will match. The actual source and tag can be retrieved from the\n"
  "returned Status object. To wait for a message to become available, use\n"
  "probe.\n";

const char* communicator_barrier_docstring = 
  "Wait for all processes within a communicator to reach the\n"
  "barrier.\n";

const char* communicator_split_docstring = 
  "Split the communicator into multiple, disjoint communicators\n"
  "each of which is based on a particular color. This is a\n"
  "collective operation that returns a new communicator that is a\n"
  "subgroup of this. This routine is functionally equivalent to\n"
  "MPI_Comm_split.\n\n"
  "color is the color of this process. All processes with the\n"
  "same color value will be placed into the same group.\n\n"
  "If provided, key is a key value that will be used to determine\n"
  "the ordering of processes with the same color in the resulting\n"
  "communicator. If omitted, the key will default to the rank of\n"
  "the process in the current communicator.\n\n"
  "Returns a new Communicator instance containing all of the \n"
  "processes in this communicator that have the same color.\n";

const char* communicator_abort_docstring = 
  "Makes a \"best attempt\" to abort all of the tasks in the group of\n"
  "this communicator. Depending on the underlying MPI\n"
  "implementation, this may either abort the entire program (and\n"
  "possibly return errcode to the environment) or only abort\n"
  "some processes, allowing the others to continue. Consult the\n"
  "documentation for your MPI implementation. This is equivalent to\n"
  "a call to MPI_Abort\n\n"
  "errcode is the error code to return from aborted processes.\n";

/***********************************************************
 * request documentation                                   *
 ***********************************************************/
const char* request_docstring = 
  "The Request class contains information about a non-blocking send\n"
  "or receive and will be returned from isend or irecv, respectively.\n"
  "When a Request object represents a completed irecv, the `value' \n"
  "attribute will contain the received value.\n";

const char* request_with_value_docstring = 
  "This class is an implementation detail. Any call that accepts a\n"
  "Request also accepts a RequestWithValue, and vice versa.\n";

const char* request_wait_docstring =
  "Wait until the communication associated with this request has\n"
  "completed. For a request that is associated with an isend(), returns\n"
  "a Status object describing the communication. For an irecv()\n"
  "operation, returns the received value by default. However, when\n"
  "return_status=True, a (value, status) pair is returned by a\n"
  "completed irecv request.\n";

const char* request_test_docstring =
  "Determine whether the communication associated with this request\n"
  "has completed successfully. If so, returns the Status object\n"
  "describing the communication (for an isend request) or a tuple\n"
  "containing the received value and a Status object (for an irecv\n"
  "request). Note that once test() returns a Status object, the\n"
  "request has completed and wait() should not be called.\n";

const char* request_cancel_docstring =
  "Cancel a pending communication, assuming it has not already been\n"
  "completed.\n";

const char* request_value_docstring =
  "If this request originated in an irecv(), this property makes the"
  "sent value accessible once the request completes.\n"
  "\n"
  "If no value is available, ValueError is raised.\n";

/***********************************************************
 * skeleton/content documentation                          *
 ***********************************************************/
const char* object_without_skeleton_docstring = 
  "The ObjectWithoutSkeleton class is an exception class used only\n"
  "when the skeleton() or get_content() function is called with an\n"
  "object that is not supported by the skeleton/content mechanism.\n"
  "All C++ types for which skeletons and content can be transmitted\n"
  "must be registered with the C++ routine:\n"
  "  boost::mpi::python::register_skeleton_and_content\n";

const char* object_without_skeleton_object_docstring = 
  "The object on which skeleton() or get_content() was invoked.\n";

const char* skeleton_proxy_docstring = 
  "The SkeletonProxy class is used to represent the skeleton of an\n"
  "object. The SkeletonProxy can be used as the value parameter of\n"
  "send() or isend() operations, but instead of transmitting the\n"
  "entire object, only its skeleton (\"shape\") will be sent, without\n"
  "the actual data. Its content can then be transmitted, separately.\n"
  "\n"
  "User code cannot generate SkeletonProxy instances directly. To\n"
  "refer to the skeleton of an object, use skeleton(object). Skeletons\n"
  "can also be received with the recv() and irecv() methods.\n"
  "\n"
  "Note that the skeleton/content mechanism can only be used with C++\n"
  "types that have been explicitly registered.\n";

const char* skeleton_proxy_object_docstring = 
  "The actual object whose skeleton is represented by this proxy object.\n";

const char* content_docstring = 
  "The content is a proxy class that represents the content of an object,\n"
  "which can be separately sent or received from its skeleton.\n"
  "\n"
  "User code cannot generate content instances directly. Call the\n"
  "get_content() routine to retrieve the content proxy for a particular\n"
  "object. The content instance can be used with any of the send() or\n"
  "recv() variants. Note that get_content() can only be used with C++\n"
  "data types that have been explicitly registered with the Python\n"
  "skeleton/content mechanism.\n";

const char* skeleton_docstring = 
  "The skeleton function retrieves the SkeletonProxy for its object\n"
  "parameter, allowing the transmission of the skeleton (or \"shape\")\n"
  "of the object separately from its data. The skeleton/content mechanism\n"
  "is useful when a large data structure remains structurally the same\n"
  "throughout a computation, but its content (i.e., the values in the\n"
  "structure) changes several times. Tranmission of the content part does\n"
  "not require any serialization or unnecessary buffer copies, so it is\n"
  "very efficient for large data structures.\n"
  "\n"
  "Only C++ types that have been explicitly registered with the Boost.MPI\n"
  "Python library can be used with the skeleton/content mechanism. Use:\b"
  "  boost::mpi::python::register_skeleton_and_content\n";

const char* get_content_docstring = 
  "The get_content function retrieves the content for its object parameter,\n"
  "allowing the transmission of the data in a data structure separately\n"
  "from its skeleton (or \"shape\"). The skeleton/content mechanism\n"
  "is useful when a large data structure remains structurally the same\n"
  "throughout a computation, but its content (i.e., the values in the\n"
  "structure) changes several times. Tranmission of the content part does\n"
  "not require any serialization or unnecessary buffer copies, so it is\n"
  "very efficient for large data structures.\n"
  "\n"
  "Only C++ types that have been explicitly registered with the Boost.MPI\n"
  "Python library can be used with the skeleton/content mechanism. Use:\b"
  "  boost::mpi::python::register_skeleton_and_content\n";

/***********************************************************
 * status documentation                                    *
 ***********************************************************/
const char* status_docstring = 
  "The Status class stores information about a given message, including\n"
  "its source, tag, and whether the message transmission was cancelled\n"
  "or resulted in an error.\n";

const char* status_source_docstring =
  "The source of the incoming message.\n";

const char* status_tag_docstring =
  "The tag of the incoming message.\n";

const char* status_error_docstring =
  "The error code associated with this transmission.\n";

const char* status_cancelled_docstring =
  "Whether this transmission was cancelled.\n";

/***********************************************************
 * timer documentation                                     *
 ***********************************************************/
const char* timer_docstring =
  "The Timer class is a simple wrapper around the MPI timing facilities.\n";

const char* timer_default_constructor_docstring =
  "Initializes the timer. After this call, elapsed == 0.\n";

const char* timer_restart_docstring =
  "Restart the timer, after which elapsed == 0.\n";

const char* timer_elapsed_docstring =
  "The time elapsed since initialization or the last restart(),\n"
  "whichever is more recent.\n";

const char* timer_elapsed_min_docstring =
  "Returns the minimum non-zero value that elapsed may return\n"
  "This is the resolution of the timer.\n";

const char* timer_elapsed_max_docstring =
  "Return an estimate of the maximum possible value of elapsed. Note\n"
  "that this routine may return too high a value on some systems.\n";

const char* timer_time_is_global_docstring = 
  "Determines whether the elapsed time values are global times or\n"
  "local processor times.\n";

} } } // end namespace boost::mpi::python