OpenMPI  0.1.1
rml.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2004-2010 The Trustees of Indiana University and Indiana
3  * University Research and Technology
4  * Corporation. All rights reserved.
5  * Copyright (c) 2004-2005 The University of Tennessee and The University
6  * of Tennessee Research Foundation. All rights
7  * reserved.
8  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
9  * University of Stuttgart. All rights reserved.
10  * Copyright (c) 2004-2005 The Regents of the University of California.
11  * All rights reserved.
12  * $COPYRIGHT$
13  *
14  * Additional copyrights may follow
15  *
16  * $HEADER$
17  */
18 
19 /**
20  * @file
21  *
22  * Runtime Messaging Layer (RML) Communication Interface
23  *
24  * The Runtime Messaging Layer (RML) provices basic point-to-point
25  * communication between ORTE processes. The system is available for
26  * most architectures, with some exceptions (the Cray XT3/XT4, for example).
27  */
28 
29 
30 #ifndef ORTE_MCA_RML_RML_H_
31 #define ORTE_MCA_RML_RML_H_
32 
33 #include "orte_config.h"
34 #include "orte/types.h"
35 
36 #ifdef HAVE_UNISTD_H
37 #include <unistd.h>
38 #endif
39 
40 #include "opal/mca/mca.h"
41 #include "opal/mca/crs/crs.h"
42 #include "opal/mca/crs/base/base.h"
43 
44 #include "orte/mca/rml/rml_types.h"
45 
46 BEGIN_C_DECLS
47 
48 
49 /* ******************************************************************** */
50 
51 
52 struct opal_buffer_t;
53 struct orte_process_name_t;
54 struct orte_rml_module_t;
55 
56 
57 /* ******************************************************************** */
58 
59 
60 /**
61  * RML component initialization
62  *
63  * Create an instance (module) of the given RML component. Upon
64  * returning, the module data structure should be fully populated and
65  * all functions should be usable. Non-blocking receive calls may be
66  * posted upon return from this function, although communication need
67  * not be enabled until enable_comm() call is called on the module.
68  *
69  * @return Exactly one module created by the call to the component's
70  * initialization function should be returned. The module structure
71  * should be fully populated, and the priority should be set to a
72  * reasonable value.
73  *
74  * @param[out] priority Selection priority for the given component
75  *
76  * @retval NULL An error occurred and initialization did not occur
77  * @retval non-NULL The module was successfully initialized
78  */
79 typedef struct orte_rml_module_t* (*orte_rml_component_init_fn_t)(int *priority);
80 
81 
82 /**
83  * RML component interface
84  *
85  * Component interface for the RML framework. A public instance of
86  * this structure, called mca_rml_[component name]_component, must
87  * exist in any RML component.
88  */
90  /* Base component description */
91  mca_base_component_t rml_version;
92  /* Base component data block */
94  /* Component intialization function */
96 };
97 /** Convienence typedef */
99 
100 
101 /* ******************************************************************** */
102 
103 
104 /**
105  * Funtion prototype for callback from non-blocking iovec send and receive
106  *
107  * Funtion prototype for callback from non-blocking iovec send and
108  * receive. The iovec pointer will be the same pointer passed to
109  * either send_nb and recv_nb. The peer memory location may not be
110  * the same, and is owned by the RML, not the calling process.
111  *
112  * @note The parameter in/out parameters are relative to the user's callback
113  * function.
114  *
115  * @param[in] status Completion status - equivalent to the return value
116  * from blocking send/recv
117  * @param[in] peer Opaque name of peer process
118  * @param[in] msg Array of iovecs describing user buffers and lengths
119  * @param[in] count Number of elements in iovec array
120  * @param[in] tag User defined tag for matching send/recv
121  * @param[in] cbdata User data passed to send_nb() or recv_nb()
122  */
123 typedef void (*orte_rml_callback_fn_t)(int status,
124  struct orte_process_name_t* peer,
125  struct iovec* msg,
126  int count,
127  orte_rml_tag_t tag,
128  void* cbdata);
129 
130 
131 /**
132  * Funtion prototype for callback from non-blocking buffer send and receive
133  *
134  * Funtion prototype for callback from non-blocking buffer send and
135  * receive. The buffer may not be the same pointer passed to either
136  * send_buffer_nb and recv_buffer_nb. The peer memory location may
137  * not be the same, and is owned by the RML, not the calling process.
138  *
139  * @note The parameter in/out parameters are relative to the user's callback
140  * function.
141  *
142  * @param[in] status Completion status - equivalent to the return value
143  * from blocking send/recv
144  * @param[in] peer Name of peer process
145  * @param[in] buffer Message buffer
146  * @param[in] tag User defined tag for matching send/recv
147  * @param[in] cbdata User data passed to send_nb() or recv_nb()
148  */
149 typedef void (*orte_rml_buffer_callback_fn_t)(int status,
150  struct orte_process_name_t* peer,
151  struct opal_buffer_t* buffer,
152  orte_rml_tag_t tag,
153  void* cbdata);
154 
155 
156 /**
157  * Function prototype for exception callback
158  *
159  * Function prototype for callback triggered when a communication error is detected.
160  *
161  * @note The parameter in/out parameters are relative to the user's callback
162  * function.
163  *
164  * @param[in] peer Name of peer process
165  * @param[in] exception Description of the error causing the exception
166  */
168  orte_rml_exception_t exception);
169 
170 
171 /* ******************************************************************** */
172 
173 
174 /**
175  * Enable communication using the RML module
176  *
177  * Enable communication using the RML module. Before this call, only
178  * the non-blocking receive and ping interfaces may be used. After
179  * this call returns, the module must be fully functional, capable of
180  * sending and receiving data. This function will be called after the
181  * process has been assigned a proces identifier.
182  *
183  * @note While the ping interface may be used between the call to the
184  * component's initialization function and this call, care must be
185  * taken when doing so. The remote process must have already called
186  * enable_comm() or the remote process will not reply to the ping.
187  * As the ping interface is generally used by MPI processes to find a
188  * daemon to contact, this should not be a major limitation.
189  *
190  * @retval ORTE_SUCCESS Communications successfully enabled
191  * @retval ORTE_ERROR An unspecified error occurred
192  */
193 typedef int (*orte_rml_module_enable_comm_fn_t)(void);
194 
195 
196 /**
197  * Finalize the RML module
198  *
199  * Finalize the RML module, ending all communication and cleaning up
200  * all resources associated with the module. After the finalize
201  * function is called, all interface functions (and the module
202  * structure itself) are not available for use.
203  *
204  * @note Whether or not the finalize function returns successfully,
205  * the module should not be used once this function is called.
206  *
207  * @retval ORTE_SUCCESS Success
208  * @retval ORTE_ERROR An unspecified error occurred
209  */
210 typedef int (*orte_rml_module_finalize_fn_t)(void);
211 
212 
213 /**
214  * Get a "contact info" string for the local process
215  *
216  * Get a "contact info" string that can be used by other processes to
217  * share the contact information for the given process. The "contact
218  * info" string includes the process identifier for the given process
219  * and uses only basic ascii characters. It should be quoted when
220  * evaluated by a shell, although no special escaping is necessary.
221  *
222  * @note The function may return a contact info string which contains
223  * multiple addresses.
224  *
225  * @retval non-NULL The contact information for this process
226  * @retval NULL An error occurred when trying to get the current
227  * process contact info
228  */
229 typedef char* (*orte_rml_module_get_contact_info_fn_t)(void);
230 
231 
232 /**
233  * Update the RML with a remote process's contact info
234  *
235  * Update the RML with a remote process's contact information, as
236  * returned from the get_contact_info() function on the remote
237  * process. Before a send can be initiated to a remote process,
238  * either this function must be called for that process or that
239  * process must have already established a connection to the local
240  * process.
241  *
242  * @note The user may not always explicitly call this function
243  * directly, but may instead cause it to be called through one of the
244  * contact setup functions available in
245  * orte/mca/rml/base/rml_contact.h.
246  *
247  * @param[in] contact_info The contact information string of a peer
248  *
249  * @retval ORTE_SUCCESS The contact information was successfully updated
250  * @retval ORTE_ERROR An unspecified error occurred during the update
251  */
252 typedef int (*orte_rml_module_set_contact_info_fn_t)(const char *contact_info);
253 
254 
255 /**
256  * "Ping" another process to determine availability
257  *
258  * Ping another process to determine if it is available. This
259  * function only verifies that the process is alive and will allow a
260  * connection to the local process. It does *not* qualify as
261  * establishing communication with the remote process, as required by
262  * the note for set_contact_info().
263  *
264  * @param[in] contact_info The contact info string for the remote process
265  * @param[in] tv Timeout after which the ping should be failed
266  *
267  * @retval ORTE_SUCESS The process is available and will allow connections
268  * from the local process
269  * @retval ORTE_ERROR An unspecified error occurred during the update
270  */
271 typedef int (*orte_rml_module_ping_fn_t)(const char* contact_info,
272  const struct timeval* tv);
273 
274 
275 /**
276  * Send an iovec blocking message
277  *
278  * Send an iovec blocking message to the specified peer. The call
279  * will return when the buffer may be modified. The return of a call
280  * to send() does not give any indication of remote completion.
281  *
282  * @param[in] peer Name of receiving process
283  * @param[in] msg iovec array describing send buffer
284  * @param[in] count Length of iovec array
285  * @param[in] tag User defined tag for matching send/recv
286  * @param[in] flags Currently unused.
287  *
288  * @retval >0 Number of bytes successfully sent (will be
289  * length of all iovecs)
290  * @retval ORTE_ERR_BAD_PARAM One of the parameters was invalid
291  * @retval ORTE_ERR_ADDRESSEE_UNKNOWN Contact information for the
292  * receiving process is not available
293  * @retval ORTE_ERROR An unspecified error occurred
294  */
295 typedef int (*orte_rml_module_send_fn_t)(struct orte_process_name_t* peer,
296  struct iovec *msg,
297  int count,
298  int tag,
299  int flags);
300 
301 
302 /**
303  * Send a buffer blocking message
304  *
305  * Send a buffer blocking message to the specified peer. The call
306  * will return when the buffer may be modified. The return of a call
307  * to send() does not give any indication of remote completion.
308  *
309  * @param[in] peer Name of receiving process
310  * @param[in] buffer send buffer
311  * @param[in] tag User defined tag for matching send/recv
312  * @param[in] flags Currently unused.
313  *
314  * @retval >0 Number of bytes successfully sent (will be
315  * length of buffer)
316  * @retval ORTE_ERR_BAD_PARAM One of the parameters was invalid
317  * @retval ORTE_ERR_ADDRESSEE_UNKNOWN Contact information for the
318  * receiving process is not available
319  * @retval ORTE_ERROR An unspecified error occurred
320  */
322  struct opal_buffer_t* buffer,
323  orte_rml_tag_t tag,
324  int flags);
325 
326 
327 /**
328  * Send an iovec non-blocking message
329  *
330  * Send an iovec blocking message to the specified peer. The call
331  * will return immediately, although the iovec may not be modified
332  * until the completion callback is triggered. The iovec *may* be
333  * passed to another call to send_nb before the completion callback is
334  * triggered. The callback being triggered does not give any
335  * indication of remote completion.
336  *
337  * @param[in] peer Name of receiving process
338  * @param[in] msg iovec array describing send buffer
339  * @param[in] count Length of iovec array
340  * @param[in] tag User defined tag for matching send/recv
341  * @param[in] flags Currently unused
342  * @param[in] cbfunc Callback function on message comlpetion
343  * @param[in] cbdata User data to provide during completion callback
344  *
345  * @retval ORTE_SUCCESS The message was successfully started
346  * @retval ORTE_ERR_BAD_PARAM One of the parameters was invalid
347  * @retval ORTE_ERR_ADDRESSEE_UNKNOWN Contact information for the
348  * receiving process is not available
349  * @retval ORTE_ERROR An unspecified error occurred
350  */
352  struct iovec* msg,
353  int count,
354  orte_rml_tag_t tag,
355  int flags,
356  orte_rml_callback_fn_t cbfunc,
357  void* cbdata);
358 
359 
360 /**
361  * Send an buffer non-blocking message
362  *
363  * Send an buffer blocking message to the specified peer. The call
364  * will return immediately, although the buffer may not be modified
365  * until the completion callback is triggered. The buffer *may* be
366  * passed to another call to send_nb before the completion callback is
367  * triggered. The callback being triggered does not give any
368  * indication of remote completion.
369  *
370  * @param[in] peer Name of receiving process
371  * @param[in] buffer Buffer array describing send buffer
372  * @param[in] tag User defined tag for matching send/recv
373  * @param[in] flags Currently unused
374  * @param[in] cbfunc Callback function on message comlpetion
375  * @param[in] cbdata User data to provide during completion callback
376  *
377  * @retval ORTE_SUCCESS The message was successfully started
378  * @retval ORTE_ERR_BAD_PARAM One of the parameters was invalid
379  * @retval ORTE_ERR_ADDRESSEE_UNKNOWN Contact information for the
380  * receiving process is not available
381  * @retval ORTE_ERROR An unspecified error occurred
382  */
384  struct opal_buffer_t* buffer,
385  orte_rml_tag_t tag,
386  int flags,
388  void* cbdata);
389 
390 /**
391  * Receive an iovec blocking message
392  *
393  * Receive a message into a user-provided iovec. The call will not
394  * return until the buffer has been received. The remote process does
395  * not need to be connected to the current process to post the
396  * receive, so it is possible to post a receive with no sending
397  * process (ie, it will never complete). The buffer must not be
398  * currently in use with any other RML communication function during a
399  * receive call.
400  *
401  * @param[in] peer Peer process or ORTE_NAME_WILDCARD for wildcard receive
402  * @param[out] msg iovec array of receive buffer space
403  * @param[in] count Number of iovec entries in the array
404  * @param[in] tag User defined tag for matching send/recv
405  * @param[in] flags May be ORTE_RML_PEEK to return up to the number
406  * of bytes provided in the iovec array without
407  * removing the message from the queue.
408  *
409  * @retval >0 Number of bytes successfully received (may be smaller
410  * than the posted buffer size
411  * @retval ORTE_ERR_BAD_PARAM One of the parameters was invalid
412  * @retval ORTE_ERROR An unspecified error occurred
413  */
414 typedef int (*orte_rml_module_recv_fn_t)(struct orte_process_name_t* peer,
415  struct iovec *msg,
416  int count,
417  orte_rml_tag_t tag,
418  int flags);
419 
420 
421 /**
422  * Receive a buffer blocking message
423  *
424  * Receive a message into a user-provided buffer. The call will not
425  * return until the buffer has been received. The remote process does
426  * not need to be connected to the current process to post the
427  * receive, so it is possible to post a receive with no sending
428  * process (ie, it will never complete). The buffer must not be
429  * currently in use with any other RML communication function during a
430  * receive call.
431  *
432  * @param[in] peer Peer process or ORTE_NAME_WILDCARD for wildcard receive
433  * @param[out] buffer A dss buffer to update with the received data
434  * @param[in] tag User defined tag for matching send/recv
435  * @param[in] flags Flags modifying receive behavior
436  *
437  * @retval >0 Number of bytes successfully received (may be smaller
438  * than the posted buffer size
439  * @retval ORTE_ERR_BAD_PARAM One of the parameters was invalid
440  * @retval ORTE_ERROR An unspecified error occurred
441  */
443  struct opal_buffer_t *buf,
444  orte_rml_tag_t tag,
445  int flags);
446 
447 
448 /**
449  * Receive an iovec non-blocking message
450  *
451  * Receive a message into a user-provided iovec. The call will not
452  * return until the buffer has been received. The remote process does
453  * not need to be connected to the current process to post the
454  * receive, so it is possible to post a receive with no sending
455  * process (ie, it will never complete). The buffer must not be
456  * currently in use with any other RML communication function during a
457  * receive call.
458  *
459  * @param[in] peer Peer process or ORTE_NAME_WILDCARD for wildcard receive
460  * @param[out] msg iovec array of receive buffer space
461  * @param[in] count Number of iovec entries in the array
462  * @param[in] tag User defined tag for matching send/recv
463  * @param[in] flags May be ORTE_RML_PEEK to return up to the number
464  * of bytes provided in the iovec array without
465  * removing the message from the queue.
466  * @param[in] cbfunc Callback function on message comlpetion
467  * @param[in] cbdata User data to provide during completion callback
468  *
469  * @retval ORTE_SUCCESS The message was successfully started
470  * @retval ORTE_ERR_BAD_PARAM One of the parameters was invalid
471  * @retval ORTE_ERR_ADDRESSEE_UNKNOWN Contact information for the
472  * receiving process is not available
473  * @retval ORTE_ERROR An unspecified error occurred
474  */
476  struct iovec* msg,
477  int count,
478  orte_rml_tag_t tag,
479  int flags,
480  orte_rml_callback_fn_t cbfunc,
481  void* cbdata);
482 
483 
484 /**
485  * Receive a buffer non-blocking message
486  *
487  * Receive a message into a user-provided buffer. The call will not
488  * return until the buffer has been received. The remote process does
489  * not need to be connected to the current process to post the
490  * receive, so it is possible to post a receive with no sending
491  * process (ie, it will never complete). The buffer must not be
492  * currently in use with any other RML communication function during a
493  * receive call.
494  *
495  * @param[in] peer Peer process or ORTE_NAME_WILDCARD for wildcard receive
496  * @param[in] tag User defined tag for matching send/recv
497  * @param[in] flags May be ORTE_RML_PEEK to return up to the number
498  * of bytes provided in the iovec array without
499  * removing the message from the queue.
500  * @param[in] cbfunc Callback function on message comlpetion
501  * @param[in] cbdata User data to provide during completion callback
502  *
503  * @retval ORTE_SUCCESS The message was successfully started
504  * @retval ORTE_ERR_BAD_PARAM One of the parameters was invalid
505  * @retval ORTE_ERR_ADDRESSEE_UNKNOWN Contact information for the
506  * receiving process is not available
507  * @retval ORTE_ERROR An unspecified error occurred
508  */
510  orte_rml_tag_t tag,
511  int flags,
513  void* cbdata);
514 
515 
516 /**
517  * Cancel a posted non-blocking receive
518  *
519  * Attempt to cancel a posten non-blocking receive.
520  *
521  * @param[in] peer Peer process or ORTE_NAME_WILDCARD, exactly as passed
522  * to the non-blocking receive call
523  * @param[in] tag Posted receive tag
524  *
525  * @retval ORTE_SUCCESS The receive was successfully cancelled
526  * @retval ORTE_ERR_BAD_PARAM One of the parameters was invalid
527  * @retval ORTE_ERR_NOT_FOUND A matching receive was not found
528  * @retval ORTE_ERROR An unspecified error occurred
529  */
531  orte_rml_tag_t tag);
532 
533 
534 /**
535  * Register or deregister an exception callback function
536  *
537  * Register or deregister a callback when an asynchronous
538  * communication exception occurs.
539  *
540  * @param[in] cbfunc User callback
541  *
542  * @retval ORTE_SUCCESS The operation completed successfully
543  * @retval ORTE_ERROR An unspecifed error occurred
544  */
546 
547 
548 /**
549  * Handle fault tolerance updates
550  *
551  * Handle fault tolerance updates
552  *
553  * @param[in] state Fault tolerance state update
554  *
555  * @retval ORTE_SUCCESS The operation completed successfully
556  * @retval ORTE_ERROR An unspecifed error occurred
557  */
558 typedef int (*orte_rml_module_ft_event_fn_t)(int state);
559 
560 /**
561  * Purge the RML/OOB of contact info and pending messages
562  * to/from a specified process. Used when a process aborts
563  * and is to be restarted
564  */
565 typedef int (*orte_rml_module_purge_fn_t)(struct orte_process_name_t *peer);
566 
567 /* ******************************************************************** */
568 
569 
570 /**
571  * RML module interface
572  *
573  * Module interface to the RML communication system. A global
574  * instance of this module, orte_rml, provices an interface into the
575  * active RML interface.
576  */
578  /** Enable communication once a process name has been assigned */
580  /** Shutdown the communication system and clean up resources */
582 
583  /** Get contact information for local process */
585  /** Set contact information for remote process */
587 
588  /** Ping process for connectivity check */
590 
591  /** Send blocking iovec message */
593  /** Send blocking buffer message */
595  /** Send non-blocking iovec message */
597  /** Send non-blocking buffer message */
599 
600  /** Receive blocking iovec message */
602  /** Receive blocking buffer message */
604  /** Receive non-blocking iovec message */
606  /** Receive non-blocking buffer message */
608  /** Cancel posted non-blocking receive */
610 
611  /** Add callback for communication exception */
613  /** Delete callback for communication exception */
615 
616  /** Fault tolerance handler */
618 
619  /** Purge information */
621 };
622 /** Convienence typedef */
624 
625 /** Interface for RML communication */
626 ORTE_DECLSPEC extern orte_rml_module_t orte_rml;
627 
628 
629 /* ******************************************************************** */
630 
631 
632 /** Macro for use in components that are of type rml */
633 #define ORTE_RML_BASE_VERSION_2_0_0 \
634  MCA_BASE_VERSION_2_0_0, \
635  "rml", 2, 0, 0
636 
637 
638 /* ******************************************************************** */
639 
640 
641 END_C_DECLS
642 
643 #endif
RML module interface.
Definition: rml.h:577
RML component interface.
Definition: rml.h:89
orte_rml_module_finalize_fn_t finalize
Shutdown the communication system and clean up resources.
Definition: rml.h:581
orte_rml_module_set_contact_info_fn_t set_contact_info
Set contact information for remote process.
Definition: rml.h:586
orte_rml_module_send_nb_fn_t send_nb
Send blocking buffer message.
Definition: rml.h:594
Common type for all MCA components.
Definition: mca.h:250
ORTE_DECLSPEC orte_rml_module_t orte_rml
Interface for RML communication.
Definition: rml_base_components.c:37
orte_rml_module_recv_buffer_fn_t recv_buffer
Receive non-blocking iovec message.
Definition: rml.h:605
int(* orte_rml_module_ft_event_fn_t)(int state)
Handle fault tolerance updates.
Definition: rml.h:558
Definition: types.h:146
struct orte_rml_module_t *(* orte_rml_component_init_fn_t)(int *priority)
RML component initialization.
Definition: rml.h:79
int(* orte_rml_module_set_contact_info_fn_t)(const char *contact_info)
Update the RML with a remote process's contact info.
Definition: rml.h:252
int(* orte_rml_module_ping_fn_t)(const char *contact_info, const struct timeval *tv)
"Ping" another process to determine availability
Definition: rml.h:271
orte_rml_module_exception_fn_t add_exception_handler
Add callback for communication exception.
Definition: rml.h:612
int(* orte_rml_module_enable_comm_fn_t)(void)
Enable communication using the RML module.
Definition: rml.h:193
Top-level interface for all MCA components.
int(* orte_rml_module_send_nb_fn_t)(struct orte_process_name_t *peer, struct iovec *msg, int count, orte_rml_tag_t tag, int flags, orte_rml_callback_fn_t cbfunc, void *cbdata)
Send an iovec non-blocking message.
Definition: rml.h:351
void(* orte_rml_callback_fn_t)(int status, struct orte_process_name_t *peer, struct iovec *msg, int count, orte_rml_tag_t tag, void *cbdata)
Funtion prototype for callback from non-blocking iovec send and receive.
Definition: rml.h:123
orte_rml_module_ft_event_fn_t ft_event
Fault tolerance handler.
Definition: rml.h:617
int(* orte_rml_module_send_buffer_fn_t)(struct orte_process_name_t *peer, struct opal_buffer_t *buffer, orte_rml_tag_t tag, int flags)
Send a buffer blocking message.
Definition: rml.h:321
int(* orte_rml_module_send_fn_t)(struct orte_process_name_t *peer, struct iovec *msg, int count, int tag, int flags)
Send an iovec blocking message.
Definition: rml.h:295
int(* orte_rml_module_recv_buffer_nb_fn_t)(struct orte_process_name_t *peer, orte_rml_tag_t tag, int flags, orte_rml_buffer_callback_fn_t cbfunc, void *cbdata)
Receive a buffer non-blocking message.
Definition: rml.h:509
int(* orte_rml_module_purge_fn_t)(struct orte_process_name_t *peer)
Purge the RML/OOB of contact info and pending messages to/from a specified process.
Definition: rml.h:565
orte_rml_module_purge_fn_t purge
Purge information.
Definition: rml.h:620
int(* orte_rml_module_exception_fn_t)(orte_rml_exception_callback_t cbfunc)
Register or deregister an exception callback function.
Definition: rml.h:545
Definition: ompi_uio.h:29
orte_rml_module_recv_fn_t recv
Receive blocking iovec message.
Definition: rml.h:601
orte_rml_module_exception_fn_t del_exception_handler
Delete callback for communication exception.
Definition: rml.h:614
Meta data for MCA v2.0.0 components.
Definition: mca.h:309
orte_rml_module_recv_buffer_nb_fn_t recv_buffer_nb
Receive non-blocking buffer message.
Definition: rml.h:607
uint32_t orte_rml_tag_t
Message matching tag.
Definition: rml_types.h:220
int(* orte_rml_module_recv_nb_fn_t)(struct orte_process_name_t *peer, struct iovec *msg, int count, orte_rml_tag_t tag, int flags, orte_rml_callback_fn_t cbfunc, void *cbdata)
Receive an iovec non-blocking message.
Definition: rml.h:475
int(* orte_rml_module_finalize_fn_t)(void)
Finalize the RML module.
Definition: rml.h:210
orte_rml_module_recv_nb_fn_t recv_nb
Receive blocking buffer message.
Definition: rml.h:603
orte_rml_module_send_fn_t send
Send blocking iovec message.
Definition: rml.h:592
int(* orte_rml_module_recv_fn_t)(struct orte_process_name_t *peer, struct iovec *msg, int count, orte_rml_tag_t tag, int flags)
Receive an iovec blocking message.
Definition: rml.h:414
int(* orte_rml_module_send_buffer_nb_fn_t)(struct orte_process_name_t *peer, struct opal_buffer_t *buffer, orte_rml_tag_t tag, int flags, orte_rml_buffer_callback_fn_t cbfunc, void *cbdata)
Send an buffer non-blocking message.
Definition: rml.h:383
void(* orte_rml_buffer_callback_fn_t)(int status, struct orte_process_name_t *peer, struct opal_buffer_t *buffer, orte_rml_tag_t tag, void *cbdata)
Funtion prototype for callback from non-blocking buffer send and receive.
Definition: rml.h:149
Structure for holding a buffer to be used with the RML or OOB subsystems.
Definition: dss_types.h:159
int(* orte_rml_module_recv_buffer_fn_t)(struct orte_process_name_t *peer, struct opal_buffer_t *buf, orte_rml_tag_t tag, int flags)
Receive a buffer blocking message.
Definition: rml.h:442
orte_rml_module_ping_fn_t ping
Ping process for connectivity check.
Definition: rml.h:589
orte_rml_module_get_contact_info_fn_t get_contact_info
Get contact information for local process.
Definition: rml.h:584
Checkpoint and Restart Service (CRS) Interface.
orte_rml_module_send_buffer_fn_t send_buffer
Send non-blocking iovec message.
Definition: rml.h:596
void(* orte_rml_exception_callback_t)(const orte_process_name_t *peer, orte_rml_exception_t exception)
Function prototype for exception callback.
Definition: rml.h:167
orte_rml_module_send_buffer_nb_fn_t send_buffer_nb
Send non-blocking buffer message.
Definition: rml.h:598
orte_rml_module_recv_cancel_fn_t recv_cancel
Cancel posted non-blocking receive.
Definition: rml.h:609
orte_rml_module_enable_comm_fn_t enable_comm
Enable communication once a process name has been assigned.
Definition: rml.h:579
Contains the typedefs for the use of the rml.
int(* orte_rml_module_recv_cancel_fn_t)(orte_process_name_t *peer, orte_rml_tag_t tag)
Cancel a posted non-blocking receive.
Definition: rml.h:530
char *(* orte_rml_module_get_contact_info_fn_t)(void)
Get a "contact info" string for the local process.
Definition: rml.h:229