OpenMPI  0.1.1
msgq_interface.h
1 /*
2  * Copyright (c) 2007 Cisco Systems, Inc. All rights reserved.
3  * Copyright (c) 2004-2007 The University of Tennessee and The University
4  * of Tennessee Research Foundation. All rights
5  * reserved.
6  * $COPYRIGHT$
7  *
8  * Additional copyrights may follow
9  *
10  * $HEADER$
11  */
12 
13 /* $Header: /home/tv/src/mpi/src/mpi_interface.h,v 1.13 2003/03/12 14:03:42 jcownie Exp $ */
14 /* $Locker: $ */
15 
16 /**********************************************************************
17  * Copyright (C) 2000-2004 by Etnus, LLC
18  *
19  * Permission is hereby granted to use, reproduce, prepare derivative
20  * works, and to redistribute to others.
21  *
22  * DISCLAIMER
23  *
24  * Neither Etnus, nor any of their employees, makes any warranty
25  * express or implied, or assumes any legal liability or
26  * responsibility for the accuracy, completeness, or usefulness of any
27  * information, apparatus, product, or process disclosed, or
28  * represents that its use would not infringe privately owned rights.
29  *
30  * This code was written by
31  * James Cownie: Etnus, LLC. <jcownie@etnus.com>
32  **********************************************************************/
33 
34 /**********************************************************************
35  * Copyright (C) 1999 by Etnus, Inc.
36  * Copyright (C) 1997-1998 Dolphin Interconnect Solutions Inc.
37  *
38  * Permission is hereby granted to use, reproduce, prepare derivative
39  * works, and to redistribute to others.
40  *
41  * DISCLAIMER
42  *
43  * Neither Dolphin Interconnect Solutions, nor any of their employees,
44  * makes any warranty express or implied, or assumes any legal
45  * liability or responsibility for the accuracy, completeness, or
46  * usefulness of any information, apparatus, product, or process
47  * disclosed, or represents that its use would not infringe privately
48  * owned rights.
49  *
50  * This code was written by
51  * James Cownie: Dolphin Interconnect Solutions. <jcownie@dolphinics.com>
52  * And now we're Etnus :-
53  * James Cownie: Etnus LLC <jcownie@etnus.com>
54  **********************************************************************/
55 
56 
57 /* Update log
58  *
59  * Aug 5 2002 CLG: Tiny fix to 64 bit taddr_t definition on sun.
60  * Oct 6 2000 JHC: Add all of the MPI-2 relevant types and functions.
61  * This does need a compatibility number change to
62  * ensure new libraries can't get loaded into old debuggers.
63  * New debuggers can continue to use old libraries, though.
64  * New functions under control of FOR_MPI2
65  * Oct 2 2000 JHC: Add the mqs_get_comm_group function to support
66  * partial acquisition.
67  * Mar 21 2000 JHC: Lower the version compatibility again, but add
68  * a new DLL provided call to tell us the width it
69  * believes mqs_taddr_t is. If the DLL doesn't provide this
70  * call, we assume it's old and use the appropriate old width.
71  * This lets us gracefully handle widening the interface on AIX.
72  * Mar 17 2000 JHC: Add FORCE_32BIT_MPI conditional compilation flag.
73  * Mar 3 2000 JHC: Widen the tword_t and taddr_t on AIX, now that IBM
74  * has 64 bit machines. Increment the version compatibility
75  * number on AIX (only) since this is an incompatible change in
76  * the interface.
77  * Oct 1 1998 JHC: Change MQS_INVALID_PROCESS to -1, TV would never generate
78  * the old value anyway.
79  * May 26 1998 JHC: Change interface compatibility, add extra strings in the
80  * mqs_pending_operation.
81  * Apr 23 1998 JHC: Make mqs_tword_t and mqs_taddr_t into 64 bit entities on
82  * SGI. Expand the comment above their definition.
83  * Mar 9 1998 JHC: Added mqs_sizeof_ft. Of course we always needed this !
84  * Nov 6 1997 JHC: Worked over somewhat to keep John happy :-)
85  * Oct 27 1997 James Cownie <jcownie@dolphinics.com>: Created.
86  */
87 
88 /***********************************************************************
89  * This header file defines the interface between a debugger and a
90  * dynamically loaded library use to implement access to MPI message
91  * queues.
92  *
93  * The interface is specified at the C level, to avoid C++ compiler issues.
94  *
95  * The interface allows code in the DLL to
96  * 1) find named types from the debugger's type system and look up fields in them
97  * 2) find the address of named external variables
98  * 3) access objects at absolute addresses in the target process.
99  * 4) convert objects from target format to host format.
100  *
101  * A number of different objects are passed backwards and forwards
102  * between the debugger and the DLL :-
103  *
104  * executable images
105  * processes
106  * communicators
107  *
108  * Many of these are opaque to the DLL, in such cases they will be
109  * defined in the interface as pointers to opaque structures, since
110  * this provides type checking while maintaining information hiding.
111  *
112  * All named entities in here start with the prefix "mqs_" (for
113  * Message Queue Support), all the debugger callbacks are made via
114  * callback tables, so the real (linkage) names of the functions are
115  * not visible to the DLL.
116  */
117 
118 #ifndef _MPI_INTERFACE_INCLUDED
119 #define _MPI_INTERFACE_INCLUDED
120 
121 #include "ompi_config.h"
122 #include <stdio.h> /* For FILENAME_MAX */
123 
124 /* No MPI2 support yet */
125 #define FOR_MPI2 0
126 
127 BEGIN_C_DECLS
128 
129 /***********************************************************************
130  * Version of the interface this header represents
131  */
132 enum
133 {
134 #if (FOR_MPI2)
135  MQS_INTERFACE_COMPATIBILITY = 3 /* Has MPI-2 functions */
136 #else
137  MQS_INTERFACE_COMPATIBILITY = 2
138 #endif
139 };
140 
141 /***********************************************************************
142  * type definitions.
143  */
144 
145 /* Opaque types are used here to provide a degree of type checking
146  * through the prototypes of the interface functions.
147  *
148  * Only pointers to these types are ever passed across the interface.
149  * Internally to the debugger, or the DLL you should immediately cast
150  * these pointers to pointers to the concrete types that you actually
151  * want to use.
152  *
153  * (An alternative would be to use void * for all of these arguments,
154  * but that would remove a useful degree of type checking, assuming
155  * that you are thinking while typing the casts :-)
156  */
157 
158 /* Types which will be (cast to) concrete types in the DLL */
159 typedef struct _mqs_image_info mqs_image_info;
160 typedef struct _mqs_process_info mqs_process_info;
161 #if (FOR_MPI2)
162 typedef struct _mqs_job_info mqs_job_info;
163 #endif
164 
165 /* Types which will be (cast to) concrete types in the debugger */
166 typedef struct mqs_image_ mqs_image;
167 #if (FOR_MPI2)
168 typedef struct mqs_job_ mqs_job;
169 #endif
170 typedef struct mqs_process_ mqs_process;
171 typedef struct mqs_type_ mqs_type;
172 
173 /* *** BEWARE ***
174  * On machines with two pointer lengths (such as SGI -n32, -64 compilations,
175  * and AIX and Solaris soon), it is quite likely that TotalView and the DLL
176  * will have been compiled with the 32 bit model, *but* will need to debug
177  * code compiled with the 64 bit one. The mqs_taddr_t and mqs_tword_t need
178  * to be a type which even when compiled with the 32 bit model compiler can
179  * hold the longer (64 bit) pointer.
180  *
181  * You may need to add your host to this #if, if you have a machine with
182  * two compilation models.
183  * *** END BEWARE ***
184  *
185  * It would be better not to have this target dependence in the
186  * interface, but it is unreasonable to require a 64 bit interface on
187  * 32 bit machines, and we need the 64 bit interface in some places.
188  */
189 
190 #if !defined (FORCE_32BIT_MPI) && (defined (__sgi) || defined (__hpux) || defined (_AIX) || defined(__sun))
191 typedef unsigned long long mqs_taddr_t; /* Something long enough for a target address */
192 typedef long long mqs_tword_t; /* Something long enough for a word */
193 #else
194 typedef unsigned long mqs_taddr_t; /* Something long enough for a target address */
195 typedef long mqs_tword_t; /* Something long enough for a word */
196 #endif
197 
198 /***********************************************************************
199  * Defined structures which form part of the interface.
200  */
201 
202 /* A structure for (target) architectural information */
203 typedef struct
204 {
205  int short_size; /* sizeof (short) */
206  int int_size; /* sizeof (int) */
207  int long_size; /* sizeof (long) */
208  int long_long_size; /* sizeof (long long) */
209  int pointer_size; /* sizeof (void *) */
210  int bool_size; /* sizeof(bool) */
211  int size_t_size; /* sizeof(size_t) */
213 
214 /* Result codes.
215  * mqs_ok is returned for success.
216  * Anything else implies a failure of some sort.
217  *
218  * Most of the functions actually return one of these, however to avoid
219  * any potential issues with different compilers implementing enums as
220  * different sized objects, we actually use int as the result type.
221  *
222  * Note that both the DLL and the debugger will use values starting at
223  * mqs_first_user_code, since you always know which side you were calling,
224  * this shouldn't be a problem.
225  *
226  * See below for functions to convert codes to strings.
227  */
228 enum {
229  mqs_ok = 0,
230  mqs_no_information,
231  mqs_end_of_list,
232  mqs_first_user_code = 100 /* Allow for more pre-defines */
233 };
234 
235 #if (FOR_MPI2)
236 /* For handling attachment to new processes in MPI-2 we need to know
237  * where they are.
238  */
239 typedef struct mqs_process_location {
240  long pid;
241  char image_name [FILENAME_MAX];
242  char host_name [64];
243 } mqs_process_location;
244 #endif
245 
246 /* Languages */
247 typedef enum {
248  mqs_lang_c = 'c',
249  mqs_lang_cplus = 'C',
250  mqs_lang_f77 = 'f',
251  mqs_lang_f90 = 'F'
252 } mqs_lang_code;
253 
254 /* Which queue are we interested in ? */
255 typedef enum
256 {
257  mqs_pending_sends,
258  mqs_pending_receives,
259  mqs_unexpected_messages
260 } mqs_op_class;
261 
262 /* A value to represent an invalid process index. */
263 enum
264 {
265  MQS_INVALID_PROCESS = -1
266 };
267 
268 enum mqs_status
269 {
270  mqs_st_pending, mqs_st_matched, mqs_st_complete
271 };
272 
273 /* Additional error codes and error string conversion. */
274 enum {
275  err_silent_failure = mqs_first_user_code,
276 
277  err_no_current_communicator,
278  err_bad_request,
279  err_no_store,
280 
281  err_failed_qhdr,
282  err_unexpected,
283  err_posted,
284 
285  err_failed_queue,
286  err_first,
287 
288  err_context_id,
289  err_tag,
290  err_tagmask,
291  err_lsrc,
292  err_srcmask,
293  err_next,
294  err_ptr,
295 
296  err_missing_type,
297  err_missing_symbol,
298 
299  err_db_shandle,
300  err_db_comm,
301  err_db_target,
302  err_db_tag,
303  err_db_data,
304  err_db_byte_length,
305  err_db_next,
306 
307  err_failed_rhandle,
308  err_is_complete,
309  err_buf,
310  err_len,
311  err_s,
312 
313  err_failed_status,
314  err_count,
315  err_MPI_SOURCE,
316  err_MPI_TAG,
317 
318  err_failed_commlist,
319  err_sequence_number,
320  err_comm_first,
321 
322  err_failed_communicator,
323  err_lrank_to_grank,
324  err_send_context,
325  err_recv_context,
326  err_comm_next,
327  err_comm_name,
328 
329  err_all_communicators,
330  err_mpid_sends,
331  err_mpid_recvs,
332  err_group_corrupt
333 };
334 
335 /* A structure to represent a communicator */
336 typedef struct
337 {
338  mqs_taddr_t unique_id; /* A unique tag for the communicator */
339  mqs_tword_t local_rank; /* The rank of this process Comm_rank */
340  mqs_tword_t size; /* Comm_size */
341  char name[64]; /* the name if it has one */
343 
344 /*
345  * We currently assume that all messages are flattened into contiguous buffers.
346  * This is potentially incorrect, but let's leave that complication for a while.
347  */
348 
349 typedef struct
350 {
351  /* Fields for all messages */
352  int status; /* Status of the message (really enum mqs_status) */
353  mqs_tword_t desired_local_rank; /* Rank of target/source -1 for ANY */
354  mqs_tword_t desired_global_rank; /* As above but in COMM_WORLD */
355  int tag_wild; /* Flag for wildcard receive */
356  mqs_tword_t desired_tag; /* Only if !tag_wild */
357  mqs_tword_t desired_length; /* Length of the message buffer */
358  int system_buffer; /* Is it a system or user buffer ? */
359  mqs_taddr_t buffer; /* Where data is */
360 
361  /* Fields valid if status >= matched or it's a send */
362  mqs_tword_t actual_local_rank; /* Actual local rank */
363  mqs_tword_t actual_global_rank; /* As above but in COMM_WORLD */
364  mqs_tword_t actual_tag;
365  mqs_tword_t actual_length;
366 
367  /* Additional strings which can be filled in if the DLL has more
368  * info. (Uninterpreted by the debugger, simply displayed to the
369  * user).
370  *
371  * Can be used to give the name of the function causing this request,
372  * for instance.
373  *
374  * Up to five lines each of 64 characters.
375  */
376  char extra_text[5][64];
378 
379 /***********************************************************************
380  * Callbacks from the DLL into the debugger.
381  ***********************************************************************
382  * These are all made via a table of function pointers.
383  */
384 
385 /* Hang information on the image */
386 typedef void (*mqs_put_image_info_ft) (mqs_image *, mqs_image_info *);
387 /* Get it back */
388 typedef mqs_image_info * (*mqs_get_image_info_ft) (mqs_image *);
389 
390 #if (FOR_MPI2)
391 /* Given a job and an index return the process object */
392 typedef mqs_process * (*mqs_get_process_ft) (mqs_job *, int);
393 
394 /* Hang information on the job */
395 typedef void (*mqs_put_job_info_ft) (mqs_job *, mqs_job_info *);
396 /* Get it back */
397 typedef mqs_job_info * (*mqs_get_job_info_ft) (mqs_job *);
398 #endif
399 
400 /* Given a process return the image it is an instance of */
401 typedef mqs_image * (*mqs_get_image_ft) (mqs_process *);
402 
403 /* Given a process return its rank in comm_world */
404 typedef int (*mqs_get_global_rank_ft) (mqs_process *);
405 
406 /* Given an image look up the specified function */
407 typedef int (*mqs_find_function_ft) (mqs_image *, char *, mqs_lang_code, mqs_taddr_t * );
408 
409 /* Given an image look up the specified symbol */
410 typedef int (*mqs_find_symbol_ft) (mqs_image *, char *, mqs_taddr_t * );
411 
412 /* Hang information on the process */
413 typedef void (*mqs_put_process_info_ft) (mqs_process *, mqs_process_info *);
414 /* Get it back */
415 typedef mqs_process_info * (*mqs_get_process_info_ft) (mqs_process *);
416 
417 #if (FOR_MPI2)
418 /* Given a process, return the job it belongs to */
419 typedef mqs_job * (*mqs_get_process_job_ft) (mqs_process *);
420 /* Given a process, return its identity (index in the job's universe of processes) */
421 typedef int (*mqs_get_process_identity_ft) (mqs_job *);
422 #endif
423 
424 /* Allocate store */
425 typedef void * (*mqs_malloc_ft) (size_t);
426 /* Free it again */
427 typedef void (*mqs_free_ft) (void *);
428 
429 /***********************************************************************
430  * Type access functions
431  */
432 
433 /* Given an executable image look up a named type in it.
434  * Returns a type handle, or the null pointer if the type could not be
435  * found. Since the debugger may load debug information lazily, the
436  * MPI run time library should ensure that the type definitions
437  * required occur in a file whose debug information will already have
438  * been loaded, for instance by placing them in the same file as the
439  * startup breakpoint function.
440  */
441 typedef mqs_type * (*mqs_find_type_ft)(mqs_image *, char *, mqs_lang_code);
442 
443 /* Given the handle for a type (assumed to be a structure) return the
444  * byte offset of the named field. If the field cannot be found
445  * the result will be -1.
446  */
447 typedef int (*mqs_field_offset_ft) (mqs_type *, char *);
448 
449 /* Given the handle for a type return the size of the type in bytes.
450  * (Just like sizeof ())
451  */
452 typedef int (*mqs_sizeof_ft) (mqs_type *);
453 
454 /* Fill in the sizes of target types for this process */
455 typedef void (*mqs_get_type_sizes_ft) (mqs_process *, mqs_target_type_sizes *);
456 
457 /***********************************************************************
458  * Target store access functions
459  */
460 
461 /* Fetch data from the process into a buffer into a specified buffer.
462  * N.B.
463  * The data is the same as that in the target process when accessed
464  * as a byte array. You *must* use mqs_target_to_host to do any
465  * necessary byte flipping if you want to look at it at larger
466  * granularity.
467  */
468 typedef int (*mqs_fetch_data_ft) (mqs_process *, mqs_taddr_t, int, void *);
469 
470 /* Convert data into host format */
471 typedef void (*mqs_target_to_host_ft) (mqs_process *, const void *, void *, int);
472 
473 /***********************************************************************
474  * Miscellaneous functions.
475  */
476 /* Print a message (intended for debugging use *ONLY*). */
477 typedef void (*mqs_dprints_ft) (const char *);
478 /* Convert an error code from the debugger into an error message */
479 typedef char * (*mqs_errorstring_ft) (int);
480 
481 /***********************************************************************
482  * Call back tables
483  */
484 typedef struct mqs_basic_callbacks
485 {
486  mqs_malloc_ft mqs_malloc_fp;
487  mqs_free_ft mqs_free_fp;
488  mqs_dprints_ft mqs_dprints_fp;
489  mqs_errorstring_ft mqs_errorstring_fp;
490  mqs_put_image_info_ft mqs_put_image_info_fp;
491  mqs_get_image_info_ft mqs_get_image_info_fp;
492  mqs_put_process_info_ft mqs_put_process_info_fp;
493  mqs_get_process_info_ft mqs_get_process_info_fp;
494 #if (FOR_MPI2)
495  mqs_put_job_info_ft mqs_put_job_info_fp;
496  mqs_get_job_info_ft mqs_get_job_info_fp;
497 #endif
499 
500 #if (FOR_MPI2)
501 typedef struct mqs_job_callbacks {
502  mqs_get_process_ft mqs_get_process_fp;
503 } mqs_job_callbacks;
504 #endif
505 
506 typedef struct mqs_image_callbacks
507 {
508  mqs_get_type_sizes_ft mqs_get_type_sizes_fp;
509  mqs_find_function_ft mqs_find_function_fp;
510  mqs_find_symbol_ft mqs_find_symbol_fp;
511  mqs_find_type_ft mqs_find_type_fp;
512  mqs_field_offset_ft mqs_field_offset_fp;
513  mqs_sizeof_ft mqs_sizeof_fp;
515 
516 typedef struct mqs_process_callbacks
517 {
518  mqs_get_global_rank_ft mqs_get_global_rank_fp;
519  mqs_get_image_ft mqs_get_image_fp;
520  mqs_fetch_data_ft mqs_fetch_data_fp;
521  mqs_target_to_host_ft mqs_target_to_host_fp;
522 #if (FOR_MPI2)
523  mqs_get_process_job_ft mqs_get_process_job_fp;
524  mqs_get_process_identity_ft mqs_get_process_identity_fp;
525 #endif
527 
528 /***********************************************************************
529  * Calls from the debugger into the DLL.
530  ***********************************************************************/
531 
532 /* Provide the library with the pointers to the the debugger functions
533  * it needs The DLL need only save the pointer, the debugger promises
534  * to maintain the table of functions valid for as long as
535  * needed. (The table remains the property of the debugger, and should
536  * not be messed with, or deallocated by the DLL). This applies to
537  * all of the callback tables.
538  */
539 OMPI_DECLSPEC extern void mqs_setup_basic_callbacks (const mqs_basic_callbacks *);
540 
541 /* Version handling */
542 OMPI_DECLSPEC extern char *mqs_version_string (void);
543 OMPI_DECLSPEC extern int mqs_version_compatibility(void);
544 /* This gives the width which has been compiled into the DLL, it is
545  * _not_ the width of a specific process, which could be smaller than
546  * this.
547  */
548 OMPI_DECLSPEC extern int mqs_dll_taddr_width(void);
549 
550 /* Provide a text string for an error value */
551 OMPI_DECLSPEC extern char * mqs_dll_error_string (int);
552 
553 /***********************************************************************
554  * Calls related to an executable image.
555  */
556 
557 /* Setup debug information for a specific image, this must save
558  * the callbacks (probably in the mqs_image_info), and use those
559  * functions for accessing this image.
560  *
561  * The DLL should use the mqs_put_image_info and mqs_get_image_info functions
562  * to associate whatever information it wants to keep with the image.
563  * (For instance all of the type offsets it needs could be kept here).
564  * the debugger will call mqs_destroy_image_info when it no longer wants to
565  * keep information about the given executable.
566  *
567  * This will be called once for each executable image in the parallel
568  * program.
569  */
570 OMPI_DECLSPEC extern int mqs_setup_image (mqs_image *, const mqs_image_callbacks *);
571 
572 /* Does this image have the necessary symbols to allow access to the message
573  * queues ?
574  *
575  * This function will be called once for each image, and the information
576  * cached inside the debugger.
577  *
578  * Returns an error enumeration to show whether the image has queues
579  * or not, and an error string to be used in a pop-up complaint to the
580  * user, as if in printf (error_string, name_of_image);
581  *
582  * The pop-up display is independent of the result. (So you can silently
583  * disable things, or loudly enable them).
584  */
585 
586 OMPI_DECLSPEC extern int mqs_image_has_queues (mqs_image *, char **);
587 
588 /* This will be called by the debugger to let you tidy up whatever is
589  * required when the mqs_image_info is no longer needed.
590  */
591 OMPI_DECLSPEC extern void mqs_destroy_image_info (mqs_image_info *);
592 
593 #if (FOR_MPI2)
594 /***********************************************************************
595  * Calls related to a specific job, which owns a universe of processes.
596  */
597 extern int mqs_setup_job (mqs_job *, const mqs_job_callbacks *);
598 extern int mqs_destroy_job_info (mqs_job_info *);
599 #endif
600 
601 /***********************************************************************
602  * Calls related to a specific process. These will only be called if the
603  * image which this is an instance of passes the has_message_queues tests.
604  *
605  * If you can't tell whether the process will have valid message queues
606  * just by looking at the image, then you should return mqs_ok from
607  * mqs_image_has_queues and let mqs_process_has_queues handle it.
608  */
609 
610 /* Set up whatever process specific information we need.
611  * For instance addresses of global variables should be handled here,
612  * rather than in the image information if anything is a dynamic library
613  * which could end up mapped differently in different processes.
614  */
615 OMPI_DECLSPEC extern int mqs_setup_process (mqs_process *, const mqs_process_callbacks *);
616 OMPI_DECLSPEC extern void mqs_destroy_process_info (mqs_process_info *);
617 
618 /* Like the mqs_has_message_queues function, but will only be called
619  * if the image claims to have message queues. This lets you actually
620  * delve inside the process to look at variables before deciding if
621  * the process really can support message queue extraction.
622  */
623 OMPI_DECLSPEC extern int mqs_process_has_queues (mqs_process *, char **);
624 
625 /***********************************************************************
626  * The functions which actually extract the information we need !
627  *
628  * The model here is that the debugger calls down to the library to initialise
629  * an iteration over a specific class of things, and then keeps calling
630  * the "next" function until it returns mqs_false.
631  *
632  * For communicators we separate stepping from extracting information,
633  * because we want to use the state of the communicator iterator to qualify
634  * the selections of the operation iterator.
635  *
636  * Whenever mqs_true is returned the description has been updated,
637  * mqs_false means there is no more information to return, and
638  * therefore the description contains no useful information.
639  *
640  * We will only have one of each type of iteration running at once, so
641  * the library should save the iteration state in the
642  * mqs_process_info.
643  */
644 
645 
646 /* Check that the DLL's model of the communicators in the process is
647  * up to date, ideally by checking the sequence number.
648  */
649 OMPI_DECLSPEC extern int mqs_update_communicator_list (mqs_process *);
650 
651 /* Prepare to iterate over all of the communicators in the process. */
652 OMPI_DECLSPEC extern int mqs_setup_communicator_iterator (mqs_process *);
653 
654 /* Extract information about the current communicator */
655 OMPI_DECLSPEC extern int mqs_get_communicator (mqs_process *, mqs_communicator *);
656 
657 /* Extract the group from the current communicator.
658  * The debugger already knows comm_size, so can allocate a
659  * suitably sized array for the result. The result is the
660  * rank in COMM_WORLD of the index'th element in the current
661  * communicator.
662  */
663 OMPI_DECLSPEC extern int mqs_get_comm_group (mqs_process *, int *);
664 
665 /* Move on to the next communicator in this process. */
666 OMPI_DECLSPEC extern int mqs_next_communicator (mqs_process *);
667 
668 /* Prepare to iterate over the pending operations in the currently
669  * active communicator in this process.
670  *
671  * The int is *really* mqs_op_class
672  */
673 OMPI_DECLSPEC extern int mqs_setup_operation_iterator (mqs_process *, int);
674 
675 /* Return information about the next appropriate pending operation in
676  * the current communicator, mqs_false when we've seen them all.
677  */
678 OMPI_DECLSPEC extern int mqs_next_operation (mqs_process *, mqs_pending_operation *);
679 
680 #if (FOR_MPI2)
681 /* Information about newly created (or connected to) processes.
682  * This is how we pick up processes created with MPI_Spawn (and friends),
683  * or attached to with MPI_Comm_connect or MPI_Comm_join.
684  */
685 extern int mqs_setup_new_process_iterator (mqs_process *);
686 extern int mqs_next_new_process (mqs_process *, mqs_process_location *);
687 
688 /* Once the debugger has attached to a newly created process it will
689  * set it up in the normal way, and then set its identity.
690  */
691 extern int mqs_set_process_identity (mqs_process *, int);
692 #endif
693 
694 END_C_DECLS
695 
696 #endif /* defined (_MPI_INTERFACE_INCLUDED) */
Definition: msgq_interface.h:516
Definition: msgq_interface.h:506
Definition: msgq_interface.h:484
Definition: msgq_interface.h:203
Definition: msgq_interface.h:349
Definition: msgq_interface.h:336