openmpi  3.1.6
About: Open MPI is a high performance Message Passing Interface (MPI) library project combining technologies and resources from several other projects (FT-MPI, LA-MPI, LAM/MPI, and PACX-MPI) in order to build the best MPI library available. 3.x series.
  Fossies Dox: openmpi-3.1.6.tar.bz2  ("unofficial" and yet experimental doxygen-generated source code documentation)  

ompi_msgq_dll.c
Go to the documentation of this file.
1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
2 /*
3  * Copyright (c) 2007-2016 Cisco Systems, Inc. All rights reserved.
4  * Copyright (c) 2004-2010 The University of Tennessee and The University
5  * of Tennessee Research Foundation. All rights
6  * reserved.
7  * Copyright (c) 2008-2009 Sun Microsystems, Inc. All rights reserved.
8  * Copyright (c) 2015 Los Alamos National Security, LLC. All rights
9  * reserved.
10  * Copyright (c) 2016 Intel, Inc. All rights reserved.
11  * Copyright (c) 2016 Research Organization for Information Science
12  * and Technology (RIST). All rights reserved.
13  * $COPYRIGHT$
14  *
15  * Additional copyrights may follow
16  *
17  * $HEADER$
18  */
19 
20 
42 /* Update log
43  *
44  * Jul 12 2001 FNW: Add a meaningful ID to the communicator name, and switch
45  * to using the recv_context as the unique_id field.
46  * Mar 6 2001 JHC: Add mqs_get_comm_group to allow a debugger to acquire
47  * processes less eagerly.
48  * Dec 13 2000 JHC: totalview/2514: Modify image_has_queues to return
49  * a silent FALSE if none of the expected data is
50  * present. This way you won't get complaints when
51  * you try this on non MPICH processes.
52  * Sep 8 2000 JVD: #include <string.h> to silence Linux Alpha compiler warnings.
53  * Mar 21 2000 JHC: Add the new entrypoint mqs_dll_taddr_width
54  * Nov 26 1998 JHC: Fix the problem that we weren't handling
55  * MPIR_Ignore_queues properly.
56  * Oct 22 1998 JHC: Fix a zero allocation problem
57  * Aug 19 1998 JHC: Fix some problems in our use of target_to_host on
58  * big endian machines.
59  * May 28 1998 JHC: Use the extra information we can return to say
60  * explicitly that sends are only showing non-blocking ops
61  * May 19 1998 JHC: Changed the names of the structs and added casts
62  * where needed to reflect the change to the way we handle
63  * type safety across the interface.
64  * Oct 27 1997 JHC: Created by exploding db_message_state_mpich.cxx
65  */
66 
67 /*
68  The following was added by William Gropp to improve the portability
69  to systems with non-ANSI C compilers
70  */
71 
72 #include "ompi_config.h"
73 
74 #ifdef HAVE_NO_C_CONST
75 #define const
76 #endif
77 #include <string.h>
78 #include <stdlib.h>
79 
80 /* Notice to developers!!!!
81  * The following include files with _dbg.h suffixes contains definitions
82  * that are shared between the debuggger plugins and the OMPI code base.
83  * This is done instead of including the non-_dbg suffixed files because
84  * of the different way compilers may handle extern definitions. The
85  * particular case that is causing problems is when there is an extern
86  * variable or function that is accessed in a static inline function.
87  * For example, here is the code we often see in a header file.
88  *
89  * extern int request_complete;
90  * static inline check_request(void) {
91  * request_complete = 1;
92  * }
93  *
94  * If this code exists in a header file and gets included in a source
95  * file, then some compilers expect to have request_complete defined
96  * somewhere even if request_complete is never referenced and
97  * check_request is never called. Other compilers do not need them defined
98  * if they are never referenced in the source file.
99  *
100  * In the case of extern functions we something like the following:
101  *
102  * extern int foo();
103  * static inline bar(void) {
104  * foo();
105  * }
106  *
107  * If this code exists it actually compiles fine however an undefined symbol
108  * is kept for foo() and in the case of some tools that load in plugins with
109  * RTLD_NOW this undefined symbol causes the dlopen to fail since we do not
110  * have (nor really need) the supporting library containing foo().
111  *
112  * Therefore, to handle cases like the above with compilers that require the
113  * symbols (like Sun Studio) instead of pulling in all of OMPI into the
114  * plugins or defining dummy symbols here we separate the definitions used by
115  * both sets of code into the _dbg.h files.
116  *
117  * This means if one needs to add another definition that the plugins must see
118  * one should either move the definition into one of the existing _dbg.h file or
119  * create a new _dbg.h file.
120  */
121 #include "ompi/group/group_dbg.h"
124 #include "mpi.h" /* needed for MPI_ANY_TAG */
125 
126 #include "msgq_interface.h"
127 #include "ompi_msgq_dll_defs.h"
128 
129 /*
130  End of inclusion
131  */
132 
133 
134 /* Essential macros for C */
135 #ifndef NULL
136 #define NULL ((void *)0)
137 #endif
138 #ifndef TRUE
139 #define TRUE (0==0)
140 #endif
141 #ifndef FALSE
142 #define FALSE (0==1)
143 #endif
144 
145 #ifdef OLD_STYLE_CPP_CONCAT
146 #define concat(a,b) ab
147 #define stringize(a) "a"
148 #else
149 #define concat(a,b) a##b
150 #define stringize(a) #a
151 #endif
152 
153 #define OPAL_ALIGN(x,a,t) (((x)+((t)(a)-1)) & ~(((t)(a)-1)))
154 
158 #define VERBOSE_GENERAL 0x00000001
159 #define VERBOSE_GROUP 0x00000002
160 #define VERBOSE_COMM 0x00000004
161 #define VERBOSE_LISTS 0x00000008
162 #define VERBOSE_REQ 0x00000010
163 #define VERBOSE_REQ_DUMP 0x00000020
164 
165 #define VERBOSE 0x00000000
166 
167 #if VERBOSE
168 #define DEBUG(LEVEL, WHAT) if(LEVEL & VERBOSE) { printf WHAT; }
169 #else
170 #define DEBUG(LEVEL,WHAT)
171 #endif /* VERBOSE */
172 
173 
174 /* Set up the basic callbacks into the debugger */
175 
177 {
179 } /* mqs_setup_callbacks */
180 
181 
182 
183 /* Version handling functions.
184  * This one should never be changed.
185  */
187 {
189 } /* mqs_version_compatibility */
190 
192 
193 /* This one can say what you like */
194 char *mqs_version_string (void)
195 {
196  int offset;
198  "Open MPI message queue support for parallel debuggers ");
200  return mqs_version_str;
201 } /* mqs_version_string */
202 
203 /* So the debugger can tell what interface width the library was compiled with */
205 {
206  return sizeof (mqs_taddr_t);
207 } /* mqs_dll_taddr_width */
208 
209 
210 /* Functions to handle translation groups.
211  * We have a list of these on the process info, so that we can
212  * share the group between multiple communicators.
213  */
214 
215 /* Translate a process number */
216 static int translate (group_t *this, int index)
217 {
218  if (index == MQS_INVALID_PROCESS ||
219  ((unsigned int)index) >= ((unsigned int) this->entries))
220  return MQS_INVALID_PROCESS;
221  return this->local_to_global[index];
222 } /* translate */
223 
224 
225 /* Search the group list for this group, if not found create it.
226  */
228  mqs_taddr_t group_base )
229 {
232  mqs_image * image = mqs_get_image (proc);
233  mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image);
234  communicator_t *comm = extra->communicator_list;
235  int *tr;
236  char *trbuffer;
237  int i, np, is_dense;
238  group_t *group;
240  mqs_taddr_t tablep;
241 
242  np = ompi_fetch_int( proc,
243  group_base + i_info->ompi_group_t.offset.grp_proc_count,
244  p_info );
245  if( np < 0 ) {
246  DEBUG(VERBOSE_COMM, ("Get a size for the communicator = %d\n", np));
247  return NULL; /* Makes no sense ! */
248  }
249  is_dense =
250  ompi_fetch_int( proc,
251  group_base + i_info->ompi_group_t.offset.grp_flags,
252  p_info );
253  is_dense = (0 != (is_dense & OMPI_GROUP_DENSE));
254 
255  /* Iterate over each communicator seeing if we can find this group */
256  for (;comm; comm = comm->next) {
257  group = comm->group;
258  if( group && (group->group_base == group_base) ) {
259  group->ref_count++; /* Someone else is interested */
260  DEBUG(VERBOSE_GROUP, ("Increase refcount for group 0x%p to %d\n",
261  (void*)group, group->ref_count) );
262  return group;
263  }
264  }
265 
266  /* Hmm, couldn't find one, so fetch it */
267  group = (group_t *)mqs_malloc (sizeof (group_t));
268  tr = (int *)mqs_malloc (np*sizeof(int));
269  trbuffer = (char *)mqs_malloc (np*sizeof(mqs_taddr_t));
270  group->local_to_global = tr;
271  group->group_base = group_base;
272  DEBUG(VERBOSE_GROUP, ("Create a new group 0x%p with %d members\n",
273  (void*)group, np) );
274 
275  tablep = ompi_fetch_pointer( proc,
276  group_base + i_info->ompi_group_t.offset.grp_proc_pointers,
277  p_info);
278 
279  if( (0 != np) &&
280  (mqs_ok != mqs_fetch_data(proc, tablep, np * p_info->sizes.pointer_size,
281  trbuffer)) ) {
282  DEBUG(VERBOSE_GROUP,("Failed to read the proc data. Destroy group %p\n",
283  (void*)group));
284  mqs_free (group);
285  mqs_free (tr);
286  mqs_free (trbuffer);
287  return NULL;
288  }
289 
300  if( NULL == extra->world_proc_array ) {
301  extra->world_proc_array = mqs_malloc( np * sizeof(mqs_taddr_t) );
302  for( i = 0; i < np; i++ ) {
303  mqs_target_to_host( proc, trbuffer + p_info->sizes.pointer_size*i,
304  &value, p_info->sizes.pointer_size );
305  extra->world_proc_array[i] = value;
306  group->local_to_global[i] = is_dense ? i : -1;
307  }
308  extra->world_proc_array_entries = np;
309  } else {
310  int j;
311 
312  for( i = 0; i < np; i++ ) {
313  mqs_target_to_host( proc, trbuffer + p_info->sizes.pointer_size*i,
314  &value, p_info->sizes.pointer_size );
315  if (is_dense) {
316  /* get the global rank this MPI process */
317  for( j = 0; j < extra->world_proc_array_entries; j++ ) {
318  if( value == extra->world_proc_array[j] ) {
319  group->local_to_global[i] = j;
320  break;
321  }
322  }
323  } else {
324  group->local_to_global[i] = -1;
325  }
326  }
327  }
328 
329  mqs_free(trbuffer);
330 
331  group->entries = np;
332  group->ref_count = 1;
333  return group;
334 } /* find_or_create_group */
335 
336 
337 static void group_decref (group_t * group)
338 {
339  DEBUG(VERBOSE_GROUP, ("Decrement reference count for group %p to %d\n", (void*)group,
340  (group->ref_count - 1)));
341  if (--(group->ref_count) == 0) {
342  mqs_free (group->local_to_global);
343  DEBUG(VERBOSE_GROUP, ("Destroy group %p\n", (void*)group));
344  mqs_free (group);
345  }
346 } /* group_decref */
347 
348 
353 {
354  mpi_image_info *i_info = (mpi_image_info *)mqs_malloc (sizeof (mpi_image_info));
355 
356  if (!i_info)
357  return err_no_store;
358 
359  memset ((void *)i_info, 0, sizeof (mpi_image_info));
360  i_info->image_callbacks = icb; /* Before we do *ANYTHING* */
361  i_info->extra = NULL;
362 
363  mqs_put_image_info (image, (mqs_image_info *)i_info);
364 
365  return mqs_ok;
366 } /* mqs_setup_image */
367 
368 
369 
374 int mqs_image_has_queues (mqs_image *image, char **message)
375 {
376  mpi_image_info * i_info = (mpi_image_info *)mqs_get_image_info (image);
377 
378  i_info->extra = NULL;
379 
380  /* Default failure message ! */
381  *message = "The symbols and types in the Open MPI library used by the debugger\n"
382  "to extract the message queues are not as expected in\n"
383  "the image '%s'\n"
384  "No message queue display is possible.\n"
385  "This is probably an Open MPI version or configuration problem.";
386 
387  /* Force in the file containing our breakpoint function, to ensure
388  * that types have been read from there before we try to look them
389  * up.
390  */
391  mqs_find_function (image, "ompi_debugger_setup_dlls", mqs_lang_c, NULL);
392 
393  /* Are we supposed to ignore this ? (e.g. it's really an HPF
394  * runtime using the Open MPI process acquisition, but not wanting
395  * queue display)
396  */
397  if (mqs_find_symbol (image, "MPIR_Ignore_queues", NULL) == mqs_ok) {
398  *message = NULL; /* Fail silently */
399  return err_silent_failure;
400  }
401 
402  /* Fill in the type information */
403  return ompi_fill_in_type_info(image, message);
404 } /* mqs_image_has_queues */
405 
406 
413 {
414  /* Extract the addresses of the global variables we need and save them away */
416 
417  if (p_info) {
418  mqs_image *image;
419  mpi_image_info *i_info;
420  mpi_process_info_extra *extra;
421 
422  p_info->process_callbacks = pcb;
423 
424  p_info->extra = mqs_malloc(sizeof(mpi_process_info_extra));
425  extra = (mpi_process_info_extra*) p_info->extra;
426 
427  /* Now we can get the rest of the info ! */
428  image = mqs_get_image (process);
429  i_info = (mpi_image_info *)mqs_get_image_info (image);
430 
431  /* We have no communicators yet */
432  extra->communicator_list = NULL;
433  /* Enforce the generation of the communicators list */
434  extra->comm_lowest_free = 0;
435  extra->comm_number_free = 0;
436  /* By default we don't show our internal requests*/
437  extra->show_internal_requests = 0;
438 
439  extra->world_proc_array_entries = 0;
440  extra->world_proc_array = NULL;
441 
442  mqs_get_type_sizes (process, &p_info->sizes);
443  /*
444  * Before going any further make sure we know exactly how the
445  * Open MPI library was compiled. This means we know the size
446  * of each of the basic types as stored in the
447  * MPIR_debug_typedefs_sizeof array.
448  */
449  {
450  mqs_taddr_t typedefs_sizeof;
451 
452  if (mqs_find_symbol (image, "MPIR_debug_typedefs_sizeof", &typedefs_sizeof) != mqs_ok) {
453  return err_no_store;
454  }
455  p_info->sizes.short_size = ompi_fetch_int( process, /* sizeof (short) */
456  typedefs_sizeof,
457  p_info );
458  typedefs_sizeof += p_info->sizes.int_size;
459  p_info->sizes.int_size = ompi_fetch_int( process, /* sizeof (int) */
460  typedefs_sizeof,
461  p_info );
462  typedefs_sizeof += p_info->sizes.int_size;
463  p_info->sizes.long_size = ompi_fetch_int( process, /* sizeof (long) */
464  typedefs_sizeof,
465  p_info );
466  typedefs_sizeof += p_info->sizes.int_size;
467  p_info->sizes.long_long_size = ompi_fetch_int( process, /* sizeof (long long) */
468  typedefs_sizeof,
469  p_info );
470  typedefs_sizeof += p_info->sizes.int_size;
471  p_info->sizes.pointer_size = ompi_fetch_int( process, /* sizeof (void *) */
472  typedefs_sizeof,
473  p_info );
474  typedefs_sizeof += p_info->sizes.int_size;
475  p_info->sizes.bool_size = ompi_fetch_int( process, /* sizeof (bool) */
476  typedefs_sizeof,
477  p_info );
478  typedefs_sizeof += p_info->sizes.int_size;
479  p_info->sizes.size_t_size = ompi_fetch_int( process, /* sizeof (size_t) */
480  typedefs_sizeof,
481  p_info );
483  ("sizes short = %d int = %d long = %d long long = %d "
484  "void* = %d bool = %d size_t = %d\n",
485  p_info->sizes.short_size, p_info->sizes.int_size,
486  p_info->sizes.long_size, p_info->sizes.long_long_size,
487  p_info->sizes.pointer_size, p_info->sizes.bool_size,
488  p_info->sizes.size_t_size) );
489  }
490 
492 
493  return mqs_ok;
494  }
495  return err_no_store;
496 } /* mqs_setup_process */
497 
498 
502 {
505  mqs_image * image = mqs_get_image (proc);
506  mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image);
507 
508  /* Don't bother with a pop up here, it's unlikely to be helpful */
509  *msg = 0;
510  DEBUG(VERBOSE_GENERAL,("checking the status of the OMPI dll\n"));
511  if (mqs_find_symbol (image, "ompi_mpi_communicators", &extra->commlist_base) != mqs_ok)
512  return err_all_communicators;
513 
514  if (mqs_find_symbol (image, "mca_pml_base_send_requests", &extra->send_queue_base) != mqs_ok)
515  return err_mpid_sends;
516 
517  if (mqs_find_symbol (image, "mca_pml_base_recv_requests", &extra->recv_queue_base) != mqs_ok)
518  return err_mpid_recvs;
519  DEBUG(VERBOSE_GENERAL,("process_has_queues returned success\n"));
520  return mqs_ok;
521 } /* mqs_process_has_queues */
522 
523 
528 {
531  mqs_image * image = mqs_get_image (proc);
532  mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image);
533  mqs_tword_t number_free; /* the number of available positions in
534  * the communicator array. */
535  mqs_tword_t lowest_free; /* the lowest free communicator */
536 
537  lowest_free = ompi_fetch_int( proc,
538  extra->commlist_base + i_info->opal_pointer_array_t.offset.lowest_free,
539  p_info );
540  number_free = ompi_fetch_int( proc,
541  extra->commlist_base + i_info->opal_pointer_array_t.offset.number_free,
542  p_info );
543  if( (lowest_free != extra->comm_lowest_free) ||
544  (number_free != extra->comm_number_free) ) {
545  DEBUG(VERBOSE_COMM, ("Recreate the communicator list\n"
546  " lowest_free [current] %d != [stored] %d\n"
547  " number_free [current] %d != [stored] %d\n",
548  (int)lowest_free, (int)extra->comm_lowest_free,
549  (int)number_free, (int)extra->comm_number_free) );
550  return 1;
551  }
552  DEBUG(VERBOSE_COMM, ("Communicator list not modified\n") );
553  return 0;
554 } /* mqs_communicators_changed */
555 
556 
563  int recv_ctx )
564 {
566  communicator_t * comm = extra->communicator_list;
567 
568  for( ; comm; comm = comm->next ) {
569  if( comm->comm_info.unique_id == (mqs_taddr_t)recv_ctx )
570  return comm;
571  }
572 
573  return NULL;
574 } /* find_communicator */
575 
576 
579 static int compare_comms (const void *a, const void *b)
580 {
581  communicator_t * ca = *(communicator_t **)a;
582  communicator_t * cb = *(communicator_t **)b;
583 
584  return cb->comm_info.unique_id - ca->comm_info.unique_id;
585 } /* compare_comms */
586 
587 
591 {
594  mqs_image * image = mqs_get_image (proc);
595  mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image);
596  communicator_t **commp, *old;
597  int i, commcount = 0, context_id;
598  mqs_tword_t comm_size, lowest_free, number_free;
599  mqs_taddr_t comm_addr_base;
600  mqs_taddr_t comm_ptr;
601 
602  DEBUG(VERBOSE_COMM,("rebuild_communicator_list called "
603  "(commlist_base %llx, array offset %ld array size %d)\n",
604  (long long)extra->commlist_base,
605  (long)i_info->opal_pointer_array_t.offset.addr,
606  i_info->opal_pointer_array_t.size));
611  comm_size = ompi_fetch_int( proc,
612  extra->commlist_base + i_info->opal_pointer_array_t.offset.size,
613  p_info );
614  lowest_free = ompi_fetch_int( proc,
615  extra->commlist_base + i_info->opal_pointer_array_t.offset.lowest_free,
616  p_info );
617  number_free = ompi_fetch_int( proc,
618  extra->commlist_base + i_info->opal_pointer_array_t.offset.number_free,
619  p_info );
620  extra->comm_lowest_free = lowest_free;
621  extra->comm_number_free = number_free;
622 
623  DEBUG(VERBOSE_COMM,("Number of coms %d lowest_free %d number_free %d\n",
624  (int)comm_size, (int)lowest_free, (int)number_free));
625  /* In Open MPI the MPI_COMM_WORLD is always at index 0. By default, the
626  * MPI_COMM_WORLD will never get modified. Except, when the fault tolerance
627  * features are enabled in Open MPI. Therefore, we will regenerate the
628  * list of proc pointers every time we rescan the communicators list.
629  * We can use the fact that MPI_COMM_WORLD is at index 0 to force the
630  * creation of the world_proc_array.
631  */
632  extra->world_proc_array_entries = 0;
633  mqs_free( extra->world_proc_array );
634  extra->world_proc_array = NULL;
635 
636  /* Now get the pointer to the array of pointers to communicators */
637  comm_addr_base =
638  ompi_fetch_pointer( proc,
639  extra->commlist_base + i_info->opal_pointer_array_t.offset.addr,
640  p_info );
641  DEBUG(VERBOSE_COMM,("Array of communicators starting at 0x%llx (sizeof(mqs_taddr_t*) = %d)\n",
642  (long long)comm_addr_base, (int)sizeof(mqs_taddr_t)));
643  for( i = 0; (commcount < (comm_size - number_free)) && (i < comm_size); i++ ) {
644  /* Get the communicator pointer */
645  comm_ptr =
646  ompi_fetch_pointer( proc,
647  comm_addr_base + i * p_info->sizes.pointer_size,
648  p_info );
649  DEBUG(VERBOSE_GENERAL,("Fetch communicator pointer 0x%llx\n", (long long)comm_ptr));
650  if( 0 == comm_ptr ) continue;
651  commcount++;
652  /* Now let's grab the data we want from inside */
653  DEBUG(VERBOSE_GENERAL, ("Retrieve context_id from 0x%llx and local_rank from 0x%llx\n",
654  (long long)(comm_ptr + i_info->ompi_communicator_t.offset.c_contextid),
655  (long long)(comm_ptr + i_info->ompi_communicator_t.offset.c_my_rank)));
656  context_id = ompi_fetch_int( proc,
657  comm_ptr + i_info->ompi_communicator_t.offset.c_contextid,
658  p_info );
659  /* Do we already have this communicator ? */
660  old = find_communicator(p_info, context_id);
661  if( NULL == old ) {
662  mqs_taddr_t group_base;
663 
664  old = (communicator_t *)mqs_malloc (sizeof (communicator_t));
665  /* Save the results */
666  old->next = extra->communicator_list;
667  extra->communicator_list = old;
668  old->comm_ptr = comm_ptr;
669  old->comm_info.unique_id = context_id;
670  old->comm_info.local_rank = ompi_fetch_int(proc,
671  comm_ptr + i_info->ompi_communicator_t.offset.c_my_rank,
672  p_info);
673  old->group = NULL;
674 
675  DEBUG(VERBOSE_COMM,("Create new communicator 0x%lx with context_id %d and local_rank %d\n",
676  (long)old, context_id, local_rank));
677  /* Now get the information about the group */
678  group_base =
679  ompi_fetch_pointer( proc, comm_ptr + i_info->ompi_communicator_t.offset.c_local_group,
680  p_info );
681  old->group = find_or_create_group( proc, group_base );
682  }
683  mqs_fetch_data( proc, comm_ptr + i_info->ompi_communicator_t.offset.c_name,
684  64, old->comm_info.name );
685 
686  if( NULL != old->group ) {
687  old->comm_info.size = old->group->entries;
688  }
689  old->present = TRUE;
690  DEBUG(VERBOSE_COMM,("Communicator 0x%llx %d local_rank %d name %s group %p\n",
691  (long long)old->comm_ptr, (int)old->comm_info.unique_id,
692  (int)old->comm_info.local_rank, old->comm_info.name,
693  (void*)old->group));
694  }
695 
696  /* Now iterate over the list tidying up any communicators which
697  * no longer exist, and cleaning the flags on any which do.
698  */
699  commp = &extra->communicator_list;
700  commcount = 0;
701  for (; *commp; ) {
702  communicator_t *comm = *commp;
703  if (comm->present) {
704  comm->present = FALSE;
705  commcount++;
706  DEBUG(VERBOSE_COMM, ("Keep communicator 0x%llx name %s\n",
707  (long long)comm->comm_ptr, comm->comm_info.name));
708  commp = &(*commp)->next; /* go to the next communicator */
709  } else { /* It needs to be deleted */
710  *commp = comm->next; /* Remove from the list, *commp now points to the next */
711  DEBUG(VERBOSE_COMM, ("Remove communicator 0x%llx name %s (group %p)\n",
712  (long long)comm->comm_ptr, comm->comm_info.name,
713  (void*)comm->group));
714  group_decref (comm->group); /* Group is no longer referenced from here */
715  mqs_free (comm);
716  }
717  }
718 
719  if (commcount) {
720  /* Sort the list so that it is displayed in some semi-sane order. */
721  communicator_t ** comm_array =
722  (communicator_t **) mqs_malloc(commcount * sizeof (communicator_t *));
723  communicator_t *comm = extra->communicator_list;
724 
725  for (i=0; i<commcount; i++, comm=comm->next)
726  comm_array [i] = comm;
727 
728  /* Do the sort */
729  qsort (comm_array, commcount, sizeof (communicator_t *), compare_comms);
730 
731  /* Rebuild the list */
732  extra->communicator_list = NULL;
733  for (i=0; i<commcount; i++) {
734  comm = comm_array[i];
735  comm->next = extra->communicator_list;
736  extra->communicator_list = comm;
737  }
738 
739  mqs_free (comm_array);
740  }
741 
742  return mqs_ok;
743 } /* rebuild_communicator_list */
744 
745 
749 {
750  if (communicators_changed (proc))
751  return rebuild_communicator_list (proc);
752  return mqs_ok;
753 } /* mqs_update_communicator_list */
754 
755 
761 {
764 
765  /* Start at the front of the list again */
766  extra->current_communicator = extra->communicator_list;
767  /* Reset the operation iterator too */
768  extra->next_msg.free_list = 0;
769  extra->next_msg.current_item = 0;
770  extra->next_msg.opal_list_t_pos.list = 0;
771 
772  DEBUG(VERBOSE_COMM,("mqs_setup_communicator_iterator called\n"));
773  return extra->current_communicator == NULL ? mqs_end_of_list : mqs_ok;
774 } /* mqs_setup_communicator_iterator */
775 
776 
780 {
783 
784  if (extra->current_communicator) {
785  *comm = extra->current_communicator->comm_info;
786  DEBUG(VERBOSE_COMM,("mqs_get_communicator %d local_rank %d name %s\n",
787  (int)comm->unique_id, (int)comm->local_rank,
788  comm->name));
789  return mqs_ok;
790  }
791  DEBUG(VERBOSE_COMM,("No more communicators for this iteration\n"));
793 } /* mqs_get_communicator */
794 
795 
798 int mqs_get_comm_group (mqs_process *proc, int *group_members)
799 {
802  communicator_t *comm = extra->current_communicator;
803 
804  if (comm && comm->group) {
805  group_t * g = comm->group;
806  int i;
807 
808  for (i=0; i<g->entries; i++)
809  group_members[i] = g->local_to_global[i];
810 
811  return mqs_ok;
812  }
814 } /* mqs_get_comm_group */
815 
816 
820 {
823 
825  return (extra->current_communicator != NULL) ? mqs_ok : mqs_end_of_list;
826 } /* mqs_next_communicator */
827 
832  mqs_opal_list_t_pos* position, mqs_taddr_t list )
833 {
834  mqs_image * image = mqs_get_image (proc);
835  mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image);
836 
837  position->list = list;
838  position->sentinel = position->list + i_info->opal_list_t.offset.opal_list_sentinel;
839  position->current_item =
840  ompi_fetch_pointer( proc, position->sentinel + i_info->opal_list_item_t.offset.opal_list_next,
841  p_info );
842  if( position->current_item == position->sentinel )
843  position->current_item = 0;
844  DEBUG(VERBOSE_LISTS,("opal_list_t_init_parser list = 0x%llx, sentinel = 0x%llx, "
845  "current_item = 0x%llx\n", (long long)position->list,
846  (long long)position->sentinel, (long long)position->current_item));
847  return mqs_ok;
848 }
849 
851  mqs_opal_list_t_pos* position, mqs_taddr_t* active_item )
852 {
853  mqs_image * image = mqs_get_image (proc);
854  mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image);
855 
856  *active_item = position->current_item;
857  if( 0 == position->current_item )
858  return mqs_end_of_list;
859 
860  position->current_item =
861  ompi_fetch_pointer( proc,
862  position->current_item + i_info->opal_list_item_t.offset.opal_list_next,
863  p_info );
864  if( position->current_item == position->sentinel )
865  position->current_item = 0;
866  return mqs_ok;
867 }
868 
869 #if defined(CODE_NOT_USED)
870 
873 static void opal_free_list_t_dump_position( mqs_opal_free_list_t_pos* position )
874 {
875  printf( "position->opal_list_t_pos.current_item = 0x%llx\n", (long long)position->opal_list_t_pos.current_item );
876  printf( "position->opal_list_t_pos.list = 0x%llx\n", (long long)position->opal_list_t_pos.list );
877  printf( "position->opal_list_t_pos.sentinel = 0x%llx\n", (long long)position->opal_list_t_pos.sentinel );
878  printf( "position->current_item = 0x%llx\n", (long long)position->current_item );
879  printf( "position->upper_bound = 0x%llx\n", (long long)position->upper_bound );
880  printf( "position->header_space = %llx\n", (long long)position->header_space );
881  printf( "position->free_list = 0x%llx\n", (long long)position->free_list );
882  printf( "position->fl_frag_class = 0x%llx\n", (long long)position->fl_frag_class );
883  printf( "position->fl_mpool = 0x%llx\n", (long long)position->fl_mpool );
884  printf( "position->fl_frag_size = %llx\n", (long long)position->fl_frag_size );
885  printf( "position->fl_frag_alignment = %llx\n", (long long)position->fl_frag_alignment );
886  printf( "position->fl_num_per_alloc = %llx\n", (long long)position->fl_num_per_alloc );
887  printf( "position->fl_num_allocated = %llx\n", (long long)position->fl_num_allocated );
888  printf( "position->fl_num_initial_alloc = %llx\n", (long long)position->fl_num_initial_alloc );
889 }
890 #endif /* CODE_NOT_USED */
891 
893  mqs_opal_free_list_t_pos* position, mqs_taddr_t free_list )
894 {
895  mqs_image * image = mqs_get_image (proc);
896  mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image);
897  mqs_taddr_t active_allocation;
898 
899  position->free_list = free_list;
900 
901  position->fl_frag_size =
902  ompi_fetch_size_t( proc, position->free_list + i_info->opal_free_list_t.offset.fl_frag_size,
903  p_info );
904  position->fl_frag_alignment =
905  ompi_fetch_size_t( proc, position->free_list + i_info->opal_free_list_t.offset.fl_frag_alignment,
906  p_info );
907  position->fl_frag_class =
908  ompi_fetch_pointer( proc, position->free_list + i_info->opal_free_list_t.offset.fl_frag_class,
909  p_info );
910  position->fl_mpool =
911  ompi_fetch_pointer( proc, position->free_list + i_info->opal_free_list_t.offset.fl_mpool,
912  p_info );
913  position->fl_num_per_alloc =
914  ompi_fetch_size_t( proc, position->free_list + i_info->opal_free_list_t.offset.fl_num_per_alloc,
915  p_info );
916  position->fl_num_allocated =
917  ompi_fetch_size_t( proc, position->free_list + i_info->opal_free_list_t.offset.fl_num_allocated,
918  p_info );
919 
920  if( 0 == position->fl_mpool ) {
921  position->header_space = position->fl_frag_size;
922  } else {
923  DEBUG(VERBOSE_GENERAL, ("BLAH !!! (CORRECT ME)\n"));
924  position->header_space = position->fl_frag_size;
925  }
926  position->header_space = OPAL_ALIGN( position->header_space,
927  position->fl_frag_alignment, mqs_taddr_t );
928 
935  if( position->fl_num_allocated <= position->fl_num_per_alloc ) {
936  position->fl_num_initial_alloc = position->fl_num_allocated;
937  } else {
938  position->fl_num_initial_alloc = position->fl_num_allocated % position->fl_num_per_alloc;
939  if( 0 == position->fl_num_initial_alloc )
940  position->fl_num_initial_alloc = position->fl_num_per_alloc;
941  }
942  DEBUG(VERBOSE_LISTS,("opal_free_list_t fl_frag_size = %lld fl_header_space = %lld\n"
943  " fl_frag_alignment = %lld fl_num_per_alloc = %lld\n"
944  " fl_num_allocated = %lld fl_num_initial_alloc = %lld\n"
945  " header_space = %lld\n",
946  (long long)position->fl_frag_size, (long long)position->header_space,
947  (long long)position->fl_frag_alignment, (long long)position->fl_num_per_alloc,
948  (long long)position->fl_num_allocated, (long long)position->fl_num_initial_alloc,
949  (long long)position->header_space));
950 
954  opal_list_t_init_parser( proc, p_info, &position->opal_list_t_pos,
955  position->free_list + i_info->opal_free_list_t.offset.fl_allocations );
956  next_item_opal_list_t( proc, p_info, &position->opal_list_t_pos, &active_allocation );
957  DEBUG(VERBOSE_LISTS,("active_allocation 0x%llx header_space %d\n",
958  (long long)active_allocation, (int)position->header_space));
959  if( 0 == active_allocation ) { /* the end of the list */
960  position->upper_bound = 0;
961  } else {
965  active_allocation += i_info->opal_free_list_item_t.size;
966  active_allocation = OPAL_ALIGN( active_allocation,
967  position->fl_frag_alignment, mqs_taddr_t );
971  position->upper_bound =
972  position->fl_num_initial_alloc * position->header_space + active_allocation;
973  DEBUG(VERBOSE_LISTS,("there are some elements in the list "
974  "active_allocation = %llx upper_bound = %llx\n",
975  (long long)active_allocation, (long long)position->upper_bound));
976  }
977  position->current_item = active_allocation;
978 
979  /*opal_free_list_t_dump_position( position );*/
980  return mqs_ok;
981 }
982 
987  mqs_opal_free_list_t_pos* position, mqs_taddr_t* active_item )
988 {
989  mqs_image * image = mqs_get_image (proc);
990  mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image);
991  mqs_taddr_t active_allocation;
992 
993  *active_item = position->current_item;
994  if( 0 == position->current_item ) /* the end ... */
995  return mqs_ok;
996 
997  position->current_item += position->header_space;
998  if( position->current_item >= position->upper_bound ) {
999  DEBUG(VERBOSE_LISTS,("Reach the end of one of the opal_free_list_t "
1000  "allocations. Go to the next one\n"));
1001  /* we should go to the next allocation */
1002  next_item_opal_list_t( proc, p_info,
1003  &position->opal_list_t_pos, &active_allocation );
1004  if( 0 == active_allocation ) { /* we're at the end */
1005  position->current_item = 0;
1006  return mqs_ok;
1007  }
1011  active_allocation += i_info->opal_free_list_item_t.size;
1012  active_allocation = OPAL_ALIGN( active_allocation,
1013  position->fl_frag_alignment, mqs_taddr_t );
1017  position->upper_bound =
1018  position->fl_num_per_alloc * position->header_space + active_allocation;
1019  position->current_item = active_allocation;
1020  DEBUG(VERBOSE_LISTS,("there are more elements in the list "
1021  "active_allocation = %llx upper_bound = %llx\n",
1022  (long long)active_allocation, (long long)position->upper_bound));
1023  /*opal_free_list_t_dump_position( position );*/
1024  }
1025  DEBUG(VERBOSE_LISTS,("Free list actual position 0x%llx next element at 0x%llx\n",
1026  (long long)*active_item, (long long)position->current_item));
1027  return mqs_ok;
1028 }
1029 
1030 static void dump_request( mqs_taddr_t current_item, mqs_pending_operation *res )
1031 {
1032  if(!(VERBOSE_REQ_DUMP & VERBOSE)) return;
1033  printf( "\n+===============================================+\n"
1034  "|Request 0x%llx contain \n"
1035  "| res->status = %d\n"
1036  "| res->desired_local_rank = %ld\n"
1037  "| res->desired_global_rank = %ld\n"
1038  "| res->tag_wild = %ld\n"
1039  "| res->desired_tag = %ld\n"
1040  "| res->system_buffer = %s\n"
1041  "| res->buffer = 0x%llx\n"
1042  "| res->desired_length = %ld\n",
1043  (long long)current_item, res->status, (long)res->desired_local_rank,
1044  (long)res->desired_global_rank, (long)res->tag_wild, (long)res->desired_tag,
1045  (TRUE == res->system_buffer ? "TRUE" : "FALSE"), (long long)res->buffer,
1046  (long)res->desired_length );
1047 
1048  if( res->status > mqs_st_pending ) {
1049  printf( "| res->actual_length = %ld\n"
1050  "| res->actual_tag = %ld\n"
1051  "| res->actual_local_rank = %ld\n"
1052  "| res->actual_global_rank = %ld\n",
1053  (long)res->actual_length, (long)res->actual_tag,
1054  (long)res->actual_local_rank, (long)res->actual_global_rank );
1055  }
1056  if( '\0' != res->extra_text[0][0] )
1057  printf( "| extra[0] = %s\n", res->extra_text[0] );
1058  if( '\0' != res->extra_text[1][0] )
1059  printf( "| extra[1] = %s\n", res->extra_text[1] );
1060  if( '\0' != res->extra_text[2][0] )
1061  printf( "| extra[2] = %s\n", res->extra_text[2] );
1062  if( '\0' != res->extra_text[3][0] )
1063  printf( "| extra[3] = %s\n", res->extra_text[3] );
1064  if( '\0' != res->extra_text[4][0] )
1065  printf( "| extra[4] = %s\n", res->extra_text[4] );
1066  printf( "+===============================================+\n\n" );
1067 }
1068 
1073 static int fetch_request( mqs_process *proc, mpi_process_info *p_info,
1074  mqs_pending_operation *res, int look_for_user_buffer )
1075 {
1076  mqs_image * image = mqs_get_image (proc);
1077  mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image);
1078  mqs_taddr_t current_item;
1079  mqs_tword_t req_complete, req_pml_complete, req_valid, req_type;
1080  mqs_taddr_t req_buffer, req_comm;
1082 
1083  /* If we get a PML request with an internal tag we will jump back here */
1084  rescan_requests:
1085  while( 1 ) {
1086  opal_free_list_t_next_item( proc, p_info,
1087  &extra->next_msg, &current_item );
1088  if( 0 == current_item ) {
1089  DEBUG(VERBOSE_REQ,("no more items in the %s request queue\n",
1090  look_for_user_buffer ? "receive" : "send" ));
1091  return mqs_end_of_list;
1092  }
1093  req_valid = ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_state, p_info );
1094  if( OMPI_REQUEST_INVALID == req_valid ) continue;
1095  req_comm = ompi_fetch_pointer( proc, current_item + i_info->mca_pml_base_request_t.offset.req_comm, p_info );
1096  if( extra->current_communicator->comm_ptr == req_comm ) break;
1097  DEBUG(VERBOSE_REQ,("unmatched request (0x%llx) req_comm = %llx current_com = %llx\n",
1098  (long long)current_item, (long long)req_comm,
1099  (long long)extra->current_communicator->comm_ptr));
1100  }
1101 
1102  res->extra_text[0][0] = 0; res->extra_text[1][0] = 0; res->extra_text[2][0] = 0;
1103  res->extra_text[3][0] = 0; res->extra_text[4][0] = 0;
1104 
1105  req_type = ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_type, p_info );
1106  if( OMPI_REQUEST_PML == req_type ) {
1107  mqs_taddr_t ompi_datatype;
1108  char data_name[64];
1109 
1114  res->desired_tag =
1115  ompi_fetch_int( proc, current_item + i_info->mca_pml_base_request_t.offset.req_tag, p_info );
1116  if( MPI_ANY_TAG == (int)res->desired_tag ) {
1117  res->tag_wild = TRUE;
1118  } else {
1119  /* Don't allow negative tags to show up */
1120  if( ((int)res->desired_tag < 0) && (0 == extra->show_internal_requests) )
1121  goto rescan_requests;
1122  res->tag_wild = FALSE;
1123  }
1124 
1125  req_type =
1126  ompi_fetch_int( proc, current_item + i_info->mca_pml_base_request_t.offset.req_type,
1127  p_info);
1128  req_complete =
1129  ompi_fetch_bool( proc,
1130  current_item + i_info->ompi_request_t.offset.req_complete,
1131  p_info );
1132  req_pml_complete =
1133  ompi_fetch_bool( proc,
1134  current_item + i_info->mca_pml_base_request_t.offset.req_pml_complete,
1135  p_info );
1136  res->status = (0 == req_complete ? mqs_st_pending : mqs_st_complete);
1137 
1138  res->desired_local_rank = ompi_fetch_int( proc, current_item + i_info->mca_pml_base_request_t.offset.req_peer, p_info );
1140  res->desired_local_rank );
1141 
1142  res->buffer = ompi_fetch_pointer( proc, current_item + i_info->mca_pml_base_request_t.offset.req_addr,
1143  p_info );
1144  /* Set this to true if it's a buffered request */
1145  res->system_buffer = FALSE;
1146 
1147  /* The pointer to the request datatype */
1148  ompi_datatype =
1149  ompi_fetch_pointer( proc,
1150  current_item + i_info->mca_pml_base_request_t.offset.req_datatype, p_info );
1151  /* Retrieve the count as specified by the user */
1152  res->desired_length =
1153  ompi_fetch_size_t( proc,
1154  ompi_datatype + i_info->ompi_datatype_t.offset.size,
1155  p_info );
1156  /* Be user friendly, show the datatype name */
1157  mqs_fetch_data( proc, ompi_datatype + i_info->ompi_datatype_t.offset.name,
1158  64, data_name );
1159  if( '\0' != data_name[0] ) {
1160  snprintf( (char*)res->extra_text[1], 64, "Data: %d * %s",
1161  (int)res->desired_length, data_name );
1162  }
1163  /* And now compute the real length as specified by the user */
1164  res->desired_length *=
1165  ompi_fetch_size_t( proc,
1166  current_item + i_info->mca_pml_base_request_t.offset.req_count,
1167  p_info );
1168 
1169  if( MCA_PML_REQUEST_SEND == req_type ) {
1170  snprintf( (char *)res->extra_text[0], 64, "Send: 0x%llx", (long long)current_item );
1171  req_buffer =
1172  ompi_fetch_pointer( proc,
1173  current_item + i_info->mca_pml_base_send_request_t.offset.req_addr,
1174  p_info );
1175  res->system_buffer = ( req_buffer == res->buffer ? FALSE : TRUE );
1176  res->actual_length =
1177  ompi_fetch_size_t( proc,
1178  current_item + i_info->mca_pml_base_send_request_t.offset.req_bytes_packed, p_info );
1179  res->actual_tag = res->desired_tag;
1182  } else if( MCA_PML_REQUEST_RECV == req_type ) {
1183  snprintf( (char *)res->extra_text[0], 64, "Receive: 0x%llx", (long long)current_item );
1189  res->actual_tag =
1190  ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_status +
1191  i_info->ompi_status_public_t.offset.MPI_TAG, p_info );
1192  if( MPI_ANY_TAG != (int)res->actual_tag ) {
1193  res->status = mqs_st_matched;
1194  res->desired_length =
1195  ompi_fetch_size_t( proc,
1196  current_item + i_info->mca_pml_base_recv_request_t.offset.req_bytes_packed,
1197  p_info );
1198  res->actual_local_rank =
1199  ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_status +
1200  i_info->ompi_status_public_t.offset.MPI_SOURCE, p_info );
1202  res->actual_local_rank );
1203  }
1204  } else {
1205  snprintf( (char *)res->extra_text[0], 64, "Unknown type of request 0x%llx", (long long)current_item );
1206  }
1207  if( 0 != req_pml_complete ) {
1208  snprintf( (char *)res->extra_text[1], 64, "Data transfer completed" );
1209  }
1210 
1211  /* If the length we're looking for is the count ... */
1212  /*res->desired_length =
1213  ompi_fetch_int( proc, current_item + i_info->mca_pml_base_request_t.offset.req_count, p_info );*/
1214 
1215  if( (mqs_st_pending < res->status) && (MCA_PML_REQUEST_SEND != req_type) ) { /* The real data from the status */
1216  res->actual_length =
1217  ompi_fetch_size_t( proc, current_item + i_info->ompi_request_t.offset.req_status +
1218  i_info->ompi_status_public_t.offset._ucount, p_info );
1219  res->actual_tag =
1220  ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_status +
1221  i_info->ompi_status_public_t.offset.MPI_TAG, p_info );
1222  res->actual_local_rank =
1223  ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_status +
1224  i_info->ompi_status_public_t.offset.MPI_SOURCE, p_info );
1226  res->actual_local_rank );
1227  }
1228  dump_request( current_item, res );
1229  }
1230  return mqs_ok;
1231 }
1232 
1233 
1237 {
1240 
1241  extra->what = (mqs_op_class)op;
1242 
1243  switch (op) {
1244  case mqs_pending_sends:
1245  DEBUG(VERBOSE_REQ,("setup the send queue iterator\n"));
1246  opal_free_list_t_init_parser( proc, p_info, &extra->next_msg, extra->send_queue_base );
1247  return mqs_ok;
1248 
1249  case mqs_pending_receives:
1250  DEBUG(VERBOSE_REQ,("setup the receive queue iterator\n"));
1251  opal_free_list_t_init_parser( proc, p_info, &extra->next_msg, extra->recv_queue_base );
1252  return mqs_ok;
1253 
1254  case mqs_unexpected_messages: /* TODO */
1255  return mqs_no_information;
1256 
1257  default:
1258  return err_bad_request;
1259  }
1260 } /* mqs_setup_operation_iterator */
1261 
1262 
1269 {
1272 
1273  switch (extra->what) {
1274  case mqs_pending_receives:
1275  DEBUG(VERBOSE_REQ,("digging for the receive queue\n"));
1276  return fetch_request( proc, p_info, op, TRUE );
1278  /* TODO: not handled yet */
1279  return err_bad_request;
1280  case mqs_pending_sends:
1281  DEBUG(VERBOSE_REQ,("digging for the send queue\n"));
1282  return fetch_request( proc, p_info, op, FALSE );
1283  default: return err_bad_request;
1284  }
1285 } /* mqs_next_operation */
1286 
1287 
1291 {
1292  mpi_process_info *p_info = (mpi_process_info *)mp_info;
1294  /* Need to handle the communicators and groups too */
1295  communicator_t *comm;
1296 
1297  if( NULL != extra) {
1298  comm = extra->communicator_list;
1299  while (comm) {
1300  communicator_t *next = comm->next;
1301 
1302  if( NULL != comm->group )
1303  group_decref (comm->group); /* Group is no longer referenced from here */
1304  mqs_free (comm);
1305 
1306  comm = next;
1307  }
1308  if (NULL != extra) {
1309  mqs_free(extra);
1310  }
1311  }
1312  mqs_free (p_info);
1313 } /* mqs_destroy_process_info */
1314 
1315 
1320 {
1321  mqs_free (info);
1322 } /* mqs_destroy_image_info */
1323 
1324 
1325 /* Convert an error code into a printable string */
1326 char * mqs_dll_error_string (int errcode)
1327 {
1328  switch (errcode) {
1329  case err_silent_failure:
1330  return "";
1332  return "No current communicator in the communicator iterator";
1333  case err_bad_request:
1334  return "Attempting to setup to iterate over an unknown queue of operations";
1335  case err_no_store:
1336  return "Unable to allocate store";
1337  case err_failed_qhdr:
1338  return "Failed to find type MPID_QHDR";
1339  case err_unexpected:
1340  return "Failed to find field 'unexpected' in MPID_QHDR";
1341  case err_posted:
1342  return "Failed to find field 'posted' in MPID_QHDR";
1343  case err_failed_queue:
1344  return "Failed to find type MPID_QUEUE";
1345  case err_first:
1346  return "Failed to find field 'first' in MPID_QUEUE";
1347  case err_context_id:
1348  return "Failed to find field 'context_id' in MPID_QEL";
1349  case err_tag:
1350  return "Failed to find field 'tag' in MPID_QEL";
1351  case err_tagmask:
1352  return "Failed to find field 'tagmask' in MPID_QEL";
1353  case err_lsrc:
1354  return "Failed to find field 'lsrc' in MPID_QEL";
1355  case err_srcmask:
1356  return "Failed to find field 'srcmask' in MPID_QEL";
1357  case err_next:
1358  return "Failed to find field 'next' in MPID_QEL";
1359  case err_ptr:
1360  return "Failed to find field 'ptr' in MPID_QEL";
1361  case err_missing_type:
1362  return "Failed to find some type";
1363  case err_missing_symbol:
1364  return "Failed to find field the global symbol";
1365  case err_db_shandle:
1366  return "Failed to find field 'db_shandle' in MPIR_SQEL";
1367  case err_db_comm:
1368  return "Failed to find field 'db_comm' in MPIR_SQEL";
1369  case err_db_target:
1370  return "Failed to find field 'db_target' in MPIR_SQEL";
1371  case err_db_tag:
1372  return "Failed to find field 'db_tag' in MPIR_SQEL";
1373  case err_db_data:
1374  return "Failed to find field 'db_data' in MPIR_SQEL";
1375  case err_db_byte_length:
1376  return "Failed to find field 'db_byte_length' in MPIR_SQEL";
1377  case err_db_next:
1378  return "Failed to find field 'db_next' in MPIR_SQEL";
1379  case err_failed_rhandle:
1380  return "Failed to find type MPIR_RHANDLE";
1381  case err_is_complete:
1382  return "Failed to find field 'is_complete' in MPIR_RHANDLE";
1383  case err_buf:
1384  return "Failed to find field 'buf' in MPIR_RHANDLE";
1385  case err_len:
1386  return "Failed to find field 'len' in MPIR_RHANDLE";
1387  case err_s:
1388  return "Failed to find field 's' in MPIR_RHANDLE";
1389  case err_failed_status:
1390  return "Failed to find type MPI_Status";
1391  case err_count:
1392  return "Failed to find field 'count' in MPIR_Status";
1393  case err_MPI_SOURCE:
1394  return "Failed to find field 'MPI_SOURCE' in MPIR_Status";
1395  case err_MPI_TAG:
1396  return "Failed to find field 'MPI_TAG' in MPIR_Status";
1397  case err_failed_commlist:
1398  return "Failed to find type MPIR_Comm_list";
1399  case err_sequence_number:
1400  return "Failed to find field 'sequence_number' in MPIR_Comm_list";
1401  case err_comm_first:
1402  return "Failed to find field 'comm_first' in MPIR_Comm_list";
1404  return "Failed to find type MPIR_Communicator";
1405  case err_lrank_to_grank:
1406  return "Failed to find field 'lrank_to_grank' in MPIR_Communicator";
1407  case err_send_context:
1408  return "Failed to find field 'send_context' in MPIR_Communicator";
1409  case err_recv_context:
1410  return "Failed to find field 'recv_context' in MPIR_Communicator";
1411  case err_comm_next:
1412  return "Failed to find field 'comm_next' in MPIR_Communicator";
1413  case err_comm_name:
1414  return "Failed to find field 'comm_name' in MPIR_Communicator";
1415  case err_all_communicators:
1416  return "Failed to find the global symbol MPIR_All_communicators";
1417  case err_mpid_sends:
1418  return "Failed to access the global send requests list";
1419  case err_mpid_recvs:
1420  return "Failed to access the global receive requests list";
1421  case err_group_corrupt:
1422  return "Could not read a communicator's group from the process (probably a store corruption)";
1423 
1424  default: return "Unknown error code";
1425  }
1426 } /* mqs_dll_error_string */
mqs_dll_taddr_width
int mqs_dll_taddr_width(void)
Definition: ompi_msgq_dll.c:204
mpi_image_info::mca_pml_base_request_t
struct mpi_image_info::@6 mca_pml_base_request_t
mqs_pending_operation::desired_local_rank
mqs_tword_t desired_local_rank
Definition: msgq_interface.h:353
mqs_ompi_opal_list_t_pos::sentinel
mqs_taddr_t sentinel
Definition: ompi_msgq_dll_defs.h:76
mqs_st_complete
@ mqs_st_complete
Definition: msgq_interface.h:270
find_or_create_group
static group_t * find_or_create_group(mqs_process *proc, mqs_taddr_t group_base)
Definition: ompi_msgq_dll.c:227
mqs_get_communicator
int mqs_get_communicator(mqs_process *proc, mqs_communicator *comm)
Fetch information about the current communicator.
Definition: ompi_msgq_dll.c:779
mqs_opal_free_list_t_pos::fl_mpool
mqs_tword_t fl_mpool
Definition: ompi_msgq_dll_defs.h:86
mqs_opal_free_list_t_pos::fl_num_initial_alloc
mqs_tword_t fl_num_initial_alloc
Definition: ompi_msgq_dll_defs.h:91
mqs_pending_operation::system_buffer
int system_buffer
Definition: msgq_interface.h:358
msg
static char msg[512]
Definition: rcache_base_mem_cb.c:41
rebuild_communicator_list
static int rebuild_communicator_list(mqs_process *proc)
Rebuild our list of communicators because something has changed.
Definition: ompi_msgq_dll.c:590
mpi_image_info::opal_free_list_item_t
struct mpi_image_info::@2 opal_free_list_item_t
mqs_setup_basic_callbacks
void mqs_setup_basic_callbacks(const mqs_basic_callbacks *cb)
Calls from the debugger into the DLL.
Definition: ompi_msgq_dll.c:176
OPAL_ALIGN
#define OPAL_ALIGN(x, a, t)
Definition: ompi_msgq_dll.c:153
mqs_opal_free_list_t_pos::fl_frag_size
mqs_tword_t fl_frag_size
Definition: ompi_msgq_dll_defs.h:87
VERBOSE_GROUP
#define VERBOSE_GROUP
Definition: ompi_msgq_dll.c:159
mqs_target_type_sizes::int_size
int int_size
Definition: msgq_interface.h:206
VERBOSE_LISTS
#define VERBOSE_LISTS
Definition: ompi_msgq_dll.c:161
info
static output_desc_t info[64]
Definition: output.c:114
mqs_op_class
mqs_op_class
Definition: msgq_interface.h:256
communicator_t::group
group_t * group
Definition: ompi_msgq_dll_defs.h:67
mqs_image
struct mqs_image_ mqs_image
Definition: msgq_interface.h:166
group
void group(tm_affinity_mat_t *, tm_tree_t *, tm_tree_t *, int, int, int, double *, tm_tree_t **)
err_db_shandle
@ err_db_shandle
Definition: msgq_interface.h:299
err_failed_commlist
@ err_failed_commlist
Definition: msgq_interface.h:318
dump_request
static void dump_request(mqs_taddr_t current_item, mqs_pending_operation *res)
Definition: ompi_msgq_dll.c:1030
ompi_fill_in_type_info
int ompi_fill_in_type_info(mqs_image *image, char **message)
Definition: ompi_common_dll.c:91
mqs_image_has_queues
int mqs_image_has_queues(mqs_image *image, char **message)
Check for all the information we require to access the Open MPI message queues.
Definition: ompi_msgq_dll.c:374
err_group_corrupt
@ err_group_corrupt
Definition: msgq_interface.h:332
mqs_pending_operation::desired_tag
mqs_tword_t desired_tag
Definition: msgq_interface.h:356
mqs_target_type_sizes::long_long_size
int long_long_size
Definition: msgq_interface.h:208
mpi_image_info::ompi_datatype_t
struct mpi_image_info::@14 ompi_datatype_t
ompi_msgq_dll_defs.h
err_no_current_communicator
@ err_no_current_communicator
Definition: msgq_interface.h:277
mqs_opal_free_list_t_pos::fl_num_allocated
mqs_tword_t fl_num_allocated
Definition: ompi_msgq_dll_defs.h:90
err_mpid_recvs
@ err_mpid_recvs
Definition: msgq_interface.h:331
err_recv_context
@ err_recv_context
Definition: msgq_interface.h:325
mpi_image_info::opal_list_item_t
struct mpi_image_info::@0 opal_list_item_t
err_db_tag
@ err_db_tag
Definition: msgq_interface.h:302
mpi_process_info_extra::communicator_list
struct communicator_t * communicator_list
Definition: ompi_msgq_dll_defs.h:100
err_all_communicators
@ err_all_communicators
Definition: msgq_interface.h:329
mqs_pending_operation::desired_length
mqs_tword_t desired_length
Definition: msgq_interface.h:357
mqs_pending_operation::tag_wild
int tag_wild
Definition: msgq_interface.h:355
mpi_image_info::ompi_communicator_t
struct mpi_image_info::@11 ompi_communicator_t
mqs_version_string
char * mqs_version_string(void)
Definition: ompi_msgq_dll.c:194
err_lrank_to_grank
@ err_lrank_to_grank
Definition: msgq_interface.h:323
mqs_process_callbacks
Definition: msgq_interface.h:517
VERBOSE_REQ_DUMP
#define VERBOSE_REQ_DUMP
Definition: ompi_msgq_dll.c:163
err_next
@ err_next
Definition: msgq_interface.h:293
mqs_opal_free_list_t_pos::upper_bound
mqs_taddr_t upper_bound
Definition: ompi_msgq_dll_defs.h:82
communicator_t::comm_info
mqs_communicator comm_info
Definition: ompi_msgq_dll_defs.h:70
mqs_opal_free_list_t_pos::current_item
mqs_taddr_t current_item
Definition: ompi_msgq_dll_defs.h:81
opal_list_t_init_parser
static int opal_list_t_init_parser(mqs_process *proc, mpi_process_info *p_info, mqs_opal_list_t_pos *position, mqs_taddr_t list)
Parsing the opal_list_t.
Definition: ompi_msgq_dll.c:831
mpi_process_info
Definition: ompi_common_dll_defs.h:269
err_count
@ err_count
Definition: msgq_interface.h:314
mpi_process_info_extra::world_proc_array_entries
int world_proc_array_entries
Definition: ompi_msgq_dll_defs.h:115
mpi_process_info_extra::show_internal_requests
mqs_tword_t show_internal_requests
Definition: ompi_msgq_dll_defs.h:111
mqs_pending_operation::status
int status
Definition: msgq_interface.h:352
OMPI_REQUEST_INVALID
@ OMPI_REQUEST_INVALID
Indicates that the request should not be progressed.
Definition: request_dbg.h:39
mqs_next_operation
int mqs_next_operation(mqs_process *proc, mqs_pending_operation *op)
Fetch the next valid operation.
Definition: ompi_msgq_dll.c:1268
mqs_ok
@ mqs_ok
Definition: msgq_interface.h:229
mqs_communicator::local_rank
mqs_tword_t local_rank
Definition: msgq_interface.h:339
mqs_pending_receives
@ mqs_pending_receives
Definition: msgq_interface.h:258
err_lsrc
@ err_lsrc
Definition: msgq_interface.h:291
VERBOSE_COMM
#define VERBOSE_COMM
Definition: ompi_msgq_dll.c:160
mqs_put_process_info
#define mqs_put_process_info
Definition: ompi_common_dll_defs.h:287
err_unexpected
@ err_unexpected
Definition: msgq_interface.h:282
mqs_taddr_t
unsigned long mqs_taddr_t
Definition: msgq_interface.h:194
mpi_process_info_extra::next_msg
mqs_opal_free_list_t_pos next_msg
Definition: ompi_msgq_dll_defs.h:118
mqs_update_communicator_list
int mqs_update_communicator_list(mqs_process *proc)
Update the list of communicators in the process if it has changed.
Definition: ompi_msgq_dll.c:748
err_tagmask
@ err_tagmask
Definition: msgq_interface.h:290
compare_comms
static int compare_comms(const void *a, const void *b)
Comparison function for sorting communicators.
Definition: ompi_msgq_dll.c:579
mqs_target_type_sizes::pointer_size
int pointer_size
Definition: msgq_interface.h:209
mqs_target_type_sizes::short_size
int short_size
Definition: msgq_interface.h:205
err_mpid_sends
@ err_mpid_sends
Definition: msgq_interface.h:330
err_failed_rhandle
@ err_failed_rhandle
Definition: msgq_interface.h:307
err_db_byte_length
@ err_db_byte_length
Definition: msgq_interface.h:304
mpi_image_info::offset
struct mpi_image_info::@0::@15 offset
mqs_target_type_sizes::long_size
int long_size
Definition: msgq_interface.h:207
mqs_ompi_opal_list_t_pos
Definition: ompi_msgq_dll_defs.h:73
mpi_process_info_extra::send_queue_base
mqs_taddr_t send_queue_base
Definition: ompi_msgq_dll_defs.h:103
mqs_fetch_data
#define mqs_fetch_data
Definition: ompi_common_dll_defs.h:302
mqs_basic_callbacks
Call back tables.
Definition: msgq_interface.h:485
mqs_destroy_process_info
void mqs_destroy_process_info(mqs_process_info *mp_info)
Destroy the info.
Definition: ompi_msgq_dll.c:1290
err_tag
@ err_tag
Definition: msgq_interface.h:289
mqs_version_str
static char mqs_version_str[256]
Definition: ompi_msgq_dll.c:191
err_s
@ err_s
Definition: msgq_interface.h:311
mpi_process_info::process_callbacks
const struct mqs_process_callbacks * process_callbacks
Definition: ompi_common_dll_defs.h:270
mqs_pending_operation
Definition: msgq_interface.h:350
VERBOSE_GENERAL
#define VERBOSE_GENERAL
The internal debugging interface.
Definition: ompi_msgq_dll.c:158
mpi_image_info::ompi_status_public_t
struct mpi_image_info::@13 ompi_status_public_t
mqs_get_comm_group
int mqs_get_comm_group(mqs_process *proc, int *group_members)
Get the group information about the current communicator.
Definition: ompi_msgq_dll.c:798
err_silent_failure
@ err_silent_failure
Definition: msgq_interface.h:275
mqs_process_has_queues
int mqs_process_has_queues(mqs_process *proc, char **msg)
Check the process for message queues.
Definition: ompi_msgq_dll.c:501
mqs_pending_sends
@ mqs_pending_sends
Definition: msgq_interface.h:257
mpi_process_info_extra::recv_queue_base
mqs_taddr_t recv_queue_base
Definition: ompi_msgq_dll_defs.h:104
communicators_changed
static int communicators_changed(mqs_process *proc)
Check if the communicators have changed by looking at the pointer array values for lowest_free and nu...
Definition: ompi_msgq_dll.c:527
value
#define value
Definition: btl_openib_lex.c:606
MCA_PML_REQUEST_SEND
@ MCA_PML_REQUEST_SEND
Definition: pml_base_request_dbg.h:25
mqs_opal_free_list_t_pos::fl_frag_alignment
mqs_tword_t fl_frag_alignment
Definition: ompi_msgq_dll_defs.h:88
err_ptr
@ err_ptr
Definition: msgq_interface.h:294
mqs_get_image
#define mqs_get_image
Definition: ompi_common_dll_defs.h:300
mqs_lang_c
@ mqs_lang_c
Definition: msgq_interface.h:248
mqs_image_info
struct _mqs_image_info mqs_image_info
type definitions.
Definition: msgq_interface.h:159
mqs_image_callbacks
Definition: msgq_interface.h:507
err_first
@ err_first
Definition: msgq_interface.h:286
mqs_pending_operation::actual_tag
mqs_tword_t actual_tag
Definition: msgq_interface.h:364
opal_free_list_t_init_parser
static int opal_free_list_t_init_parser(mqs_process *proc, mpi_process_info *p_info, mqs_opal_free_list_t_pos *position, mqs_taddr_t free_list)
Definition: ompi_msgq_dll.c:892
mqs_end_of_list
@ mqs_end_of_list
Definition: msgq_interface.h:231
mpi_image_info::extra
void * extra
Definition: ompi_common_dll_defs.h:262
mpi_image_info::opal_free_list_t
struct mpi_image_info::@3 opal_free_list_t
err_len
@ err_len
Definition: msgq_interface.h:310
opal_free_list_t_next_item
static int opal_free_list_t_next_item(mqs_process *proc, mpi_process_info *p_info, mqs_opal_free_list_t_pos *position, mqs_taddr_t *active_item)
Return the current position and move the internal counter to the next element.
Definition: ompi_msgq_dll.c:986
group_t::entries
int entries
Definition: ompi_msgq_dll_defs.h:59
mpi_process_info_extra::comm_number_free
mqs_tword_t comm_number_free
Definition: ompi_msgq_dll_defs.h:108
pml_base_request_dbg.h
translate
static int translate(group_t *this, int index)
Definition: ompi_msgq_dll.c:216
ompi_fetch_pointer
mqs_taddr_t ompi_fetch_pointer(mqs_process *proc, mqs_taddr_t addr, mpi_process_info *p_info)
Functions to access the image memory.
Definition: ompi_common_dll.c:524
group_decref
static void group_decref(group_t *group)
Definition: ompi_msgq_dll.c:337
err_comm_next
@ err_comm_next
Definition: msgq_interface.h:326
mqs_setup_operation_iterator
int mqs_setup_operation_iterator(mqs_process *proc, int op)
Setup to iterate over pending operations.
Definition: ompi_msgq_dll.c:1236
mpi_image_info::opal_pointer_array_t
struct mpi_image_info::@9 opal_pointer_array_t
snprintf
#define snprintf
Definition: pmix_config_bottom.h:428
group_t::local_to_global
int * local_to_global
Definition: ompi_msgq_dll_defs.h:60
mqs_put_image_info
#define mqs_put_image_info
Definition: ompi_common_dll_defs.h:285
mqs_free
#define mqs_free
Definition: ompi_common_dll_defs.h:283
mqs_st_pending
@ mqs_st_pending
Definition: msgq_interface.h:270
DEBUG
#define DEBUG(LEVEL, WHAT)
Definition: ompi_msgq_dll.c:170
mpi_image_info::ompi_request_t
struct mpi_image_info::@5 ompi_request_t
mqs_tword_t
long mqs_tword_t
Definition: msgq_interface.h:195
mpi_process_info_extra::what
mqs_op_class what
Definition: ompi_msgq_dll_defs.h:119
mqs_opal_free_list_t_pos::header_space
mqs_tword_t header_space
Definition: ompi_msgq_dll_defs.h:83
err_db_next
@ err_db_next
Definition: msgq_interface.h:305
mqs_opal_free_list_t_pos::free_list
mqs_taddr_t free_list
Definition: ompi_msgq_dll_defs.h:84
mqs_pending_operation::extra_text
char extra_text[5][64]
Definition: msgq_interface.h:376
err_context_id
@ err_context_id
Definition: msgq_interface.h:288
mqs_dll_error_string
char * mqs_dll_error_string(int errcode)
Definition: ompi_msgq_dll.c:1326
MCA_PML_REQUEST_RECV
@ MCA_PML_REQUEST_RECV
Definition: pml_base_request_dbg.h:26
FALSE
#define FALSE
Definition: ompi_msgq_dll.c:142
err_failed_status
@ err_failed_status
Definition: msgq_interface.h:313
mpi_process_info_extra
Definition: ompi_msgq_dll_defs.h:99
err_MPI_SOURCE
@ err_MPI_SOURCE
Definition: msgq_interface.h:315
next_item_opal_list_t
static int next_item_opal_list_t(mqs_process *proc, mpi_process_info *p_info, mqs_opal_list_t_pos *position, mqs_taddr_t *active_item)
Definition: ompi_msgq_dll.c:850
mpi_image_info
Copyright (C) 2000-2004 by Etnus, LLC.
Definition: ompi_common_dll_defs.h:51
VERBOSE_REQ
#define VERBOSE_REQ
Definition: ompi_msgq_dll.c:162
mqs_opal_free_list_t_pos::opal_list_t_pos
mqs_opal_list_t_pos opal_list_t_pos
Definition: ompi_msgq_dll_defs.h:80
communicator_t::present
int present
Definition: ompi_msgq_dll_defs.h:69
ompi_fetch_size_t
mqs_taddr_t ompi_fetch_size_t(mqs_process *proc, mqs_taddr_t addr, mpi_process_info *p_info)
Definition: ompi_common_dll.c:567
mqs_opal_free_list_t_pos::fl_frag_class
mqs_tword_t fl_frag_class
Definition: ompi_msgq_dll_defs.h:85
mqs_get_image_info
#define mqs_get_image_info
Definition: ompi_common_dll_defs.h:286
mqs_pending_operation::desired_global_rank
mqs_tword_t desired_global_rank
Definition: msgq_interface.h:354
err_failed_qhdr
@ err_failed_qhdr
Definition: msgq_interface.h:281
mqs_find_symbol
#define mqs_find_symbol
Definition: ompi_common_dll_defs.h:298
OMPI_REQUEST_PML
@ OMPI_REQUEST_PML
MPI point-to-point request.
Definition: request_dbg.h:23
err_buf
@ err_buf
Definition: msgq_interface.h:309
mqs_setup_image
int mqs_setup_image(mqs_image *image, const mqs_image_callbacks *icb)
Perform basic setup for the image, we just allocate and clear our info.
Definition: ompi_msgq_dll.c:352
TRUE
#define TRUE
Definition: ompi_msgq_dll.c:139
mqs_process
struct mqs_process_ mqs_process
Definition: msgq_interface.h:170
err_db_target
@ err_db_target
Definition: msgq_interface.h:301
mpi_image_info::size
int size
Definition: ompi_common_dll_defs.h:58
mpi_process_info_extra::comm_lowest_free
mqs_tword_t comm_lowest_free
Definition: ompi_msgq_dll_defs.h:110
process
static int process(char *orig_line, char *basename, opal_cmd_line_t *cmd_line, int argc, char **argv, char ***new_argv, int num_procs)
Definition: orted_submit.c:2675
mqs_opal_free_list_t_pos::fl_num_per_alloc
mqs_tword_t fl_num_per_alloc
Definition: ompi_msgq_dll_defs.h:89
mpi_process_info_extra::commlist_base
mqs_taddr_t commlist_base
Definition: ompi_msgq_dll_defs.h:106
err_sequence_number
@ err_sequence_number
Definition: msgq_interface.h:319
err_failed_communicator
@ err_failed_communicator
Definition: msgq_interface.h:322
mqs_destroy_image_info
void mqs_destroy_image_info(mqs_image_info *info)
Free off the data we associated with an image.
Definition: ompi_msgq_dll.c:1319
MQS_INTERFACE_COMPATIBILITY
@ MQS_INTERFACE_COMPATIBILITY
Definition: msgq_interface.h:137
mpi_image_info::ompi_group_t
struct mpi_image_info::@10 ompi_group_t
mpi_process_info_extra::current_communicator
struct communicator_t * current_communicator
Definition: ompi_msgq_dll_defs.h:113
err_missing_symbol
@ err_missing_symbol
Definition: msgq_interface.h:297
mqs_st_matched
@ mqs_st_matched
Definition: msgq_interface.h:270
mpi_process_info::extra
void * extra
Definition: ompi_common_dll_defs.h:275
mqs_no_information
@ mqs_no_information
Definition: msgq_interface.h:230
err_is_complete
@ err_is_complete
Definition: msgq_interface.h:308
mqs_malloc
#define mqs_malloc
Definition: ompi_common_dll_defs.h:282
mqs_ompi_opal_list_t_pos::list
mqs_taddr_t list
Definition: ompi_msgq_dll_defs.h:75
mqs_target_type_sizes::bool_size
int bool_size
Definition: msgq_interface.h:210
mqs_communicator::name
char name[64]
Definition: msgq_interface.h:341
ompi_get_lib_version
int ompi_get_lib_version(char *buf, int size)
Definition: ompi_common_dll.c:635
err_no_store
@ err_no_store
Definition: msgq_interface.h:279
mqs_pending_operation::actual_length
mqs_tword_t actual_length
Definition: msgq_interface.h:365
mpi_image_info::mca_pml_base_send_request_t
struct mpi_image_info::@7 mca_pml_base_send_request_t
mqs_find_function
#define mqs_find_function
Definition: ompi_common_dll_defs.h:297
mqs_basic_entrypoints
const mqs_basic_callbacks * mqs_basic_entrypoints
Copyright (C) 2000-2004 by Etnus, LLC.
Definition: ompi_common_dll.c:50
mqs_ompi_opal_list_t_pos::current_item
mqs_taddr_t current_item
Definition: ompi_msgq_dll_defs.h:74
mqs_target_type_sizes::size_t_size
int size_t_size
Definition: msgq_interface.h:211
ompi_fetch_bool
mqs_tword_t ompi_fetch_bool(mqs_process *proc, mqs_taddr_t addr, mpi_process_info *p_info)
Definition: ompi_common_dll.c:556
err_comm_name
@ err_comm_name
Definition: msgq_interface.h:327
mqs_next_communicator
int mqs_next_communicator(mqs_process *proc)
Step to the next communicator.
Definition: ompi_msgq_dll.c:819
ompi_fetch_int
mqs_tword_t ompi_fetch_int(mqs_process *proc, mqs_taddr_t addr, mpi_process_info *p_info)
Definition: ompi_common_dll.c:540
fetch_request
static int fetch_request(mqs_process *proc, mpi_process_info *p_info, mqs_pending_operation *res, int look_for_user_buffer)
Handle the send queue as well as the receive queue.
Definition: ompi_msgq_dll.c:1073
mqs_get_process_info
#define mqs_get_process_info
Definition: ompi_common_dll_defs.h:288
mqs_get_type_sizes
#define mqs_get_type_sizes
Definition: ompi_common_dll_defs.h:296
OMPI_GROUP_DENSE
#define OMPI_GROUP_DENSE
Definition: group_dbg.h:24
VERBOSE
#define VERBOSE
Definition: ompi_msgq_dll.c:165
err_failed_queue
@ err_failed_queue
Definition: msgq_interface.h:285
request_dbg.h
mqs_opal_free_list_t_pos
Definition: ompi_msgq_dll_defs.h:79
mqs_communicator
Definition: msgq_interface.h:337
group_t
Copyright (C) 2000-2004 by Etnus, LLC.
Definition: ompi_msgq_dll_defs.h:56
mpi_process_info_extra::world_proc_array
mqs_taddr_t * world_proc_array
Definition: ompi_msgq_dll_defs.h:116
msgq_interface.h
mqs_unexpected_messages
@ mqs_unexpected_messages
Definition: msgq_interface.h:259
communicator_t::next
struct communicator_t * next
Definition: ompi_msgq_dll_defs.h:66
err_posted
@ err_posted
Definition: msgq_interface.h:283
mqs_pending_operation::actual_global_rank
mqs_tword_t actual_global_rank
Definition: msgq_interface.h:363
OMPI_MAX_VER_SIZE
#define OMPI_MAX_VER_SIZE
Definition: ompi_common_dll_defs.h:335
mqs_communicator::size
mqs_tword_t size
Definition: msgq_interface.h:340
ompi_config.h
communicator_t::comm_ptr
mqs_taddr_t comm_ptr
Definition: ompi_msgq_dll_defs.h:68
mqs_version_compatibility
int mqs_version_compatibility(void)
Definition: ompi_msgq_dll.c:186
err_missing_type
@ err_missing_type
Definition: msgq_interface.h:296
err_MPI_TAG
@ err_MPI_TAG
Definition: msgq_interface.h:316
err_comm_first
@ err_comm_first
Definition: msgq_interface.h:320
err_db_data
@ err_db_data
Definition: msgq_interface.h:303
mqs_setup_process
int mqs_setup_process(mqs_process *process, const mqs_process_callbacks *pcb)
Setup information needed for a specific process.
Definition: ompi_msgq_dll.c:412
err_srcmask
@ err_srcmask
Definition: msgq_interface.h:292
err_bad_request
@ err_bad_request
Definition: msgq_interface.h:278
mpi_process_info::sizes
mqs_target_type_sizes sizes
Definition: ompi_common_dll_defs.h:272
mqs_target_to_host
#define mqs_target_to_host
Definition: ompi_common_dll_defs.h:303
communicator_t
Definition: ompi_msgq_dll_defs.h:65
mqs_pending_operation::buffer
mqs_taddr_t buffer
Definition: msgq_interface.h:359
err_send_context
@ err_send_context
Definition: msgq_interface.h:324
mqs_setup_communicator_iterator
int mqs_setup_communicator_iterator(mqs_process *proc)
Setup to iterate over communicators.
Definition: ompi_msgq_dll.c:760
MQS_INVALID_PROCESS
@ MQS_INVALID_PROCESS
Definition: msgq_interface.h:265
mpi_image_info::opal_list_t
struct mpi_image_info::@1 opal_list_t
err_db_comm
@ err_db_comm
Definition: msgq_interface.h:300
NULL
#define NULL
Copyright (C) 2000-2004 by Etnus, LLC.
Definition: ompi_msgq_dll.c:136
mqs_pending_operation::actual_local_rank
mqs_tword_t actual_local_rank
Definition: msgq_interface.h:362
mqs_process_info
struct _mqs_process_info mqs_process_info
Definition: msgq_interface.h:160
group_dbg.h
mpi_image_info::mca_pml_base_recv_request_t
struct mpi_image_info::@8 mca_pml_base_recv_request_t
find_communicator
static communicator_t * find_communicator(mpi_process_info *p_info, int recv_ctx)
Find a matching communicator on our list.
Definition: ompi_msgq_dll.c:562
mqs_communicator::unique_id
mqs_taddr_t unique_id
Definition: msgq_interface.h:338