/* * Copyright (c) 2007-2008 Cisco Systems, Inc. All rights reserved. * Copyright (c) 2004-2010 The University of Tennessee and The University * of Tennessee Research Foundation. All rights * reserved. * Copyright (c) 2008-2009 Sun Microsystems, Inc. All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow * * $HEADER$ */ /********************************************************************** * Copyright (C) 2000-2004 by Etnus, LLC. * Copyright (C) 1999 by Etnus, Inc. * Copyright (C) 1997-1998 Dolphin Interconnect Solutions Inc. * * Permission is hereby granted to use, reproduce, prepare derivative * works, and to redistribute to others. * * DISCLAIMER * * Neither Dolphin Interconnect Solutions, Etnus LLC, nor any of their * employees, makes any warranty express or implied, or assumes any * legal liability or responsibility for the accuracy, completeness, * or usefulness of any information, apparatus, product, or process * disclosed, or represents that its use would not infringe privately * owned rights. * * This code was written by * James Cownie: Dolphin Interconnect Solutions. * Etnus LLC **********************************************************************/ /* Update log * * Jul 12 2001 FNW: Add a meaningful ID to the communicator name, and switch * to using the recv_context as the unique_id field. * Mar 6 2001 JHC: Add mqs_get_comm_group to allow a debugger to acquire * processes less eagerly. * Dec 13 2000 JHC: totalview/2514: Modify image_has_queues to return * a silent FALSE if none of the expected data is * present. This way you won't get complaints when * you try this on non MPICH processes. * Sep 8 2000 JVD: #include to silence Linux Alpha compiler warnings. * Mar 21 2000 JHC: Add the new entrypoint mqs_dll_taddr_width * Nov 26 1998 JHC: Fix the problem that we weren't handling * MPIR_Ignore_queues properly. * Oct 22 1998 JHC: Fix a zero allocation problem * Aug 19 1998 JHC: Fix some problems in our use of target_to_host on * big endian machines. * May 28 1998 JHC: Use the extra information we can return to say * explicitly that sends are only showing non-blocking ops * May 19 1998 JHC: Changed the names of the structs and added casts * where needed to reflect the change to the way we handle * type safety across the interface. * Oct 27 1997 JHC: Created by exploding db_message_state_mpich.cxx */ /* The following was added by William Gropp to improve the portability to systems with non-ANSI C compilers */ #include "ompi_config.h" #ifdef HAVE_NO_C_CONST #define const #endif #if defined(HAVE_STRING_H) #include #endif /* defined(HAVE_STRING_H) */ #if defined(HAVE_STDLIB_H) #include #endif /* defined(HAVE_STDLIB_H) */ /* Notice to developers!!!! * The following include files with _dbg.h suffixes contains definitions * that are shared between the debuggger plugins and the OMPI code base. * This is done instead of including the non-_dbg suffixed files because * of the different way compilers may handle extern definitions. The * particular case that is causing problems is when there is an extern * variable or function that is accessed in a static inline function. * For example, here is the code we often see in a header file. * * extern int request_complete; * static inline check_request(void) { * request_complete = 1; * } * * If this code exists in a header file and gets included in a source * file, then some compilers expect to have request_complete defined * somewhere even if request_complete is never referenced and * check_request is never called. Other compilers do not need them defined * if they are never referenced in the source file. * * In the case of extern functions we something like the following: * * extern int foo(); * static inline bar(void) { * foo(); * } * * If this code exists it actually compiles fine however an undefined symbol * is kept for foo() and in the case of some tools that load in plugins with * RTLD_NOW this undefined symbol causes the dlopen to fail since we do not * have (nor really need) the supporting library containing foo(). * * Therefore, to handle cases like the above with compilers that require the * symbols (like Sun Studio) instead of pulling in all of OMPI into the * plugins or defining dummy symbols here we separate the definitions used by * both sets of code into the _dbg.h files. * * This means if one needs to add another definition that the plugins must see * one should either move the definition into one of the existing _dbg.h file or * create a new _dbg.h file. */ #include "ompi/group/group_dbg.h" #include "ompi/request/request_dbg.h" #include "ompi/mca/pml/base/pml_base_request_dbg.h" #include "mpi.h" /* needed for MPI_ANY_TAG */ #include "msgq_interface.h" #include "ompi_msgq_dll_defs.h" /* End of inclusion */ /* Essential macros for C */ #ifndef NULL #define NULL ((void *)0) #endif #ifndef TRUE #define TRUE (0==0) #endif #ifndef FALSE #define FALSE (0==1) #endif #ifdef OLD_STYLE_CPP_CONCAT #define concat(a,b) a/**/b #define stringize(a) "a" #else #define concat(a,b) a##b #define stringize(a) #a #endif #define OPAL_ALIGN(x,a,t) (((x)+((t)(a)-1)) & ~(((t)(a)-1))) /** * The internal debugging interface. */ #define VERBOSE_GENERAL 0x00000001 #define VERBOSE_GROUP 0x00000002 #define VERBOSE_COMM 0x00000004 #define VERBOSE_LISTS 0x00000008 #define VERBOSE_REQ 0x00000010 #define VERBOSE_REQ_DUMP 0x00000020 #define VERBOSE 0x00000000 #if VERBOSE #define DEBUG(LEVEL, WHAT) if(LEVEL & VERBOSE) { printf WHAT; } #else #define DEBUG(LEVEL,WHAT) #endif /* VERBOSE */ /**********************************************************************/ /* Set up the basic callbacks into the debugger */ void mqs_setup_basic_callbacks (const mqs_basic_callbacks * cb) { mqs_basic_entrypoints = cb; } /* mqs_setup_callbacks */ /**********************************************************************/ /* Version handling functions. * This one should never be changed. */ int mqs_version_compatibility (void) { return MQS_INTERFACE_COMPATIBILITY; } /* mqs_version_compatibility */ /* This one can say what you like */ char *mqs_version_string (void) { return "Open MPI message queue support for parallel" " debuggers compiled on " __DATE__; } /* mqs_version_string */ /* So the debugger can tell what interface width the library was compiled with */ int mqs_dll_taddr_width (void) { return sizeof (mqs_taddr_t); } /* mqs_dll_taddr_width */ /**********************************************************************/ /* Functions to handle translation groups. * We have a list of these on the process info, so that we can * share the group between multiple communicators. */ /**********************************************************************/ /* Translate a process number */ static int translate (group_t *this, int index) { if (index == MQS_INVALID_PROCESS || ((unsigned int)index) >= ((unsigned int) this->entries)) return MQS_INVALID_PROCESS; return this->local_to_global[index]; } /* translate */ /**********************************************************************/ /* Search the group list for this group, if not found create it. */ static group_t * find_or_create_group( mqs_process *proc, mqs_taddr_t group_base ) { mpi_process_info *p_info = (mpi_process_info *)mqs_get_process_info (proc); mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; mqs_image * image = mqs_get_image (proc); mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image); communicator_t *comm = extra->communicator_list; int *tr; char *trbuffer; int i, np, is_dense; group_t *group; mqs_taddr_t value; mqs_taddr_t tablep; np = ompi_fetch_int( proc, group_base + i_info->ompi_group_t.offset.grp_proc_count, p_info ); if( np < 0 ) { DEBUG(VERBOSE_COMM, ("Get a size for the communicator = %d\n", np)); return NULL; /* Makes no sense ! */ } is_dense = ompi_fetch_int( proc, group_base + i_info->ompi_group_t.offset.grp_flags, p_info ); is_dense = (0 != (is_dense & OMPI_GROUP_DENSE)); /* Iterate over each communicator seeing if we can find this group */ for (;comm; comm = comm->next) { group = comm->group; if( group && (group->group_base == group_base) ) { group->ref_count++; /* Someone else is interested */ DEBUG(VERBOSE_GROUP, ("Increase refcount for group 0x%p to %d\n", (void*)group, group->ref_count) ); return group; } } /* Hmm, couldn't find one, so fetch it */ group = (group_t *)mqs_malloc (sizeof (group_t)); tr = (int *)mqs_malloc (np*sizeof(int)); trbuffer = (char *)mqs_malloc (np*sizeof(mqs_taddr_t)); group->local_to_global = tr; group->group_base = group_base; DEBUG(VERBOSE_GROUP, ("Create a new group 0x%p with %d members\n", (void*)group, np) ); tablep = ompi_fetch_pointer( proc, group_base + i_info->ompi_group_t.offset.grp_proc_pointers, p_info); if( (0 != np) && (mqs_ok != mqs_fetch_data(proc, tablep, np * p_info->sizes.pointer_size, trbuffer)) ) { DEBUG(VERBOSE_GROUP,("Failed to read the proc data. Destroy group %p\n", (void*)group)); mqs_free (group); mqs_free (tr); mqs_free (trbuffer); return NULL; } /** * Now convert the process representation into the local representation. * We will endup with an array of Open MPI internal pointers to proc * structure. By comparing this pointers to the MPI_COMM_WORLD group * we can figure out the global rank in the MPI_COMM_WORLD of the process. * * Note that this only works for dense groups. Someday we may * support more than dense groups, but that's what we've got for * today. */ if( NULL == extra->world_proc_array ) { extra->world_proc_array = mqs_malloc( np * sizeof(mqs_taddr_t) ); for( i = 0; i < np; i++ ) { mqs_target_to_host( proc, trbuffer + p_info->sizes.pointer_size*i, &value, p_info->sizes.pointer_size ); extra->world_proc_array[i] = value; group->local_to_global[i] = is_dense ? i : -1; } extra->world_proc_array_entries = np; } else { int j; for( i = 0; i < np; i++ ) { mqs_target_to_host( proc, trbuffer + p_info->sizes.pointer_size*i, &value, p_info->sizes.pointer_size ); if (is_dense) { /* get the global rank this MPI process */ for( j = 0; j < extra->world_proc_array_entries; j++ ) { if( value == extra->world_proc_array[j] ) { group->local_to_global[i] = j; break; } } } else { group->local_to_global[i] = -1; } } } mqs_free(trbuffer); group->entries = np; group->ref_count = 1; return group; } /* find_or_create_group */ /***********************************************************************/ static void group_decref (group_t * group) { DEBUG(VERBOSE_GROUP, ("Decrement reference count for group %p to %d\n", (void*)group, (group->ref_count - 1))); if (--(group->ref_count) == 0) { mqs_free (group->local_to_global); DEBUG(VERBOSE_GROUP, ("Destroy group %p\n", (void*)group)); mqs_free (group); } } /* group_decref */ /*********************************************************************** * Perform basic setup for the image, we just allocate and clear * our info. */ int mqs_setup_image (mqs_image *image, const mqs_image_callbacks *icb) { mpi_image_info *i_info = (mpi_image_info *)mqs_malloc (sizeof (mpi_image_info)); if (!i_info) return err_no_store; memset ((void *)i_info, 0, sizeof (mpi_image_info)); i_info->image_callbacks = icb; /* Before we do *ANYTHING* */ i_info->extra = NULL; mqs_put_image_info (image, (mqs_image_info *)i_info); return mqs_ok; } /* mqs_setup_image */ /*********************************************************************** * Check for all the information we require to access the Open MPI message queues. * Stash it into our structure on the image if we're successful. */ int mqs_image_has_queues (mqs_image *image, char **message) { mpi_image_info * i_info = (mpi_image_info *)mqs_get_image_info (image); i_info->extra = NULL; /* Default failure message ! */ *message = "The symbols and types in the Open MPI library used by the debugger\n" "to extract the message queues are not as expected in\n" "the image '%s'\n" "No message queue display is possible.\n" "This is probably an Open MPI version or configuration problem."; /* Force in the file containing our breakpoint function, to ensure * that types have been read from there before we try to look them * up. */ mqs_find_function (image, "MPIR_Breakpoint", mqs_lang_c, NULL); /* Are we supposed to ignore this ? (e.g. it's really an HPF * runtime using the Open MPI process acquisition, but not wanting * queue display) */ if (mqs_find_symbol (image, "MPIR_Ignore_queues", NULL) == mqs_ok) { *message = NULL; /* Fail silently */ return err_silent_failure; } /* Fill in the type information */ return ompi_fill_in_type_info(image, message); } /* mqs_image_has_queues */ /*********************************************************************** * Setup information needed for a specific process. * TV assumes that this will hang something onto the process, * if nothing is attached to it, then TV will believe that this process * has no message queue information. */ int mqs_setup_process (mqs_process *process, const mqs_process_callbacks *pcb) { /* Extract the addresses of the global variables we need and save them away */ mpi_process_info *p_info = (mpi_process_info *)mqs_malloc (sizeof (mpi_process_info)); if (p_info) { mqs_image *image; mpi_image_info *i_info; mpi_process_info_extra *extra; p_info->process_callbacks = pcb; p_info->extra = mqs_malloc(sizeof(mpi_process_info_extra)); extra = (mpi_process_info_extra*) p_info->extra; /* Now we can get the rest of the info ! */ image = mqs_get_image (process); i_info = (mpi_image_info *)mqs_get_image_info (image); /* We have no communicators yet */ extra->communicator_list = NULL; /* Enforce the generation of the communicators list */ extra->comm_lowest_free = 0; extra->comm_number_free = 0; /* By default we don't show our internal requests*/ extra->show_internal_requests = 0; extra->world_proc_array_entries = 0; extra->world_proc_array = NULL; mqs_get_type_sizes (process, &p_info->sizes); /* * Before going any further make sure we know exactly how the * Open MPI library was compiled. This means we know the size * of each of the basic types as stored in the * MPIR_debug_typedefs_sizeof array. */ { mqs_taddr_t typedefs_sizeof; if(mqs_find_symbol (image, "MPIR_debug_typedefs_sizeof", &typedefs_sizeof) != mqs_ok) return err_no_store; p_info->sizes.short_size = ompi_fetch_int( process, /* sizeof (short) */ typedefs_sizeof, p_info ); typedefs_sizeof += p_info->sizes.int_size; p_info->sizes.int_size = ompi_fetch_int( process, /* sizeof (int) */ typedefs_sizeof, p_info ); typedefs_sizeof += p_info->sizes.int_size; p_info->sizes.long_size = ompi_fetch_int( process, /* sizeof (long) */ typedefs_sizeof, p_info ); typedefs_sizeof += p_info->sizes.int_size; p_info->sizes.long_long_size = ompi_fetch_int( process, /* sizeof (long long) */ typedefs_sizeof, p_info ); typedefs_sizeof += p_info->sizes.int_size; p_info->sizes.pointer_size = ompi_fetch_int( process, /* sizeof (void *) */ typedefs_sizeof, p_info ); typedefs_sizeof += p_info->sizes.int_size; p_info->sizes.bool_size = ompi_fetch_int( process, /* sizeof (bool) */ typedefs_sizeof, p_info ); typedefs_sizeof += p_info->sizes.int_size; p_info->sizes.size_t_size = ompi_fetch_int( process, /* sizeof (size_t) */ typedefs_sizeof, p_info ); DEBUG( VERBOSE_GENERAL, ("sizes short = %d int = %d long = %d long long = %d " "void* = %d bool = %d size_t = %d\n", p_info->sizes.short_size, p_info->sizes.int_size, p_info->sizes.long_size, p_info->sizes.long_long_size, p_info->sizes.pointer_size, p_info->sizes.bool_size, p_info->sizes.size_t_size) ); } mqs_put_process_info (process, (mqs_process_info *)p_info); return mqs_ok; } return err_no_store; } /* mqs_setup_process */ /*********************************************************************** * Check the process for message queues. */ int mqs_process_has_queues (mqs_process *proc, char **msg) { mpi_process_info *p_info = (mpi_process_info *)mqs_get_process_info (proc); mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; mqs_image * image = mqs_get_image (proc); mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image); /* Don't bother with a pop up here, it's unlikely to be helpful */ *msg = 0; DEBUG(VERBOSE_GENERAL,("checking the status of the OMPI dll\n")); if (mqs_find_symbol (image, "ompi_mpi_communicators", &extra->commlist_base) != mqs_ok) return err_all_communicators; if (mqs_find_symbol (image, "mca_pml_base_send_requests", &extra->send_queue_base) != mqs_ok) return err_mpid_sends; if (mqs_find_symbol (image, "mca_pml_base_recv_requests", &extra->recv_queue_base) != mqs_ok) return err_mpid_recvs; DEBUG(VERBOSE_GENERAL,("process_has_queues returned success\n")); return mqs_ok; } /* mqs_process_has_queues */ /*********************************************************************** * Check if the communicators have changed by looking at the * pointer array values for lowest_free and number_free. */ static int communicators_changed (mqs_process *proc) { mpi_process_info *p_info = (mpi_process_info *)mqs_get_process_info (proc); mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; mqs_image * image = mqs_get_image (proc); mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image); mqs_tword_t number_free; /* the number of available positions in * the communicator array. */ mqs_tword_t lowest_free; /* the lowest free communicator */ lowest_free = ompi_fetch_int( proc, extra->commlist_base + i_info->opal_pointer_array_t.offset.lowest_free, p_info ); number_free = ompi_fetch_int( proc, extra->commlist_base + i_info->opal_pointer_array_t.offset.number_free, p_info ); if( (lowest_free != extra->comm_lowest_free) || (number_free != extra->comm_number_free) ) { DEBUG(VERBOSE_COMM, ("Recreate the communicator list\n" " lowest_free [current] %d != [stored] %d\n" " number_free [current] %d != [stored] %d\n", (int)lowest_free, (int)extra->comm_lowest_free, (int)number_free, (int)extra->comm_number_free) ); return 1; } DEBUG(VERBOSE_COMM, ("Communicator list not modified\n") ); return 0; } /* mqs_communicators_changed */ /*********************************************************************** * Find a matching communicator on our list. We check the recv context * as well as the address since the communicator structures may be * being re-allocated from a free list, in which case the same * address will be re-used a lot, which could confuse us. */ static communicator_t * find_communicator( mpi_process_info *p_info, int recv_ctx ) { mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; communicator_t * comm = extra->communicator_list; for( ; comm; comm = comm->next ) { if( comm->comm_info.unique_id == (mqs_taddr_t)recv_ctx ) return comm; } return NULL; } /* find_communicator */ /*********************************************************************** * Comparison function for sorting communicators. */ static int compare_comms (const void *a, const void *b) { communicator_t * ca = *(communicator_t **)a; communicator_t * cb = *(communicator_t **)b; return cb->comm_info.unique_id - ca->comm_info.unique_id; } /* compare_comms */ /*********************************************************************** * Rebuild our list of communicators because something has changed */ static int rebuild_communicator_list (mqs_process *proc) { mpi_process_info *p_info = (mpi_process_info *)mqs_get_process_info (proc); mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; mqs_image * image = mqs_get_image (proc); mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image); communicator_t **commp, *old; int i, commcount = 0, context_id, local_rank; mqs_tword_t comm_size, lowest_free, number_free; mqs_taddr_t comm_addr_base; mqs_taddr_t comm_ptr; DEBUG(VERBOSE_COMM,("rebuild_communicator_list called " "(commlist_base %llx, array offset %ld array size %d)\n", (long long)extra->commlist_base, (long)i_info->opal_pointer_array_t.offset.addr, i_info->opal_pointer_array_t.size)); /** * Start by getting the number of registered communicators in the * global communicator array. */ comm_size = ompi_fetch_int( proc, extra->commlist_base + i_info->opal_pointer_array_t.offset.size, p_info ); lowest_free = ompi_fetch_int( proc, extra->commlist_base + i_info->opal_pointer_array_t.offset.lowest_free, p_info ); number_free = ompi_fetch_int( proc, extra->commlist_base + i_info->opal_pointer_array_t.offset.number_free, p_info ); extra->comm_lowest_free = lowest_free; extra->comm_number_free = number_free; DEBUG(VERBOSE_COMM,("Number of coms %d lowest_free %d number_free %d\n", (int)comm_size, (int)lowest_free, (int)number_free)); /* In Open MPI the MPI_COMM_WORLD is always at index 0. By default, the * MPI_COMM_WORLD will never get modified. Except, when the fault tolerance * features are enabled in Open MPI. Therefore, we will regenerate the * list of proc pointers every time we rescan the communicators list. * We can use the fact that MPI_COMM_WORLD is at index 0 to force the * creation of the world_proc_array. */ extra->world_proc_array_entries = 0; mqs_free( extra->world_proc_array ); extra->world_proc_array = NULL; /* Now get the pointer to the array of pointers to communicators */ comm_addr_base = ompi_fetch_pointer( proc, extra->commlist_base + i_info->opal_pointer_array_t.offset.addr, p_info ); DEBUG(VERBOSE_COMM,("Array of communicators starting at 0x%llx (sizeof(mqs_taddr_t*) = %d)\n", (long long)comm_addr_base, (int)sizeof(mqs_taddr_t))); for( i = 0; (commcount < (comm_size - number_free)) && (i < comm_size); i++ ) { /* Get the communicator pointer */ comm_ptr = ompi_fetch_pointer( proc, comm_addr_base + i * p_info->sizes.pointer_size, p_info ); DEBUG(VERBOSE_GENERAL,("Fetch communicator pointer 0x%llx\n", (long long)comm_ptr)); if( 0 == comm_ptr ) continue; commcount++; /* Now let's grab the data we want from inside */ DEBUG(VERBOSE_GENERAL, ("Retrieve context_id from 0x%llx and local_rank from 0x%llx\n", (long long)(comm_ptr + i_info->ompi_communicator_t.offset.c_contextid), (long long)(comm_ptr + i_info->ompi_communicator_t.offset.c_my_rank))); context_id = ompi_fetch_int( proc, comm_ptr + i_info->ompi_communicator_t.offset.c_contextid, p_info ); local_rank = ompi_fetch_int( proc, comm_ptr + i_info->ompi_communicator_t.offset.c_my_rank, p_info ); /* Do we already have this communicator ? */ old = find_communicator(p_info, context_id); if( NULL == old ) { mqs_taddr_t group_base; old = (communicator_t *)mqs_malloc (sizeof (communicator_t)); /* Save the results */ old->next = extra->communicator_list; extra->communicator_list = old; old->comm_ptr = comm_ptr; old->comm_info.unique_id = context_id; old->comm_info.local_rank = local_rank; old->group = NULL; DEBUG(VERBOSE_COMM,("Create new communicator 0x%lx with context_id %d and local_rank %d\n", (long)old, context_id, local_rank)); /* Now get the information about the group */ group_base = ompi_fetch_pointer( proc, comm_ptr + i_info->ompi_communicator_t.offset.c_local_group, p_info ); old->group = find_or_create_group( proc, group_base ); } mqs_fetch_data( proc, comm_ptr + i_info->ompi_communicator_t.offset.c_name, 64, old->comm_info.name ); if( NULL != old->group ) { old->comm_info.size = old->group->entries; } old->present = TRUE; DEBUG(VERBOSE_COMM,("Communicator 0x%llx %d local_rank %d name %s group %p\n", (long long)old->comm_ptr, (int)old->comm_info.unique_id, (int)old->comm_info.local_rank, old->comm_info.name, (void*)old->group)); } /* Now iterate over the list tidying up any communicators which * no longer exist, and cleaning the flags on any which do. */ commp = &extra->communicator_list; commcount = 0; for (; *commp; ) { communicator_t *comm = *commp; if (comm->present) { comm->present = FALSE; commcount++; DEBUG(VERBOSE_COMM, ("Keep communicator 0x%llx name %s\n", (long long)comm->comm_ptr, comm->comm_info.name)); commp = &(*commp)->next; /* go to the next communicator */ } else { /* It needs to be deleted */ *commp = comm->next; /* Remove from the list, *commp now points to the next */ DEBUG(VERBOSE_COMM, ("Remove communicator 0x%llx name %s (group %p)\n", (long long)comm->comm_ptr, comm->comm_info.name, (void*)comm->group)); group_decref (comm->group); /* Group is no longer referenced from here */ mqs_free (comm); } } if (commcount) { /* Sort the list so that it is displayed in some semi-sane order. */ communicator_t ** comm_array = (communicator_t **) mqs_malloc(commcount * sizeof (communicator_t *)); communicator_t *comm = extra->communicator_list; for (i=0; inext) comm_array [i] = comm; /* Do the sort */ qsort (comm_array, commcount, sizeof (communicator_t *), compare_comms); /* Rebuild the list */ extra->communicator_list = NULL; for (i=0; inext = extra->communicator_list; extra->communicator_list = comm; } mqs_free (comm_array); } return mqs_ok; } /* rebuild_communicator_list */ /*********************************************************************** * Update the list of communicators in the process if it has changed. */ int mqs_update_communicator_list (mqs_process *proc) { if (communicators_changed (proc)) return rebuild_communicator_list (proc); return mqs_ok; } /* mqs_update_communicator_list */ /*********************************************************************** * Setup to iterate over communicators. * This is where we check whether our internal communicator list needs * updating and if so do it. */ int mqs_setup_communicator_iterator (mqs_process *proc) { mpi_process_info *p_info = (mpi_process_info *)mqs_get_process_info (proc); mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; /* Start at the front of the list again */ extra->current_communicator = extra->communicator_list; /* Reset the operation iterator too */ extra->next_msg.free_list = 0; extra->next_msg.current_item = 0; extra->next_msg.opal_list_t_pos.list = 0; DEBUG(VERBOSE_COMM,("mqs_setup_communicator_iterator called\n")); return extra->current_communicator == NULL ? mqs_end_of_list : mqs_ok; } /* mqs_setup_communicator_iterator */ /*********************************************************************** * Fetch information about the current communicator. */ int mqs_get_communicator (mqs_process *proc, mqs_communicator *comm) { mpi_process_info *p_info = (mpi_process_info *)mqs_get_process_info (proc); mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; if (extra->current_communicator) { *comm = extra->current_communicator->comm_info; DEBUG(VERBOSE_COMM,("mqs_get_communicator %d local_rank %d name %s\n", (int)comm->unique_id, (int)comm->local_rank, comm->name)); return mqs_ok; } DEBUG(VERBOSE_COMM,("No more communicators for this iteration\n")); return err_no_current_communicator; } /* mqs_get_communicator */ /*********************************************************************** * Get the group information about the current communicator. */ int mqs_get_comm_group (mqs_process *proc, int *group_members) { mpi_process_info *p_info = (mpi_process_info *)mqs_get_process_info (proc); mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; communicator_t *comm = extra->current_communicator; if (comm && comm->group) { group_t * g = comm->group; int i; for (i=0; ientries; i++) group_members[i] = g->local_to_global[i]; return mqs_ok; } return err_no_current_communicator; } /* mqs_get_comm_group */ /*********************************************************************** * Step to the next communicator. */ int mqs_next_communicator (mqs_process *proc) { mpi_process_info *p_info = (mpi_process_info *)mqs_get_process_info (proc); mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; extra->current_communicator = extra->current_communicator->next; return (extra->current_communicator != NULL) ? mqs_ok : mqs_end_of_list; } /* mqs_next_communicator */ /** * Parsing the opal_list_t. */ 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 ) { mqs_image * image = mqs_get_image (proc); mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image); position->list = list; position->sentinel = position->list + i_info->opal_list_t.offset.opal_list_sentinel; position->current_item = ompi_fetch_pointer( proc, position->sentinel + i_info->opal_list_item_t.offset.opal_list_next, p_info ); if( position->current_item == position->sentinel ) position->current_item = 0; DEBUG(VERBOSE_LISTS,("opal_list_t_init_parser list = 0x%llx, sentinel = 0x%llx, " "current_item = 0x%llx\n", (long long)position->list, (long long)position->sentinel, (long long)position->current_item)); return mqs_ok; } 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 ) { mqs_image * image = mqs_get_image (proc); mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image); *active_item = position->current_item; if( 0 == position->current_item ) return mqs_end_of_list; position->current_item = ompi_fetch_pointer( proc, position->current_item + i_info->opal_list_item_t.offset.opal_list_next, p_info ); if( position->current_item == position->sentinel ) position->current_item = 0; return mqs_ok; } #if defined(CODE_NOT_USED) /** * Parsing the ompi_free_list lists. */ static void ompi_free_list_t_dump_position( mqs_ompi_free_list_t_pos* position ) { printf( "position->opal_list_t_pos.current_item = 0x%llx\n", (long long)position->opal_list_t_pos.current_item ); printf( "position->opal_list_t_pos.list = 0x%llx\n", (long long)position->opal_list_t_pos.list ); printf( "position->opal_list_t_pos.sentinel = 0x%llx\n", (long long)position->opal_list_t_pos.sentinel ); printf( "position->current_item = 0x%llx\n", (long long)position->current_item ); printf( "position->upper_bound = 0x%llx\n", (long long)position->upper_bound ); printf( "position->header_space = %llx\n", (long long)position->header_space ); printf( "position->free_list = 0x%llx\n", (long long)position->free_list ); printf( "position->fl_frag_class = 0x%llx\n", (long long)position->fl_frag_class ); printf( "position->fl_mpool = 0x%llx\n", (long long)position->fl_mpool ); printf( "position->fl_frag_size = %llx\n", (long long)position->fl_frag_size ); printf( "position->fl_frag_alignment = %llx\n", (long long)position->fl_frag_alignment ); printf( "position->fl_num_per_alloc = %llx\n", (long long)position->fl_num_per_alloc ); printf( "position->fl_num_allocated = %llx\n", (long long)position->fl_num_allocated ); printf( "position->fl_num_initial_alloc = %llx\n", (long long)position->fl_num_initial_alloc ); } #endif /* CODE_NOT_USED */ static int ompi_free_list_t_init_parser( mqs_process *proc, mpi_process_info *p_info, mqs_ompi_free_list_t_pos* position, mqs_taddr_t free_list ) { mqs_image * image = mqs_get_image (proc); mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image); mqs_taddr_t active_allocation; position->free_list = free_list; position->fl_frag_size = ompi_fetch_size_t( proc, position->free_list + i_info->ompi_free_list_t.offset.fl_frag_size, p_info ); position->fl_frag_alignment = ompi_fetch_size_t( proc, position->free_list + i_info->ompi_free_list_t.offset.fl_frag_alignment, p_info ); position->fl_frag_class = ompi_fetch_pointer( proc, position->free_list + i_info->ompi_free_list_t.offset.fl_frag_class, p_info ); position->fl_mpool = ompi_fetch_pointer( proc, position->free_list + i_info->ompi_free_list_t.offset.fl_mpool, p_info ); position->fl_num_per_alloc = ompi_fetch_size_t( proc, position->free_list + i_info->ompi_free_list_t.offset.fl_num_per_alloc, p_info ); position->fl_num_allocated = ompi_fetch_size_t( proc, position->free_list + i_info->ompi_free_list_t.offset.fl_num_allocated, p_info ); if( 0 == position->fl_mpool ) { position->header_space = position->fl_frag_size; } else { DEBUG(VERBOSE_GENERAL, ("BLAH !!! (CORRECT ME)\n")); position->header_space = position->fl_frag_size; } position->header_space = OPAL_ALIGN( position->header_space, position->fl_frag_alignment, mqs_taddr_t ); /** * Work around the strange ompi_free_list_t way to allocate elements. The first chunk is * not required to have the same size as the others. * A similar work around should be set for the last chunk of allocations too !!! But how * can we solve ONE equation with 2 unknowns ? */ if( position->fl_num_allocated <= position->fl_num_per_alloc ) { position->fl_num_initial_alloc = position->fl_num_allocated; } else { position->fl_num_initial_alloc = position->fl_num_allocated % position->fl_num_per_alloc; if( 0 == position->fl_num_initial_alloc ) position->fl_num_initial_alloc = position->fl_num_per_alloc; } DEBUG(VERBOSE_LISTS,("ompi_free_list_t fl_frag_size = %lld fl_header_space = %lld\n" " fl_frag_alignment = %lld fl_num_per_alloc = %lld\n" " fl_num_allocated = %lld fl_num_initial_alloc = %lld\n" " header_space = %lld\n", (long long)position->fl_frag_size, (long long)position->header_space, (long long)position->fl_frag_alignment, (long long)position->fl_num_per_alloc, (long long)position->fl_num_allocated, (long long)position->fl_num_initial_alloc, (long long)position->header_space)); /** * Initialize the pointer to the opal_list_t. */ opal_list_t_init_parser( proc, p_info, &position->opal_list_t_pos, position->free_list + i_info->ompi_free_list_t.offset.fl_allocations ); next_item_opal_list_t( proc, p_info, &position->opal_list_t_pos, &active_allocation ); DEBUG(VERBOSE_LISTS,("active_allocation 0x%llx header_space %d\n", (long long)active_allocation, (int)position->header_space)); if( 0 == active_allocation ) { /* the end of the list */ position->upper_bound = 0; } else { /** * Handle alignment issues... */ active_allocation += i_info->ompi_free_list_item_t.size; active_allocation = OPAL_ALIGN( active_allocation, position->fl_frag_alignment, mqs_taddr_t ); /** * Now let's try to compute the upper bound ... */ position->upper_bound = position->fl_num_initial_alloc * position->header_space + active_allocation; DEBUG(VERBOSE_LISTS,("there are some elements in the list " "active_allocation = %llx upper_bound = %llx\n", (long long)active_allocation, (long long)position->upper_bound)); } position->current_item = active_allocation; /*ompi_free_list_t_dump_position( position );*/ return mqs_ok; } /** * Return the current position and move the internal counter to the next element. */ static int ompi_free_list_t_next_item( mqs_process *proc, mpi_process_info *p_info, mqs_ompi_free_list_t_pos* position, mqs_taddr_t* active_item ) { mqs_image * image = mqs_get_image (proc); mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image); mqs_taddr_t active_allocation; *active_item = position->current_item; if( 0 == position->current_item ) /* the end ... */ return mqs_ok; position->current_item += position->header_space; if( position->current_item >= position->upper_bound ) { DEBUG(VERBOSE_LISTS,("Reach the end of one of the ompi_free_list_t " "allocations. Go to the next one\n")); /* we should go to the next allocation */ next_item_opal_list_t( proc, p_info, &position->opal_list_t_pos, &active_allocation ); if( 0 == active_allocation ) { /* we're at the end */ position->current_item = 0; return mqs_ok; } /** * Handle alignment issues... */ active_allocation += i_info->ompi_free_list_item_t.size; active_allocation = OPAL_ALIGN( active_allocation, position->fl_frag_alignment, mqs_taddr_t ); /** * Now let's try to compute the upper bound ... */ position->upper_bound = position->fl_num_per_alloc * position->header_space + active_allocation; position->current_item = active_allocation; DEBUG(VERBOSE_LISTS,("there are more elements in the list " "active_allocation = %llx upper_bound = %llx\n", (long long)active_allocation, (long long)position->upper_bound)); /*ompi_free_list_t_dump_position( position );*/ } DEBUG(VERBOSE_LISTS,("Free list actual position 0x%llx next element at 0x%llx\n", (long long)*active_item, (long long)position->current_item)); return mqs_ok; } static void dump_request( mqs_taddr_t current_item, mqs_pending_operation *res ) { if(!(VERBOSE_REQ_DUMP & VERBOSE)) return; printf( "\n+===============================================+\n" "|Request 0x%llx contain \n" "| res->status = %d\n" "| res->desired_local_rank = %ld\n" "| res->desired_global_rank = %ld\n" "| res->tag_wild = %ld\n" "| res->desired_tag = %ld\n" "| res->system_buffer = %s\n" "| res->buffer = 0x%llx\n" "| res->desired_length = %ld\n", (long long)current_item, res->status, (long)res->desired_local_rank, (long)res->desired_global_rank, (long)res->tag_wild, (long)res->desired_tag, (TRUE == res->system_buffer ? "TRUE" : "FALSE"), (long long)res->buffer, (long)res->desired_length ); if( res->status > mqs_st_pending ) { printf( "| res->actual_length = %ld\n" "| res->actual_tag = %ld\n" "| res->actual_local_rank = %ld\n" "| res->actual_global_rank = %ld\n", (long)res->actual_length, (long)res->actual_tag, (long)res->actual_local_rank, (long)res->actual_global_rank ); } if( '\0' != res->extra_text[0][0] ) printf( "| extra[0] = %s\n", res->extra_text[0] ); if( '\0' != res->extra_text[1][0] ) printf( "| extra[1] = %s\n", res->extra_text[1] ); if( '\0' != res->extra_text[2][0] ) printf( "| extra[2] = %s\n", res->extra_text[2] ); if( '\0' != res->extra_text[3][0] ) printf( "| extra[3] = %s\n", res->extra_text[3] ); if( '\0' != res->extra_text[4][0] ) printf( "| extra[4] = %s\n", res->extra_text[4] ); printf( "+===============================================+\n\n" ); } /** * TODO: ompi_request_completed can be used to detect any changes in the request handles. */ /** * Handle the send queue as well as the receive queue. The unexpected queue * is a whole different story ... */ static int fetch_request( mqs_process *proc, mpi_process_info *p_info, mqs_pending_operation *res, int look_for_user_buffer ) { mqs_image * image = mqs_get_image (proc); mpi_image_info *i_info = (mpi_image_info *)mqs_get_image_info (image); mqs_taddr_t current_item; mqs_tword_t req_complete, req_pml_complete, req_valid, req_type; mqs_taddr_t req_buffer, req_comm; mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; /* If we get a PML request with an internal tag we will jump back here */ rescan_requests: while( 1 ) { ompi_free_list_t_next_item( proc, p_info, &extra->next_msg, ¤t_item ); if( 0 == current_item ) { DEBUG(VERBOSE_REQ,("no more items in the %s request queue\n", look_for_user_buffer ? "receive" : "send" )); return mqs_end_of_list; } req_valid = ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_state, p_info ); if( OMPI_REQUEST_INVALID == req_valid ) continue; req_comm = ompi_fetch_pointer( proc, current_item + i_info->mca_pml_base_request_t.offset.req_comm, p_info ); if( extra->current_communicator->comm_ptr == req_comm ) break; DEBUG(VERBOSE_REQ,("unmatched request (0x%llx) req_comm = %llx current_com = %llx\n", (long long)current_item, (long long)req_comm, (long long)extra->current_communicator->comm_ptr)); } res->extra_text[0][0] = 0; res->extra_text[1][0] = 0; res->extra_text[2][0] = 0; res->extra_text[3][0] = 0; res->extra_text[4][0] = 0; req_type = ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_type, p_info ); if( OMPI_REQUEST_PML == req_type ) { mqs_taddr_t ompi_datatype; char data_name[64]; /** * First retrieve the tag. If the tag is negative and the user didn't * request the internal requests information then move along. */ res->desired_tag = ompi_fetch_int( proc, current_item + i_info->mca_pml_base_request_t.offset.req_tag, p_info ); if( MPI_ANY_TAG == (int)res->desired_tag ) { res->tag_wild = TRUE; } else { /* Don't allow negative tags to show up */ if( ((int)res->desired_tag < 0) && (0 == extra->show_internal_requests) ) goto rescan_requests; res->tag_wild = FALSE; } req_type = ompi_fetch_int( proc, current_item + i_info->mca_pml_base_request_t.offset.req_type, p_info); req_complete = ompi_fetch_bool( proc, current_item + i_info->ompi_request_t.offset.req_complete, p_info ); req_pml_complete = ompi_fetch_bool( proc, current_item + i_info->mca_pml_base_request_t.offset.req_pml_complete, p_info ); res->status = (0 == req_complete ? mqs_st_pending : mqs_st_complete); res->desired_local_rank = ompi_fetch_int( proc, current_item + i_info->mca_pml_base_request_t.offset.req_peer, p_info ); res->desired_global_rank = translate( extra->current_communicator->group, res->desired_local_rank ); res->buffer = ompi_fetch_pointer( proc, current_item + i_info->mca_pml_base_request_t.offset.req_addr, p_info ); /* Set this to true if it's a buffered request */ res->system_buffer = FALSE; /* The pointer to the request datatype */ ompi_datatype = ompi_fetch_pointer( proc, current_item + i_info->mca_pml_base_request_t.offset.req_datatype, p_info ); /* Retrieve the count as specified by the user */ res->desired_length = ompi_fetch_size_t( proc, ompi_datatype + i_info->ompi_datatype_t.offset.size, p_info ); /* Be user friendly, show the datatype name */ mqs_fetch_data( proc, ompi_datatype + i_info->ompi_datatype_t.offset.name, 64, data_name ); if( '\0' != data_name[0] ) { snprintf( (char*)res->extra_text[1], 64, "Data: %d * %s", (int)res->desired_length, data_name ); } /* And now compute the real length as specified by the user */ res->desired_length *= ompi_fetch_size_t( proc, current_item + i_info->mca_pml_base_request_t.offset.req_count, p_info ); if( MCA_PML_REQUEST_SEND == req_type ) { snprintf( (char *)res->extra_text[0], 64, "Send: 0x%llx", (long long)current_item ); req_buffer = ompi_fetch_pointer( proc, current_item + i_info->mca_pml_base_send_request_t.offset.req_addr, p_info ); res->system_buffer = ( req_buffer == res->buffer ? FALSE : TRUE ); res->actual_length = ompi_fetch_size_t( proc, current_item + i_info->mca_pml_base_send_request_t.offset.req_bytes_packed, p_info ); res->actual_tag = res->desired_tag; res->actual_local_rank = res->desired_local_rank; res->actual_global_rank = res->actual_local_rank; } else if( MCA_PML_REQUEST_RECV == req_type ) { snprintf( (char *)res->extra_text[0], 64, "Receive: 0x%llx", (long long)current_item ); /** * There is a trick with the MPI_TAG. All receive requests set it to MPI_ANY_TAG * when the request get initialized, and to the real tag once the request * is matched. */ res->actual_tag = ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_status + i_info->ompi_status_public_t.offset.MPI_TAG, p_info ); if( MPI_ANY_TAG != (int)res->actual_tag ) { res->status = mqs_st_matched; res->desired_length = ompi_fetch_size_t( proc, current_item + i_info->mca_pml_base_recv_request_t.offset.req_bytes_packed, p_info ); res->actual_local_rank = ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_status + i_info->ompi_status_public_t.offset.MPI_SOURCE, p_info ); res->actual_global_rank = translate( extra->current_communicator->group, res->actual_local_rank ); } } else { snprintf( (char *)res->extra_text[0], 64, "Unknown type of request 0x%llx", (long long)current_item ); } if( 0 != req_pml_complete ) { snprintf( (char *)res->extra_text[1], 64, "Data transfer completed" ); } /* If the length we're looking for is the count ... */ /*res->desired_length = ompi_fetch_int( proc, current_item + i_info->mca_pml_base_request_t.offset.req_count, p_info );*/ if( (mqs_st_pending < res->status) && (MCA_PML_REQUEST_SEND != req_type) ) { /* The real data from the status */ res->actual_length = ompi_fetch_size_t( proc, current_item + i_info->ompi_request_t.offset.req_status + i_info->ompi_status_public_t.offset._ucount, p_info ); res->actual_tag = ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_status + i_info->ompi_status_public_t.offset.MPI_TAG, p_info ); res->actual_local_rank = ompi_fetch_int( proc, current_item + i_info->ompi_request_t.offset.req_status + i_info->ompi_status_public_t.offset.MPI_SOURCE, p_info ); res->actual_global_rank = translate( extra->current_communicator->group, res->actual_local_rank ); } dump_request( current_item, res ); } return mqs_ok; } /*********************************************************************** * Setup to iterate over pending operations */ int mqs_setup_operation_iterator (mqs_process *proc, int op) { mpi_process_info *p_info = (mpi_process_info *)mqs_get_process_info (proc); mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; extra->what = (mqs_op_class)op; switch (op) { case mqs_pending_sends: DEBUG(VERBOSE_REQ,("setup the send queue iterator\n")); ompi_free_list_t_init_parser( proc, p_info, &extra->next_msg, extra->send_queue_base ); return mqs_ok; case mqs_pending_receives: DEBUG(VERBOSE_REQ,("setup the receive queue iterator\n")); ompi_free_list_t_init_parser( proc, p_info, &extra->next_msg, extra->recv_queue_base ); return mqs_ok; case mqs_unexpected_messages: /* TODO */ return mqs_no_information; default: return err_bad_request; } } /* mqs_setup_operation_iterator */ /*********************************************************************** * Fetch the next valid operation. * Since Open MPI only maintains a single queue of each type of operation, * we have to run over it and filter out the operations which * match the active communicator. */ int mqs_next_operation (mqs_process *proc, mqs_pending_operation *op) { mpi_process_info *p_info = (mpi_process_info *)mqs_get_process_info (proc); mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; switch (extra->what) { case mqs_pending_receives: DEBUG(VERBOSE_REQ,("digging for the receive queue\n")); return fetch_request( proc, p_info, op, TRUE ); case mqs_unexpected_messages: /* TODO: not handled yet */ return err_bad_request; case mqs_pending_sends: DEBUG(VERBOSE_REQ,("digging for the send queue\n")); return fetch_request( proc, p_info, op, FALSE ); default: return err_bad_request; } } /* mqs_next_operation */ /*********************************************************************** * Destroy the info. */ void mqs_destroy_process_info (mqs_process_info *mp_info) { mpi_process_info *p_info = (mpi_process_info *)mp_info; mpi_process_info_extra *extra = (mpi_process_info_extra*) p_info->extra; /* Need to handle the communicators and groups too */ communicator_t *comm; if( NULL != extra) { comm = extra->communicator_list; while (comm) { communicator_t *next = comm->next; if( NULL != comm->group ) group_decref (comm->group); /* Group is no longer referenced from here */ mqs_free (comm); comm = next; } if (NULL != extra) { mqs_free(extra); } } mqs_free (p_info); } /* mqs_destroy_process_info */ /*********************************************************************** * Free off the data we associated with an image. Since we malloced it * we just free it. */ void mqs_destroy_image_info (mqs_image_info *info) { mqs_free (info); } /* mqs_destroy_image_info */ /***********************************************************************/ /* Convert an error code into a printable string */ char * mqs_dll_error_string (int errcode) { switch (errcode) { case err_silent_failure: return ""; case err_no_current_communicator: return "No current communicator in the communicator iterator"; case err_bad_request: return "Attempting to setup to iterate over an unknown queue of operations"; case err_no_store: return "Unable to allocate store"; case err_failed_qhdr: return "Failed to find type MPID_QHDR"; case err_unexpected: return "Failed to find field 'unexpected' in MPID_QHDR"; case err_posted: return "Failed to find field 'posted' in MPID_QHDR"; case err_failed_queue: return "Failed to find type MPID_QUEUE"; case err_first: return "Failed to find field 'first' in MPID_QUEUE"; case err_context_id: return "Failed to find field 'context_id' in MPID_QEL"; case err_tag: return "Failed to find field 'tag' in MPID_QEL"; case err_tagmask: return "Failed to find field 'tagmask' in MPID_QEL"; case err_lsrc: return "Failed to find field 'lsrc' in MPID_QEL"; case err_srcmask: return "Failed to find field 'srcmask' in MPID_QEL"; case err_next: return "Failed to find field 'next' in MPID_QEL"; case err_ptr: return "Failed to find field 'ptr' in MPID_QEL"; case err_missing_type: return "Failed to find some type"; case err_missing_symbol: return "Failed to find field the global symbol"; case err_db_shandle: return "Failed to find field 'db_shandle' in MPIR_SQEL"; case err_db_comm: return "Failed to find field 'db_comm' in MPIR_SQEL"; case err_db_target: return "Failed to find field 'db_target' in MPIR_SQEL"; case err_db_tag: return "Failed to find field 'db_tag' in MPIR_SQEL"; case err_db_data: return "Failed to find field 'db_data' in MPIR_SQEL"; case err_db_byte_length: return "Failed to find field 'db_byte_length' in MPIR_SQEL"; case err_db_next: return "Failed to find field 'db_next' in MPIR_SQEL"; case err_failed_rhandle: return "Failed to find type MPIR_RHANDLE"; case err_is_complete: return "Failed to find field 'is_complete' in MPIR_RHANDLE"; case err_buf: return "Failed to find field 'buf' in MPIR_RHANDLE"; case err_len: return "Failed to find field 'len' in MPIR_RHANDLE"; case err_s: return "Failed to find field 's' in MPIR_RHANDLE"; case err_failed_status: return "Failed to find type MPI_Status"; case err_count: return "Failed to find field 'count' in MPIR_Status"; case err_MPI_SOURCE: return "Failed to find field 'MPI_SOURCE' in MPIR_Status"; case err_MPI_TAG: return "Failed to find field 'MPI_TAG' in MPIR_Status"; case err_failed_commlist: return "Failed to find type MPIR_Comm_list"; case err_sequence_number: return "Failed to find field 'sequence_number' in MPIR_Comm_list"; case err_comm_first: return "Failed to find field 'comm_first' in MPIR_Comm_list"; case err_failed_communicator: return "Failed to find type MPIR_Communicator"; case err_lrank_to_grank: return "Failed to find field 'lrank_to_grank' in MPIR_Communicator"; case err_send_context: return "Failed to find field 'send_context' in MPIR_Communicator"; case err_recv_context: return "Failed to find field 'recv_context' in MPIR_Communicator"; case err_comm_next: return "Failed to find field 'comm_next' in MPIR_Communicator"; case err_comm_name: return "Failed to find field 'comm_name' in MPIR_Communicator"; case err_all_communicators: return "Failed to find the global symbol MPIR_All_communicators"; case err_mpid_sends: return "Failed to access the global send requests list"; case err_mpid_recvs: return "Failed to access the global receive requests list"; case err_group_corrupt: return "Could not read a communicator's group from the process (probably a store corruption)"; default: return "Unknown error code"; } } /* mqs_dll_error_string */